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, resolveInterceptorsBean<?> 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 BeanContainerT - 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.ELResolverExpressionFactory 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 AnnotatedTypeInjectionTargetBeanAttributes<?> 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 AnnotatedTypeInjectionTarget<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 InjectionTargetBean<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 ProducerBeanInjectionPoint createInjectionPoint(AnnotatedField<?> field)
InjectionPoint for the given AnnotatedField.field - the AnnotatedField defining the injection pointInjectionPointjava.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 pointInjectionPointjava.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.