Package org.jvnet.hk2.internal

Class ServiceLocatorImpl

    • Field Detail

      • BIND_TRACING_PATTERN_PROPERTY

        private static final java.lang.String BIND_TRACING_PATTERN_PROPERTY
        See Also:
        Constant Field Values

      • BIND_TRACING_PATTERN

        private static final java.lang.String BIND_TRACING_PATTERN

      • BIND_TRACING_STACKS_PROPERTY

        private static final java.lang.String BIND_TRACING_STACKS_PROPERTY
        See Also:
        Constant Field Values

      • BIND_TRACING_STACKS

        private static boolean BIND_TRACING_STACKS

      • sLock

        private static final java.lang.Object sLock

      • currentLocatorId

        private static long currentLocatorId

      • readWriteLock

        private final java.util.concurrent.locks.ReentrantReadWriteLock readWriteLock

      • wLock

        private final java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock wLock

      • rLock

        private final java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock rLock

      • nextServiceId

        private final java.util.concurrent.atomic.AtomicLong nextServiceId

      • locatorName

        private final java.lang.String locatorName

      • id

        private final long id

      • neutralContextClassLoader

        private volatile boolean neutralContextClassLoader

      • descriptorsByAdvertisedContract

        private final java.util.HashMap<java.lang.String,​IndexedListData> descriptorsByAdvertisedContract

      • descriptorsByName

        private final java.util.HashMap<java.lang.String,​IndexedListData> descriptorsByName

      • singletonContext

        private final Context<javax.inject.Singleton> singletonContext

      • allValidators

        private final java.util.LinkedHashSet<ValidationService> allValidators

      • errorHandlers

        private final java.util.LinkedList<ErrorService> errorHandlers

      • configListeners

        private final java.util.LinkedList<ServiceHandle<?>> configListeners

      • hasInterceptionServices

        private volatile boolean hasInterceptionServices

      • interceptionServices

        private final java.util.LinkedList<InterceptionService> interceptionServices

      • contextCache

        private final Cache<java.lang.Class<? extends java.lang.annotation.Annotation>,​Context<?>> contextCache

      • classAnalyzerLock

        private final java.lang.Object classAnalyzerLock

      • classAnalyzers

        private final java.util.HashMap<java.lang.String,​ClassAnalyzer> classAnalyzers

      • defaultClassAnalyzer

        private java.lang.String defaultClassAnalyzer

      • defaultUnqualified

        private volatile Unqualified defaultUnqualified

      • allResolvers

        private java.util.concurrent.ConcurrentHashMap<java.lang.Class<? extends java.lang.annotation.Annotation>,​InjectionResolver<?>> allResolvers

    • Constructor Detail

      • ServiceLocatorImpl

        public ServiceLocatorImpl​(java.lang.String name,
                          ServiceLocatorImpl parent)
        Called by the Generator, and hence must be a public method
        Parameters:
        name - The name of this locator
        parent - The parent of this locator (may be null)

    • Method Detail

      • getAndIncrementLocatorId

        private static long getAndIncrementLocatorId()

      • validate

        private boolean validate​(SystemDescriptor<?> descriptor,
                         Injectee onBehalfOf,
                         Filter filter)
        Must be called under lock
        Parameters:
        descriptor - The descriptor to validate
        onBehalfOf - The fella who is being validated (or null)
        Returns:
        true if every validator returned true

      • getDescriptors

        private java.util.List<SystemDescriptor<?>> getDescriptors​(Filter filter,
                                                           Injectee onBehalfOf,
                                                           boolean getParents,
                                                           boolean doValidation,
                                                           boolean getLocals)

      • protectedGetDescriptors

        private java.util.List<ActiveDescriptor<?>> protectedGetDescriptors​(Filter filter)

      • getDescriptors

        public java.util.List<ActiveDescriptor<?>> getDescriptors​(Filter filter)
        Description copied from interface: ServiceLocator
        Gets the list of descriptors that match the given filter
        Specified by:
        getDescriptors in interface ServiceLocator
        Parameters:
        filter - A filter to use when determining which services should apply
        Returns:
        A non-null but possibly empty list of descriptors in ranked order that match the given filter

      • getBestDescriptor

        public ActiveDescriptor<?> getBestDescriptor​(Filter filter)
        Description copied from interface: ServiceLocator
        Gets the descriptor that best matches this filter, taking ranking and service id into account
        Specified by:
        getBestDescriptor in interface ServiceLocator
        Parameters:
        filter - The non-null filter to use to retrieve the best descriptor
        Returns:
        The best descriptor matching the filter, or null if there is no descriptor that matches the filter

      • reifyDescriptor

        public ActiveDescriptor<?> reifyDescriptor​(Descriptor descriptor,
                                           Injectee injectee)
                                    throws MultiException
        Description copied from interface: ServiceLocator
        Converts a descriptor to an ActiveDescriptor. Will use the registered HK2Loaders to perform this action. If no HK2Loader is available for the descriptor, will use the injectee to discover a classloader
        Specified by:
        reifyDescriptor in interface ServiceLocator
        Parameters:
        descriptor - The descriptor to convert, may not be null
        injectee - The injectee on behalf of whom this descriptor is being injected. May be null if the injectee is unknown
        Returns:
        The active descriptor as loaded with the first valid HK2Loader
        Throws:
        MultiException - if there were errors when loading or analyzing the class

      • reifyDescriptor

        public ActiveDescriptor<?> reifyDescriptor​(Descriptor descriptor)
                                    throws MultiException
        Description copied from interface: ServiceLocator
        Converts a descriptor to an ActiveDescriptor. Will use the registered HK2Loaders to perform this action
        Specified by:
        reifyDescriptor in interface ServiceLocator
        Parameters:
        descriptor - The descriptor to convert, may not be null
        Returns:
        The active descriptor as loaded with the first valid HK2Loader
        Throws:
        MultiException - if there were errors when loading or analyzing the class

      • internalGetInjecteeDescriptor

        private ActiveDescriptor<?> internalGetInjecteeDescriptor​(Injectee injectee,
                                                          boolean calledFromSecondChanceResolveMethod)

      • getInjecteeDescriptor

        public ActiveDescriptor<?> getInjecteeDescriptor​(Injectee injectee)
                                          throws MultiException
        Description copied from interface: ServiceLocator
        This method will first find a descriptor for this injectee, and then reify that descriptor. If multiple descriptors are found, they will be reified in ranking order until an ActiveDescriptor matching the Injectee is found.

        This method is responsible for using the available JustInTimeInjectionResolver to add in new descriptors should the descriptor for the given injectee not be found initially

        Specified by:
        getInjecteeDescriptor in interface ServiceLocator
        Parameters:
        injectee - the injection point for whom to find the ActiveDescriptor
        Returns:
        The active descriptor for this injection point
        Throws:
        MultiException - if there were errors when loading or analyzing the class

      • getService

        @Deprecated
public <T> T getService​(ActiveDescriptor<T> activeDescriptor,
                        ServiceHandle<?> root)
                 throws MultiException
        Deprecated.
        Description copied from interface: ServiceLocator
        This method should be called by code resolving injectee's on behalf of some root service, usually by an implementation of InjectionResolver.resolve(Injectee, ServiceHandle). In this way the objects associated with the root object can be destroyed in the proper sequence
        Specified by:
        getService in interface ServiceLocator
        Parameters:
        activeDescriptor - The descriptor whose service to create
        root - The ultimate parent of this service creation. May be null
        Returns:
        The service matching this descriptor
        Throws:
        MultiException - if there was an error during service creation

      • getService

        public <T> T getService​(java.lang.Class<T> contractOrImpl,
                        java.lang.annotation.Annotation... qualifiers)
                 throws MultiException
        Description copied from interface: ServiceLocator
        Gets the best service from this locator that implements this contract or has this implementation

        Use this method only if destroying the service is not important, otherwise use ServiceLocator.getServiceHandle(Class, Annotation...)

        Specified by:
        getService in interface ServiceLocator
        Parameters:
        contractOrImpl - May not be null, and is the contract or concrete implementation to get the best instance of
        qualifiers - The set of qualifiers that must match this service definition
        Returns:
        An instance of the contract or impl. May return null if there is no provider that provides the given implementation or contract
        Throws:
        MultiException - if there was an error during service creation

      • getService

        public <T> T getService​(java.lang.reflect.Type contractOrImpl,
                        java.lang.annotation.Annotation... qualifiers)
                 throws MultiException
        Description copied from interface: ServiceLocator
        Gets the best service from this locator that implements this contract or has this implementation

        Use this method only if destroying the service is not important, otherwise use ServiceLocator.getServiceHandle(Type, Annotation...)

        Specified by:
        getService in interface ServiceLocator
        Parameters:
        contractOrImpl - May not be null, and is the contract or concrete implementation to get the best instance of
        qualifiers - The set of qualifiers that must match this service definition
        Returns:
        An instance of the contract or impl. May return null if there is no provider that provides the given implementation or contract
        Throws:
        MultiException - if there was an error during service creation

      • getService

        public <T> T getService​(java.lang.Class<T> contractOrImpl,
                        java.lang.String name,
                        java.lang.annotation.Annotation... qualifiers)
                 throws MultiException
        Description copied from interface: ServiceLocator
        Gets the best service from this locator that implements this contract or has this implementation and has the given name

        Use this method only if destroying the service is not important, otherwise use ServiceLocator.getServiceHandle(Class, String, Annotation...)

        Specified by:
        getService in interface ServiceLocator
        Parameters:
        contractOrImpl - May not be null, and is the contract or concrete implementation to get the best instance of
        name - May be null (to indicate any name is ok), and is the name of the implementation to be returned
        qualifiers - The set of qualifiers that must match this service definition
        Returns:
        An instance of the contract or impl. May return null if there is no provider that provides the given implementation or contract
        Throws:
        MultiException - if there was an error during service creation

      • getService

        public <T> T getService​(java.lang.reflect.Type contractOrImpl,
                        java.lang.String name,
                        java.lang.annotation.Annotation... qualifiers)
                 throws MultiException
        Description copied from interface: ServiceLocator
        Gets the best service from this locator that implements this contract or has this implementation and has the given name

        Use this method only if destroying the service is not important, otherwise use ServiceLocator.getServiceHandle(Type, String, Annotation...)

        Specified by:
        getService in interface ServiceLocator
        Parameters:
        contractOrImpl - May not be null, and is the contract or concrete implementation to get the best instance of
        name - May be null (to indicate any name is ok), and is the name of the implementation to be returned
        qualifiers - The set of qualifiers that must match this service definition
        Returns:
        An instance of the contract or impl. May return null if there is no provider that provides the given implementation or contract
        Throws:
        MultiException - if there was an error during service creation

      • internalGetService

        private <T> T internalGetService​(java.lang.reflect.Type contractOrImpl,
                                 java.lang.String name,
                                 Unqualified unqualified,
                                 java.lang.annotation.Annotation... qualifiers)

      • internalGetService

        private <T> T internalGetService​(java.lang.reflect.Type contractOrImpl,
                                 java.lang.String name,
                                 Unqualified unqualified,
                                 boolean calledFromSecondChanceResolveMethod,
                                 java.lang.annotation.Annotation... qualifiers)

      • getUnqualifiedService

        <T> T getUnqualifiedService​(java.lang.reflect.Type contractOrImpl,
                            Unqualified unqualified,
                            boolean isIterable,
                            java.lang.annotation.Annotation... qualifiers)
                     throws MultiException
        This method is only called from the get of IterableProvider. IterableProvider has already called the JIT resolvers and so should not do so again, since it is too much work and doesn't have the information about the original injectee
        Throws:
        MultiException

      • protectedGetAllServices

        private <T> java.util.List<T> protectedGetAllServices​(java.lang.reflect.Type contractOrImpl,
                                                      java.lang.annotation.Annotation... qualifiers)

      • getAllServices

        public <T> java.util.List<T> getAllServices​(java.lang.Class<T> contractOrImpl,
                                            java.lang.annotation.Annotation... qualifiers)
                                     throws MultiException
        Description copied from interface: ServiceLocator
        Gets all services from this locator that implement this contract or have this implementation and have the provided qualifiers

        Use this method only if destroying the service is not important, otherwise use ServiceLocator.getAllServiceHandles(Class, Annotation...)

        Specified by:
        getAllServices in interface ServiceLocator
        Parameters:
        contractOrImpl - May not be null, and is the contract or concrete implementation to get the best instance of
        qualifiers - The set of qualifiers that must match this service definition
        Returns:
        A list of services implementing this contract or concrete implementation. May not return null, but may return an empty list
        Throws:
        MultiException - if there was an error during service creation

      • getAllServices

        public <T> java.util.List<T> getAllServices​(java.lang.reflect.Type contractOrImpl,
                                            java.lang.annotation.Annotation... qualifiers)
                                     throws MultiException
        Description copied from interface: ServiceLocator
        Gets all services from this locator that implement this contract or have this implementation and have the provided qualifiers

        Use this method only if destroying the service is not important, otherwise use ServiceLocator.getAllServiceHandles(Type, Annotation...)

        Specified by:
        getAllServices in interface ServiceLocator
        Parameters:
        contractOrImpl - May not be null, and is the contract or concrete implementation to get the best instance of
        qualifiers - The set of qualifiers that must match this service definition
        Returns:
        A list of services implementing this contract or concrete implementation. May not return null, but may return an empty list
        Throws:
        MultiException - if there was an error during service creation

      • getAllServices

        public <T> java.util.List<T> getAllServices​(java.lang.annotation.Annotation qualifier,
                                            java.lang.annotation.Annotation... qualifiers)
                                     throws MultiException
        Description copied from interface: ServiceLocator
        Gets all services from this locator that have the provided qualifiers

        Use this method only if destroying the services is not important, otherwise use ServiceLocator.getAllServiceHandles(Annotation, Annotation...)

        Specified by:
        getAllServices in interface ServiceLocator
        Parameters:
        qualifier - May not be null, and is a qualifier that must match the service definition
        qualifiers - The set of qualifiers that must match this service definition
        Returns:
        A list of services implementing this contract or concrete implementation. May not return null, but may return an empty list
        Throws:
        MultiException - if there was an error during service creation

      • getAllServices

        public java.util.List<?> getAllServices​(Filter searchCriteria)
                                 throws MultiException
        Description copied from interface: ServiceLocator
        Gets all services from this locator that match the provided Filter

        Use this method only if destroying the service is not important, otherwise use ServiceLocator.getAllServiceHandles(Filter)

        This method should also be used with care to avoid classloading a large number of services

        Specified by:
        getAllServices in interface ServiceLocator
        Parameters:
        searchCriteria - The returned service will match the Filter (in other words, searchCriteria.matches returns true). May not be null
        Returns:
        A list of services matching this filter. May not return null, but may return an empty list
        Throws:
        MultiException - if there was an error during service creation

      • getName

        public java.lang.String getName()
        Description copied from interface: ServiceLocator
        Returns the name of this ServiceLocator
        Specified by:
        getName in interface ServiceLocator
        Returns:
        The name of this ServiceLocator, will not return null

      • getState

        public ServiceLocatorState getState()
        Description copied from interface: ServiceLocator
        Returns the current state of this service locator. This method will work in all service locator states
        Specified by:
        getState in interface ServiceLocator
        Returns:
        The current state of the service locator

      • shutdown

        public void shutdown()
        Description copied from interface: ServiceLocator
        This method will shutdown every service associated with this ServiceLocator. Those services that have a preDestroy shall have their preDestroy called
        Specified by:
        shutdown in interface ServiceLocator

      • create

        public <T> T create​(java.lang.Class<T> createMe)
        Description copied from interface: ServiceLocator
        This method will analyze the given class, and create it if can. The object created in this way will not be managed by HK2. It is the responsibility of the caller to ensure that any lifecycle this object has is honored
        Specified by:
        create in interface ServiceLocator
        Parameters:
        createMe - The class to create, may not be null
        Returns:
        An instance of the object

      • create

        public <T> T create​(java.lang.Class<T> createMe,
                    java.lang.String strategy)
        Description copied from interface: ServiceLocator
        This method will analyze the given class, and create it if can. The object created in this way will not be managed by HK2. It is the responsibility of the caller to ensure that any lifecycle this object has is honored
        Specified by:
        create in interface ServiceLocator
        Parameters:
        createMe - The class to create, may not be null
        strategy - The name of the ClassAnalyzer that should be used. If null the default analyzer will be used
        Returns:
        An instance of the object

      • inject

        public void inject​(java.lang.Object injectMe)
        Description copied from interface: ServiceLocator
        This will analyze the given object and inject into its fields and methods. The object injected in this way will not be managed by HK2
        Specified by:
        inject in interface ServiceLocator
        Parameters:
        injectMe - The object to be analyzed and injected into

      • assistedInject

        public java.lang.Object assistedInject​(java.lang.Object injectMe,
                                       java.lang.reflect.Method method,
                                       MethodParameter... params)
        Description copied from interface: ServiceLocator
        This will invoke the given method on the given object. The values for the method will either be taken from the params list or will be gotten from this ServiceLocator taking into account all injection resolvers
        Specified by:
        assistedInject in interface ServiceLocator
        Parameters:
        injectMe - The non-null object to inject into
        method - The non-null method to inject into
        params - A list of parameter values known by the caller. The indexes in params may not repeat and must be in the valid range of parameters for the passed in method
        Returns:
        The return value of the method (null if the method is void type)

      • assistedInject

        public java.lang.Object assistedInject​(java.lang.Object injectMe,
                                       java.lang.reflect.Method method,
                                       ServiceHandle<?> root,
                                       MethodParameter... params)
        Description copied from interface: ServiceLocator
        This will invoke the given method on the given object. The values for the method will either be taken from the params list or will be gotten from this ServiceLocator taking into account all injection resolvers
        Specified by:
        assistedInject in interface ServiceLocator
        Parameters:
        injectMe - The non-null object to inject into
        method - The non-null method to inject into
        root - A possibly null ServiceHandle that can be used after this call to destroy any hanging PerLookup instances created
        params - A list of parameter values known by the caller. The indexes in params may not repeat and must be in the valid range of parameters for the passed in method
        Returns:
        The return value of the method (null if the method is void type)

      • inject

        public void inject​(java.lang.Object injectMe,
                   java.lang.String strategy)
        Description copied from interface: ServiceLocator
        This will analyze the given object and inject into its fields and methods. The object injected in this way will not be managed by HK2
        Specified by:
        inject in interface ServiceLocator
        Parameters:
        injectMe - The object to be analyzed and injected into
        strategy - The name of the ClassAnalyzer that should be used. If null the default analyzer will be used

      • postConstruct

        public void postConstruct​(java.lang.Object postConstructMe)
        Description copied from interface: ServiceLocator
        This will analyze the given object and call the postConstruct method. The object given will not be managed by HK2
        Specified by:
        postConstruct in interface ServiceLocator
        Parameters:
        postConstructMe - The object to postConstruct

      • postConstruct

        public void postConstruct​(java.lang.Object postConstructMe,
                          java.lang.String strategy)
        Description copied from interface: ServiceLocator
        This will analyze the given object and call the postConstruct method. The object given will not be managed by HK2
        Specified by:
        postConstruct in interface ServiceLocator
        Parameters:
        postConstructMe - The object to postConstruct
        strategy - The name of the ClassAnalyzer that should be used. If null the default analyzer will be used

      • preDestroy

        public void preDestroy​(java.lang.Object preDestroyMe)
        Description copied from interface: ServiceLocator
        This will analyze the given object and call the preDestroy method. The object given will not be managed by HK2
        Specified by:
        preDestroy in interface ServiceLocator
        Parameters:
        preDestroyMe - The object to preDestroy

      • preDestroy

        public void preDestroy​(java.lang.Object preDestroyMe,
                       java.lang.String strategy)
        Description copied from interface: ServiceLocator
        This will analyze the given object and call the preDestroy method. The object given will not be managed by HK2
        Specified by:
        preDestroy in interface ServiceLocator
        Parameters:
        preDestroyMe - The object to preDestroy
        strategy - The name of the ClassAnalyzer that should be used. If null the default analyzer will be used

      • createAndInitialize

        public <U> U createAndInitialize​(java.lang.Class<U> createMe)
        Creates, injects and postConstructs, all in one
        Specified by:
        createAndInitialize in interface ServiceLocator
        Parameters:
        createMe - The non-null class to create this object from
        Returns:
        An instance of the object that has been created, injected and post constructed

      • createAndInitialize

        public <U> U createAndInitialize​(java.lang.Class<U> createMe,
                                 java.lang.String strategy)
        Creates, injects and postConstructs, all in one
        Specified by:
        createAndInitialize in interface ServiceLocator
        Parameters:
        createMe - The non-null class to create this object from
        strategy - The name of the ClassAnalyzer that should be used. If null the default analyzer will be used
        Returns:
        An instance of the object that has been created, injected and post constructed

      • getName

        private static java.lang.String getName​(java.lang.String name,
                                        java.lang.annotation.Annotation... qualifiers)

      • getEffectiveUnqualified

        private Unqualified getEffectiveUnqualified​(Unqualified givenUnqualified,
                                            boolean isIterable,
                                            java.lang.annotation.Annotation[] qualifiers)

      • internalGetDescriptor

        private <T> ActiveDescriptor<T> internalGetDescriptor​(Injectee onBehalfOf,
                                                      java.lang.reflect.Type contractOrImpl,
                                                      java.lang.String name,
                                                      Unqualified unqualified,
                                                      boolean isIterable,
                                                      boolean calledFromSecondChanceResolveMethod,
                                                      java.lang.annotation.Annotation... qualifiers)
                                               throws MultiException
        Throws:
        MultiException

      • getServiceHandle

        public <T> ServiceHandle<T> getServiceHandle​(java.lang.Class<T> contractOrImpl,
                                             java.lang.annotation.Annotation... qualifiers)
                                      throws MultiException
        Description copied from interface: ServiceLocator
        Gets a ServiceHandle that can be used to get and destroy the service that best matches the given criteria
        Specified by:
        getServiceHandle in interface ServiceLocator
        Parameters:
        contractOrImpl - May not be null, and is the contract or concrete implementation to get the best instance of
        qualifiers - The set of qualifiers that must match this service definition
        Returns:
        Will return the service handle corresponding to the service or null if none were found
        Throws:
        MultiException - if there was an issue during lookup

      • getServiceHandle

        public <T> ServiceHandle<T> getServiceHandle​(java.lang.reflect.Type contractOrImpl,
                                             java.lang.annotation.Annotation... qualifiers)
                                      throws MultiException
        Description copied from interface: ServiceLocator
        Gets a ServiceHandle that can be used to get and destroy the service that best matches the given criteria
        Specified by:
        getServiceHandle in interface ServiceLocator
        Parameters:
        contractOrImpl - May not be null, and is the contract or concrete implementation to get the best instance of
        qualifiers - The set of qualifiers that must match this service definition
        Returns:
        Will return the service handle corresponding to the service or null if none were found
        Throws:
        MultiException - if there was an issue during lookup

      • getUnqualifiedServiceHandle

        <T> ServiceHandle<T> getUnqualifiedServiceHandle​(java.lang.reflect.Type contractOrImpl,
                                                 Unqualified unqualified,
                                                 boolean isIterable,
                                                 java.lang.annotation.Annotation... qualifiers)
                                          throws MultiException
        Throws:
        MultiException

      • protectedGetAllServiceHandles

        private java.util.List<ServiceHandle<?>> protectedGetAllServiceHandles​(java.lang.reflect.Type contractOrImpl,
                                                                       java.lang.annotation.Annotation... qualifiers)

      • getAllServiceHandles

        public <T> java.util.List<ServiceHandle<T>> getAllServiceHandles​(java.lang.Class<T> contractOrImpl,
                                                                 java.lang.annotation.Annotation... qualifiers)
                                                          throws MultiException
        Description copied from interface: ServiceLocator
        Gets a list of ServiceHandle that can be used to get and destroy services associated with descriptors that match the provided criteria
        Specified by:
        getAllServiceHandles in interface ServiceLocator
        Parameters:
        contractOrImpl - May not be null, and is the contract or concrete implementation to get the best instance of
        qualifiers - The set of qualifiers that must match this service definition
        Returns:
        A non-null but possibly empty list of service handles matching the given criteria
        Throws:
        MultiException - if there was an error during service lookup

      • getAllServiceHandles

        public java.util.List<ServiceHandle<?>> getAllServiceHandles​(java.lang.reflect.Type contractOrImpl,
                                                             java.lang.annotation.Annotation... qualifiers)
                                                      throws MultiException
        Description copied from interface: ServiceLocator
        Gets a list of ServiceHandle that can be used to get and destroy services associated with descriptors that match the provided criteria
        Specified by:
        getAllServiceHandles in interface ServiceLocator
        Parameters:
        contractOrImpl - May not be null, and is the contract or concrete implementation to get the best instance of
        qualifiers - The set of qualifiers that must match this service definition
        Returns:
        A non-null but possibly empty list of service handles matching the given criteria
        Throws:
        MultiException - if there was an error during service lookup

      • getAllUnqualifiedServiceHandles

        java.util.List<ServiceHandle<?>> getAllUnqualifiedServiceHandles​(java.lang.reflect.Type contractOrImpl,
                                                                 Unqualified unqualified,
                                                                 boolean isIterable,
                                                                 java.lang.annotation.Annotation... qualifiers)
                                                          throws MultiException
        Throws:
        MultiException

      • internalGetAllServiceHandles

        private java.util.List<?> internalGetAllServiceHandles​(java.lang.reflect.Type contractOrImpl,
                                                       Unqualified unqualified,
                                                       boolean getHandles,
                                                       boolean isIterable,
                                                       java.lang.annotation.Annotation... qualifiers)
                                                throws MultiException
        Throws:
        MultiException

      • getServiceHandle

        public <T> ServiceHandle<T> getServiceHandle​(java.lang.Class<T> contractOrImpl,
                                             java.lang.String name,
                                             java.lang.annotation.Annotation... qualifiers)
                                      throws MultiException
        Description copied from interface: ServiceLocator
        Gets a ServiceHandle that can be used to get and destroy the service that best matches the given criteria
        Specified by:
        getServiceHandle in interface ServiceLocator
        Parameters:
        contractOrImpl - May not be null, and is the contract or concrete implementation to get the best instance of
        name - The name to use to further qualify the search (may be null, indicating that any name will match)
        qualifiers - The set of qualifiers that must match this service definition
        Returns:
        Will the service handle for the best service matching the given criteria, or null if no matching service could be found
        Throws:
        MultiException - if there was an error during lookup

      • getServiceHandle

        public <T> ServiceHandle<T> getServiceHandle​(java.lang.reflect.Type contractOrImpl,
                                             java.lang.String name,
                                             java.lang.annotation.Annotation... qualifiers)
                                      throws MultiException
        Description copied from interface: ServiceLocator
        Gets a ServiceHandle that can be used to get and destroy the service that best matches the given criteria
        Specified by:
        getServiceHandle in interface ServiceLocator
        Parameters:
        contractOrImpl - May not be null, and is the contract or concrete implementation to get the best instance of
        name - The name to use to further qualify the search (may be null, indicating that any name will match)
        qualifiers - The set of qualifiers that must match this service definition
        Returns:
        Will the service handle for the best service matching the given criteria, or null if no matching service could be found
        Throws:
        MultiException - if there was an error during service lookup

      • getAllServiceHandles

        public java.util.List<ServiceHandle<?>> getAllServiceHandles​(Filter searchCriteria)
                                                      throws MultiException
        Description copied from interface: ServiceLocator
        Gets a list of ServiceHandle whose ActiveDescriptors match the supplied filter. The returned ServiceHandles may be used to get or destroy the services associated with the matching descriptors
        Specified by:
        getAllServiceHandles in interface ServiceLocator
        Parameters:
        searchCriteria - A filter to use when determining which descriptors should apply
        Returns:
        A non-null but possibly empty list of service handles that match the given filter
        Throws:
        MultiException - if there was an error during service handle creation

      • getAllServiceHandles

        public java.util.List<ServiceHandle<?>> getAllServiceHandles​(java.lang.annotation.Annotation qualifier,
                                                             java.lang.annotation.Annotation... qualifiers)
                                                      throws MultiException
        Description copied from interface: ServiceLocator
        Gets a list of ServiceHandle that can be used to get and destroy services associated with descriptors that match the provided criteria
        Specified by:
        getAllServiceHandles in interface ServiceLocator
        Parameters:
        qualifier - May not be null, and is a qualifier that must match the service definition
        qualifiers - The set of qualifiers that must match this service definition
        Returns:
        A non-null but possibly empty list of service handles matching the given criteria
        Throws:
        MultiException - if there was an error during service lookup

      • checkConfiguration

        private ServiceLocatorImpl.CheckConfigurationData checkConfiguration​(DynamicConfigurationImpl dci)
        Checks the configuration operation before anything happens to the internal data structures.
        Parameters:
        dci - The configuration that contains the proposed modifications
        Returns:
        A set of descriptors that is being removed fromthe configuration

      • getAllContracts

        private static java.util.List<java.lang.String> getAllContracts​(ActiveDescriptor<?> desc)

      • removeConfigurationInternal

        private void removeConfigurationInternal​(java.util.List<SystemDescriptor<?>> unbinds)

      • reupInjectionResolvers

        private void reupInjectionResolvers()

      • reupInterceptionServices

        private void reupInterceptionServices()

      • reupErrorHandlers

        private void reupErrorHandlers()

      • reupConfigListeners

        private void reupConfigListeners()

      • reupInstanceListenersHandlers

        private void reupInstanceListenersHandlers​(java.util.Collection<SystemDescriptor<?>> checkList)

      • reupClassAnalyzers

        private void reupClassAnalyzers()

      • reupCache

        private void reupCache​(java.util.HashSet<java.lang.String> affectedContracts)

      • reup

        private void reup​(java.util.List<SystemDescriptor<?>> thingsAdded,
                  boolean instanceListenersModified,
                  boolean injectionResolversModified,
                  boolean errorHandlersModified,
                  boolean classAnalyzersModified,
                  boolean dynamicConfigurationListenersModified,
                  java.util.HashSet<java.lang.String> affectedContracts,
                  boolean interceptionServicesModified)

      • getAllChildren

        private void getAllChildren​(java.util.LinkedList<ServiceLocatorImpl> allMyChildren)

      • callAllConfigurationListeners

        private void callAllConfigurationListeners​(java.util.List<ServiceHandle<?>> allListeners)

      • isInjectAnnotation

        boolean isInjectAnnotation​(java.lang.annotation.Annotation annotation)

      • isInjectAnnotation

        boolean isInjectAnnotation​(java.lang.annotation.Annotation annotation,
                           boolean isConstructor)

      • getInjectionResolver

        InjectionResolver<?> getInjectionResolver​(java.lang.Class<? extends java.lang.annotation.Annotation> annoType)

      • _resolveContext

        private Context<?> _resolveContext​(java.lang.Class<? extends java.lang.annotation.Annotation> scope)
                            throws java.lang.IllegalStateException
        Throws:
        java.lang.IllegalStateException

      • resolveContext

        Context<?> resolveContext​(java.lang.Class<? extends java.lang.annotation.Annotation> scope)
                   throws java.lang.IllegalStateException
        Throws:
        java.lang.IllegalStateException

      • loadClass

        private java.lang.Class<?> loadClass​(Descriptor descriptor,
                                     Injectee injectee)

      • getLocatorId

        public long getLocatorId()
        Description copied from interface: ServiceLocator
        This returns the unique locator ID for this locator. The locator ID will be assigned at the time of creation and must be a monotonacally increasing number (starting at zero)
        Specified by:
        getLocatorId in interface ServiceLocator
        Returns:
        The identifier for this service locator

      • getNextServiceId

        long getNextServiceId()

      • checkState

        private void checkState()

      • getAllValidators

        private java.util.LinkedHashSet<ValidationService> getAllValidators()

      • getDefaultClassAnalyzerName

        public java.lang.String getDefaultClassAnalyzerName()
        Description copied from interface: ServiceLocator
        Gets the name of the default class analyzer service
        Specified by:
        getDefaultClassAnalyzerName in interface ServiceLocator
        Returns:
        The name of the default class analyzer. Will not return null

      • setDefaultClassAnalyzerName

        public void setDefaultClassAnalyzerName​(java.lang.String defaultClassAnalyzer)
        Description copied from interface: ServiceLocator
        Sets the name of the default class analyzer that should be used for all Descriptors that return null as their class analyzer. If null is given then the default class analyzer name of ClassAnalyzer.DEFAULT_IMPLEMENTATION_NAME will be used
        Specified by:
        setDefaultClassAnalyzerName in interface ServiceLocator
        Parameters:
        defaultClassAnalyzer - The possibly null name of the default class analyzer (the class analyzer that will be used if a descriptor has not explicitly set the name of its class analyzer)

      • setDefaultUnqualified

        public void setDefaultUnqualified​(Unqualified unqualified)
        Description copied from interface: ServiceLocator
        This sets the default Unqualified annotation that will be put on all injection points that do not have any qualifiers. This Unqualified will not be returned by the Injectee.getUnqualified() method as it is considered to be the systems default Unqualified annotation. If an injection point has its own Unqualified annotation returned from Injectee.getUnqualified() then that one takes precedence over this one. Further any injection point that is a IterableProvider will not have the default unqualified applied to it

        This method may be called at any time, but will only affect lookups and injections that have not yet occurred

        Specified by:
        setDefaultUnqualified in interface ServiceLocator
        Parameters:
        unqualified - The Unqualified annotation that will be (virtually) put on injection points that have no qualifiers and no other Unqualified annotation. If null then this ServiceLocator has no default Unqualified annotation to be applied
        See Also:
        UnqualifiedImpl

      • getParent

        public ServiceLocator getParent()
        Description copied from interface: ServiceLocator
        Gets the parent service locator for this locator
        Specified by:
        getParent in interface ServiceLocator
        Returns:
        The parent service locator for this locator, or null if this service locator does not have a parent

      • getNeutralContextClassLoader

        public boolean getNeutralContextClassLoader()
        Description copied from interface: ServiceLocator
        This returns the value of neutralContextClassLoader. If this value is true then HK2 will ensure that the context class loader on the thread is maintained whenever hk2 calls into user code. If this value is false then the value of the context class loader on the thread may be changed by the code hk2 is calling.

        When set to false this value is used to increase performance since getting and setting the context class loader can be expensive. However, if the user code being called by hk2 may change the context class loader of the thread, this value should be true to ensure that tricky and hard to find bugs don't arise when this thread is used for other purposes later on

        All new ServiceLocator implementation have this value initially set to true

        Specified by:
        getNeutralContextClassLoader in interface ServiceLocator
        Returns:
        If true hk2 will ensure that the context class loader cannot be changed by user code. If false hk2 will not modify the context class loader of the thread when user code has finished

      • setNeutralContextClassLoader

        public void setNeutralContextClassLoader​(boolean neutralContextClassLoader)
        Description copied from interface: ServiceLocator
        This sets the value of neutralContextClassLoader. If this value is true then HK2 will ensure that the context class loader on the thread is maintained whenever hk2 calls into user code. If this value is false then the value of the context class loader on the thread may be changed by the code hk2 is calling.

        When set to false this value is used to increase performance since getting and setting the context class loader can be expensive. However, if the user code being called by hk2 may change the context class loader of the thread, this value should be true to ensure that tricky and hard to find bugs don't arise when this thread is used for other purposes later on

        All new ServiceLocator implementation have this value initially set to true

        Specified by:
        setNeutralContextClassLoader in interface ServiceLocator
        Parameters:
        neutralContextClassLoader - true if hk2 should ensure context class loader neutrality, false if hk2 should not change the context class loader on the thread around user code calls

      • getMe

        private ServiceLocatorImpl getMe()
        Used to get the ServiceLocatorImpl in inner classes
        Returns:
        This current object

      • hasInjectAnnotation

        boolean hasInjectAnnotation​(java.lang.reflect.AnnotatedElement annotated)

      • getErrorHandlers

        java.util.LinkedList<ErrorService> getErrorHandlers()

      • getNumberOfDescriptors

        int getNumberOfDescriptors()

      • getNumberOfChildren

        int getNumberOfChildren()

      • getServiceCacheSize

        int getServiceCacheSize()

      • getServiceCacheMaximumSize

        int getServiceCacheMaximumSize()

      • clearServiceCache

        void clearServiceCache()

      • getReflectionCacheSize

        int getReflectionCacheSize()

      • clearReflectionCache

        void clearReflectionCache()

      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object