BeanManagerImpl (Weld OSGi Bundle 2.4.0.Final API)

java.lang.Object
- org.jboss.weld.manager.BeanManagerImpl

All Implemented Interfaces:

Serializable, javax.enterprise.inject.spi.BeanManager, WeldManager
```
public class BeanManagerImpl
extends Object
implements WeldManager, Serializable
```
Implementation of the Bean Manager.
Essentially a singleton for registering Beans, Contexts, Observers, Interceptors etc. as well as providing resolution

Author:

Pete Muir, Marius Bogoevici, Ales Justin, Jozef Hartinger

See Also:

Serialized Form

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addAccessibleBeanManager(BeanManagerImpl accessibleBeanManager)`
`void`	`addBean(javax.enterprise.inject.spi.Bean<?> bean)`
`void`	`addBeans(Collection<? extends javax.enterprise.inject.spi.Bean<?>> beans)` Optimization which modifies CopyOnWrite structures only once instead of once for every bean.
`void`	`addContext(javax.enterprise.context.spi.Context context)`
`void`	`addDecorator(javax.enterprise.inject.spi.Decorator<?> bean)`
`void`	`addInterceptor(javax.enterprise.inject.spi.Interceptor<?> bean)`
`void`	`addObserver(javax.enterprise.inject.spi.ObserverMethod<?> observer)` Does the actual observer registration
`boolean`	`areInterceptorBindingsEquivalent(Annotation interceptorBinding1, Annotation interceptorBinding2)`
`boolean`	`areQualifiersEquivalent(Annotation qualifier1, Annotation qualifier2)`
`void`	`cleanup()`
`void`	`cleanupAfterBoot()` Clear the bean set that is only used to make sure that no duplicate beans are added.
`BeanManagerImpl`	`createActivity()` Create a new child activity.
`<T> javax.enterprise.inject.spi.AnnotatedType<T>`	`createAnnotatedType(Class<T> type)`
`<T> javax.enterprise.inject.spi.AnnotatedType<T>`	`createAnnotatedType(Class<T> type, String id)` Obtain an `AnnotatedType` that may be used to read the annotations of the given class or interface.
`<T> javax.enterprise.inject.spi.Bean<T>`	`createBean(javax.enterprise.inject.spi.BeanAttributes<T> attributes, Class<T> beanClass, javax.enterprise.inject.spi.InjectionTargetFactory<T> injectionTargetFactory)`
`<T,X> javax.enterprise.inject.spi.Bean<T>`	`createBean(javax.enterprise.inject.spi.BeanAttributes<T> attributes, Class<X> beanClass, javax.enterprise.inject.spi.ProducerFactory<X> producerFactory)`
`javax.enterprise.inject.spi.BeanAttributes<?>`	`createBeanAttributes(javax.enterprise.inject.spi.AnnotatedMember<?> member)`
`<T> javax.enterprise.inject.spi.BeanAttributes<T>`	`createBeanAttributes(javax.enterprise.inject.spi.AnnotatedType<T> type)`
`<T> WeldCreationalContext<T>`	`createCreationalContext(javax.enterprise.context.spi.Contextual<T> contextual)`
`<T> EnhancedAnnotatedType<T>`	`createEnhancedAnnotatedType(Class<T> type)`
`FieldInjectionPointAttributes<?,?>`	`createInjectionPoint(javax.enterprise.inject.spi.AnnotatedField<?> field)`
`ParameterInjectionPointAttributes<?,?>`	`createInjectionPoint(javax.enterprise.inject.spi.AnnotatedParameter<?> parameter)`
`<T> javax.enterprise.inject.spi.InjectionTarget<T>`	`createInjectionTarget(javax.enterprise.inject.spi.AnnotatedType<T> type)`
`<T> javax.enterprise.inject.spi.InjectionTarget<T>`	`createInjectionTarget(EjbDescriptor<T> descriptor)` The injection target for the given EJB, or null if Weld was not given this descriptor in the deployment.
`<T> WeldInjectionTargetBuilder<T>`	`createInjectionTargetBuilder(javax.enterprise.inject.spi.AnnotatedType<T> type)` Returns a new instance of `WeldInjectionTargetBuilder` which can be used to create a new `WeldInjectionTarget` for the specified type.
`<T> void`	`disposeAnnotatedType(Class<T> type, String id)` Dispose the `AnnotatedType` created for the identified type.
`boolean`	`equals(Object obj)`
`javax.enterprise.event.Event<Object>`	`event()`
`Set<QualifierInstance>`	`extractInterceptorBindingsForQualifierInstance(Iterable<QualifierInstance> annotations)`
`void`	`fireEvent(Object event, Annotation... qualifiers)` Fires an event object with given event object for given bindings
`<X> javax.enterprise.inject.spi.InjectionTarget<X>`	`fireProcessInjectionTarget(javax.enterprise.inject.spi.AnnotatedType<X> annotatedType)` Fire a ProcessInjectionTarget event for the given type.
`<X> javax.enterprise.inject.spi.InjectionTarget<X>`	`fireProcessInjectionTarget(javax.enterprise.inject.spi.AnnotatedType<X> annotatedType, javax.enterprise.inject.spi.InjectionTarget<X> injectionTarget)` Fire a ProcessInjectionTarget event for the given type.
`Iterable<javax.enterprise.inject.spi.Bean<?>>`	`getAccessibleBeans()`
`Iterable<javax.enterprise.inject.spi.Decorator<?>>`	`getAccessibleDecorators()`
`Iterable<javax.enterprise.inject.spi.Interceptor<?>>`	`getAccessibleInterceptors()`
`ObserverNotifier`	`getAccessibleLenientObserverNotifier()` Get the lenient observer notifier for accessible observer methods.
`HashSet<BeanManagerImpl>`	`getAccessibleManagers()`
`Iterable<String>`	`getAccessibleNamespaces()`
`<T> SessionBean<T>`	`getBean(EjbDescriptor<T> descriptor)` Get the Bean object for the given EJB, or null if Weld was not given this descriptor in the deployment.
`<T> javax.enterprise.inject.spi.Bean<T>`	`getBean(Resolvable resolvable)`
`TypeSafeBeanResolver`	`getBeanResolver()` Get the web bean resolver.
`List<javax.enterprise.inject.spi.Bean<?>>`	`getBeans()` The beans registered with the Web Bean manager which are resolvable.
`Set<javax.enterprise.inject.spi.Bean<?>>`	`getBeans(javax.enterprise.inject.spi.InjectionPoint injectionPoint)`
`Set<javax.enterprise.inject.spi.Bean<?>>`	`getBeans(String name)`
`Set<javax.enterprise.inject.spi.Bean<?>>`	`getBeans(Type beanType, Annotation... qualifiers)`
`Set<javax.enterprise.inject.spi.Bean<?>>`	`getBeans(Type beanType, Set<Annotation> qualifiers)`
`ClientProxyProvider`	`getClientProxyProvider()`
`ContainerLifecycleEvents`	`getContainerLifecycleEvents()`
`javax.enterprise.context.spi.Context`	`getContext(Class<? extends Annotation> scopeType)` Gets an active context of the given scope.
`String`	`getContextId()`
`protected Map<Class<? extends Annotation>,List<javax.enterprise.context.spi.Context>>`	`getContexts()`
`BeanManagerImpl`	`getCurrent()`
`TypeSafeDecoratorResolver`	`getDecoratorResolver()` Get the decorator resolver.
`List<javax.enterprise.inject.spi.Decorator<?>>`	`getDecorators()`
`<T> EjbDescriptor<T>`	`getEjbDescriptor(String beanName)` Get the EjbDescriptor for the given EJB name
`javax.el.ELResolver`	`getELResolver()`
`ModuleEnablement`	`getEnabled()` Enabled Alternatives, Interceptors and Decorators
`Map<EjbDescriptor<?>,SessionBean<?>>`	`getEnterpriseBeans()` Gets the class-mapped beans.
`<T extends javax.enterprise.inject.spi.Extension> T`	`getExtension(Class<T> extensionClass)`
`ObserverNotifier`	`getGlobalLenientObserverNotifier()` Get the lenient global observer notifier.
`ObserverNotifier`	`getGlobalStrictObserverNotifier()` Get the Strict global observer notifier.
`AtomicInteger`	`getChildIds()`
`String`	`getId()` The ID of the manager, identical to the ID provided by the BDA
`Object`	`getInjectableReference(javax.enterprise.inject.spi.InjectionPoint injectionPoint, javax.enterprise.inject.spi.Bean<?> resolvedBean, javax.enterprise.context.spi.CreationalContext<?> creationalContext)` Get a reference, registering the injection point used.
`Object`	`getInjectableReference(javax.enterprise.inject.spi.InjectionPoint injectionPoint, javax.enterprise.context.spi.CreationalContext<?> creationalContext)`
`<T> WeldInjectionTargetFactory<T>`	`getInjectionTargetFactory(javax.enterprise.inject.spi.AnnotatedType<T> type)` Creates an `InjectionTargetFactory` for a given type.
`<T> WeldInstance<Object>`	`getInstance(javax.enterprise.context.spi.CreationalContext<?> ctx)`
`Set<Annotation>`	`getInterceptorBindingDefinition(Class<? extends Annotation> bindingType)`
`int`	`getInterceptorBindingHashCode(Annotation interceptorBinding)`
`InterceptorMetadataReader`	`getInterceptorMetadataReader()`
`ConcurrentMap<SlimAnnotatedType<?>,InterceptionModel>`	`getInterceptorModelRegistry()`
`TypeSafeInterceptorResolver`	`getInterceptorResolver()`
`List<javax.enterprise.inject.spi.Interceptor<?>>`	`getInterceptors()`
`<T> InjectionTargetFactoryImpl<T>`	`getLocalInjectionTargetFactory(javax.enterprise.inject.spi.AnnotatedType<T> type)` Creates an `InjectionTargetFactory` for a given type.
`NameBasedResolver`	`getNameBasedResolver()`
`protected List<String>`	`getNamespaces()`
`List<javax.enterprise.inject.spi.ObserverMethod<?>>`	`getObservers()`
`javax.enterprise.inject.spi.Bean<?>`	`getPassivationCapableBean(BeanIdentifier identifier)`
`javax.enterprise.inject.spi.Bean<?>`	`getPassivationCapableBean(String id)`
`<X> FieldProducerFactory<X>`	`getProducerFactory(javax.enterprise.inject.spi.AnnotatedField<? super X> field, javax.enterprise.inject.spi.Bean<X> declaringBean)`
`<X> MethodProducerFactory<X>`	`getProducerFactory(javax.enterprise.inject.spi.AnnotatedMethod<? super X> method, javax.enterprise.inject.spi.Bean<X> declaringBean)`
`int`	`getQualifierHashCode(Annotation qualifier)`
`Object`	`getReference(javax.enterprise.inject.spi.Bean<?> bean, Type requestedType, javax.enterprise.context.spi.CreationalContext<?> creationalContext)`
`Object`	`getReference(javax.enterprise.inject.spi.Bean<?> bean, Type requestedType, javax.enterprise.context.spi.CreationalContext<?> creationalContext, boolean noProxy)`
`Object`	`getReference(javax.enterprise.inject.spi.InjectionPoint injectionPoint, javax.enterprise.inject.spi.Bean<?> resolvedBean, javax.enterprise.context.spi.CreationalContext<?> creationalContext)` Deprecated. Use `getInjectableReference(InjectionPoint, Bean, CreationalContext)` instead
`ServiceRegistry`	`getServices()` Get the services registered for this manager
`Set<Annotation>`	`getStereotypeDefinition(Class<? extends Annotation> stereotype)`
`javax.enterprise.context.spi.Context`	`getUnwrappedContext(Class<? extends Annotation> scopeType)`
`int`	`hashCode()`
`javax.enterprise.inject.Instance<Object>`	`instance()`
`<X> javax.enterprise.inject.spi.BeanAttributes<?>`	`internalCreateBeanAttributes(javax.enterprise.inject.spi.AnnotatedMember<X> member)`
`boolean`	`isBeanEnabled(javax.enterprise.inject.spi.Bean<?> bean)`
`boolean`	`isContextActive(Class<? extends Annotation> scopeType)` Indicates whether there is an active context for a given scope.
`boolean`	`isInterceptorBinding(Class<? extends Annotation> annotationType)`
`boolean`	`isNormalScope(Class<? extends Annotation> annotationType)`
`boolean`	`isPassivatingScope(Class<? extends Annotation> annotationType)`
`boolean`	`isQualifier(Class<? extends Annotation> annotationType)`
`boolean`	`isScope(Class<? extends Annotation> annotationType)`
`boolean`	`isStereotype(Class<? extends Annotation> annotationType)`
`static BeanManagerImpl`	`newChildActivityManager(BeanManagerImpl parentManager)` Create a new child manager
`static BeanManagerImpl`	`newManager(BeanManagerImpl rootManager, String id, ServiceRegistry services)`
`static BeanManagerImpl`	`newRootManager(String contextId, String id, ServiceRegistry serviceRegistry)` Create a new, root, manager
`protected Object`	`readResolve()`
`protected void`	`registerBeanNamespace(javax.enterprise.inject.spi.Bean<?> bean)`
`<X> javax.enterprise.inject.spi.Bean<? extends X>`	`resolve(Set<javax.enterprise.inject.spi.Bean<? extends X>> beans)`
`List<javax.enterprise.inject.spi.Decorator<?>>`	`resolveDecorators(Set<Type> types, Annotation... qualifiers)`
`List<javax.enterprise.inject.spi.Decorator<?>>`	`resolveDecorators(Set<Type> types, Set<Annotation> qualifiers)`
`List<javax.enterprise.inject.spi.Interceptor<?>>`	`resolveInterceptors(javax.enterprise.inject.spi.InterceptionType type, Annotation... interceptorBindings)` Resolves a list of interceptors based on interception type and interceptor bindings.
`List<javax.enterprise.inject.spi.Interceptor<?>>`	`resolveInterceptors(javax.enterprise.inject.spi.InterceptionType type, Collection<Annotation> interceptorBindings)` Resolves a list of interceptors based on interception type and interceptor bindings.
`<T> Set<javax.enterprise.inject.spi.ObserverMethod<? super T>>`	`resolveObserverMethods(T event, Annotation... bindings)`
`BeanManagerImpl`	`setCurrent(Class<? extends Annotation> scopeType)` Associate an activity with the current context for a normal scope
`void`	`setEnabled(ModuleEnablement enabled)`
`String`	`toString()` Gets a string representation
`BeanManagerImpl`	`unwrap()`
`void`	`validate(javax.enterprise.inject.spi.InjectionPoint ij)`
`javax.el.ExpressionFactory`	`wrapExpressionFactory(javax.el.ExpressionFactory expressionFactory)`

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

- Method Detail
  - newRootManager
```
public static BeanManagerImpl newRootManager(String contextId,
                                             String id,
                                             ServiceRegistry serviceRegistry)
```
    Create a new, root, manager
    
    Parameters:
    
    serviceRegistry -
    
    Returns:
  - newManager
```
public static BeanManagerImpl newManager(BeanManagerImpl rootManager,
                                         String id,
                                         ServiceRegistry services)
```
  - newChildActivityManager
```
public static BeanManagerImpl newChildActivityManager(BeanManagerImpl parentManager)
```
    Create a new child manager
    
    Parameters:
    
    parentManager - the parent manager
    
    Returns:
    
    new child manager
  - getContextId
```
public String getContextId()
```
  - addAccessibleBeanManager
```
public void addAccessibleBeanManager(BeanManagerImpl accessibleBeanManager)
```
  - getAccessibleManagers
```
public HashSet<BeanManagerImpl> getAccessibleManagers()
```
  - addBean
```
public void addBean(javax.enterprise.inject.spi.Bean<?> bean)
```
  - addBeans
```
public void addBeans(Collection<? extends javax.enterprise.inject.spi.Bean<?>> beans)
```
    Optimization which modifies CopyOnWrite structures only once instead of once for every bean.
    
    Parameters:
    
    beans -
  - addDecorator
```
public void addDecorator(javax.enterprise.inject.spi.Decorator<?> bean)
```
  - resolveObserverMethods
```
public <T> Set<javax.enterprise.inject.spi.ObserverMethod<? super T>> resolveObserverMethods(T event,
                                                                                             Annotation... bindings)
```
    Specified by:
    
    resolveObserverMethods in interface javax.enterprise.inject.spi.BeanManager
  - addInterceptor
```
public void addInterceptor(javax.enterprise.inject.spi.Interceptor<?> bean)
```
  - getEnabled
```
public ModuleEnablement getEnabled()
```
    Enabled Alternatives, Interceptors and Decorators
    
    Returns:
  - setEnabled
```
public void setEnabled(ModuleEnablement enabled)
```
  - isBeanEnabled
```
public boolean isBeanEnabled(javax.enterprise.inject.spi.Bean<?> bean)
```
  - getBeans
```
public Set<javax.enterprise.inject.spi.Bean<?>> getBeans(Type beanType,
                                                         Annotation... qualifiers)
```
    Specified by:
    
    getBeans in interface javax.enterprise.inject.spi.BeanManager
  - getBeans
```
public Set<javax.enterprise.inject.spi.Bean<?>> getBeans(Type beanType,
                                                         Set<Annotation> qualifiers)
```
  - getBeans
```
public Set<javax.enterprise.inject.spi.Bean<?>> getBeans(javax.enterprise.inject.spi.InjectionPoint injectionPoint)
```
  - registerBeanNamespace
```
protected void registerBeanNamespace(javax.enterprise.inject.spi.Bean<?> bean)
```
  - getEnterpriseBeans
```
public Map<EjbDescriptor<?>,SessionBean<?>> getEnterpriseBeans()
```
    Gets the class-mapped beans. For internal use.
    
    Returns:
    
    The bean map
  - getBeans
```
public List<javax.enterprise.inject.spi.Bean<?>> getBeans()
```
    The beans registered with the Web Bean manager which are resolvable. Does not include interceptor and decorator beans
    
    Returns:
    
    The list of known beans
  - getDecorators
```
public List<javax.enterprise.inject.spi.Decorator<?>> getDecorators()
```
  - getInterceptors
```
public List<javax.enterprise.inject.spi.Interceptor<?>> getInterceptors()
```
  - getAccessibleBeans
```
public Iterable<javax.enterprise.inject.spi.Bean<?>> getAccessibleBeans()
```
  - getAccessibleInterceptors
```
public Iterable<javax.enterprise.inject.spi.Interceptor<?>> getAccessibleInterceptors()
```
  - getAccessibleDecorators
```
public Iterable<javax.enterprise.inject.spi.Decorator<?>> getAccessibleDecorators()
```
  - addContext
```
public void addContext(javax.enterprise.context.spi.Context context)
```
  - addObserver
```
public void addObserver(javax.enterprise.inject.spi.ObserverMethod<?> observer)
```
    Does the actual observer registration
    
    Parameters:
    
    observer - =
  - fireEvent
```
public void fireEvent(Object event,
                      Annotation... qualifiers)
```
    Fires an event object with given event object for given bindings
    
    Specified by:
    
    fireEvent in interface javax.enterprise.inject.spi.BeanManager
    
    Parameters:
    
    event - The event object to pass along
    
    qualifiers - The binding types to match
    
    See Also:
    
    BeanManager.fireEvent(java.lang.Object, java.lang.annotation.Annotation[])
  - getContext
```
public javax.enterprise.context.spi.Context getContext(Class<? extends Annotation> scopeType)
```
    Gets an active context of the given scope. Throws an exception if there are no active contexts found or if there are too many matches
    
    Specified by:
    
    getContext in interface javax.enterprise.inject.spi.BeanManager
    
    Parameters:
    
    scopeType - The scope to match
    
    Returns:
    
    A single active context of the given scope
    
    Throws:
    
    IllegalStateException - if there are multiple active scopes for a given context
    
    See Also:
    
    BeanManager.getContext(java.lang.Class)
  - getUnwrappedContext
```
public javax.enterprise.context.spi.Context getUnwrappedContext(Class<? extends Annotation> scopeType)
```
  - isContextActive
```
public boolean isContextActive(Class<? extends Annotation> scopeType)
```
    Indicates whether there is an active context for a given scope.
    
    Parameters:
    
    scopeType -
    
    Returns:
    
    true if there is an active context for a given scope, false otherwise
    
    Throws:
    
    IllegalStateException - if there are multiple active scopes for a given context
  - getReference
```
public Object getReference(javax.enterprise.inject.spi.Bean<?> bean,
                           Type requestedType,
                           javax.enterprise.context.spi.CreationalContext<?> creationalContext,
                           boolean noProxy)
```
  - getReference
```
public Object getReference(javax.enterprise.inject.spi.Bean<?> bean,
                           Type requestedType,
                           javax.enterprise.context.spi.CreationalContext<?> creationalContext)
```
    Specified by:
    
    getReference in interface javax.enterprise.inject.spi.BeanManager
  - getReference
```
@Deprecated
public Object getReference(javax.enterprise.inject.spi.InjectionPoint injectionPoint,
                                       javax.enterprise.inject.spi.Bean<?> resolvedBean,
                                       javax.enterprise.context.spi.CreationalContext<?> creationalContext)
```
    Deprecated. Use getInjectableReference(InjectionPoint, Bean, CreationalContext) instead
    
    The name of this method was misleading, use getInjectableReference(InjectionPoint, Bean, CreationalContext) instead.
    
    Parameters:
    
    injectionPoint -
    
    resolvedBean -
    
    creationalContext -
    
    Returns:
    
    the injectable reference
  - getInjectableReference
```
public Object getInjectableReference(javax.enterprise.inject.spi.InjectionPoint injectionPoint,
                                     javax.enterprise.inject.spi.Bean<?> resolvedBean,
                                     javax.enterprise.context.spi.CreationalContext<?> creationalContext)
```
    Get a reference, registering the injection point used.
    
    Parameters:
    
    injectionPoint - the injection point to register
    
    resolvedBean - the bean to get a reference to
    
    creationalContext - the creationalContext
    
    Returns:
    
    the injectable reference
  - getInjectableReference
```
public Object getInjectableReference(javax.enterprise.inject.spi.InjectionPoint injectionPoint,
                                     javax.enterprise.context.spi.CreationalContext<?> creationalContext)
```
    Specified by:
    
    getInjectableReference in interface javax.enterprise.inject.spi.BeanManager
  - getBean
```
public <T> javax.enterprise.inject.spi.Bean<T> getBean(Resolvable resolvable)
```
  - getBeans
```
public Set<javax.enterprise.inject.spi.Bean<?>> getBeans(String name)
```
    Specified by:
    
    getBeans in interface javax.enterprise.inject.spi.BeanManager
  - resolveDecorators
```
public List<javax.enterprise.inject.spi.Decorator<?>> resolveDecorators(Set<Type> types,
                                                                        Annotation... qualifiers)
```
    Specified by:
    
    resolveDecorators in interface javax.enterprise.inject.spi.BeanManager
  - resolveDecorators
```
public List<javax.enterprise.inject.spi.Decorator<?>> resolveDecorators(Set<Type> types,
                                                                        Set<Annotation> qualifiers)
```
  - resolveInterceptors
```
public List<javax.enterprise.inject.spi.Interceptor<?>> resolveInterceptors(javax.enterprise.inject.spi.InterceptionType type,
                                                                            Annotation... interceptorBindings)
```
    Resolves a list of interceptors based on interception type and interceptor bindings. Transitive interceptor bindings of the interceptor bindings passed as a parameter are considered in the resolution process.
    
    Specified by:
    
    resolveInterceptors in interface javax.enterprise.inject.spi.BeanManager
    
    Parameters:
    
    type - The interception type to resolve
    
    interceptorBindings - The binding types to match
    
    Returns:
    
    A list of matching interceptors
    
    See Also:
    
    BeanManager.resolveInterceptors(javax.enterprise.inject.spi.InterceptionType, java.lang.annotation.Annotation[])
  - resolveInterceptors
```
public List<javax.enterprise.inject.spi.Interceptor<?>> resolveInterceptors(javax.enterprise.inject.spi.InterceptionType type,
                                                                            Collection<Annotation> interceptorBindings)
```
    Resolves a list of interceptors based on interception type and interceptor bindings. Transitive interceptor bindings of the interceptor bindings passed as a parameter are NOT considered in the resolution process. Therefore, the caller is responsible for filtering of transitive interceptor bindings in order to comply with interceptor binding inheritance and overriding (See JSR-346 9.5.2). This is a Weld-specific method.
    
    Parameters:
    
    type - The interception type to resolve
    
    interceptorBindings - The binding types to match
    
    Returns:
    
    A list of matching interceptors
  - getBeanResolver
```
public TypeSafeBeanResolver getBeanResolver()
```
    Get the web bean resolver. For internal use
    
    Returns:
    
    The resolver
  - getDecoratorResolver
```
public TypeSafeDecoratorResolver getDecoratorResolver()
```
    Get the decorator resolver. For internal use
    
    Returns:
    
    The resolver
  - getInterceptorResolver
```
public TypeSafeInterceptorResolver getInterceptorResolver()
```
  - getNameBasedResolver
```
public NameBasedResolver getNameBasedResolver()
```
  - getAccessibleLenientObserverNotifier
```
public ObserverNotifier getAccessibleLenientObserverNotifier()
```
    Get the lenient observer notifier for accessible observer methods. Should never be exposed to an application.
    
    Returns:
    
    The ObserverNotifier
  - getGlobalLenientObserverNotifier
```
public ObserverNotifier getGlobalLenientObserverNotifier()
```
    Get the lenient global observer notifier. Should never be exposed to an application.
    
    Returns:
    
    The ObserverNotifier
  - getGlobalStrictObserverNotifier
```
public ObserverNotifier getGlobalStrictObserverNotifier()
```
    Get the Strict global observer notifier. This one should be used for firing application / extension events.
    
    Returns:
    
    The ObserverNotifier
  - toString
```
public String toString()
```
    Gets a string representation
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    A string representation
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - createActivity
```
public BeanManagerImpl createActivity()
```
    Description copied from interface: WeldManager
    
    Create a new child activity. A child activity inherits all beans, interceptors, decorators, observers, and contexts defined by its direct and indirect parent activities. This method should not be called by the application.
    
    Specified by:
    
    createActivity in interface WeldManager
    
    Returns:
    
    the child activity
  - setCurrent
```
public BeanManagerImpl setCurrent(Class<? extends Annotation> scopeType)
```
    Description copied from interface: WeldManager
    
    Associate an activity with the current context for a normal scope
    
    Specified by:
    
    setCurrent in interface WeldManager
    
    Parameters:
    
    scopeType - the scope to associate the activity with
    
    Returns:
    
    the activity
  - getCurrent
```
public BeanManagerImpl getCurrent()
```
    Specified by:
    
    getCurrent in interface WeldManager
    
    Returns:
    
    the WeldManager that corresponds to the current activity
  - getServices
```
public ServiceRegistry getServices()
```
    Description copied from interface: WeldManager
    
    Get the services registered for this manager
    
    Specified by:
    
    getServices in interface WeldManager
    
    Returns:
    
    the services registered for this manager
  - readResolve
```
protected Object readResolve()
                      throws ObjectStreamException
```
    Throws:
    
    ObjectStreamException
  - getClientProxyProvider
```
public ClientProxyProvider getClientProxyProvider()
```
  - getContexts
```
protected Map<Class<? extends Annotation>,List<javax.enterprise.context.spi.Context>> getContexts()
```
  - getNamespaces
```
protected List<String> getNamespaces()
```
    Returns:
    
    the namespaces
  - getAccessibleNamespaces
```
public Iterable<String> getAccessibleNamespaces()
```
  - getId
```
public String getId()
```
    Description copied from interface: WeldManager
    
    The ID of the manager, identical to the ID provided by the BDA
    
    Specified by:
    
    getId in interface WeldManager
    
    Returns:
    
    the ID of the manager
  - getChildIds
```
public AtomicInteger getChildIds()
```
  - getObservers
```
public List<javax.enterprise.inject.spi.ObserverMethod<?>> getObservers()
```
  - createInjectionTarget
```
public <T> javax.enterprise.inject.spi.InjectionTarget<T> createInjectionTarget(javax.enterprise.inject.spi.AnnotatedType<T> type)
```
    Specified by:
    
    createInjectionTarget in interface javax.enterprise.inject.spi.BeanManager
  - createInjectionTarget
```
public <T> javax.enterprise.inject.spi.InjectionTarget<T> createInjectionTarget(EjbDescriptor<T> descriptor)
```
    Description copied from interface: WeldManager
    
    The injection target for the given EJB, or null if Weld was not given this descriptor in the deployment. This should only be used to create an inject contextual EJBs by the EJB container. WeldManager.fireProcessInjectionTarget(AnnotatedType) and WeldManager.fireProcessInjectionTarget(AnnotatedType, InjectionTarget) must be used to obtain an InjectionTarget for non-contextual EJB injection.
    
    Specified by:
    
    createInjectionTarget in interface WeldManager
    
    Type Parameters:
    
    T - the type of the EJB
    
    Parameters:
    
    descriptor - the given EJB descriptor
    
    Returns:
    
    the injection target for the given EJB
  - validate
```
public void validate(javax.enterprise.inject.spi.InjectionPoint ij)
```
    Specified by:
    
    validate in interface javax.enterprise.inject.spi.BeanManager
  - getInterceptorBindingDefinition
```
public Set<Annotation> getInterceptorBindingDefinition(Class<? extends Annotation> bindingType)
```
    Specified by:
    
    getInterceptorBindingDefinition in interface javax.enterprise.inject.spi.BeanManager
  - getPassivationCapableBean
```
public javax.enterprise.inject.spi.Bean<?> getPassivationCapableBean(String id)
```
    Specified by:
    
    getPassivationCapableBean in interface javax.enterprise.inject.spi.BeanManager
  - getPassivationCapableBean
```
public javax.enterprise.inject.spi.Bean<?> getPassivationCapableBean(BeanIdentifier identifier)
```
    Specified by:
    
    getPassivationCapableBean in interface WeldManager
  - getStereotypeDefinition
```
public Set<Annotation> getStereotypeDefinition(Class<? extends Annotation> stereotype)
```
    Specified by:
    
    getStereotypeDefinition in interface javax.enterprise.inject.spi.BeanManager
  - isQualifier
```
public boolean isQualifier(Class<? extends Annotation> annotationType)
```
    Specified by:
    
    isQualifier in interface javax.enterprise.inject.spi.BeanManager
  - isInterceptorBinding
```
public boolean isInterceptorBinding(Class<? extends Annotation> annotationType)
```
    Specified by:
    
    isInterceptorBinding in interface javax.enterprise.inject.spi.BeanManager
  - isNormalScope
```
public boolean isNormalScope(Class<? extends Annotation> annotationType)
```
    Specified by:
    
    isNormalScope in interface javax.enterprise.inject.spi.BeanManager
  - isPassivatingScope
```
public boolean isPassivatingScope(Class<? extends Annotation> annotationType)
```
    Specified by:
    
    isPassivatingScope in interface javax.enterprise.inject.spi.BeanManager
  - isScope
```
public boolean isScope(Class<? extends Annotation> annotationType)
```
    Specified by:
    
    isScope in interface javax.enterprise.inject.spi.BeanManager
  - isStereotype
```
public boolean isStereotype(Class<? extends Annotation> annotationType)
```
    Specified by:
    
    isStereotype in interface javax.enterprise.inject.spi.BeanManager
  - getELResolver
```
public javax.el.ELResolver getELResolver()
```
    Specified by:
    
    getELResolver in interface javax.enterprise.inject.spi.BeanManager
  - wrapExpressionFactory
```
public javax.el.ExpressionFactory wrapExpressionFactory(javax.el.ExpressionFactory expressionFactory)
```
    Specified by:
    
    wrapExpressionFactory in interface javax.enterprise.inject.spi.BeanManager
  - createCreationalContext
```
public <T> WeldCreationalContext<T> createCreationalContext(javax.enterprise.context.spi.Contextual<T> contextual)
```
    Specified by:
    
    createCreationalContext in interface javax.enterprise.inject.spi.BeanManager
    
    Specified by:
    
    createCreationalContext in interface WeldManager
  - createAnnotatedType
```
public <T> javax.enterprise.inject.spi.AnnotatedType<T> createAnnotatedType(Class<T> type)
```
    Specified by:
    
    createAnnotatedType in interface javax.enterprise.inject.spi.BeanManager
  - createEnhancedAnnotatedType
```
public <T> EnhancedAnnotatedType<T> createEnhancedAnnotatedType(Class<T> type)
```
  - createAnnotatedType
```
public <T> javax.enterprise.inject.spi.AnnotatedType<T> createAnnotatedType(Class<T> type,
                                                                            String id)
```
    Description copied from interface: WeldManager
    
    Obtain an AnnotatedType that may be used to read the annotations of the given class or interface.
    Allows multiple annotated types, based on the same underlying type, to be created. AnnotatedTypes discovered by the container use the fully qualified class name to identify the type.
    This method must only be used when creating non-contextual instances, such as Java EE components. It's not designed to work with contextual instances.
    If called after the container bootstrap finished, the client code is required to explicitly call WeldManager.disposeAnnotatedType(Class, String) as soon as the specified type should be garbage-collected (to avoid memory leaks).
    
    Specified by:
    
    createAnnotatedType in interface WeldManager
    
    Returns:
    
    the AnnotatedType
  - disposeAnnotatedType
```
public <T> void disposeAnnotatedType(Class<T> type,
                                     String id)
```
    Description copied from interface: WeldManager
    
    Dispose the AnnotatedType created for the identified type.
    This method should be explicitly called for each result of WeldManager.createAnnotatedType(Class, String) created after the container bootstrap finished.
    It's not necessary to call this method unless the identified type should be a subject of garbage collection.
    
    Specified by:
    
    disposeAnnotatedType in interface WeldManager
    
    See Also:
    
    WeldManager.createAnnotatedType(Class, String)
  - resolve
```
public <X> javax.enterprise.inject.spi.Bean<? extends X> resolve(Set<javax.enterprise.inject.spi.Bean<? extends X>> beans)
```
    Specified by:
    
    resolve in interface javax.enterprise.inject.spi.BeanManager
  - getEjbDescriptor
```
public <T> EjbDescriptor<T> getEjbDescriptor(String beanName)
```
    Description copied from interface: WeldManager
    
    Get the EjbDescriptor for the given EJB name
    
    Specified by:
    
    getEjbDescriptor in interface WeldManager
    
    Type Parameters:
    
    T - the type of the EJB
    
    Parameters:
    
    beanName - the given EJB name
    
    Returns:
    
    the EjbDescriptor for the given EJB name
  - getBean
```
public <T> SessionBean<T> getBean(EjbDescriptor<T> descriptor)
```
    Description copied from interface: WeldManager
    
    Get the Bean object for the given EJB, or null if Weld was not given this descriptor in the deployment.
    
    Specified by:
    
    getBean in interface WeldManager
    
    Type Parameters:
    
    T - the type of the bean
    
    Parameters:
    
    descriptor - the given EJB descriptor
    
    Returns:
    
    the Bean object for the given EJB
  - cleanup
```
public void cleanup()
```
  - cleanupAfterBoot
```
public void cleanupAfterBoot()
```
    Clear the bean set that is only used to make sure that no duplicate beans are added. For internal use only.
  - getInterceptorModelRegistry
```
public ConcurrentMap<SlimAnnotatedType<?>,InterceptionModel> getInterceptorModelRegistry()
```
  - getInterceptorMetadataReader
```
public InterceptorMetadataReader getInterceptorMetadataReader()
```
  - fireProcessInjectionTarget
```
public <X> javax.enterprise.inject.spi.InjectionTarget<X> fireProcessInjectionTarget(javax.enterprise.inject.spi.AnnotatedType<X> annotatedType)
```
    Description copied from interface: WeldManager
    
    Fire a ProcessInjectionTarget event for the given type. A helper method to allow integration code to easily fire the ProcessInjectionTarget for Java EE component classes supporting injection The container must use the returned InjectionTarget to inject the Java EE component.
    
    Specified by:
    
    fireProcessInjectionTarget in interface WeldManager
    
    Type Parameters:
    
    X - the type
    
    Parameters:
    
    annotatedType - the type
    
    Returns:
    
    final version of InjectionTarget after all observers have been invoked
  - fireProcessInjectionTarget
```
public <X> javax.enterprise.inject.spi.InjectionTarget<X> fireProcessInjectionTarget(javax.enterprise.inject.spi.AnnotatedType<X> annotatedType,
                                                                                     javax.enterprise.inject.spi.InjectionTarget<X> injectionTarget)
```
    Description copied from interface: WeldManager
    
    Fire a ProcessInjectionTarget event for the given type. A helper method to allow integration code to easily fire the ProcessInjectionTarget for Java EE component classes supporting injection The container must use the returned InjectionTarget to inject the Java EE component.
    
    Specified by:
    
    fireProcessInjectionTarget in interface WeldManager
    
    Type Parameters:
    
    X - the type
    
    Parameters:
    
    annotatedType - the type
    
    injectionTarget - the injection target
    
    Returns:
    
    final version of InjectionTarget after all observers have been invoked
  - extractInterceptorBindingsForQualifierInstance
```
public Set<QualifierInstance> extractInterceptorBindingsForQualifierInstance(Iterable<QualifierInstance> annotations)
```
  - instance
```
public javax.enterprise.inject.Instance<Object> instance()
```
    Specified by:
    
    instance in interface WeldManager
  - event
```
public javax.enterprise.event.Event<Object> event()
```
  - getInstance
```
public <T> WeldInstance<Object> getInstance(javax.enterprise.context.spi.CreationalContext<?> ctx)
```
  - createBeanAttributes
```
public <T> javax.enterprise.inject.spi.BeanAttributes<T> createBeanAttributes(javax.enterprise.inject.spi.AnnotatedType<T> type)
```
    Specified by:
    
    createBeanAttributes in interface javax.enterprise.inject.spi.BeanManager
  - createBeanAttributes
```
public javax.enterprise.inject.spi.BeanAttributes<?> createBeanAttributes(javax.enterprise.inject.spi.AnnotatedMember<?> member)
```
    Specified by:
    
    createBeanAttributes in interface javax.enterprise.inject.spi.BeanManager
  - internalCreateBeanAttributes
```
public <X> javax.enterprise.inject.spi.BeanAttributes<?> internalCreateBeanAttributes(javax.enterprise.inject.spi.AnnotatedMember<X> member)
```
  - createBean
```
public <T> javax.enterprise.inject.spi.Bean<T> createBean(javax.enterprise.inject.spi.BeanAttributes<T> attributes,
                                                          Class<T> beanClass,
                                                          javax.enterprise.inject.spi.InjectionTargetFactory<T> injectionTargetFactory)
```
    Specified by:
    
    createBean in interface javax.enterprise.inject.spi.BeanManager
  - createBean
```
public <T,X> javax.enterprise.inject.spi.Bean<T> createBean(javax.enterprise.inject.spi.BeanAttributes<T> attributes,
                                                            Class<X> beanClass,
                                                            javax.enterprise.inject.spi.ProducerFactory<X> producerFactory)
```
    Specified by:
    
    createBean in interface javax.enterprise.inject.spi.BeanManager
  - createInjectionPoint
```
public FieldInjectionPointAttributes<?,?> createInjectionPoint(javax.enterprise.inject.spi.AnnotatedField<?> field)
```
    Specified by:
    
    createInjectionPoint in interface javax.enterprise.inject.spi.BeanManager
  - createInjectionPoint
```
public ParameterInjectionPointAttributes<?,?> createInjectionPoint(javax.enterprise.inject.spi.AnnotatedParameter<?> parameter)
```
    Specified by:
    
    createInjectionPoint in interface javax.enterprise.inject.spi.BeanManager
  - getExtension
```
public <T extends javax.enterprise.inject.spi.Extension> T getExtension(Class<T> extensionClass)
```
    Specified by:
    
    getExtension in interface javax.enterprise.inject.spi.BeanManager
  - getContainerLifecycleEvents
```
public ContainerLifecycleEvents getContainerLifecycleEvents()
```
  - areQualifiersEquivalent
```
public boolean areQualifiersEquivalent(Annotation qualifier1,
                                       Annotation qualifier2)
```
    Specified by:
    
    areQualifiersEquivalent in interface javax.enterprise.inject.spi.BeanManager
  - areInterceptorBindingsEquivalent
```
public boolean areInterceptorBindingsEquivalent(Annotation interceptorBinding1,
                                                Annotation interceptorBinding2)
```
    Specified by:
    
    areInterceptorBindingsEquivalent in interface javax.enterprise.inject.spi.BeanManager
  - getQualifierHashCode
```
public int getQualifierHashCode(Annotation qualifier)
```
    Specified by:
    
    getQualifierHashCode in interface javax.enterprise.inject.spi.BeanManager
  - getInterceptorBindingHashCode
```
public int getInterceptorBindingHashCode(Annotation interceptorBinding)
```
    Specified by:
    
    getInterceptorBindingHashCode in interface javax.enterprise.inject.spi.BeanManager
  - getLocalInjectionTargetFactory
```
public <T> InjectionTargetFactoryImpl<T> getLocalInjectionTargetFactory(javax.enterprise.inject.spi.AnnotatedType<T> type)
```
    Creates an InjectionTargetFactory for a given type. The factory will be using this BeanManager.
  - getInjectionTargetFactory
```
public <T> WeldInjectionTargetFactory<T> getInjectionTargetFactory(javax.enterprise.inject.spi.AnnotatedType<T> type)
```
    Creates an InjectionTargetFactory for a given type. The BeanManager for the InjectionTarget will be inferred using CDI11Deployment.getBeanDeploymentArchive(Class).
    
    Specified by:
    
    getInjectionTargetFactory in interface javax.enterprise.inject.spi.BeanManager
    
    Specified by:
    
    getInjectionTargetFactory in interface WeldManager
  - getProducerFactory
```
public <X> FieldProducerFactory<X> getProducerFactory(javax.enterprise.inject.spi.AnnotatedField<? super X> field,
                                                      javax.enterprise.inject.spi.Bean<X> declaringBean)
```
    Specified by:
    
    getProducerFactory in interface javax.enterprise.inject.spi.BeanManager
  - getProducerFactory
```
public <X> MethodProducerFactory<X> getProducerFactory(javax.enterprise.inject.spi.AnnotatedMethod<? super X> method,
                                                       javax.enterprise.inject.spi.Bean<X> declaringBean)
```
    Specified by:
    
    getProducerFactory in interface javax.enterprise.inject.spi.BeanManager
  - createInjectionTargetBuilder
```
public <T> WeldInjectionTargetBuilder<T> createInjectionTargetBuilder(javax.enterprise.inject.spi.AnnotatedType<T> type)
```
    Description copied from interface: WeldManager
    
    Returns a new instance of WeldInjectionTargetBuilder which can be used to create a new WeldInjectionTarget for the specified type.
    
    Specified by:
    
    createInjectionTargetBuilder in interface WeldManager
    
    Type Parameters:
    
    T - the type
    
    Parameters:
    
    type - the specified type
    
    Returns:
    
    a new WeldInjectionTargetBuilder instance for the specified type
  - unwrap
```
public BeanManagerImpl unwrap()
```
    Specified by:
    
    unwrap in interface WeldManager
    
    Returns:
    
    an unwrapped instance (e.g. the delegate in the case of forwarding implementation)

Class BeanManagerImpl

Method Summary

Methods inherited from class java.lang.Object

Method Detail

newRootManager

newManager

newChildActivityManager

getContextId

addAccessibleBeanManager

getAccessibleManagers

addBean

addBeans

addDecorator

resolveObserverMethods

addInterceptor

getEnabled

setEnabled

isBeanEnabled

getBeans

getBeans

getBeans

registerBeanNamespace

getEnterpriseBeans

getBeans

getDecorators

getInterceptors

getAccessibleBeans

getAccessibleInterceptors

getAccessibleDecorators

addContext

addObserver

fireEvent

getContext

getUnwrappedContext

isContextActive

getReference

getReference

getReference

getInjectableReference

getInjectableReference

getBean

getBeans

resolveDecorators

resolveDecorators

resolveInterceptors

resolveInterceptors

getBeanResolver

getDecoratorResolver

getInterceptorResolver

getNameBasedResolver

getAccessibleLenientObserverNotifier

getGlobalLenientObserverNotifier

getGlobalStrictObserverNotifier

toString

equals

hashCode

createActivity

setCurrent

getCurrent

getServices

readResolve

getClientProxyProvider

getContexts

getNamespaces

getAccessibleNamespaces

getId

getChildIds

getObservers

createInjectionTarget

createInjectionTarget

validate

getInterceptorBindingDefinition

getPassivationCapableBean

getPassivationCapableBean

getStereotypeDefinition

isQualifier

isInterceptorBinding

isNormalScope

isPassivatingScope

isScope