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;
Java EE components may obtain an instance of BeanManager from JNDI by looking up the name
java:comp/BeanManager
.
Any operation of BeanManager may be called at any time during the execution of the application.
-
Method Summary
Modifier and TypeMethodDescriptionboolean
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 withNonbinding
.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 withNonbinding
.<T> AnnotatedType<T>
createAnnotatedType
(Class<T> type) Obtain anAnnotatedType
that may be used to read the annotations of the given class or interface.<T> Bean<T>
createBean
(BeanAttributes<T> attributes, Class<T> beanClass, InjectionTargetFactory<T> injectionTargetFactory) <T,
X> Bean<T> createBean
(BeanAttributes<T> attributes, Class<X> beanClass, ProducerFactory<X> producerFactory) createBeanAttributes
(AnnotatedMember<?> type) Obtains aBeanAttributes
for the givenAnnotatedType
.<T> BeanAttributes<T>
createBeanAttributes
(AnnotatedType<T> type) Obtains aBeanAttributes
for the givenAnnotatedType
.<T> CreationalContext<T>
createCreationalContext
(Contextual<T> contextual) Obtain an instance of aCreationalContext
for the given contextual type, or for a non-contextual object.createInjectionPoint
(AnnotatedField<?> field) Obtains a container provided implementation ofInjectionPoint
for the givenAnnotatedField
.createInjectionPoint
(AnnotatedParameter<?> parameter) Obtains a container provided implementation ofInjectionPoint
for the givenAnnotatedParameter
.<T> InjectionTarget<T>
createInjectionTarget
(AnnotatedType<T> type) Obtains anInjectionTarget
for the givenAnnotatedType
.void
fireEvent
(Object event, Annotation... qualifiers) Fire an event and notify observers.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.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.getContext
(Class<? extends Annotation> scopeType) Obtains an active context object for the given scope .javax.el.ELResolver
Returns aELResolver
that resolves beans by EL name.<T extends Extension>
TgetExtension
(Class<T> extensionClass) Obtains the container's instance of an Extension class declared inMETA-INF/services
.getInjectableReference
(InjectionPoint ij, CreationalContext<?> ctx) Obtains an injectable reference for a certain injection point.<T> InjectionTargetFactory<T>
getInjectionTargetFactory
(AnnotatedType<T> annotatedType) An implementation ofInjectionTargetFactory
that provides container createdInjectionTarget
instances.getInterceptorBindingDefinition
(Class<? extends Annotation> bindingType) Obtains the set of meta-annotations for a certain interceptor binding type .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 withNonbinding
.Bean<?>
Returns thePassivationCapable
bean with the given identifier.<X> ProducerFactory<X>
getProducerFactory
(AnnotatedField<? super X> field, Bean<X> declaringBean) An implementation ofProducerFactory
that provides container createdProducer
instances for the given field.<X> ProducerFactory<X>
getProducerFactory
(AnnotatedMethod<? super X> method, Bean<X> declaringBean) An implementation ofProducerFactory
that provides container createdProducer
instances for the given method.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 withNonbinding
.getReference
(Bean<?> bean, Type beanType, CreationalContext<?> ctx) Obtains a contextual reference for a certain bean and a certain bean type of the bean.getStereotypeDefinition
(Class<? extends Annotation> stereotype) Obtains meta-annotations for a certain stereotype.boolean
isInterceptorBinding
(Class<? extends Annotation> annotationType) Test the given annotation type to determine if it is an interceptor binding type .boolean
isNormalScope
(Class<? extends Annotation> annotationType) Test the given annotation type to determine if it is a normal scope type.boolean
isPassivatingScope
(Class<? extends Annotation> annotationType) Test the given annotation type to determine if it is a passivating scope type.boolean
isQualifier
(Class<? extends Annotation> annotationType) Test the given annotation type to determine if it is a qualifier type.boolean
isScope
(Class<? extends Annotation> annotationType) Test the given annotation type to determine if it is a scope type.boolean
isStereotype
(Class<? extends Annotation> annotationType) Test the given annotation type to determine if it is a stereotype.<X> Bean<? extends X>
Apply the ambiguous dependency resolution rules to a set of beans.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.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.<T> Set<ObserverMethod<? super T>>
resolveObserverMethods
(T event, Annotation... qualifiers) Return the set of observers for an event.void
validate
(InjectionPoint injectionPoint) Validate a certain injection point.javax.el.ExpressionFactory
wrapExpressionFactory
(javax.el.ExpressionFactory expressionFactory) Returns a wrapperExpressionFactory
that delegatesMethodExpression
andValueExpression
creation to the givenExpressionFactory
.
-
Method Details
-
getReference
Obtains a contextual reference for a certain bean and a certain bean type of the bean.
- Parameters:
bean
- theBean
object representing the beanbeanType
- a bean type that must be implemented by any client proxy that is returnedctx
- aCreationalContext
that may be used to destroy any object with scopeDependent
that is created- Returns:
- a contextual reference representing the bean
- Throws:
IllegalArgumentException
- if the given type is not a bean type of the given beanIllegalStateException
- if called during application initialization, before theAfterDeploymentValidation
event is fired The container is permitted to define a non-portable mode in whichgetReference(Bean, Type, CreationalContext)
may be called from an observer of theAfterBeanDiscovery
event.
-
getInjectableReference
Obtains an injectable reference for a certain injection point.
- Parameters:
ij
- the target injection pointctx
- aCreationalContext
that may be used to destroy any object with scopeDependent
that is created- Returns:
- the injectable reference
- Throws:
UnsatisfiedResolutionException
- if typesafe resolution results in an unsatisfied dependencyAmbiguousResolutionException
- typesafe resolution results in an unresolvable ambiguous dependencyIllegalStateException
- if called during application initialization, before theAfterDeploymentValidation
event is fired The container is permitted to define a non-portable mode in whichgetInjectableReference(InjectionPoint, CreationalContext)
may be called from an observer of theAfterBeanDiscovery
event.
-
createCreationalContext
Obtain an instance of aCreationalContext
for the given contextual type, or for a non-contextual object.- Parameters:
contextual
- theContextual
, or a null value in the case of a non-contextual object- Returns:
- the new
CreationalContext
-
getBeans
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.- Parameters:
beanType
- the required bean typequalifiers
- the required qualifiers- Returns:
- the resulting set of beans
- Throws:
IllegalArgumentException
- if the given type represents a type variableIllegalArgumentException
- if two instances of the same qualifier type are givenIllegalArgumentException
- if an instance of an annotation that is not a qualifier type is givenIllegalStateException
- if called during application initialization, before theAfterDeploymentValidation
event is fired The container is permitted to define a non-portable mode in whichgetBeans(Type, Annotation...)
may be called from an observer of theAfterBeanDiscovery
event.
-
getBeans
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.- Parameters:
name
- the EL name- Returns:
- the resulting set of beans
- Throws:
IllegalStateException
- if called during application initialization, before theAfterDeploymentValidation
event is fired The container is permitted to define a non-portable mode in whichgetBeans(String)
may be called from an observer of theAfterBeanDiscovery
event.
-
getPassivationCapableBean
Returns thePassivationCapable
bean with the given identifier.- Parameters:
id
- the identifier- Returns:
- a
Bean
that implementsPassivationCapable
and has the given identifier, or a null value if there is no such bean - Throws:
IllegalStateException
- if called during application initialization, before theAfterDeploymentValidation
event is fired The container is permitted to define a non-portable mode in whichgetPassivationCapableBean(String)
may be called from an observer of theAfterBeanDiscovery
event.
-
resolve
Apply the ambiguous dependency resolution rules to a set of beans.- Type Parameters:
X
- a common type of the beans- Parameters:
beans
- a set of beans of the given type- Throws:
AmbiguousResolutionException
- if the ambiguous dependency resolution rules failIllegalStateException
- if called during application initialization, before theAfterDeploymentValidation
event is fired The container is permitted to define a non-portable mode in whichresolve(Set)
may be called from an observer of theAfterBeanDiscovery
event.
-
validate
Validate a certain injection point.- 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 pointIllegalStateException
- if called during application initialization, before theAfterDeploymentValidation
event is fired The container is permitted to define a non-portable mode in whichvalidate(InjectionPoint)
may be called from an observer of theAfterBeanDiscovery
event.
-
fireEvent
Fire an event and notify observers.- Parameters:
event
- the event objectqualifiers
- the event qualifiers- Throws:
IllegalArgumentException
- if the runtime type of the event object contains a type variableIllegalArgumentException
- if two instances of the same qualifier type are givenIllegalArgumentException
- if an instance of an annotation that is not a qualifier type is givenIllegalArgumentException
- if the runtime type of the event object is assignable to the type of a container lifecycle eventObserverException
- if a notified observer throws a checked exception, it will be wrapped and rethrown as an (unchecked)ObserverException
-
resolveObserverMethods
Return the set of observers for an event.- Type Parameters:
T
- the type of the event- Parameters:
event
- the event objectqualifiers
- the event qualifiers- Throws:
IllegalArgumentException
- if the runtime type of the event object contains a type variableIllegalArgumentException
- if two instances of the same qualifier type are givenIllegalArgumentException
- if an instance of an annotation that is not a qualifier type is givenIllegalStateException
- if called during application initialization, before theAfterDeploymentValidation
event is fired The container is permitted to define a non-portable mode in whichresolveObserverMethods(Object, Annotation...)
may be called from an observer of theAfterBeanDiscovery
event.
-
resolveDecorators
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.- Parameters:
types
- the set of bean types of the decorated beanqualifiers
- the qualifiers declared by the decorated bean- Returns:
- the resulting set of decorators
- Throws:
IllegalArgumentException
- if the set of bean types is emptyIllegalArgumentException
- if an annotation which is not a binding type is passedIllegalArgumentException
- if two instances of the same binding type are passedIllegalStateException
- if called during application initialization, before theAfterDeploymentValidation
event is fired The container is permitted to define a non-portable mode in whichresolveDecorators(Set, Annotation...)
may be called from an observer of theAfterBeanDiscovery
event.
-
resolveInterceptors
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.- Parameters:
type
- the type of the interceptioninterceptorBindings
- the interceptor bindings- Returns:
- the resulting set of interceptors
- Throws:
IllegalArgumentException
- if no interceptor binding type is givenIllegalArgumentException
- if two instances of the same interceptor binding type are givenIllegalArgumentException
- if an instance of an annotation that is not an interceptor binding type is givenIllegalStateException
- if called during application initialization, before theAfterDeploymentValidation
event is fired The container is permitted to define a non-portable mode in whichresolveInterceptors(InterceptionType, Annotation...)
may be called from an observer of theAfterBeanDiscovery
event.
-
isScope
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
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
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
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
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
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
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
Obtains meta-annotations for a certain stereotype.- Parameters:
stereotype
- the stereotype- Returns:
- the set of meta-annotations
-
areQualifiersEquivalent
Determine if two qualifiers are considered equivalent for the purposes of typesafe resolution, taking into account any members annotated withNonbinding
.- Parameters:
a1
- a qualifier to checka2
- 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 withNonbinding
.- Parameters:
a1
- an interceptor binding to checka2
- an interceptor binding to check- Returns:
- true if the two interceptor bindings are equivalent, otherwise false
- Since:
- 1.1
-
getQualifierHashCode
Determine the hash code of a qualifier, using the JDK algorithm for determining an annotation hash code, ignoring any members annotated withNonbinding
.- Parameters:
qualifier
- the qualifier to consider- Returns:
- the hashCode for the qualifier
- Since:
- 1.1
-
getInterceptorBindingHashCode
Determine the hash code of an interceptor binding, using the JDK algorithm for determining an annotation hash code, ignoring any members annotated withNonbinding
.- Parameters:
interceptorBinding
- the interceptor binding to consider- Returns:
- the hashCode for the interceptor binding
- Since:
- 1.1
-
getContext
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 scopeIllegalArgumentException
- if there is more than one active context object for the given scope
-
getELResolver
javax.el.ELResolver getELResolver()Returns aELResolver
that resolves beans by EL name. -
wrapExpressionFactory
javax.el.ExpressionFactory wrapExpressionFactory(javax.el.ExpressionFactory expressionFactory) Returns a wrapperExpressionFactory
that delegatesMethodExpression
andValueExpression
creation to the givenExpressionFactory
. When a Unified EL expression is evaluated using aMethodExpression
orValueExpression
returned by the wrapperExpressionFactory
, the container handles destruction of objects with scopeDependent
.- Parameters:
expressionFactory
- theExpressionFactory
to wrap- Returns:
- the wrapped
ExpressionFactory
-
createAnnotatedType
Obtain anAnnotatedType
that may be used to read the annotations of the given class or interface.- Type Parameters:
T
- the class or interface- Parameters:
type
- theClass
object- Returns:
- the
AnnotatedType
-
createInjectionTarget
Obtains an
InjectionTarget
for the givenAnnotatedType
. The container ignores the annotations and types declared by the elements of the actual Java class and uses the metadata provided via theAnnotated
interface instead.This method is deprecated from CDI 1.1 and
getInjectionTargetFactory(AnnotatedType)
should be used instead.- Type Parameters:
T
- the type- Parameters:
type
- theAnnotatedType
- Throws:
IllegalArgumentException
- if there is a definition error associated with any injection point of the type
-
getInjectionTargetFactory
An implementation of
InjectionTargetFactory
that provides container createdInjectionTarget
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
An implementation of
ProducerFactory
that provides container createdProducer
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 fordeclaringBean
- 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
An implementation of
ProducerFactory
that provides container createdProducer
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 fordeclaringBean
- 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
Obtains aBeanAttributes
for the givenAnnotatedType
. The container ignores the annotations and types declared by the elements of the actual Java class and uses the metadata provided via theAnnotated
interface instead.- Type Parameters:
T
- the type- Parameters:
type
- theAnnotatedType
- Returns:
- a container provided implementation of
InjectionTarget
- Since:
- 1.1
-
createBeanAttributes
Obtains aBeanAttributes
for the givenAnnotatedType
. The container ignores the annotations and types declared by the elements of the actual Java class and uses the metadata provided via theAnnotated
interface instead.- Type Parameters:
T
- the type- Parameters:
type
- theAnnotatedType
- Returns:
- a container provided implementation of
InjectionTarget
- Since:
- 1.1
-
createBean
<T> Bean<T> createBean(BeanAttributes<T> attributes, Class<T> beanClass, InjectionTargetFactory<T> injectionTargetFactory) Obtains a
Bean
for the givenBeanAttributes
, bean class andInjectionTarget
.The
InjectionTarget
creates and destroys instances of the bean, performs dependency injection and lifecycle callbacks, and determines the return value ofBean.getInjectionPoints()
. TheInjectionTarget
is obtained from theInjectionTargetFactory
.#getInjectionTargetFactory()
allows use of a container createdInjectionTarget
.- Type Parameters:
T
- the type- Parameters:
attributes
- aBeanAttributes
which determines the bean types, qualifiers, scope, name and stereotypes of the returnedBean
, and the return values ofBeanAttributes.isAlternative()
andBean.isNullable()
beanClass
- a class, which determines the return value ofBean.getBeanClass()
injectionTargetFactory
- anInjectionTargetFactory
, used to obtain anInjectionTarget
- Returns:
- a container provided implementation of
Bean
- Since:
- 1.1
-
createBean
<T,X> Bean<T> createBean(BeanAttributes<T> attributes, Class<X> beanClass, ProducerFactory<X> producerFactory) Obtains a
Bean
for the givenBeanAttributes
, bean class andProducer
.The
Producer
creates and destroys instances of the decorator, and determines the return value ofBean.getInjectionPoints()
. TheProducer
is obtained from theProducerFactory
.#getProducerFactory()
allows use of a container createdProducer
.- Type Parameters:
T
- the typeX
- the type of the declaring bean- Parameters:
attributes
- aBeanAttributes
which determines the bean types, qualifiers, scope, name and stereotypes of the returnedBean
, and the return values ofBeanAttributes.isAlternative()
andBean.isNullable()
beanClass
- a class, which determines the return value ofBean#getClass()
producerFactory
- aProducerFactory
, used to obtain aProducer
- Returns:
- a container provided implementation of
Bean
- Since:
- 1.1
-
createInjectionPoint
Obtains a container provided implementation ofInjectionPoint
for the givenAnnotatedField
.- Parameters:
field
- theAnnotatedField
defining the injection point- Returns:
- the container provided
InjectionPoint
- Throws:
IllegalArgumentException
- if there is a definition error associated with the injection point- Since:
- 1.1
-
createInjectionPoint
Obtains a container provided implementation ofInjectionPoint
for the givenAnnotatedParameter
.- Parameters:
parameter
- theAnnotatedParameter
defining the injection point- Returns:
- the container provided
InjectionPoint
- Throws:
IllegalArgumentException
- if there is a definition error associated with the injection point- Since:
- 1.1
-
getExtension
Obtains the container's instance of an Extension class declared inMETA-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
-