BeanManager
Date: 2015-09-11

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.

- - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `<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.
    `javax.el.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.
    `javax.el.ExpressionFactory` | `wrapExpressionFactory(javax.el.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:
        `java.lang.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:
        `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

    - #### 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:
        `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

    - #### 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:
        `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

    - #### 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:
        `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

    - #### 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:
        `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

    - #### 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
        `java.lang.IllegalArgumentException` - if there is more than one active context object for the given scope

    - #### getELResolver

          javax.el.ELResolver getELResolver()

      Returns a `ELResolver` that resolves beans by EL name.

    - #### wrapExpressionFactory

          javax.el.ExpressionFactory wrapExpressionFactory(javax.el.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:
        `java.lang.IllegalArgumentException` - if there is a definition error associated with any injection point of the type