public interface BeanManager extends BeanContainer
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.
In CDI Lite environment, applications may obtain a BeanManager
, but invoking methods that are not inherited
from BeanContainer
results in non-portable behavior.
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
.
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:
BeanContainer.getBeans(String)
,BeanContainer.getBeans(java.lang.reflect.Type, java.lang.annotation.Annotation...)
,getPassivationCapableBean(String)
,BeanContainer.resolve(java.util.Set)
,resolveDecorators(java.util.Set, java.lang.annotation.Annotation...)
,BeanContainer.resolveInterceptors(InterceptionType, java.lang.annotation.Annotation...)
,resolveObserverMethods(Object, java.lang.annotation.Annotation...)
,validate(InjectionPoint)
,BeanContainer.createInstance()
and the following operations must not be called before the AfterDeploymentValidation
event is fired:
BeanContainer.getReference(Bean, java.lang.reflect.Type, CreationalContext)
,getInjectableReference(InjectionPoint, CreationalContext)
,or the container will throw an Exception.
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)
|
<T,X> Bean<T> |
createBean(BeanAttributes<T> attributes,
java.lang.Class<X> beanClass,
ProducerFactory<X> producerFactory)
|
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 . |
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> InterceptionFactory<T> |
createInterceptionFactory(CreationalContext<T> ctx,
java.lang.Class<T> clazz)
Create an
InterceptionFactory for the given CreationalContext and type. |
ELResolver |
getELResolver()
Returns a
ELResolver that resolves beans by EL name. |
<T extends Extension> |
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.util.Set<java.lang.annotation.Annotation> |
getStereotypeDefinition(java.lang.Class<? extends java.lang.annotation.Annotation> stereotype)
Obtains meta-annotations for a certain stereotype.
|
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.
|
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 Java 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 . |
createCreationalContext, createInstance, getBeans, getBeans, getContext, getEvent, getReference, isInterceptorBinding, isNormalScope, isQualifier, isScope, isStereotype, resolve, resolveInterceptors
Bean<?> getPassivationCapableBean(java.lang.String id)
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.id
- the identifierBean
that implements PassivationCapable
and has the given
identifier, or a null value if there is no such beanjava.lang.IllegalStateException
- if called during application initialization, before the AfterBeanDiscovery
event is fired.void validate(InjectionPoint injectionPoint)
AfterBeanDiscovery
event observer,
this method will only validate injection points discovered by the container before the AfterBeanDiscovery
event is fired.injectionPoint
- the injection point to validateInjectionException
- if there is a deployment problem (for example, an unsatisfied or unresolvable ambiguous
dependency) associated with the injection pointjava.lang.IllegalStateException
- if called during application initialization, before the AfterBeanDiscovery
event is fired.<T> java.util.Set<ObserverMethod<? super T>> resolveObserverMethods(T event, java.lang.annotation.Annotation... qualifiers)
AfterBeanDiscovery
event observer,
this method will only return observers discovered by the container before the AfterBeanDiscovery
event is fired.resolveObserverMethods
in interface BeanContainer
T
- the type of the eventevent
- the event objectqualifiers
- the event qualifiersjava.lang.IllegalArgumentException
- if the runtime type of the event object contains a type variablejava.lang.IllegalArgumentException
- if two instances of the same non repeating qualifier type are givenjava.lang.IllegalArgumentException
- if an instance of an annotation that is not a qualifier type is givenjava.lang.IllegalStateException
- if called during application initialization, before the AfterBeanDiscovery
event is fired.java.util.List<Decorator<?>> resolveDecorators(java.util.Set<java.lang.reflect.Type> types, java.lang.annotation.Annotation... qualifiers)
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.types
- the set of bean types of the decorated beanqualifiers
- the qualifiers declared by the decorated beanjava.lang.IllegalArgumentException
- if the set of bean types is emptyjava.lang.IllegalArgumentException
- if an annotation which is not a binding type is passedjava.lang.IllegalArgumentException
- if two instances of the same binding type are passedjava.lang.IllegalStateException
- if called during application initialization, before the AfterBeanDiscovery
event is fired.boolean isPassivatingScope(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
annotationType
- the annotation typetrue
if the annotation type is a passivating scope typejava.util.Set<java.lang.annotation.Annotation> getInterceptorBindingDefinition(java.lang.Class<? extends java.lang.annotation.Annotation> bindingType)
bindingType
- the interceptor binding typejava.util.Set<java.lang.annotation.Annotation> getStereotypeDefinition(java.lang.Class<? extends java.lang.annotation.Annotation> stereotype)
stereotype
- the stereotypeboolean areQualifiersEquivalent(java.lang.annotation.Annotation qualifier1, java.lang.annotation.Annotation qualifier2)
Nonbinding
.qualifier1
- a qualifier to checkqualifier2
- a qualifier to checkboolean areInterceptorBindingsEquivalent(java.lang.annotation.Annotation interceptorBinding1, java.lang.annotation.Annotation interceptorBinding2)
Nonbinding
.interceptorBinding1
- an interceptor binding to checkinterceptorBinding2
- an interceptor binding to checkint getQualifierHashCode(java.lang.annotation.Annotation qualifier)
Nonbinding
.qualifier
- the qualifier to considerint getInterceptorBindingHashCode(java.lang.annotation.Annotation interceptorBinding)
Nonbinding
.interceptorBinding
- the interceptor binding to considerELResolver getELResolver()
ELResolver
that resolves beans by EL name.ELResolver
ExpressionFactory wrapExpressionFactory(ExpressionFactory expressionFactory)
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
.expressionFactory
- the ExpressionFactory
to wrapExpressionFactory
<T> AnnotatedType<T> createAnnotatedType(java.lang.Class<T> type)
AnnotatedType
that may be used to read the annotations of the given class or interface.T
- the class or interfacetype
- the Class
objectAnnotatedType
<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.
T
- the typeannotatedType
- the annotated type to create the injection target factory forInjectionTargetFactory
<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.
X
- the declaring typefield
- 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<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.
X
- bean typemethod
- 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<T> BeanAttributes<T> createBeanAttributes(AnnotatedType<T> type)
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.T
- the typetype
- the AnnotatedType
InjectionTarget
BeanAttributes<?> createBeanAttributes(AnnotatedMember<?> type)
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
- the AnnotatedType
InjectionTarget
<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
.
T
- the typeattributes
- a BeanAttributes
which determines the bean types, qualifiers, scope, name and stereotypes of
the returned Bean
, and the return value of BeanAttributes.isAlternative()
beanClass
- a class, which determines the return value of Bean.getBeanClass()
injectionTargetFactory
- an InjectionTargetFactory
, used to obtain an InjectionTarget
Bean
<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
.
T
- the typeX
- the type of the declaring beanattributes
- a BeanAttributes
which determines the bean types, qualifiers, scope, name and stereotypes of
the returned Bean
, and the return value of BeanAttributes.isAlternative()
beanClass
- a class, which determines the return value of Bean.getClass()
producerFactory
- a ProducerFactory
, used to obtain a Producer
Bean
InjectionPoint createInjectionPoint(AnnotatedField<?> field)
InjectionPoint
for the given AnnotatedField
.field
- the AnnotatedField
defining the injection pointInjectionPoint
java.lang.IllegalArgumentException
- if there is a definition error associated with the injection pointInjectionPoint createInjectionPoint(AnnotatedParameter<?> parameter)
InjectionPoint
for the given AnnotatedParameter
.parameter
- the AnnotatedParameter
defining the injection pointInjectionPoint
java.lang.IllegalArgumentException
- if there is a definition error associated with the injection point<T extends Extension> T getExtension(java.lang.Class<T> extensionClass)
META-INF/services
.T
- the type of the extensionextensionClass
- the type of the extension classjava.lang.IllegalArgumentException
- if the container has no instance of the given class<T> InterceptionFactory<T> createInterceptionFactory(CreationalContext<T> ctx, java.lang.Class<T> clazz)
InterceptionFactory
for the given CreationalContext
and type.T
- type of the instance this factory will work onctx
- CreationalContext
for the InterceptionFactory
to createclazz
- class of the instance this factory will work onInterceptionFactory
to add services on on instances of Tjava.lang.Object getInjectableReference(InjectionPoint ij, CreationalContext<?> ctx)
Obtains an injectable reference for a certain injection point.
ij
- the target injection pointctx
- a CreationalContext
that may be used to destroy any object with scope
Dependent
that is createdUnsatisfiedResolutionException
- if typesafe resolution results in an unsatisfied dependencyAmbiguousResolutionException
- typesafe resolution results in an unresolvable ambiguous dependencyjava.lang.IllegalStateException
- if called during application initialization, before the AfterDeploymentValidation
event is fired.