ForwardingBeanManager (Weld Servlet (Uber Jar) 2.2.12.Final API)

java.lang.Object
- org.jboss.weld.util.ForwardingBeanManager

All Implemented Interfaces:

java.io.Serializable, BeanManager

Direct Known Subclasses:

BeanManagerProxy
```
public abstract class ForwardingBeanManager
extends java.lang.Object
implements BeanManager, java.io.Serializable
```
Forwarding implementation of BeanManager.

Author:

Martin Kouba

See Also:

Serialized Form

Constructor Summary

Constructors
Constructor and Description

ForwardingBeanManager()

Constructors
Constructor and Description
`ForwardingBeanManager()`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`areInterceptorBindingsEquivalent(java.lang.annotation.Annotation interceptorBinding1, java.lang.annotation.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(java.lang.annotation.Annotation qualifier1, java.lang.annotation.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(java.lang.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, java.lang.Class<T> beanClass, InjectionTargetFactory<T> injectionTargetFactory)` Obtains a `Bean` for the given `BeanAttributes`, bean class and `InjectionTarget`.
`<T,X> Bean<T>`	`createBean(BeanAttributes<T> attributes, java.lang.Class<X> beanClass, ProducerFactory<X> producerFactory)` Obtains a `Bean` for the given `BeanAttributes`, bean class and `Producer`.
`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`.
`abstract BeanManager`	`delegate()`
`boolean`	`equals(java.lang.Object obj)`
`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.
`<T extends Extension> T`	`getExtension(java.lang.Class<T> extensionClass)` Obtains the container's instance of an Extension class declared in `META-INF/services`.
`java.lang.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.
`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 .
`int`	`getInterceptorBindingHashCode(java.lang.annotation.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(java.lang.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(java.lang.annotation.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`.
`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.
`int`	`hashCode()`
`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.
`java.lang.String`	`toString()`
`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`.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - ForwardingBeanManager
```
public ForwardingBeanManager()
```
- Method Detail
  - delegate
```
public abstract BeanManager delegate()
```
  - getReference
```
public java.lang.Object getReference(Bean<?> bean,
                                     java.lang.reflect.Type beanType,
                                     CreationalContext<?> ctx)
```
    Description copied from interface: BeanManager
    
    Obtains a contextual reference for a certain bean and a certain bean type of the bean.
    
    Specified by:
    
    getReference in interface BeanManager
    
    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 Dependent that is created
    
    Returns:
    
    a contextual reference representing the bean
  - getInjectableReference
```
public java.lang.Object getInjectableReference(InjectionPoint ij,
                                               CreationalContext<?> ctx)
```
    Description copied from interface: BeanManager
    
    Obtains an injectable reference for a certain injection point.
    
    Specified by:
    
    getInjectableReference in interface BeanManager
    
    Parameters:
    
    ij - the target injection point
    
    ctx - a CreationalContext that may be used to destroy any object with scope Dependent that is created
    
    Returns:
    
    the injectable reference
  - createCreationalContext
```
public <T> CreationalContext<T> createCreationalContext(Contextual<T> contextual)
```
    Description copied from interface: BeanManager
    
    Obtain an instance of a CreationalContext for the given contextual type, or for a non-contextual object.
    
    Specified by:
    
    createCreationalContext in interface BeanManager
    
    Parameters:
    
    contextual - the Contextual, or a null value in the case of a non-contextual object
    
    Returns:
    
    the new CreationalContext
  - getBeans
```
public java.util.Set<Bean<?>> getBeans(java.lang.reflect.Type beanType,
                                       java.lang.annotation.Annotation... qualifiers)
```
    Description copied from interface: BeanManager
    
    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.
    
    Specified by:
    
    getBeans in interface BeanManager
    
    Parameters:
    
    beanType - the required bean type
    
    qualifiers - the required qualifiers
    
    Returns:
    
    the resulting set of beans
  - getBeans
```
public java.util.Set<Bean<?>> getBeans(java.lang.String name)
```
    Description copied from interface: BeanManager
    
    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.
    
    Specified by:
    
    getBeans in interface BeanManager
    
    Parameters:
    
    name - the EL name
    
    Returns:
    
    the resulting set of beans
  - getPassivationCapableBean
```
public Bean<?> getPassivationCapableBean(java.lang.String id)
```
    Description copied from interface: BeanManager
    
    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.
    
    Specified by:
    
    getPassivationCapableBean in interface BeanManager
    
    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
```
public <X> Bean<? extends X> resolve(java.util.Set<Bean<? extends X>> beans)
```
    Description copied from interface: BeanManager
    
    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.
    
    Specified by:
    
    resolve in interface BeanManager
    
    Type Parameters:
    
    X - a common type of the beans
    
    Parameters:
    
    beans - a set of beans of the given type
    
    Returns:
    
    the resolved bean, or null if null or an empty set is passed
  - validate
```
public void validate(InjectionPoint injectionPoint)
```
    Description copied from interface: BeanManager
    
    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.
    
    Specified by:
    
    validate in interface BeanManager
    
    Parameters:
    
    injectionPoint - the injection point to validate
  - fireEvent
```
public void fireEvent(java.lang.Object event,
                      java.lang.annotation.Annotation... qualifiers)
```
    Description copied from interface: BeanManager
    
    Fire an event and notify observers.
    
    Specified by:
    
    fireEvent in interface BeanManager
    
    Parameters:
    
    event - the event object
    
    qualifiers - the event qualifiers
  - resolveObserverMethods
```
public <T> java.util.Set<ObserverMethod<? super T>> resolveObserverMethods(T event,
                                                                           java.lang.annotation.Annotation... qualifiers)
```
    Description copied from interface: BeanManager
    
    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.
    
    Specified by:
    
    resolveObserverMethods in interface BeanManager
    
    Type Parameters:
    
    T - the type of the event
    
    Parameters:
    
    event - the event object
    
    qualifiers - the event qualifiers
  - resolveDecorators
```
public java.util.List<Decorator<?>> resolveDecorators(java.util.Set<java.lang.reflect.Type> types,
                                                      java.lang.annotation.Annotation... qualifiers)
```
    Description copied from interface: BeanManager
    
    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.
    
    Specified by:
    
    resolveDecorators in interface BeanManager
    
    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
  - resolveInterceptors
```
public java.util.List<Interceptor<?>> resolveInterceptors(InterceptionType type,
                                                          java.lang.annotation.Annotation... interceptorBindings)
```
    Description copied from interface: BeanManager
    
    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.
    
    Specified by:
    
    resolveInterceptors in interface BeanManager
    
    Parameters:
    
    type - the type of the interception
    
    interceptorBindings - the interceptor bindings
    
    Returns:
    
    the resulting set of interceptors
  - isScope
```
public boolean isScope(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
```
    Description copied from interface: BeanManager
    
    Test the given annotation type to determine if it is a scope type.
    
    Specified by:
    
    isScope in interface BeanManager
    
    Parameters:
    
    annotationType - the annotation type
    
    Returns:
    
    true if the annotation type is a scope type
  - isNormalScope
```
public boolean isNormalScope(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
```
    Description copied from interface: BeanManager
    
    Test the given annotation type to determine if it is a normal scope type.
    
    Specified by:
    
    isNormalScope in interface BeanManager
    
    Parameters:
    
    annotationType - the annotation type
    
    Returns:
    
    true if the annotation type is a normal scope type
  - isPassivatingScope
```
public boolean isPassivatingScope(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
```
    Description copied from interface: BeanManager
    
    Test the given annotation type to determine if it is a passivating scope type.
    
    Specified by:
    
    isPassivatingScope in interface BeanManager
    
    Parameters:
    
    annotationType - the annotation type
    
    Returns:
    
    true if the annotation type is a passivating scope type
  - isQualifier
```
public boolean isQualifier(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
```
    Description copied from interface: BeanManager
    
    Test the given annotation type to determine if it is a qualifier type.
    
    Specified by:
    
    isQualifier in interface BeanManager
    
    Parameters:
    
    annotationType - the annotation type
    
    Returns:
    
    true if the annotation type is a qualifier type
  - isInterceptorBinding
```
public boolean isInterceptorBinding(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
```
    Description copied from interface: BeanManager
    
    Test the given annotation type to determine if it is an interceptor binding type .
    
    Specified by:
    
    isInterceptorBinding in interface BeanManager
    
    Parameters:
    
    annotationType - the annotation to test
    
    Returns:
    
    true if the annotation type is a interceptor binding type
  - isStereotype
```
public boolean isStereotype(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
```
    Description copied from interface: BeanManager
    
    Test the given annotation type to determine if it is a stereotype.
    
    Specified by:
    
    isStereotype in interface BeanManager
    
    Parameters:
    
    annotationType - the annotation type
    
    Returns:
    
    true if the annotation type is a stereotype
  - getInterceptorBindingDefinition
```
public java.util.Set<java.lang.annotation.Annotation> getInterceptorBindingDefinition(java.lang.Class<? extends java.lang.annotation.Annotation> bindingType)
```
    Description copied from interface: BeanManager
    
    Obtains the set of meta-annotations for a certain interceptor binding type .
    
    Specified by:
    
    getInterceptorBindingDefinition in interface BeanManager
    
    Parameters:
    
    bindingType - the interceptor binding type
    
    Returns:
    
    the set of meta-annotations
  - getStereotypeDefinition
```
public java.util.Set<java.lang.annotation.Annotation> getStereotypeDefinition(java.lang.Class<? extends java.lang.annotation.Annotation> stereotype)
```
    Description copied from interface: BeanManager
    
    Obtains meta-annotations for a certain stereotype.
    
    Specified by:
    
    getStereotypeDefinition in interface BeanManager
    
    Parameters:
    
    stereotype - the stereotype
    
    Returns:
    
    the set of meta-annotations
  - areQualifiersEquivalent
```
public boolean areQualifiersEquivalent(java.lang.annotation.Annotation qualifier1,
                                       java.lang.annotation.Annotation qualifier2)
```
    Description copied from interface: BeanManager
    
    Determine if two qualifiers are considered equivalent for the purposes of typesafe resolution, taking into account any members annotated with Nonbinding.
    
    Specified by:
    
    areQualifiersEquivalent in interface BeanManager
    
    Parameters:
    
    qualifier1 - a qualifier to check
    
    qualifier2 - a qualifier to check
    
    Returns:
    
    true if the two qualifiers are equivalent, otherwise false
  - areInterceptorBindingsEquivalent
```
public boolean areInterceptorBindingsEquivalent(java.lang.annotation.Annotation interceptorBinding1,
                                                java.lang.annotation.Annotation interceptorBinding2)
```
    Description copied from interface: BeanManager
    
    Determine if two interceptor bindings are considered equivalent for the purposes of typesafe resolution, taking into account any members annotated with Nonbinding.
    
    Specified by:
    
    areInterceptorBindingsEquivalent in interface BeanManager
    
    Parameters:
    
    interceptorBinding1 - an interceptor binding to check
    
    interceptorBinding2 - an interceptor binding to check
    
    Returns:
    
    true if the two interceptor bindings are equivalent, otherwise false
  - getQualifierHashCode
```
public int getQualifierHashCode(java.lang.annotation.Annotation qualifier)
```
    Description copied from interface: BeanManager
    
    Determine the hash code of a qualifier, using the JDK algorithm for determining an annotation hash code, ignoring any members annotated with Nonbinding.
    
    Specified by:
    
    getQualifierHashCode in interface BeanManager
    
    Parameters:
    
    qualifier - the qualifier to consider
    
    Returns:
    
    the hashCode for the qualifier
  - getInterceptorBindingHashCode
```
public int getInterceptorBindingHashCode(java.lang.annotation.Annotation interceptorBinding)
```
    Description copied from interface: BeanManager
    
    Determine the hash code of an interceptor binding, using the JDK algorithm for determining an annotation hash code, ignoring any members annotated with Nonbinding.
    
    Specified by:
    
    getInterceptorBindingHashCode in interface BeanManager
    
    Parameters:
    
    interceptorBinding - the interceptor binding to consider
    
    Returns:
    
    the hashCode for the interceptor binding
  - getContext
```
public Context getContext(java.lang.Class<? extends java.lang.annotation.Annotation> scopeType)
```
    Description copied from interface: BeanManager
    
    Obtains an active context object for the given scope .
    
    Specified by:
    
    getContext in interface BeanManager
    
    Parameters:
    
    scopeType - the scope
    
    Returns:
    
    the context object
  - getELResolver
```
public ELResolver getELResolver()
```
    Description copied from interface: BeanManager
    
    Returns a ELResolver that resolves beans by EL name.
    
    Specified by:
    
    getELResolver in interface BeanManager
  - wrapExpressionFactory
```
public ExpressionFactory wrapExpressionFactory(ExpressionFactory expressionFactory)
```
    Description copied from interface: BeanManager
    
    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.
    
    Specified by:
    
    wrapExpressionFactory in interface BeanManager
    
    Parameters:
    
    expressionFactory - the ExpressionFactory to wrap
    
    Returns:
    
    the wrapped ExpressionFactory
  - createAnnotatedType
```
public <T> AnnotatedType<T> createAnnotatedType(java.lang.Class<T> type)
```
    Description copied from interface: BeanManager
    
    Obtain an AnnotatedType that may be used to read the annotations of the given class or interface.
    
    Specified by:
    
    createAnnotatedType in interface BeanManager
    
    Type Parameters:
    
    T - the class or interface
    
    Parameters:
    
    type - the Class object
    
    Returns:
    
    the AnnotatedType
  - createInjectionTarget
```
public <T> InjectionTarget<T> createInjectionTarget(AnnotatedType<T> type)
```
    Description copied from interface: BeanManager
    
    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 BeanManager.getInjectionTargetFactory(AnnotatedType) should be used instead.
    
    Specified by:
    
    createInjectionTarget in interface BeanManager
    
    Type Parameters:
    
    T - the type
    
    Parameters:
    
    type - the AnnotatedType
    
    Returns:
    
    a container provided implementation of InjectionTarget
  - createBeanAttributes
```
public <T> BeanAttributes<T> createBeanAttributes(AnnotatedType<T> type)
```
    Description copied from interface: BeanManager
    
    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.
    
    Specified by:
    
    createBeanAttributes in interface BeanManager
    
    Type Parameters:
    
    T - the type
    
    Parameters:
    
    type - the AnnotatedType
    
    Returns:
    
    a container provided implementation of InjectionTarget
  - createBeanAttributes
```
public BeanAttributes<?> createBeanAttributes(AnnotatedMember<?> type)
```
    Description copied from interface: BeanManager
    
    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.
    
    Specified by:
    
    createBeanAttributes in interface BeanManager
    
    Parameters:
    
    type - the AnnotatedType
    
    Returns:
    
    a container provided implementation of InjectionTarget
  - createBean
```
public <T> Bean<T> createBean(BeanAttributes<T> attributes,
                              java.lang.Class<T> beanClass,
                              InjectionTargetFactory<T> injectionTargetFactory)
```
    Description copied from interface: BeanManager
    
    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. BeanManager.getInjectionTargetFactory(AnnotatedType) allows use of a container created InjectionTarget.
    
    Specified by:
    
    createBean in interface BeanManager
    
    Type Parameters:
    
    T - the type
    
    Parameters:
    
    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
  - createBean
```
public <T,X> Bean<T> createBean(BeanAttributes<T> attributes,
                                java.lang.Class<X> beanClass,
                                ProducerFactory<X> producerFactory)
```
    Description copied from interface: BeanManager
    
    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. BeanManager.getProducerFactory(AnnotatedMethod, Bean) or BeanManager.getProducerFactory(AnnotatedField, Bean) allows use of a container created Producer.
    
    Specified by:
    
    createBean in interface BeanManager
    
    Type Parameters:
    
    T - the type
    
    X - the type of the declaring bean
    
    Parameters:
    
    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#getClass()
    
    producerFactory - a ProducerFactory, used to obtain a Producer
    
    Returns:
    
    a container provided implementation of Bean
  - createInjectionPoint
```
public InjectionPoint createInjectionPoint(AnnotatedField<?> field)
```
    Description copied from interface: BeanManager
    
    Obtains a container provided implementation of InjectionPoint for the given AnnotatedField.
    
    Specified by:
    
    createInjectionPoint in interface BeanManager
    
    Parameters:
    
    field - the AnnotatedField defining the injection point
    
    Returns:
    
    the container provided InjectionPoint
  - createInjectionPoint
```
public InjectionPoint createInjectionPoint(AnnotatedParameter<?> parameter)
```
    Description copied from interface: BeanManager
    
    Obtains a container provided implementation of InjectionPoint for the given AnnotatedParameter.
    
    Specified by:
    
    createInjectionPoint in interface BeanManager
    
    Parameters:
    
    parameter - the AnnotatedParameter defining the injection point
    
    Returns:
    
    the container provided InjectionPoint
  - getExtension
```
public <T extends Extension> T getExtension(java.lang.Class<T> extensionClass)
```
    Description copied from interface: BeanManager
    
    Obtains the container's instance of an Extension class declared in META-INF/services.
    
    Specified by:
    
    getExtension in interface BeanManager
    
    Type Parameters:
    
    T - the type of the extension
    
    Parameters:
    
    extensionClass - the type of the extension class
    
    Returns:
    
    the extension instance
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Overrides:
    
    equals in class java.lang.Object
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - getInjectionTargetFactory
```
public <T> InjectionTargetFactory<T> getInjectionTargetFactory(AnnotatedType<T> annotatedType)
```
    Description copied from interface: BeanManager
    
    An implementation of InjectionTargetFactory that provides container created InjectionTarget instances.
    
    This factory can be wrapped to add behavior to container created injection targets.
    
    Specified by:
    
    getInjectionTargetFactory in interface BeanManager
    
    Parameters:
    
    annotatedType - the annotated type to create the injection target factory for
    
    Returns:
    
    an InjectionTargetFactory
  - getProducerFactory
```
public <X> ProducerFactory<X> getProducerFactory(AnnotatedField<? super X> field,
                                                 Bean<X> declaringBean)
```
    Description copied from interface: BeanManager
    
    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.
    
    Specified by:
    
    getProducerFactory in interface BeanManager
    
    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
  - getProducerFactory
```
public <X> ProducerFactory<X> getProducerFactory(AnnotatedMethod<? super X> method,
                                                 Bean<X> declaringBean)
```
    Description copied from interface: BeanManager
    
    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.
    
    Specified by:
    
    getProducerFactory in interface BeanManager
    
    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

Class ForwardingBeanManager

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ForwardingBeanManager

Method Detail

delegate

getReference

getInjectableReference

createCreationalContext

getBeans

getBeans

getPassivationCapableBean

resolve

validate

fireEvent

resolveObserverMethods

resolveDecorators

resolveInterceptors

isScope

isNormalScope

isPassivatingScope

isQualifier

isInterceptorBinding

isStereotype

getInterceptorBindingDefinition

getStereotypeDefinition

areQualifiersEquivalent

areInterceptorBindingsEquivalent

getQualifierHashCode

getInterceptorBindingHashCode

getContext

getELResolver

wrapExpressionFactory

createAnnotatedType

createInjectionTarget

createBeanAttributes

createBeanAttributes

createBean

createBean

createInjectionPoint

createInjectionPoint

getExtension

hashCode

equals

toString

getInjectionTargetFactory

getProducerFactory

getProducerFactory