javax.enterprise.inject.spi
Interface BeanManager


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;
 

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.

Author:
Gavin King, Pete Muir, Clint Popetz, David Allen

Method Summary
<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> CreationalContext<T>
createCreationalContext(Contextual<T> contextual)
          Obtain an instance of a CreationalContext for the given contextual type, or for a non-contextual object.
<T> InjectionTarget<T>
createInjectionTarget(AnnotatedType<T> type)
          Obtains an InjectionTarget for the given AnnotatedType.
 void fireEvent(java.lang.Object event, java.lang.annotation.Annotation... qualifiers)
          Fire an event and notify observers.
 java.util.Set<Bean<?>> getBeans(java.lang.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 Java EE component from whose JNDI environment namespace the BeanManager was obtained, according to the rules of EL name resolution.
 java.util.Set<Bean<?>> getBeans(java.lang.reflect.Type beanType, java.lang.annotation.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.
 Context getContext(java.lang.Class<? extends java.lang.annotation.Annotation> scopeType)
          Obtains an active context object for the given scope.
 ELResolver getELResolver()
          Returns a ELResolver that resolves beans by EL name.
 java.lang.Object getInjectableReference(InjectionPoint ij, CreationalContext<?> ctx)
          Obtains an injectable reference for a certain injection point.
 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.
 Bean<?> getPassivationCapableBean(java.lang.String id)
          Returns the PassivationCapable bean with the given identifier.
 java.lang.Object getReference(Bean<?> bean, java.lang.reflect.Type beanType, CreationalContext<?> ctx)
          Obtains a contextual reference for a certain bean and a certain bean type of the bean.
 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 isInterceptorBinding(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
          Test the given annotation type to determine if it is an interceptor binding type.
 boolean isNormalScope(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
          Test the given annotation type to determine if it is a normal scope type.
 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.
 boolean isQualifier(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
          Test the given annotation type to determine if it is a qualifier type.
 boolean isScope(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
          Test the given annotation type to determine if it is a scope type.
 boolean isStereotype(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
          Test the given annotation type to determine if it is a stereotype.
<X> Bean<? extends X>
resolve(java.util.Set<Bean<? extends X>> beans)
          Apply the ambiguous dependency resolution rules to a set of beans.
 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.
 java.util.List<Interceptor<?>> resolveInterceptors(InterceptionType type, java.lang.annotation.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> java.util.Set<ObserverMethod<? super T>>
resolveObserverMethods(T event, java.lang.annotation.Annotation... qualifiers)
          Return the set of observers 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.
 

Method Detail

getReference

java.lang.Object getReference(Bean<?> bean,
                              java.lang.reflect.Type beanType,
                              CreationalContext<?> ctx)
Obtains a contextual reference for a certain bean and a certain bean type of the bean.

Parameters:
bean - the Bean object representing the bean
beanType - a bean type that must be implemented by any client proxy that is returned
ctx - a CreationalContext that may be used to destroy any object with scope {javax.enterprise.context.Dependent} that is created
Returns:
a contextual reference representing the bean
Throws:
IllegalArgumentException - if the given type is not a bean type of the given bean

getInjectableReference

java.lang.Object getInjectableReference(InjectionPoint ij,
                                        CreationalContext<?> ctx)
Obtains an injectable reference for a certain injection point.

Parameters:
ij - the target injection point
ctx - a CreationalContext that may be used to destroy any object with scope {javax.enterprise.context.Dependent} that is created
Returns:
the injectable reference
Throws:
UnsatisfiedResolutionException - if typesafe resolution results in an unsatisfied dependency
AmbiguousResolutionException - typesafe resolution results in an unresolvable ambiguous dependency

createCreationalContext

<T> CreationalContext<T> createCreationalContext(Contextual<T> contextual)
Obtain an instance of a CreationalContext for the given contextual type, or for a non-contextual object.

Parameters:
contextual - the Contextual, or a null value in the case of a non-contextual object
Returns:
the new CreationalContext

getBeans

java.util.Set<Bean<?>> getBeans(java.lang.reflect.Type beanType,
                                java.lang.annotation.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. If no qualifiers are given, the default qualifier is assumed.

Parameters:
beanType - the required bean type
qualifiers - the required qualifiers
Returns:
the resulting set of beans
Throws:
IllegalArgumentException - if the given type represents a type variable
IllegalArgumentException - if two instances of the same qualifier type are given
IllegalArgumentException - if an instance of an annotation that is not a qualifier type is given

getBeans

java.util.Set<Bean<?>> getBeans(java.lang.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 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

getPassivationCapableBean

Bean<?> getPassivationCapableBean(java.lang.String id)
Returns the PassivationCapable bean with the given identifier.

Parameters:
id - the identifier
Returns:
a Bean that implements PassivationCapable and has the given identifier, or a null value if there is no such bean

resolve

<X> Bean<? extends X> resolve(java.util.Set<Bean<? extends X>> beans)
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 fail

validate

void validate(InjectionPoint injectionPoint)
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 point

fireEvent

void fireEvent(java.lang.Object event,
               java.lang.annotation.Annotation... qualifiers)
Fire an event and notify observers.

Parameters:
event - the event object
qualifiers - the event qualifiers
Throws:
IllegalArgumentException - if the runtime type of the event object contains a type variable
IllegalArgumentException - if two instances of the same qualifier type are given
IllegalArgumentException - if an instance of an annotation that is not a qualifier type is given

resolveObserverMethods

<T> java.util.Set<ObserverMethod<? super T>> resolveObserverMethods(T event,
                                                                    java.lang.annotation.Annotation... qualifiers)
Return the set of observers for an event.

Type Parameters:
T - the type of the event
Parameters:
event - the event object
qualifiers - the event qualifiers
Throws:
IllegalArgumentException - if the runtime type of the event object contains a type variable
IllegalArgumentException - if two instances of the same qualifier type are given
IllegalArgumentException - if an instance of an annotation that is not a qualifier type is given

resolveDecorators

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.

Parameters:
types - the set of bean types of the decorated bean
qualifiers - the qualifiers declared by the decorated bean
Returns:
the resulting set of decorators
Throws:
IllegalArgumentException - if the set of bean types is empty
IllegalArgumentException - if an annotation which is not a binding type is passed
IllegalArgumentException - if two instances of the same binding type are passed

resolveInterceptors

java.util.List<Interceptor<?>> resolveInterceptors(InterceptionType type,
                                                   java.lang.annotation.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.

Parameters:
type - the type of the interception
interceptorBindings - the interceptor bindings
Returns:
the resulting set of interceptors
Throws:
IllegalArgumentException - if no interceptor binding type is given
IllegalArgumentException - if two instances of the same interceptor binding type are given
IllegalArgumentException - if an instance of an annotation that is not an interceptor binding type is given

isScope

boolean isScope(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
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

boolean isNormalScope(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
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

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.

Parameters:
annotationType - the annotation type
Returns:
true if the annotation type is a passivating scope type

isQualifier

boolean isQualifier(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
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

boolean isInterceptorBinding(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
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

boolean isStereotype(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
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

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.

Parameters:
bindingType - the interceptor binding type
Returns:
the set of meta-annotations

getStereotypeDefinition

java.util.Set<java.lang.annotation.Annotation> getStereotypeDefinition(java.lang.Class<? extends java.lang.annotation.Annotation> stereotype)
Obtains meta-annotations for a certain stereotype.

Parameters:
stereotype - the stereotype
Returns:
the set of meta-annotations

getContext

Context getContext(java.lang.Class<? extends java.lang.annotation.Annotation> scopeType)
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 scope
IllegalArgumentException - if there is more than one active context object for the given scope

getELResolver

ELResolver getELResolver()
Returns a ELResolver that resolves beans by EL name.


wrapExpressionFactory

ExpressionFactory wrapExpressionFactory(ExpressionFactory expressionFactory)
Returns a wrapper 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.

Parameters:
expressionFactory - the ExpressionFactory to wrap
Returns:
the wrapped ExpressionFactory

createAnnotatedType

<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.

Type Parameters:
T - the class or interface
Parameters:
type - the Class object
Returns:
the AnnotatedType

createInjectionTarget

<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.

Type Parameters:
T - the type
Parameters:
type - the AnnotatedType
Throws:
IllegalArgumentException - if there is a definition error associated with any injection point of the type


Submit a bug or feature

Copyright © 2009-2011, Oracle Corporation and/or its affiliates. All Rights Reserved. Use is subject to license terms.

Generated on 10-February-2011 12:41


Spec-Zone.ru - all specs in one place



free hit counter