Package jakarta.enterprise.inject.spi

Interface BeanManager

    • Method Detail

      • getReference

        Object getReference​(Bean<?> bean,
                    Type beanType,
                    CreationalContext<?> ctx)

        Obtains a contextual reference for a certain bean and a certain bean type of the bean.

        Parameters:
        bean - the Bean object representing the bean
        beanType - a bean type that must be implemented by any client proxy that is returned
        ctx - a CreationalContext that may be used to destroy any object with scope Dependent that is created
        Returns:
        a contextual reference representing the bean
        Throws:
        IllegalArgumentException - if the given type is not a bean type of the given bean
        IllegalStateException - if called during application initialization, before the AfterDeploymentValidation event is fired.

      • getBeans

        Set<Bean<?>> getBeans​(Type beanType,
                      Annotation... qualifiers)
        Return the set of beans which have the given required type and qualifiers and are available for injection in the module or library containing the class into which the BeanManager was injected or the Java EE component from whose JNDI environment namespace the BeanManager was obtained, according to the rules of typesafe resolution. If no qualifiers are given, the default qualifier is assumed. Note that when called during invocation of an AfterBeanDiscovery event observer, this method will only return beans discovered by the container before the AfterBeanDiscovery event is fired.
        Parameters:
        beanType - the required bean type
        qualifiers - the required qualifiers
        Returns:
        the resulting set of beans
        Throws:
        IllegalArgumentException - if the given type represents a type variable
        IllegalArgumentException - if two instances of the same non repeating qualifier type are given
        IllegalArgumentException - if an instance of an annotation that is not a qualifier type is given
        IllegalStateException - if called during application initialization, before the AfterBeanDiscovery event is fired.

      • getBeans

        Set<Bean<?>> getBeans​(String name)
        Return the set of beans which have the given EL name and are available for injection in the module or library containing the class into which the BeanManager was injected or the Java EE component from whose JNDI environment namespace the BeanManager was obtained, according to the rules of EL name resolution. Note that when called during invocation of an AfterBeanDiscovery event observer, this method will only return beans discovered by the container before the AfterBeanDiscovery event is fired.
        Parameters:
        name - the EL name
        Returns:
        the resulting set of beans
        Throws:
        IllegalStateException - if called during application initialization, before the AfterBeanDiscovery event is fired.

      • resolve

        <X> Bean<? extends X> resolve​(Set<Bean<? extends X>> beans)
        Apply the ambiguous dependency resolution rules to a set of beans. Note that when called during invocation of an AfterBeanDiscovery event observer, this method will only return beans discovered by the container before the AfterBeanDiscovery event is fired.
        Type Parameters:
        X - a common type of the beans
        Parameters:
        beans - a set of beans of the given type
        Returns:
        the resolved bean, or null if null or an empty set is passed
        Throws:
        AmbiguousResolutionException - if the ambiguous dependency resolution rules fail
        IllegalStateException - if called during application initialization, before the AfterBeanDiscovery event is fired.

      • fireEvent

        void fireEvent​(Object event,
               Annotation... qualifiers)
        Fire an event and notify observers.

        This method is deprecated from CDI 2.0 and getEvent() should be used instead.

        Parameters:
        event - the event object
        qualifiers - the event qualifiers
        Throws:
        IllegalArgumentException - if the runtime type of the event object contains a type variable
        IllegalArgumentException - if two instances of the same non repeating qualifier type are given
        IllegalArgumentException - if an instance of an annotation that is not a qualifier type is given
        IllegalArgumentException - if the runtime type of the event object is assignable to the type of a container lifecycle event
        ObserverException - if a notified observer throws a checked exception, it will be wrapped and rethrown as an (unchecked) ObserverException

      • resolveDecorators

        List<Decorator<?>> resolveDecorators​(Set<Type> types,
                                     Annotation... qualifiers)
        Return an ordered list of decorators for a set of bean types and a set of qualifiers and which are enabled in the module or library containing the class into which the BeanManager was injected or the Java EE component from whose JNDI environment namespace the BeanManager was obtained. Note that when called during invocation of an AfterBeanDiscovery event observer, this method will only return decorators discovered by the container before the AfterBeanDiscovery event is fired.
        Parameters:
        types - the set of bean types of the decorated bean
        qualifiers - the qualifiers declared by the decorated bean
        Returns:
        the resulting set of decorators
        Throws:
        IllegalArgumentException - if the set of bean types is empty
        IllegalArgumentException - if an annotation which is not a binding type is passed
        IllegalArgumentException - if two instances of the same binding type are passed
        IllegalStateException - if called during application initialization, before the AfterBeanDiscovery event is fired.

      • resolveInterceptors

        List<Interceptor<?>> resolveInterceptors​(InterceptionType type,
                                         Annotation... interceptorBindings)
        Return an ordered list of enabled interceptors for a set of interceptor bindings and a type of interception and which are enabled in the module or library containing the class into which the BeanManager was injected or the Java EE component from whose JNDI environment namespace the BeanManager was obtained. Note that when called during invocation of an AfterBeanDiscovery event observer, this method will only return interceptors discovered by the container before the AfterBeanDiscovery event is fired.
        Parameters:
        type - the type of the interception
        interceptorBindings - the interceptor bindings
        Returns:
        the resulting set of interceptors
        Throws:
        IllegalArgumentException - if no interceptor binding type is given
        IllegalArgumentException - if two instances of the same interceptor binding type are given
        IllegalArgumentException - if an instance of an annotation that is not an interceptor binding type is given
        IllegalStateException - if called during application initialization, before the AfterBeanDiscovery event is fired.

      • isScope

        boolean isScope​(Class<? extends Annotation> annotationType)
        Test the given annotation type to determine if it is a scope type.
        Parameters:
        annotationType - the annotation type
        Returns:
        true if the annotation type is a scope type

      • isNormalScope

        boolean isNormalScope​(Class<? extends Annotation> annotationType)
        Test the given annotation type to determine if it is a normal scope type.
        Parameters:
        annotationType - the annotation type
        Returns:
        true if the annotation type is a normal scope type

      • isPassivatingScope

        boolean isPassivatingScope​(Class<? extends Annotation> annotationType)
        Test the given annotation type to determine if it is a passivating scope type.
        Parameters:
        annotationType - the annotation type
        Returns:
        true if the annotation type is a passivating scope type

      • isQualifier

        boolean isQualifier​(Class<? extends Annotation> annotationType)
        Test the given annotation type to determine if it is a qualifier type.
        Parameters:
        annotationType - the annotation type
        Returns:
        true if the annotation type is a qualifier type

      • isInterceptorBinding

        boolean isInterceptorBinding​(Class<? extends Annotation> annotationType)
        Test the given annotation type to determine if it is an interceptor binding type .
        Parameters:
        annotationType - the annotation to test
        Returns:
        true if the annotation type is a interceptor binding type

      • isStereotype

        boolean isStereotype​(Class<? extends Annotation> annotationType)
        Test the given annotation type to determine if it is a stereotype.
        Parameters:
        annotationType - the annotation type
        Returns:
        true if the annotation type is a stereotype

      • getInterceptorBindingDefinition

        Set<Annotation> getInterceptorBindingDefinition​(Class<? extends Annotation> bindingType)
        Obtains the set of meta-annotations for a certain interceptor binding type .
        Parameters:
        bindingType - the interceptor binding type
        Returns:
        the set of meta-annotations

      • areQualifiersEquivalent

        boolean areQualifiersEquivalent​(Annotation qualifier1,
                                Annotation qualifier2)
        Determine if two qualifiers are considered equivalent for the purposes of typesafe resolution, taking into account any members annotated with Nonbinding.
        Parameters:
        qualifier1 - a qualifier to check
        qualifier2 - a qualifier to check
        Returns:
        true if the two qualifiers are equivalent, otherwise false
        Since:
        1.1

      • areInterceptorBindingsEquivalent

        boolean areInterceptorBindingsEquivalent​(Annotation interceptorBinding1,
                                         Annotation interceptorBinding2)
        Determine if two interceptor bindings are considered equivalent for the purposes of typesafe resolution, taking into account any members annotated with Nonbinding.
        Parameters:
        interceptorBinding1 - an interceptor binding to check
        interceptorBinding2 - an interceptor binding to check
        Returns:
        true if the two interceptor bindings are equivalent, otherwise false
        Since:
        1.1

      • getQualifierHashCode

        int getQualifierHashCode​(Annotation qualifier)
        Determine the hash code of a qualifier, using the JDK algorithm for determining an annotation hash code, ignoring any members annotated with Nonbinding.
        Parameters:
        qualifier - the qualifier to consider
        Returns:
        the hashCode for the qualifier
        Since:
        1.1

      • getInterceptorBindingHashCode

        int getInterceptorBindingHashCode​(Annotation interceptorBinding)
        Determine the hash code of an interceptor binding, using the JDK algorithm for determining an annotation hash code, ignoring any members annotated with Nonbinding.
        Parameters:
        interceptorBinding - the interceptor binding to consider
        Returns:
        the hashCode for the interceptor binding
        Since:
        1.1

      • getELResolver

        jakarta.el.ELResolver getELResolver()
        Returns a ELResolver that resolves beans by EL name.
        Returns:
        the ELResolver

      • wrapExpressionFactory

        jakarta.el.ExpressionFactory wrapExpressionFactory​(jakarta.el.ExpressionFactory expressionFactory)
        Returns a wrapper ExpressionFactory that delegates MethodExpression and ValueExpression creation to the given ExpressionFactory. When a Unified EL expression is evaluated using a MethodExpression or ValueExpression returned by the wrapper ExpressionFactory, the container handles destruction of objects with scope Dependent.
        Parameters:
        expressionFactory - the ExpressionFactory to wrap
        Returns:
        the wrapped ExpressionFactory

      • createAnnotatedType

        <T> AnnotatedType<T> createAnnotatedType​(Class<T> type)
        Obtain an AnnotatedType that may be used to read the annotations of the given class or interface.
        Type Parameters:
        T - the class or interface
        Parameters:
        type - the Class object
        Returns:
        the AnnotatedType

      • getInjectionTargetFactory

        <T> InjectionTargetFactory<T> getInjectionTargetFactory​(AnnotatedType<T> annotatedType)

        An implementation of InjectionTargetFactory that provides container created InjectionTarget instances.

        This factory can be wrapped to add behavior to container created injection targets.

        Type Parameters:
        T - the type
        Parameters:
        annotatedType - the annotated type to create the injection target factory for
        Returns:
        an InjectionTargetFactory
        Since:
        1.1

      • getProducerFactory

        <X> ProducerFactory<X> getProducerFactory​(AnnotatedField<? super X> field,
                                          Bean<X> declaringBean)

        An implementation of ProducerFactory that provides container created Producer instances for the given field.

        This factory can be wrapped to add behavior to container created producers.

        Type Parameters:
        X - the declaring type
        Parameters:
        field - the field to create the producer factory for
        declaringBean - the bean declaring the producer. May be null if the producer is static or the declaring object is non-contextual
        Returns:
        the producer factory for the field
        Since:
        1.1

      • getProducerFactory

        <X> ProducerFactory<X> getProducerFactory​(AnnotatedMethod<? super X> method,
                                          Bean<X> declaringBean)

        An implementation of ProducerFactory that provides container created Producer instances for the given method.

        This factory can be wrapped to add behavior to container created producers.

        Type Parameters:
        X - bean type
        Parameters:
        method - the method to create the producer factory for
        declaringBean - the bean declaring the producer. May be null if the producer is static or the declaring object is non-contextual
        Returns:
        the producer factory for the method
        Since:
        1.1

      • createBeanAttributes

        <T> BeanAttributes<T> createBeanAttributes​(AnnotatedType<T> type)
        Obtains a BeanAttributes for the given AnnotatedType. The container ignores the annotations and types declared by the elements of the actual Java class and uses the metadata provided via the Annotated interface instead.
        Type Parameters:
        T - the type
        Parameters:
        type - the AnnotatedType
        Returns:
        a container provided implementation of InjectionTarget
        Since:
        1.1

      • getExtension

        <T extends Extension> T getExtension​(Class<T> extensionClass)
        Obtains the container's instance of an Extension class declared in META-INF/services.
        Type Parameters:
        T - the type of the extension
        Parameters:
        extensionClass - the type of the extension class
        Returns:
        the extension instance
        Throws:
        IllegalArgumentException - if the container has no instance of the given class
        Since:
        1.1

      • getEvent

        Event<Object> getEvent()
        Returns an instance of Event with specified type java.lang.Object and specified qualifier @Default It allows typesafe synchronous or asynchronous event firing without injection of Event built-in bean requirement.
        Returns:
        a new Event object whose event type is Object and qualifier @Default
        Since:
        2.0

      • createInstance

        Instance<Object> createInstance()
        Obtains an Instance object to access to beans instances. The returned Instance object can only access instances of beans that are available for injection in the module or library containing the class into which the BeanManager was injected or the Java EE component from whose JNDI environment namespace the BeanManager was obtained, according to the rules of typesafe resolution. Note that when called during invocation of an AfterBeanDiscovery event observer, the Instance returned by this method will only give access to instances of beans discovered by the container before the AfterBeanDiscovery event is fired. Instances of dependent scoped beans obtained with this Instance must be explicitly destroyed by calling Instance.destroy(Object) If no qualifier is passed to Instance.select(java.lang.annotation.Annotation...) method, the @Default qualifier is assumed.
        Returns:
        an Instance object to request beans instances
        Throws:
        IllegalStateException - if called during application initialization, before the AfterDeploymentValidation event is fired.
        Since:
        2.0