BeanManager

```
public interface BeanManager
```
Allows a portable extension to interact directly with the container. Provides operations for obtaining contextual references for beans, along with many other operations of use to portable extensions.

Any bean may obtain an instance of BeanManager by injecting it:
```
 @Inject
 BeanManager manager;
 
```
Jakarta EE components may obtain an instance of BeanManager from JNDI by looking up the name java:comp/BeanManager.

Most operations of BeanManager may be called at any time during the execution of the application.

However, the following operations must not be called before the AfterBeanDiscovery event is fired:
and the following operations must not be called before the AfterDeploymentValidation event is fired:
- getReference(Bean, java.lang.reflect.Type, javax.enterprise.context.spi.CreationalContext),
- getInjectableReference(InjectionPoint, javax.enterprise.context.spi.CreationalContext),
or the container will throw an Exception.
Examples (en):

schedule-events

Examples (pt):

schedule-events

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`boolean`	`areInterceptorBindingsEquivalent(java.lang.annotation.Annotation interceptorBinding1, java.lang.annotation.Annotation interceptorBinding2)` Determine if two interceptor bindings are considered equivalent for the purposes of typesafe resolution, taking into account any members annotated with `Nonbinding`.
`boolean`	`areQualifiersEquivalent(java.lang.annotation.Annotation qualifier1, java.lang.annotation.Annotation qualifier2)` Determine if two qualifiers are considered equivalent for the purposes of typesafe resolution, taking into account any members annotated with `Nonbinding`.
`<T> AnnotatedType<T>`	`createAnnotatedType(java.lang.Class<T> type)` Obtain an `AnnotatedType` that may be used to read the annotations of the given class or interface.
`<T> Bean<T>`	`createBean(BeanAttributes<T> attributes, java.lang.Class<T> beanClass, InjectionTargetFactory<T> injectionTargetFactory)` Obtains a `Bean` for the given `BeanAttributes`, bean class and `InjectionTarget`.
`<T,X> Bean<T>`	`createBean(BeanAttributes<T> attributes, java.lang.Class<X> beanClass, ProducerFactory<X> producerFactory)` Obtains a `Bean` for the given `BeanAttributes`, bean class and `Producer`.
`BeanAttributes<?>`	`createBeanAttributes(AnnotatedMember<?> type)` Obtains a `BeanAttributes` for the given `AnnotatedType`.
`<T> BeanAttributes<T>`	`createBeanAttributes(AnnotatedType<T> type)` Obtains a `BeanAttributes` for the given `AnnotatedType`.
`<T> CreationalContext<T>`	`createCreationalContext(Contextual<T> contextual)` Obtain an instance of a `CreationalContext` for the given contextual type, or for a non-contextual object.
`InjectionPoint`	`createInjectionPoint(AnnotatedField<?> field)` Obtains a container provided implementation of `InjectionPoint` for the given `AnnotatedField`.
`InjectionPoint`	`createInjectionPoint(AnnotatedParameter<?> parameter)` Obtains a container provided implementation of `InjectionPoint` for the given `AnnotatedParameter`.
`<T> InjectionTarget<T>`	`createInjectionTarget(AnnotatedType<T> type)` Obtains an `InjectionTarget` for the given `AnnotatedType`.
`Instance<java.lang.Object>`	`createInstance()` Obtains an `Instance` object to access to beans instances.
`<T> InterceptionFactory<T>`	`createInterceptionFactory(CreationalContext<T> ctx, java.lang.Class<T> clazz)` Create an `InterceptionFactory` for the given `CreationalContext` and type.
`void`	`fireEvent(java.lang.Object event, java.lang.annotation.Annotation... qualifiers)` Fire an event and notify observers.
`java.util.Set<Bean<?>>`	`getBeans(java.lang.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 Jakarta EE component from whose JNDI environment namespace the `BeanManager` was obtained, according to the rules of EL name resolution.
`java.util.Set<Bean<?>>`	`getBeans(java.lang.reflect.Type beanType, java.lang.annotation.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 Jakarta EE component from whose JNDI environment namespace the `BeanManager` was obtained, according to the rules of typesafe resolution.
`Context`	`getContext(java.lang.Class<? extends java.lang.annotation.Annotation> scopeType)` Obtains an active context object for the given scope .
`ELResolver`	`getELResolver()` Returns a `ELResolver` that resolves beans by EL name.
`Event<java.lang.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.
`<T extends Extension> T`	`getExtension(java.lang.Class<T> extensionClass)` Obtains the container's instance of an Extension class declared in `META-INF/services`.
`java.lang.Object`	`getInjectableReference(InjectionPoint ij, CreationalContext<?> ctx)` Obtains an injectable reference for a certain injection point.
`<T> InjectionTargetFactory<T>`	`getInjectionTargetFactory(AnnotatedType<T> annotatedType)` An implementation of `InjectionTargetFactory` that provides container created `InjectionTarget` instances.
`java.util.Set<java.lang.annotation.Annotation>`	`getInterceptorBindingDefinition(java.lang.Class<? extends java.lang.annotation.Annotation> bindingType)` Obtains the set of meta-annotations for a certain interceptor binding type .
`int`	`getInterceptorBindingHashCode(java.lang.annotation.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`.
`Bean<?>`	`getPassivationCapableBean(java.lang.String id)` Returns the `PassivationCapable` bean with the given identifier.
`<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.
`<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.
`int`	`getQualifierHashCode(java.lang.annotation.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`.
`java.lang.Object`	`getReference(Bean<?> bean, java.lang.reflect.Type beanType, CreationalContext<?> ctx)` Obtains a contextual reference for a certain bean and a certain bean type of the bean.
`java.util.Set<java.lang.annotation.Annotation>`	`getStereotypeDefinition(java.lang.Class<? extends java.lang.annotation.Annotation> stereotype)` Obtains meta-annotations for a certain stereotype.
`boolean`	`isInterceptorBinding(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)` Test the given annotation type to determine if it is an interceptor binding type .
`boolean`	`isNormalScope(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)` Test the given annotation type to determine if it is a normal scope type.
`boolean`	`isPassivatingScope(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)` Test the given annotation type to determine if it is a passivating scope type.
`boolean`	`isQualifier(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)` Test the given annotation type to determine if it is a qualifier type.
`boolean`	`isScope(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)` Test the given annotation type to determine if it is a scope type.
`boolean`	`isStereotype(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)` Test the given annotation type to determine if it is a stereotype.
`<X> Bean<? extends X>`	`resolve(java.util.Set<Bean<? extends X>> beans)` Apply the ambiguous dependency resolution rules to a set of beans.
`java.util.List<Decorator<?>>`	`resolveDecorators(java.util.Set<java.lang.reflect.Type> types, java.lang.annotation.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 Jakarta EE component from whose JNDI environment namespace the `BeanManager` was obtained.
`java.util.List<Interceptor<?>>`	`resolveInterceptors(InterceptionType type, java.lang.annotation.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 Jakarta EE component from whose JNDI environment namespace the `BeanManager` was obtained.
`<T> java.util.Set<ObserverMethod<? super T>>`	`resolveObserverMethods(T event, java.lang.annotation.Annotation... qualifiers)` Return an ordered set of observer methods for an event.
`void`	`validate(InjectionPoint injectionPoint)` Validate a certain injection point.
`ExpressionFactory`	`wrapExpressionFactory(ExpressionFactory expressionFactory)` Returns a wrapper `ExpressionFactory` that delegates `MethodExpression` and `ValueExpression` creation to the given `ExpressionFactory`.

- Method Detail
  - getReference
```
java.lang.Object getReference(Bean<?> bean,
                              java.lang.reflect.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:
    
    java.lang.IllegalArgumentException - if the given type is not a bean type of the given bean
    
    java.lang.IllegalStateException - if called during application initialization, before the AfterDeploymentValidation event is fired.
  - getInjectableReference
```
java.lang.Object getInjectableReference(InjectionPoint ij,
                                        CreationalContext<?> ctx)
```
    Obtains an injectable reference for a certain injection point.
    
    Parameters:
    
    ij - the target injection point
    
    ctx - a CreationalContext that may be used to destroy any object with scope Dependent that is created
    
    Returns:
    
    the injectable reference
    
    Throws:
    
    UnsatisfiedResolutionException - if typesafe resolution results in an unsatisfied dependency
    
    AmbiguousResolutionException - typesafe resolution results in an unresolvable ambiguous dependency
    
    java.lang.IllegalStateException - if called during application initialization, before the AfterDeploymentValidation event is fired.
  - createCreationalContext
```
<T> CreationalContext<T> createCreationalContext(Contextual<T> contextual)
```
    Obtain an instance of a CreationalContext for the given contextual type, or for a non-contextual object.
    
    Parameters:
    
    contextual - the Contextual, or a null value in the case of a non-contextual object
    
    Returns:
    
    the new CreationalContext
  - getBeans
```
java.util.Set<Bean<?>> getBeans(java.lang.reflect.Type beanType,
                                java.lang.annotation.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 Jakarta 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:
    
    java.lang.IllegalArgumentException - if the given type represents a type variable
    
    java.lang.IllegalArgumentException - if two instances of the same non repeating qualifier type are given
    
    java.lang.IllegalArgumentException - if an instance of an annotation that is not a qualifier type is given
    
    java.lang.IllegalStateException - if called during application initialization, before the AfterBeanDiscovery event is fired.
  - getBeans
```
java.util.Set<Bean<?>> getBeans(java.lang.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 Jakarta 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:
    
    java.lang.IllegalStateException - if called during application initialization, before the AfterBeanDiscovery event is fired.
  - getPassivationCapableBean
```
Bean<?> getPassivationCapableBean(java.lang.String id)
```
    Returns the PassivationCapable bean with the given identifier.
    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:
    
    id - the identifier
    
    Returns:
    
    a Bean that implements PassivationCapable and has the given identifier, or a null value if there is no such bean
    
    Throws:
    
    java.lang.IllegalStateException - if called during application initialization, before the AfterBeanDiscovery event is fired.
  - resolve
```
<X> Bean<? extends X> resolve(java.util.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
    
    java.lang.IllegalStateException - if called during application initialization, before the AfterBeanDiscovery event is fired.
  - validate
```
void validate(InjectionPoint injectionPoint)
```
    Validate a certain injection point.
    Note that when called during invocation of an AfterBeanDiscovery event observer, this method will only validate injection points discovered by the container before the AfterBeanDiscovery event is fired.
    
    Parameters:
    
    injectionPoint - the injection point to validate
    
    Throws:
    
    InjectionException - if there is a deployment problem (for example, an unsatisfied or unresolvable ambiguous dependency) associated with the injection point
    
    java.lang.IllegalStateException - if called during application initialization, before the AfterBeanDiscovery event is fired.
  - fireEvent
```
void fireEvent(java.lang.Object event,
               java.lang.annotation.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:
    
    java.lang.IllegalArgumentException - if the runtime type of the event object contains a type variable
    
    java.lang.IllegalArgumentException - if two instances of the same non repeating qualifier type are given
    
    java.lang.IllegalArgumentException - if an instance of an annotation that is not a qualifier type is given
    
    java.lang.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
  - resolveObserverMethods
```
<T> java.util.Set<ObserverMethod<? super T>> resolveObserverMethods(T event,
                                                                    java.lang.annotation.Annotation... qualifiers)
```
    Return an ordered set of observer methods for an event.
    Note that when called during invocation of an AfterBeanDiscovery event observer, this method will only return observers discovered by the container before the AfterBeanDiscovery event is fired.
    
    Type Parameters:
    
    T - the type of the event
    
    Parameters:
    
    event - the event object
    
    qualifiers - the event qualifiers
    
    Returns:
    
    the resulting set of observer methods
    
    Throws:
    
    java.lang.IllegalArgumentException - if the runtime type of the event object contains a type variable
    
    java.lang.IllegalArgumentException - if two instances of the same non repeating qualifier type are given
    
    java.lang.IllegalArgumentException - if an instance of an annotation that is not a qualifier type is given
    
    java.lang.IllegalStateException - if called during application initialization, before the AfterBeanDiscovery event is fired.
  - resolveDecorators
```
java.util.List<Decorator<?>> resolveDecorators(java.util.Set<java.lang.reflect.Type> types,
                                               java.lang.annotation.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 Jakarta 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:
    
    java.lang.IllegalArgumentException - if the set of bean types is empty
    
    java.lang.IllegalArgumentException - if an annotation which is not a binding type is passed
    
    java.lang.IllegalArgumentException - if two instances of the same binding type are passed
    
    java.lang.IllegalStateException - if called during application initialization, before the AfterBeanDiscovery event is fired.
  - resolveInterceptors
```
java.util.List<Interceptor<?>> resolveInterceptors(InterceptionType type,
                                                   java.lang.annotation.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 Jakarta 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:
    
    java.lang.IllegalArgumentException - if no interceptor binding type is given
    
    java.lang.IllegalArgumentException - if two instances of the same interceptor binding type are given
    
    java.lang.IllegalArgumentException - if an instance of an annotation that is not an interceptor binding type is given
    
    java.lang.IllegalStateException - if called during application initialization, before the AfterBeanDiscovery event is fired.
  - isScope
```
boolean isScope(java.lang.Class<? extends java.lang.annotation.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(java.lang.Class<? extends java.lang.annotation.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(java.lang.Class<? extends java.lang.annotation.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(java.lang.Class<? extends java.lang.annotation.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(java.lang.Class<? extends java.lang.annotation.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(java.lang.Class<? extends java.lang.annotation.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
```
java.util.Set<java.lang.annotation.Annotation> getInterceptorBindingDefinition(java.lang.Class<? extends java.lang.annotation.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
  - getStereotypeDefinition
```
java.util.Set<java.lang.annotation.Annotation> getStereotypeDefinition(java.lang.Class<? extends java.lang.annotation.Annotation> stereotype)
```
    Obtains meta-annotations for a certain stereotype.
    
    Parameters:
    
    stereotype - the stereotype
    
    Returns:
    
    the set of meta-annotations
  - areQualifiersEquivalent
```
boolean areQualifiersEquivalent(java.lang.annotation.Annotation qualifier1,
                                java.lang.annotation.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(java.lang.annotation.Annotation interceptorBinding1,
                                         java.lang.annotation.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(java.lang.annotation.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(java.lang.annotation.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
  - getContext
```
Context getContext(java.lang.Class<? extends java.lang.annotation.Annotation> scopeType)
```
    Obtains an active context object for the given scope .
    
    Parameters:
    
    scopeType - the scope
    
    Returns:
    
    the context object
    
    Throws:
    
    ContextNotActiveException - if there is no active context object for the given scope
    
    java.lang.IllegalArgumentException - if there is more than one active context object for the given scope
  - getELResolver
```
ELResolver getELResolver()
```
    Returns a ELResolver that resolves beans by EL name.
    
    Returns:
    
    the ELResolver
  - wrapExpressionFactory
```
ExpressionFactory wrapExpressionFactory(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(java.lang.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
  - createInjectionTarget
```
<T> InjectionTarget<T> createInjectionTarget(AnnotatedType<T> type)
```
    Obtains an InjectionTarget 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.
    
    This method is deprecated from CDI 1.1 and getInjectionTargetFactory(AnnotatedType) should be used instead.
    
    Type Parameters:
    
    T - the type
    
    Parameters:
    
    type - the AnnotatedType
    
    Returns:
    
    a container provided implementation of InjectionTarget
    
    Throws:
    
    java.lang.IllegalArgumentException - if there is a definition error associated with any injection point of the type
  - 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.
    
    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.
    
    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.
    
    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
  - createBeanAttributes
```
BeanAttributes<?> createBeanAttributes(AnnotatedMember<?> 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.
    
    Parameters:
    
    type - the AnnotatedType
    
    Returns:
    
    a container provided implementation of InjectionTarget
    
    Since:
    
    1.1
  - createBean
```
<T> Bean<T> createBean(BeanAttributes<T> attributes,
                       java.lang.Class<T> beanClass,
                       InjectionTargetFactory<T> injectionTargetFactory)
```
    Obtains a Bean for the given BeanAttributes, bean class and InjectionTarget.
    
    The InjectionTarget creates and destroys instances of the bean, performs dependency injection and lifecycle callbacks, and determines the return value of Bean.getInjectionPoints(). The InjectionTarget is obtained from the InjectionTargetFactory. getInjectionTargetFactory(AnnotatedType) allows use of a container created InjectionTarget.
    
    Type Parameters:
    
    T - the type
    
    Parameters:
    
    attributes - a BeanAttributes which determines the bean types, qualifiers, scope, name and stereotypes of the returned Bean, and the return values of BeanAttributes.isAlternative() and Bean.isNullable()
    
    beanClass - a class, which determines the return value of Bean.getBeanClass()
    
    injectionTargetFactory - an InjectionTargetFactory, used to obtain an InjectionTarget
    
    Returns:
    
    a container provided implementation of Bean
    
    Since:
    
    1.1
  - createBean
```
<T,X> Bean<T> createBean(BeanAttributes<T> attributes,
                         java.lang.Class<X> beanClass,
                         ProducerFactory<X> producerFactory)
```
    Obtains a Bean for the given BeanAttributes, bean class and Producer.
    
    The Producer creates and destroys instances of the decorator, and determines the return value of Bean.getInjectionPoints(). The Producer is obtained from the ProducerFactory. getProducerFactory(AnnotatedMethod, Bean) or getProducerFactory(AnnotatedField, Bean) allows use of a container created Producer.
    
    Type Parameters:
    
    T - the type
    
    X - the type of the declaring bean
    
    Parameters:
    
    attributes - a BeanAttributes which determines the bean types, qualifiers, scope, name and stereotypes of the returned Bean, and the return values of BeanAttributes.isAlternative() and Bean.isNullable()
    
    beanClass - a class, which determines the return value of Bean.getClass()
    
    producerFactory - a ProducerFactory, used to obtain a Producer
    
    Returns:
    
    a container provided implementation of Bean
    
    Since:
    
    1.1
  - createInjectionPoint
```
InjectionPoint createInjectionPoint(AnnotatedField<?> field)
```
    Obtains a container provided implementation of InjectionPoint for the given AnnotatedField.
    
    Parameters:
    
    field - the AnnotatedField defining the injection point
    
    Returns:
    
    the container provided InjectionPoint
    
    Throws:
    
    java.lang.IllegalArgumentException - if there is a definition error associated with the injection point
    
    Since:
    
    1.1
  - createInjectionPoint
```
InjectionPoint createInjectionPoint(AnnotatedParameter<?> parameter)
```
    Obtains a container provided implementation of InjectionPoint for the given AnnotatedParameter.
    
    Parameters:
    
    parameter - the AnnotatedParameter defining the injection point
    
    Returns:
    
    the container provided InjectionPoint
    
    Throws:
    
    java.lang.IllegalArgumentException - if there is a definition error associated with the injection point
    
    Since:
    
    1.1
  - getExtension
```
<T extends Extension> T getExtension(java.lang.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:
    
    java.lang.IllegalArgumentException - if the container has no instance of the given class
    
    Since:
    
    1.1
  - createInterceptionFactory
```
<T> InterceptionFactory<T> createInterceptionFactory(CreationalContext<T> ctx,
                                                     java.lang.Class<T> clazz)
```
    Create an InterceptionFactory for the given CreationalContext and type.
    
    Type Parameters:
    
    T - type of the instance this factory will work on
    
    Parameters:
    
    ctx - CreationalContext for the InterceptionFactory to create
    
    clazz - class of the instance this factory will work on
    
    Returns:
    
    a new InterceptionFactory to add services on on instances of T
    
    Since:
    
    2.0
  - getEvent
```
Event<java.lang.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<java.lang.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 Jakarta 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:
    
    java.lang.IllegalStateException - if called during application initialization, before the AfterDeploymentValidation event is fired.
    
    Since:
    
    2.0

Interface BeanManager

Method Summary

Method Detail

getReference

getInjectableReference

createCreationalContext

getBeans

getBeans

getPassivationCapableBean

resolve

validate

fireEvent

resolveObserverMethods

resolveDecorators

resolveInterceptors

isScope

isNormalScope

isPassivatingScope

isQualifier

isInterceptorBinding

isStereotype

getInterceptorBindingDefinition

getStereotypeDefinition

areQualifiersEquivalent

areInterceptorBindingsEquivalent

getQualifierHashCode

getInterceptorBindingHashCode

getContext

getELResolver

wrapExpressionFactory

createAnnotatedType

createInjectionTarget

getInjectionTargetFactory

getProducerFactory

getProducerFactory

createBeanAttributes

createBeanAttributes

createBean

createBean

createInjectionPoint

createInjectionPoint

getExtension

createInterceptionFactory

getEvent

createInstance