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:
getBeans(String)
,getBeans(java.lang.reflect.Type, java.lang.annotation.Annotation...)
,getPassivationCapableBean(String)
,resolve(java.util.Set)
,resolveDecorators(java.util.Set, java.lang.annotation.Annotation...)
,resolveInterceptors(InterceptionType, java.lang.annotation.Annotation...)
,resolveObserverMethods(Object, java.lang.annotation.Annotation...)
,validate(InjectionPoint)
,createInstance()
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.
Modifier and Type | Method and Description |
---|---|
boolean |
areInterceptorBindingsEquivalent(Annotation interceptorBinding1,
Annotation interceptorBinding2)
Determine if two interceptor bindings are considered equivalent for the purposes of typesafe resolution, taking into
account any members annotated with
Nonbinding . |
boolean |
areQualifiersEquivalent(Annotation qualifier1,
Annotation qualifier2)
Determine if two qualifiers are considered equivalent for the purposes of typesafe resolution, taking into account any
members annotated with
Nonbinding . |
<T> AnnotatedType<T> |
createAnnotatedType(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,
Class<T> beanClass,
InjectionTargetFactory<T> injectionTargetFactory)
|
<T,X> Bean<T> |
createBean(BeanAttributes<T> attributes,
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 . |
<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<Object> |
createInstance()
Obtains an
Instance object to access to beans instances. |
<T> InterceptionFactory<T> |
createInterceptionFactory(CreationalContext<T> ctx,
Class<T> clazz)
Create an
InterceptionFactory for the given CreationalContext and type. |
void |
fireEvent(Object event,
Annotation... qualifiers)
Fire an event and notify observers.
|
Set<Bean<?>> |
getBeans(String name)
Return the set of beans which have the given EL name and are available for injection in the module or library containing
the class into which the BeanManager was injected or the Jakarta EE component from whose JNDI environment namespace
the BeanManager was obtained, according to the rules of EL name resolution.
|
Set<Bean<?>> |
getBeans(Type beanType,
Annotation... qualifiers)
Return the set of beans which have the given required type and qualifiers and are available for injection in the module
or library containing the class into which the BeanManager was injected or the Jakarta EE component from whose JNDI
environment namespace the BeanManager was obtained, according to the rules of typesafe resolution.
|
Context |
getContext(Class<? extends Annotation> scopeType)
Obtains an active context object for the given
scope .
|
javax.el.ELResolver |
getELResolver()
Returns a
ELResolver that resolves beans by EL name. |
Event<Object> |
getEvent()
Returns an instance of Event with specified type java.lang.Object and specified qualifier @Default
It allows typesafe synchronous or asynchronous event firing without injection of
Event built-in bean requirement. |
<T extends Extension> |
getExtension(Class<T> extensionClass)
Obtains the container's instance of an Extension class declared in
META-INF/services . |
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. |
Set<Annotation> |
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 with
Nonbinding . |
Bean<?> |
getPassivationCapableBean(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(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 . |
Object |
getReference(Bean<?> bean,
Type beanType,
CreationalContext<?> ctx)
Obtains a contextual reference for a certain bean and a certain bean type of the bean.
|
Set<Annotation> |
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> |
resolve(Set<Bean<? extends X>> beans)
Apply the ambiguous dependency resolution rules to a set of beans.
|
List<Decorator<?>> |
resolveDecorators(Set<Type> types,
Annotation... qualifiers)
Return an ordered list of decorators for a set of bean types and a set of qualifiers and which are
enabled in the module or library containing the class into which the BeanManager was injected or the Jakarta 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 Jakarta EE component from whose JNDI environment namespace the BeanManager was obtained.
|
<T> Set<ObserverMethod<? super T>> |
resolveObserverMethods(T event,
Annotation... qualifiers)
Return an ordered set of observer methods for an event.
|
void |
validate(InjectionPoint injectionPoint)
Validate a certain injection point.
|
javax.el.ExpressionFactory |
wrapExpressionFactory(javax.el.ExpressionFactory expressionFactory)
Returns a wrapper
ExpressionFactory that delegates MethodExpression and
ValueExpression creation to the given ExpressionFactory . |
Object getReference(Bean<?> bean, Type beanType, CreationalContext<?> ctx)
Obtains a contextual reference for a certain bean and a certain bean type of the bean.
bean
- the Bean
object representing the beanbeanType
- a bean type that must be implemented by any client proxy that is returnedctx
- a CreationalContext
that may be used to destroy any object with scope
Dependent
that is createdIllegalArgumentException
- if the given type is not a bean type of the given beanIllegalStateException
- if called during application initialization, before the AfterDeploymentValidation
event is fired.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 dependencyIllegalStateException
- if called during application initialization, before the AfterDeploymentValidation
event is fired.<T> CreationalContext<T> createCreationalContext(Contextual<T> contextual)
CreationalContext
for the given
contextual type, or for a non-contextual object.contextual
- the Contextual
, or a null value in the case of a non-contextual
objectCreationalContext
Set<Bean<?>> getBeans(Type beanType, Annotation... qualifiers)
AfterBeanDiscovery
event observer,
this method will only return beans discovered by the container before the AfterBeanDiscovery
event is fired.beanType
- the required bean typequalifiers
- the required qualifiersIllegalArgumentException
- if the given type represents a type variableIllegalArgumentException
- if two instances of the same non repeating qualifier type are givenIllegalArgumentException
- if an instance of an annotation that is not a qualifier type is givenIllegalStateException
- if called during application initialization, before the AfterBeanDiscovery
event is fired.Set<Bean<?>> getBeans(String name)
AfterBeanDiscovery
event observer,
this method will only return beans discovered by the container before the AfterBeanDiscovery
event is fired.name
- the EL nameIllegalStateException
- if called during application initialization, before the AfterBeanDiscovery
event is fired.Bean<?> getPassivationCapableBean(String id)
PassivationCapable
bean with the given identifier.
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 beanIllegalStateException
- if called during application initialization, before the AfterBeanDiscovery
event is fired.<X> Bean<? extends X> resolve(Set<Bean<? extends X>> beans)
AfterBeanDiscovery
event observer,
this method will only return beans discovered by the container before the AfterBeanDiscovery
event is fired.X
- a common type of the beansbeans
- a set of beans of the given typeAmbiguousResolutionException
- if the ambiguous dependency resolution rules failIllegalStateException
- 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 pointIllegalStateException
- if called during application initialization, before the AfterBeanDiscovery
event is fired.void fireEvent(Object event, Annotation... qualifiers)
This method is deprecated from CDI 2.0 and getEvent()
should be used instead.
event
- the event objectqualifiers
- the event qualifiersIllegalArgumentException
- if the runtime type of the event object contains a type variableIllegalArgumentException
- if two instances of the same non repeating 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
<T> Set<ObserverMethod<? super T>> resolveObserverMethods(T event, Annotation... qualifiers)
AfterBeanDiscovery
event observer,
this method will only return observers discovered by the container before the AfterBeanDiscovery
event is fired.T
- the type of the eventevent
- the event objectqualifiers
- the event qualifiersIllegalArgumentException
- if the runtime type of the event object contains a type variableIllegalArgumentException
- if two instances of the same non repeating qualifier type are givenIllegalArgumentException
- if an instance of an annotation that is not a qualifier type is givenIllegalStateException
- if called during application initialization, before the AfterBeanDiscovery
event is fired.List<Decorator<?>> resolveDecorators(Set<Type> types, Annotation... qualifiers)
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 beanIllegalArgumentException
- 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 the AfterBeanDiscovery
event is fired.List<Interceptor<?>> resolveInterceptors(InterceptionType type, Annotation... interceptorBindings)
AfterBeanDiscovery
event observer,
this method will only return interceptors discovered by the container before the AfterBeanDiscovery
event is
fired.type
- the type of the interceptioninterceptorBindings
- the interceptor bindingsIllegalArgumentException
- 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 the AfterBeanDiscovery
event is fired.boolean isScope(Class<? extends Annotation> annotationType)
annotationType
- the annotation typeboolean isNormalScope(Class<? extends Annotation> annotationType)
annotationType
- the annotation typeboolean isPassivatingScope(Class<? extends Annotation> annotationType)
annotationType
- the annotation typeboolean isQualifier(Class<? extends Annotation> annotationType)
annotationType
- the annotation typeboolean isInterceptorBinding(Class<? extends Annotation> annotationType)
annotationType
- the annotation to testboolean isStereotype(Class<? extends Annotation> annotationType)
annotationType
- the annotation typeSet<Annotation> getInterceptorBindingDefinition(Class<? extends Annotation> bindingType)
bindingType
- the interceptor binding typeSet<Annotation> getStereotypeDefinition(Class<? extends Annotation> stereotype)
stereotype
- the stereotypeboolean areQualifiersEquivalent(Annotation qualifier1, Annotation qualifier2)
Nonbinding
.qualifier1
- a qualifier to checkqualifier2
- a qualifier to checkboolean areInterceptorBindingsEquivalent(Annotation interceptorBinding1, Annotation interceptorBinding2)
Nonbinding
.interceptorBinding1
- an interceptor binding to checkinterceptorBinding2
- an interceptor binding to checkint getQualifierHashCode(Annotation qualifier)
Nonbinding
.qualifier
- the qualifier to considerint getInterceptorBindingHashCode(Annotation interceptorBinding)
Nonbinding
.interceptorBinding
- the interceptor binding to considerContext getContext(Class<? extends Annotation> scopeType)
scopeType
- the scopeContextNotActiveException
- if there is no active context object for the given scopeIllegalArgumentException
- if there is more than one active context object for the given scopejavax.el.ELResolver getELResolver()
ELResolver
that resolves beans by EL name.ELResolver
javax.el.ExpressionFactory wrapExpressionFactory(javax.el.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(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> 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.
T
- the typetype
- the AnnotatedType
InjectionTarget
IllegalArgumentException
- if there is a definition error associated with any injection point of the type<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.
annotatedType
- 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.
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<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.
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<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, 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 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
Bean
<T,X> Bean<T> createBean(BeanAttributes<T> attributes, 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 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
Bean
InjectionPoint createInjectionPoint(AnnotatedField<?> field)
InjectionPoint
for the given AnnotatedField
.field
- the AnnotatedField
defining the injection pointInjectionPoint
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
IllegalArgumentException
- if there is a definition error associated with the injection point<T extends Extension> T getExtension(Class<T> extensionClass)
META-INF/services
.T
- the type of the extensionextensionClass
- the type of the extension classIllegalArgumentException
- if the container has no instance of the given class<T> InterceptionFactory<T> createInterceptionFactory(CreationalContext<T> ctx, 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 TEvent<Object> getEvent()
Event
built-in bean requirement.Event
object whose event type is Object and qualifier @DefaultInstance<Object> createInstance()
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.Instance
object to request beans instancesIllegalStateException
- if called during application initialization, before the AfterDeploymentValidation
event is fired.Comments to: cdi-dev@eclipse.org.
Copyright © 2019 Eclipse Foundation.
Use is subject to license terms.