javax.enterprise.inject.spi

Interface BeanManager

public interface BeanManager

The interface BeanManager is the central point for dealing with CDI. The BeanManager provides operations for resolving CDI Beans, obtaining the Contextual References of them, etc. There are operations related with;

• Firing observer events
• Creating CreationalContexts
• Resolution of beans, interceptors, decorators and observers
• Other utility methods etc..

Method Summary

Modifier and Type	Method and Description
boolean	areInterceptorBindingsEquivalent(Annotation interceptorBinding1, Annotation interceptorBinding2) Check whether the 2 given Interceptor Binding annotations are the same.
boolean	areQualifiersEquivalent(Annotation qualifier1, Annotation qualifier2) Check whether the 2 given qualifiers are the same.
<T> AnnotatedType<T>	createAnnotatedType(Class<T> type) Returns a AnnotatedType instance for the given class.
<T> Bean<T>	createBean(BeanAttributes<T> attributes, Class<T> beanClass, InjectionTargetFactory<T> injectionTargetFactory) Create a Bean from the given bean attributes.
<T,X> Bean<T>	createBean(BeanAttributes<T> attributes, Class<X> beanClass, ProducerFactory<X> producerFactory) Create a Bean from the given bean attributes.
BeanAttributes<?>	createBeanAttributes(AnnotatedMember<?> member) This method creates bean meta information from a given AnnotatedMember.
<T> BeanAttributes<T>	createBeanAttributes(AnnotatedType<T> type) This method creates bean meta information from a given AnnotatedType.
<T> CreationalContext<T>	createCreationalContext(Contextual<T> contextual) Returns a new creational context implementation.
InjectionPoint	createInjectionPoint(AnnotatedField<?> field) Create an InjectionPoint for an annotated field.
InjectionPoint	createInjectionPoint(AnnotatedParameter<?> parameter) Create an InjectionPoint for an annotated parameter.
<T> InjectionTarget<T>	createInjectionTarget(AnnotatedType<T> type) Creates a new instance of injection target Bean.
Instance<Object>	createInstance()
<T> InterceptionFactory<T>	createInterceptionFactory(CreationalContext<T> creationalContext, Class<T> clazz) Can be used to wrap a CDI proxy around a contextual instance inside of producer methods or Custom Beans.
void	fireEvent(Object event, Annotation... qualifiers) Fires a synchronous event with given even object and qualifiers.
Set<Bean<?>>	getBeans(String name) Returns set of beans with given Expression Language name.
Set<Bean<?>>	getBeans(Type beanType, Annotation... qualifiers) Returns set of beans that their api types contain given bean type and given qualifiers.
Context	getContext(Class<? extends Annotation> scope) Returns a context with given scope type.
javax.el.ELResolver	getELResolver() Returns CDI container Expression Language resolver.
Event<Object>	getEvent()
<T extends Extension> T	getExtension(Class<T> extensionClass) Resolves the Extension instance which gets used by this very BeanManager.
Object	getInjectableReference(InjectionPoint injectionPoint, CreationalContext<?> ctx) Gets injection point bean reference.
<T> InjectionTargetFactory<T>	getInjectionTargetFactory(AnnotatedType<T> type)
Set<Annotation>	getInterceptorBindingDefinition(Class<? extends Annotation> qualifier) Returns a set of meta-annotations that are defined on the binding
int	getInterceptorBindingHashCode(Annotation interceptorBinding)
Bean<?>	getPassivationCapableBean(String id) Returns passivation capable bean given id.
<X> ProducerFactory<X>	getProducerFactory(AnnotatedField<? super X> field, Bean<X> declaringBean)
<X> ProducerFactory<X>	getProducerFactory(AnnotatedMethod<? super X> method, Bean<X> declaringBean)
int	getQualifierHashCode(Annotation qualifier)
Object	getReference(Bean<?> bean, Type beanType, CreationalContext<?> ctx) Returns a bean instance reference for the given bean.
Set<Annotation>	getStereotypeDefinition(Class<? extends Annotation> stereotype) Returns a set of meta-annotations that are defined on the stereotype type.
boolean	isInterceptorBinding(Class<? extends Annotation> annotationType) Returns true if given type is a interceptor binding, false otherwise.
boolean	isNormalScope(Class<? extends Annotation> annotationType) Returns true if given type is a normal scope type, false otherwise.
boolean	isPassivatingScope(Class<? extends Annotation> annotationType) Returns true if given type is a passivating scope type, false otherwise.
boolean	isQualifier(Class<? extends Annotation> annotationType) Returns true if given type is a qualifier, false otherwise.
boolean	isScope(Class<? extends Annotation> annotationType) Returns true if given type is a scope type, false otherwise.
boolean	isStereotype(Class<? extends Annotation> annotationType) Returns true if given type is a stereotype type, false otherwise.
<X> Bean<? extends X>	resolve(Set<Bean<? extends X>> beans) Returns a bean object that is resolved according to the type safe resolution rules.
List<Decorator<?>>	resolveDecorators(Set<Type> types, Annotation... qualifiers) Returns a list of decorator.
List<Interceptor<?>>	resolveInterceptors(InterceptionType type, Annotation... interceptorBindings) Returns a list of interceptor.
<T> Set<ObserverMethod<? super T>>	resolveObserverMethods(T event, Annotation... qualifiers) Returns set of observer methods.
void	validate(InjectionPoint injectionPoint) Validates injection point.
javax.el.ExpressionFactory	wrapExpressionFactory(javax.el.ExpressionFactory expressionFactory) Wrapped around given expression factory and add CDI functionality.

Method Detail

getReference

Object getReference(Bean<?> bean,
                    Type beanType,
                    CreationalContext<?> ctx)

Returns a bean instance reference for the given bean.

Parameters:

bean - bean that its reference is getting

beanType - bean api type that is implemented by the proxy

ctx - creational context is used to destroy any object with scope @Dependent

Returns:

bean reference

Throws:

IllegalArgumentException - if given bean type is not api type of the given bean object

IllegalStateException - if this method gets called before the AfterDeploymentValidation event is fired.

getInjectableReference

Object getInjectableReference(InjectionPoint injectionPoint,
                              CreationalContext<?> ctx)

Gets injection point bean reference.

Parameters:

injectionPoint - injection point definition

ctx - creational context that is passed to the Contextual.create(CreationalContext) method

Returns:

bean reference

Throws:

UnsatisfiedResolutionException - if no bean found for the given injection point

AmbiguousResolutionException - if more than one bean found

IllegalStateException - if this method gets called before the AfterDeploymentValidation event is fired.

createCreationalContext

<T> CreationalContext<T> createCreationalContext(Contextual<T> contextual)

Returns a new creational context implementation.

Returns:

new creational context

getBeans

Set<Bean<?>> getBeans(Type beanType,
                      Annotation... qualifiers)

Returns set of beans that their api types contain given bean type and given qualifiers.

If no qualifier is given, @Current is assumed.

Parameters:

beanType - required bean type

qualifiers - required qualifiers

Returns:

set of beans

Throws:

IllegalArgumentException - given bean type is a TypeVariable

IllegalArgumentException - given qualifier annotation is not a qualifier

IllegalArgumentException - same qualifier is given

IllegalStateException - if this method gets called before the AfterBeanDiscovery event is fired.

getBeans

Set<Bean<?>> getBeans(String name)

Returns set of beans with given Expression Language name.

Parameters:

name - name of the bean

Returns:

set of beans with given name

Throws:

IllegalStateException - if this method gets called before the AfterBeanDiscovery event is fired.

getPassivationCapableBean

Bean<?> getPassivationCapableBean(String id)

Returns passivation capable bean given id.

Parameters:

id - bean id

Returns:

passivation capable bean given id

Throws:

IllegalStateException - if this method gets called before the AfterBeanDiscovery event is fired.

resolve

<X> Bean<? extends X> resolve(Set<Bean<? extends X>> beans)

Returns a bean object that is resolved according to the type safe resolution rules.

Type Parameters:

X - bean class info

Parameters:

beans - set of beans

Returns:

bean that is resolved according to the type safe resolution rules

Throws:

AmbiguousResolutionException - if ambigious exists

IllegalStateException - if this method gets called before the AfterBeanDiscovery event is fired.

createInterceptionFactory

<T> InterceptionFactory<T> createInterceptionFactory(CreationalContext<T> creationalContext,
                                                     Class<T> clazz)

Can be used to wrap a CDI proxy around a contextual instance inside of producer methods or Custom Beans.

Type Parameters:

T - the type of the BeanClass

Parameters:

creationalContext - used to store Interceptor and Decorator instances which are by definition Dependent

clazz - the BeanClass

Returns:

an InterceptionFactory which will use the given CreationalContext to store created instances.

fireEvent

void fireEvent(Object event,
               Annotation... qualifiers)

Fires a synchronous event with given even object and qualifiers. For firing asynchronous events you first have to get an Event via getEvent() and then use the Event.fireAsync(Object) or Event.fireAsync(Object, NotificationOptions) methods.

Parameters:

event - observer event object

qualifiers - event qualifiers

Throws:

IllegalArgumentException - event object contains a TypeVariable

IllegalArgumentException - given qualifier annotation is not a qualifier

IllegalArgumentException - same qualifier is given

See Also:

getEvent()

getEvent

Event<Object> getEvent()

Returns:

an Event instance with Object/Default

resolveObserverMethods

<T> Set<ObserverMethod<? super T>> resolveObserverMethods(T event,
                                                          Annotation... qualifiers)

Returns set of observer methods.

Type Parameters:

T - event type

Parameters:

event - even object

qualifiers - event qualifiers

Returns:

set of observer methods

Throws:

IllegalStateException - if this method gets called before the AfterBeanDiscovery event is fired.

resolveDecorators

List<Decorator<?>> resolveDecorators(Set<Type> types,
                                     Annotation... qualifiers)

Returns a list of decorator.

Parameters:

types - bean types of the decorated bean

qualifiers - decorated bean qualifiers

Returns:

list of decorator

Throws:

IllegalArgumentException - given qualifier annotation is not a qualifier

IllegalArgumentException - same qualifier is given

IllegalArgumentException - if types is empty set

IllegalStateException - if this method gets called before the AfterBeanDiscovery event is fired.

resolveInterceptors

List<Interceptor<?>> resolveInterceptors(InterceptionType type,
                                         Annotation... interceptorBindings)

Returns a list of interceptor.

Parameters:

type - interception type

interceptorBindings - interceptor bindings

Returns:

list of interceptor

Throws:

IllegalArgumentException - given binding annotation is not a binding

IllegalArgumentException - same binding is given

IllegalArgumentException - binding is not an interceptor binding

IllegalStateException - if this method gets called before the AfterBeanDiscovery event is fired.

validate

void validate(InjectionPoint injectionPoint)

Validates injection point.

Parameters:

injectionPoint - injection point

Throws:

InjectionException - if problem exist

IllegalStateException - if this method gets called before the AfterBeanDiscovery event is fired.

isScope

boolean isScope(Class<? extends Annotation> annotationType)

Returns true if given type is a scope type, false otherwise.

Parameters:

annotationType - annotation type

Returns:

true if given type is a scope type, false otherwise

isNormalScope

boolean isNormalScope(Class<? extends Annotation> annotationType)

Returns true if given type is a normal scope type, false otherwise.

Parameters:

annotationType - annotation type

Returns:

true if given type is a scope type, false otherwise

isPassivatingScope

boolean isPassivatingScope(Class<? extends Annotation> annotationType)

Returns true if given type is a passivating scope type, false otherwise.

Parameters:

annotationType - annotation type

Returns:

true if given type is a scope type, false otherwise

isQualifier

boolean isQualifier(Class<? extends Annotation> annotationType)

Returns true if given type is a qualifier, false otherwise.

Parameters:

annotationType - annotation type

Returns:

true if given type is a qualifier, false otherwise

areQualifiersEquivalent

boolean areQualifiersEquivalent(Annotation qualifier1,
                                Annotation qualifier2)

Check whether the 2 given qualifiers are the same. This takes Nonbinding into account by ignoring those properties.

Parameters:

qualifier1 -

qualifier2 -

Returns:

true if all non-nonbinding attributes are equals, false otherwise

getQualifierHashCode

int getQualifierHashCode(Annotation qualifier)

Parameters:

qualifier -

Returns:

the hashCode of the Annotation. All Nonbinding fields get ignored

isInterceptorBinding

boolean isInterceptorBinding(Class<? extends Annotation> annotationType)

Returns true if given type is a interceptor binding, false otherwise.

Parameters:

annotationType - annotation type

Returns:

true if given type is a interceptor binding, false otherwise

areInterceptorBindingsEquivalent

boolean areInterceptorBindingsEquivalent(Annotation interceptorBinding1,
                                         Annotation interceptorBinding2)

Check whether the 2 given Interceptor Binding annotations are the same. This takes Nonbinding into account by ignoring those properties.

Parameters:

interceptorBinding1 -

interceptorBinding2 -

Returns:

true if all non-nonbinding attributes are equals, false otherwise

getInterceptorBindingHashCode

int getInterceptorBindingHashCode(Annotation interceptorBinding)

Parameters:

interceptorBinding -

Returns:

the hashCode of the Annotation. All Nonbinding fields get ignored

isStereotype

boolean isStereotype(Class<? extends Annotation> annotationType)

Returns true if given type is a stereotype type, false otherwise.

Parameters:

annotationType - annotation type

Returns:

true if given type is a stereotype, false otherwise

getInterceptorBindingDefinition

Set<Annotation> getInterceptorBindingDefinition(Class<? extends Annotation> qualifier)

Returns a set of meta-annotations that are defined on the binding

Parameters:

qualifier - binding class

Returns:

a set of meta-annotations that are defined on the binding

getStereotypeDefinition

Set<Annotation> getStereotypeDefinition(Class<? extends Annotation> stereotype)

Returns a set of meta-annotations that are defined on the stereotype type.

Parameters:

stereotype - stereotype type class

Returns:

a set of meta-annotations that are defined on the stereotype type

getContext

Context getContext(Class<? extends Annotation> scope)

Returns a context with given scope type.

Parameters:

scope - scope type class type

Returns:

a context with given scope type

createInstance

Instance<Object> createInstance()

Returns:

an Instance. Basically the same like CDI.current()...

Since:

2.0

getELResolver

javax.el.ELResolver getELResolver()

Returns CDI container Expression Language resolver.

Returns:

el resolver

createAnnotatedType

<T> AnnotatedType<T> createAnnotatedType(Class<T> type)

Returns a AnnotatedType instance for the given class.

Type Parameters:

T - class type

Parameters:

type - class

Returns:

a AnnotatedType instance

createInjectionTarget

<T> InjectionTarget<T> createInjectionTarget(AnnotatedType<T> type)

Creates a new instance of injection target Bean.

Type Parameters:

T - bean type

Parameters:

type - annotated type

Returns:

injection target

createInjectionPoint

InjectionPoint createInjectionPoint(AnnotatedField<?> field)

Create an InjectionPoint for an annotated field.

Parameters:

field -

Returns:

injection point

Throws:

IllegalArgumentException - if there is a definition error on the given field

createInjectionPoint

InjectionPoint createInjectionPoint(AnnotatedParameter<?> parameter)

Create an InjectionPoint for an annotated parameter.

Parameters:

parameter -

Returns:

injection point

Throws:

IllegalArgumentException - if there is a definition error on the given parameter

getInjectionTargetFactory

<T> InjectionTargetFactory<T> getInjectionTargetFactory(AnnotatedType<T> type)

Type Parameters:

T -

Parameters:

type -

Returns:

the InjectionTargetFactory which is able to create InjectionTargets for the given AnnotatedType.

getProducerFactory

<X> ProducerFactory<X> getProducerFactory(AnnotatedField<? super X> field,
                                          Bean<X> declaringBean)

Type Parameters:

X -

Parameters:

field -

declaringBean -

Returns:

the ProducerFactory which is able to create Producers for the given AnnotatedField.

getProducerFactory

<X> ProducerFactory<X> getProducerFactory(AnnotatedMethod<? super X> method,
                                          Bean<X> declaringBean)

Type Parameters:

X -

Parameters:

method -

declaringBean -

Returns:

the ProducerFactory which is able to create Producers for the given AnnotatedMethod.

createBeanAttributes

<T> BeanAttributes<T> createBeanAttributes(AnnotatedType<T> type)

This method creates bean meta information from a given AnnotatedType. The created BeanAttributes can later be used to create a Bean via createBean(BeanAttributes, Class, InjectionTargetFactory) or createBean(BeanAttributes, Class, ProducerFactory)

Type Parameters:

T -

Parameters:

type -

Returns:

the BeanAttributes created from parsing the given AnnotatedType

createBeanAttributes

BeanAttributes<?> createBeanAttributes(AnnotatedMember<?> member)

This method creates bean meta information from a given AnnotatedMember. The created BeanAttributes can later be used to create a Bean via createBean(BeanAttributes, Class, InjectionTargetFactory) or createBean(BeanAttributes, Class, ProducerFactory).

Parameters:

member -

Returns:

the BeanAttributes created from parsing the given AnnotatedType

createBean

<T> Bean<T> createBean(BeanAttributes<T> attributes,
                       Class<T> beanClass,
                       InjectionTargetFactory<T> injectionTargetFactory)

Create a Bean from the given bean attributes. This version of the method uses a given InjectionTargetFactory.

Type Parameters:

T -

Parameters:

attributes -

beanClass -

injectionTargetFactory -

Returns:

the container created Bean

createBean

<T,X> Bean<T> createBean(BeanAttributes<T> attributes,
                         Class<X> beanClass,
                         ProducerFactory<X> producerFactory)

Create a Bean from the given bean attributes. This version of the method uses a given ProducerFactory.

Type Parameters:

T -

Parameters:

attributes -

beanClass -

producerFactory -

Returns:

the container created Bean

getExtension

<T extends Extension> T getExtension(Class<T> extensionClass)

Resolves the Extension instance which gets used by this very BeanManager. The given extensionClass must be the effective class registered into META-INF/services and not some base class.

Type Parameters:

T -

Parameters:

extensionClass -

Returns:

the Extension instance of this very BeanManager

wrapExpressionFactory

javax.el.ExpressionFactory wrapExpressionFactory(javax.el.ExpressionFactory expressionFactory)

Wrapped around given expression factory and add CDI functionality.

Parameters:

expressionFactory - expression factory

Returns:

wrapped expression factory