Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source
   * Copyright 2010, Red Hat, Inc., and individual contributors
   * by the @authors tag. See the copyright.txt in the distribution for a
   * full listing of individual contributors.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
  * http://www.apache.org/licenses/LICENSE-2.0
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package javax.enterprise.inject.spi;
 
 import java.util.List;
 import java.util.Set;
 

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.

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:

and the following operations must not be called before the AfterDeploymentValidation event is fired:

or the container will throw an Exception.

Author(s):
Gavin King
Pete Muir
Clint Popetz
David Allen
Antoine Sabot-Durand
 
 public interface BeanManager {

    

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 javax.enterprise.context.spi.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:
java.lang.IllegalArgumentException if the given type is not a bean type of the given bean
java.lang.IllegalStateException if called during application initialization, before the AfterDeploymentValidation event is fired.
    public Object getReference(Bean<?> beanType beanTypeCreationalContext<?> ctx);

    

Obtains an injectable reference for a certain injection point.

Parameters:
ij the target injection point
ctx a javax.enterprise.context.spi.CreationalContext that may be used to destroy any object with scope javax.enterprise.context.Dependent that is created
Returns:
the injectable reference
Throws:
javax.enterprise.inject.UnsatisfiedResolutionException if typesafe resolution results in an unsatisfied dependency
javax.enterprise.inject.AmbiguousResolutionException typesafe resolution results in an unresolvable ambiguous dependency
java.lang.IllegalStateException if called during application initialization, before the AfterDeploymentValidation event is fired.
    public Object getInjectableReference(InjectionPoint ijCreationalContext<?> ctx);

    
Obtain an instance of a javax.enterprise.context.spi.CreationalContext for the given contextual type, or for a non-contextual object.

Parameters:
contextual the javax.enterprise.context.spi.Contextual, or a null value in the case of a non-contextual object
Returns:
the new javax.enterprise.context.spi.CreationalContext
    public <T> CreationalContext<T> createCreationalContext(Contextual<T> contextual);

    
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.

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.

Parameters:
beanType the required bean type
qualifiers the required qualifiers
Returns:
the resulting set of beans
Throws:
java.lang.IllegalArgumentException if the given type represents a type variable
java.lang.IllegalArgumentException if two instances of the same qualifier type are given
java.lang.IllegalArgumentException if an instance of an annotation that is not a qualifier type is given
java.lang.IllegalStateException if called during application initialization, before the AfterBeanDiscovery event is fired.
    public Set<Bean<?>> getBeans(Type beanTypeAnnotation... qualifiers);

    
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.

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.

Parameters:
name the EL name
Returns:
the resulting set of beans
Throws:
java.lang.IllegalStateException if called during application initialization, before the AfterBeanDiscovery event is fired.
    public Set<Bean<?>> getBeans(String name);

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

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
Throws:
java.lang.IllegalStateException if called during application initialization, before the AfterBeanDiscovery event is fired.
    public Bean<?> getPassivationCapableBean(String id);

    
Apply the ambiguous dependency resolution rules to a set of beans.

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.

Parameters:
<X> a common type of the beans
beans a set of beans of the given type
Returns:
the resolved bean, or null if null or an empty set is passed
Throws:
javax.enterprise.inject.AmbiguousResolutionException if the ambiguous dependency resolution rules fail
java.lang.IllegalStateException if called during application initialization, before the AfterBeanDiscovery event is fired.
    public <X> Bean<? extends X> resolve(Set<Bean<? extends X>> beans);

    
Validate a certain injection point.

Note that when called during invocation of an AfterBeanDiscovery event observer, this method will only validate injection points discovered by the container before the AfterBeanDiscovery event is fired.

Parameters:
injectionPoint the injection point to validate
Throws:
javax.enterprise.inject.InjectionException if there is a deployment problem (for example, an unsatisfied or unresolvable ambiguous dependency) associated with the injection point
java.lang.IllegalStateException if called during application initialization, before the AfterBeanDiscovery event is fired.
    public void validate(InjectionPoint injectionPoint);

    
Fire an event and notify observers.

Parameters:
event the event object
qualifiers the event qualifiers
Throws:
java.lang.IllegalArgumentException if the runtime type of the event object contains a type variable
java.lang.IllegalArgumentException if two instances of the same qualifier type are given
java.lang.IllegalArgumentException if an instance of an annotation that is not a qualifier type is given
java.lang.IllegalArgumentException if the runtime type of the event object is assignable to the type of a container lifecycle event
javax.enterprise.event.ObserverException if a notified observer throws a checked exception, it will be wrapped and rethrown as an (unchecked) javax.enterprise.event.ObserverException
    public void fireEvent(Object eventAnnotation... qualifiers);

    
Return the set of observers for an event.

Note that when called during invocation of an AfterBeanDiscovery event observer, this method will only return observers discovered by the container before the AfterBeanDiscovery event is fired.

Parameters:
<T> the type of the event
event the event object
qualifiers the event qualifiers
Throws:
java.lang.IllegalArgumentException if the runtime type of the event object contains a type variable
java.lang.IllegalArgumentException if two instances of the same qualifier type are given
java.lang.IllegalArgumentException if an instance of an annotation that is not a qualifier type is given
java.lang.IllegalStateException if called during application initialization, before the AfterBeanDiscovery event is fired.
    public <T> Set<ObserverMethod<? super T>> resolveObserverMethods(T eventAnnotation... 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.

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.

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:
java.lang.IllegalArgumentException if the set of bean types is empty
java.lang.IllegalArgumentException if an annotation which is not a binding type is passed
java.lang.IllegalArgumentException if two instances of the same binding type are passed
java.lang.IllegalStateException if called during application initialization, before the AfterBeanDiscovery event is fired.
    public List<Decorator<?>> resolveDecorators(Set<TypetypesAnnotation... qualifiers);

    
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.

Note that when called during invocation of an AfterBeanDiscovery event observer, this method will only return interceptors discovered by the container before the AfterBeanDiscovery event is fired.

Parameters:
type the type of the interception
interceptorBindings the interceptor bindings
Returns:
the resulting set of interceptors
Throws:
java.lang.IllegalArgumentException if no interceptor binding type is given
java.lang.IllegalArgumentException if two instances of the same interceptor binding type are given
java.lang.IllegalArgumentException if an instance of an annotation that is not an interceptor binding type is given
java.lang.IllegalStateException if called during application initialization, before the AfterBeanDiscovery event is fired.
    public List<Interceptor<?>> resolveInterceptors(InterceptionType typeAnnotation... interceptorBindings);

    
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
    public boolean isScope(Class<? extends AnnotationannotationType);

    
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
    public boolean isNormalScope(Class<? extends AnnotationannotationType);

    
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
    public boolean isPassivatingScope(Class<? extends AnnotationannotationType);

    
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
    public boolean isQualifier(Class<? extends AnnotationannotationType);

    
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
    public boolean isInterceptorBinding(Class<? extends AnnotationannotationType);

    
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
    public boolean isStereotype(Class<? extends AnnotationannotationType);

    
Obtains the set of meta-annotations for a certain interceptor binding type .

Parameters:
bindingType the interceptor binding type
Returns:
the set of meta-annotations
    public Set<AnnotationgetInterceptorBindingDefinition(Class<? extends AnnotationbindingType);

    
Obtains meta-annotations for a certain stereotype.

Parameters:
stereotype the stereotype
Returns:
the set of meta-annotations
    public Set<AnnotationgetStereotypeDefinition(Class<? extends Annotationstereotype);

    
Determine if two qualifiers are considered equivalent for the purposes of typesafe resolution, taking into account any members annotated with javax.enterprise.util.Nonbinding.

Parameters:
qualifier1 a qualifier to check
qualifier2 a qualifier to check
Returns:
true if the two qualifiers are equivalent, otherwise false
Since:
1.1
    public boolean areQualifiersEquivalent(Annotation qualifier1Annotation qualifier2);

    
Determine if two interceptor bindings are considered equivalent for the purposes of typesafe resolution, taking into account any members annotated with javax.enterprise.util.Nonbinding.

Parameters:
interceptorBinding1 an interceptor binding to check
interceptorBinding2 an interceptor binding to check
Returns:
true if the two interceptor bindings are equivalent, otherwise false
Since:
1.1
    public boolean areInterceptorBindingsEquivalent(Annotation interceptorBinding1Annotation interceptorBinding2);

    
Determine the hash code of a qualifier, using the JDK algorithm for determining an annotation hash code, ignoring any members annotated with javax.enterprise.util.Nonbinding.

Parameters:
qualifier the qualifier to consider
Returns:
the hashCode for the qualifier
Since:
1.1
    public int getQualifierHashCode(Annotation qualifier);

    
Determine the hash code of an interceptor binding, using the JDK algorithm for determining an annotation hash code, ignoring any members annotated with javax.enterprise.util.Nonbinding.

Parameters:
interceptorBinding the interceptor binding to consider
Returns:
the hashCode for the interceptor binding
Since:
1.1
    public int getInterceptorBindingHashCode(Annotation interceptorBinding);

    
Obtains an active context object for the given scope .

Parameters:
scopeType the scope
Returns:
the context object
Throws:
javax.enterprise.context.ContextNotActiveException if there is no active context object for the given scope
java.lang.IllegalArgumentException if there is more than one active context object for the given scope
    public Context getContext(Class<? extends AnnotationscopeType);

    
Returns a javax.el.ELResolver that resolves beans by EL name.
    public ELResolver getELResolver();

    
Returns a wrapper javax.el.ExpressionFactory that delegates javax.el.MethodExpression and javax.el.ValueExpression creation to the given javax.el.ExpressionFactory. When a Unified EL expression is evaluated using a javax.el.MethodExpression or javax.el.ValueExpression returned by the wrapper javax.el.ExpressionFactory, the container handles destruction of objects with scope javax.enterprise.context.Dependent.

Parameters:
expressionFactory the javax.el.ExpressionFactory to wrap
Returns:
the wrapped javax.el.ExpressionFactory
    public ExpressionFactory wrapExpressionFactory(ExpressionFactory expressionFactory);

    
Obtain an AnnotatedType that may be used to read the annotations of the given class or interface.

Parameters:
<T> the class or interface
type the java.lang.Class object
Returns:
the AnnotatedType
    public <T> AnnotatedType<T> createAnnotatedType(Class<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(javax.enterprise.inject.spi.AnnotatedType) should be used instead.

Parameters:
<T> the type
type the AnnotatedType
Returns:
a container provided implementation of InjectionTarget
Throws:
java.lang.IllegalArgumentException if there is a definition error associated with any injection point of the type
    public <T> InjectionTarget<T> createInjectionTarget(AnnotatedType<T> type);

    

An implementation of InjectionTargetFactory that provides container created InjectionTarget instances.

This factory can be wrapped to add behavior to container created injection targets.

Parameters:
annotatedType the annotated type to create the injection target factory for
Returns:
an InjectionTargetFactory
Since:
1.1
    public <T> InjectionTargetFactory<T> getInjectionTargetFactory(AnnotatedType<T> annotatedType);

    

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.

Parameters:
field the field to create the producer factory for
declaringBean the bean declaring the producer. May be null if the producer is static or the declaring object is non-contextual
Returns:
the producer factory for the field
Since:
1.1
    public <X> ProducerFactory<X> getProducerFactory(AnnotatedField<? super X> fieldBean<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.

Parameters:
method the method to create the producer factory for
declaringBean the bean declaring the producer. May be null if the producer is static or the declaring object is non-contextual
Returns:
the producer factory for the method
Since:
1.1
    public <X> ProducerFactory<X> getProducerFactory(AnnotatedMethod<? super X> methodBean<X> declaringBean);

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

Parameters:
<T> the type
type the AnnotatedType
Returns:
a container provided implementation of InjectionTarget
Since:
1.1
    public <T> BeanAttributes<T> createBeanAttributes(AnnotatedType<T> type);

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

Parameters:
type the AnnotatedType
Returns:
a container provided implementation of InjectionTarget
Since:
1.1
    public BeanAttributes<?> createBeanAttributes(AnnotatedMember<?> type);

    

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(javax.enterprise.inject.spi.AnnotatedType) allows use of a container created InjectionTarget.

Parameters:
<T> the type
attributes 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
Returns:
a container provided implementation of Bean
Since:
1.1
    public <T> Bean<T> createBean(BeanAttributes<T> attributesClass<T> beanClass,
            InjectionTargetFactory<T> injectionTargetFactory);

    

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(javax.enterprise.inject.spi.AnnotatedMethod,javax.enterprise.inject.spi.Bean) or getProducerFactory(javax.enterprise.inject.spi.AnnotatedField,javax.enterprise.inject.spi.Bean) allows use of a container created Producer.

Parameters:
<T> the type
<X> the type of the declaring bean
attributes 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 java.lang.Object.getClass()
producerFactory a ProducerFactory, used to obtain a Producer
Returns:
a container provided implementation of Bean
Since:
1.1
    public <T, X> Bean<T> createBean(BeanAttributes<T> attributesClass<X> beanClassProducerFactory<X> producerFactory);

    
Obtains a container provided implementation of InjectionPoint for the given AnnotatedField.

Parameters:
field the AnnotatedField defining the injection point
Returns:
the container provided InjectionPoint
Throws:
java.lang.IllegalArgumentException if there is a definition error associated with the injection point
Since:
1.1
    public InjectionPoint createInjectionPoint(AnnotatedField<?> field);

    
Obtains a container provided implementation of InjectionPoint for the given AnnotatedParameter.

Parameters:
parameter the AnnotatedParameter defining the injection point
Returns:
the container provided InjectionPoint
Throws:
java.lang.IllegalArgumentException if there is a definition error associated with the injection point
Since:
1.1
    public InjectionPoint createInjectionPoint(AnnotatedParameter<?> parameter);

    
Obtains the container's instance of an Extension class declared in META-INF/services.

Parameters:
<T> the type of the extension
extensionClass the type of the extension class
Returns:
the extension instance
Throws:
java.lang.IllegalArgumentException if the container has no instance of the given class
Since:
1.1
    public <T extends Extension> T getExtension(Class<T> extensionClass);
New to GrepCode? Check out our FAQ X