Modifier and Type | Interface and Description |
---|---|
interface |
Decorator<T>
Represents an enabled decorator.
|
interface |
Interceptor<T>
Represents an enabled interceptor.
|
Modifier and Type | Method and Description |
---|---|
<T> Bean<T> |
BeanManager.createBean(BeanAttributes<T> attributes,
Class<T> beanClass,
InjectionTargetFactory<T> injectionTargetFactory)
|
<T,X> Bean<T> |
BeanManager.createBean(BeanAttributes<T> attributes,
Class<X> beanClass,
ProducerFactory<X> producerFactory)
|
Bean<X> |
ProcessBean.getBean()
Returns the
Bean object that is about to be registered. |
Bean<?> |
InjectionPoint.getBean()
Get the
Bean object representing the bean that defines the injection point. |
Bean<?> |
BeanManager.getPassivationCapableBean(String id)
Returns the
PassivationCapable bean with the given identifier. |
<X> Bean<? extends X> |
BeanManager.resolve(Set<Bean<? extends X>> beans)
Apply the ambiguous dependency resolution rules to a set of beans.
|
Modifier and Type | Method and Description |
---|---|
Set<Bean<?>> |
BeanManager.getBeans(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.
|
Set<Bean<?>> |
BeanManager.getBeans(Type beanType,
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.
|
Modifier and Type | Method and Description |
---|---|
void |
AfterBeanDiscovery.addBean(Bean<?> bean)
Fires an event of type
ProcessBean containing the given
Bean and then registers the Bean with the
container, thereby making it available for injection into other beans. |
InjectionTarget<T> |
InjectionTargetFactory.createInjectionTarget(Bean<T> bean)
Create a new injection target for a bean.
|
<T> Producer<T> |
ProducerFactory.createProducer(Bean<T> bean)
Create a new producer for a bean.
|
<X> ProducerFactory<X> |
BeanManager.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> |
BeanManager.getProducerFactory(AnnotatedMethod<? super X> method,
Bean<X> declaringBean)
An implementation of
ProducerFactory that provides container created Producer instances for the given
method. |
Object |
BeanManager.getReference(Bean<?> bean,
Type beanType,
CreationalContext<?> ctx)
Obtains a contextual reference for a certain bean and a certain bean type of the bean.
|
Modifier and Type | Method and Description |
---|---|
<X> Bean<? extends X> |
BeanManager.resolve(Set<Bean<? extends X>> beans)
Apply the ambiguous dependency resolution rules to a set of beans.
|
Modifier and Type | Interface and Description |
---|---|
interface |
DecorableBean<T>
Marker interface for a
Bean that can have decorators. |
interface |
WeldDecorator<T>
Sub-interface of
Decorator that contains metadata information about Weld-deployed
Decorators (including custom decorators). |
Modifier and Type | Class and Description |
---|---|
class |
AbstractBean<T,S>
An abstract bean representation common for all beans
|
class |
AbstractClassBean<T>
An abstract bean representation common for class-based beans
|
class |
AbstractProducerBean<X,T,S extends Member>
The implicit producer bean
|
class |
AbstractSyntheticBean<T>
|
class |
CommonBean<T>
Common superclass for beans that are identified using id.
|
class |
CustomDecoratorWrapper<T>
A wrapper for a decorated instance.
|
class |
DecoratorImpl<T> |
class |
ForwardingBean<T>
A delegating bean
|
class |
ForwardingDecorator<T> |
class |
ForwardingInterceptor<T>
Delegating implementation of
Interceptor . |
class |
InterceptorImpl<T> |
class |
ManagedBean<T>
Represents a simple bean
|
class |
NewManagedBean<T>
Represents a @New simple bean
|
class |
NewSessionBean<T>
Represents a @New enterprise bean
|
class |
ProducerField<X,T>
Represents a producer field
|
class |
ProducerMethod<X,T>
Represents a producer method bean
|
class |
RIBean<T>
Abstract base class with functions specific to RI built-in beans
|
class |
SessionBean<T>
An enterprise bean representation
|
class |
SyntheticClassBean<T>
Represents a class bean created based on extension-provided
InjectionTarget implementation. |
class |
SyntheticDecorator<T>
Represents a
Decorator created based on extension-provided InjectionTarget implementation. |
class |
SyntheticProducerBean<T,X>
Represents a producer field or producer method created based on extension-provided
Producer implementation. |
Modifier and Type | Method and Description |
---|---|
protected abstract Bean<T> |
ForwardingBean.delegate() |
Modifier and Type | Class and Description |
---|---|
class |
AbstractBuiltInBean<T> |
class |
AbstractBuiltInMetadataBean<T>
|
class |
AbstractDecorableBuiltInBean<T>
Built-in bean that can be decorated by a
Decorator |
class |
AbstractFacadeBean<T>
The built-in bean for facade objects.
|
class |
AbstractStaticallyDecorableBuiltInBean<T>
A decorated built-in bean for which, unlike
AbstractFacadeBean , decorators only need to be resolved once. |
class |
BeanManagerBean |
class |
BeanManagerImplBean |
class |
BeanMetadataBean
Allows a bean to obtain information about itself.
|
class |
ContextBean<T extends Context> |
class |
ConversationBean |
class |
DecoratedBeanMetadataBean
Allows a decorator to obtain information about the bean it decorates.
|
class |
DecoratorMetadataBean
Allows a decorator to obtain information about itself.
|
class |
EventBean |
class |
EventMetadataBean
Built-in bean for event metadata.
|
class |
ExtensionBean |
class |
InjectionPointBean
Bean for InjectionPoint metadata
|
class |
InstanceBean |
class |
InterceptedBeanMetadataBean
Allows an interceptor to obtain information about the bean it intercepts.
|
class |
InterceptorMetadataBean
Allows an interceptor to obtain information about itself.
|
Modifier and Type | Method and Description |
---|---|
Bean<?> |
BeanManagerProxy.getPassivationCapableBean(String id) |
protected Bean<?> |
InterceptedBeanMetadataBean.newInstance(InjectionPoint ip,
CreationalContext<Bean<?>> ctx) |
protected Bean<?> |
BeanMetadataBean.newInstance(InjectionPoint ip,
CreationalContext<Bean<?>> creationalContext) |
<X> Bean<? extends X> |
BeanManagerProxy.resolve(Set<Bean<? extends X>> beans) |
Modifier and Type | Method and Description |
---|---|
Set<Bean<?>> |
BeanManagerProxy.getBeans(String name) |
Set<Bean<?>> |
BeanManagerProxy.getBeans(Type beanType,
Annotation... qualifiers) |
Modifier and Type | Method and Description |
---|---|
Object |
BeanManagerProxy.getReference(Bean<?> bean,
Type beanType,
CreationalContext<?> ctx) |
Modifier and Type | Method and Description |
---|---|
protected Bean<?> |
InterceptedBeanMetadataBean.newInstance(InjectionPoint ip,
CreationalContext<Bean<?>> ctx) |
protected Bean<?> |
BeanMetadataBean.newInstance(InjectionPoint ip,
CreationalContext<Bean<?>> creationalContext) |
<X> Bean<? extends X> |
BeanManagerProxy.resolve(Set<Bean<? extends X>> beans) |
Modifier and Type | Class and Description |
---|---|
class |
AbstractEEBean<T> |
class |
EEResourceProducerField<X,T> |
class |
HttpServletRequestBean
Built-in bean exposing
HttpServletRequest . |
class |
HttpSessionBean
Built-in bean exposing
HttpSession . |
class |
PrincipalBean |
class |
ServletContextBean
Built-in bean exposing
ServletContext . |
class |
StaticEEResourceProducerField<X,T>
A resource producer field that is static (not injected).
|
class |
UserTransactionBean |
Modifier and Type | Method and Description |
---|---|
Bean<?> |
ProxyMethodHandler.getBean() |
Bean<?> |
ProxyFactory.getBean() |
Modifier and Type | Method and Description |
---|---|
protected Class<?> |
AbstractBeanInstance.computeInstanceType(Bean<?> bean) |
<T> T |
ClientProxyProvider.getClientProxy(Bean<T> bean) |
<T> T |
ClientProxyProvider.getClientProxy(Bean<T> bean,
Type requestedType)
Gets a client proxy for a bean
Looks for a proxy in the pool.
|
static <T> void |
ProxyFactory.setBeanInstance(T proxy,
BeanInstance beanInstance,
Bean<?> bean)
Convenience method to set the underlying bean instance for a proxy.
|
Constructor and Description |
---|
ClientProxyFactory(Class<?> proxiedBeanType,
Set<? extends Type> typeClosure,
Bean<?> bean) |
ContextBeanInstance(Bean<T> bean,
String id)
Creates a new locator for instances of the given bean.
|
DecorationHelper(TargetBeanInstance originalInstance,
Bean<?> bean,
Class<T> proxyClassForDecorator,
BeanManagerImpl beanManager,
ContextualStore contextualStore,
List<Decorator<?>> decorators) |
DecoratorProxyFactory(Class<T> proxyType,
WeldInjectionPointAttributes<?,?> delegateInjectionPoint,
Bean<?> bean) |
EnterpriseProxyFactory(Class<T> proxiedBeanType,
Bean<T> bean)
Produces a factory for a specific bean implementation.
|
InterceptedSubclassFactory(Class<?> proxiedBeanType,
Set<? extends Type> typeClosure,
Bean<?> bean,
Set<MethodSignature> enhancedMethodSignatures) |
InterceptedSubclassFactory(Class<?> proxiedBeanType,
Set<? extends Type> typeClosure,
String proxyName,
Bean<?> bean,
Set<MethodSignature> enhancedMethodSignatures)
Creates a new proxy factory when the name of the proxy class is already
known, such as during de-serialization
|
ProxyFactory(Class<?> proxiedBeanType,
Set<? extends Type> typeClosure,
Bean<?> bean)
created a new proxy factory from a bean instance.
|
ProxyFactory(Class<?> proxiedBeanType,
Set<? extends Type> typeClosure,
String proxyName,
Bean<?> bean)
Creates a new proxy factory when the name of the proxy class is already
known, such as during de-serialization
|
ProxyMethodHandler(BeanInstance beanInstance,
Bean<?> bean) |
TargetBeanInstance(Bean<?> bean,
Object instance) |
Modifier and Type | Method and Description |
---|---|
boolean |
SpecializationAndEnablementRegistry.isCandidateForLifecycleEvent(Bean<?> bean) |
boolean |
SpecializationAndEnablementRegistry.isEnabledInAnyBeanDeployment(Bean<?> bean) |
boolean |
SpecializationAndEnablementRegistry.isSpecializedInAnyBeanDeployment(Bean<?> bean) |
Set<? extends AbstractBean<?,?>> |
SpecializationAndEnablementRegistry.resolveSpecializedBeans(Bean<?> specializingBean)
Returns a set of beans specialized by this bean.
|
protected void |
Validator.validateBean(Bean<?> bean,
Collection<CommonBean<?>> specializedBeans,
BeanManagerImpl manager,
List<RuntimeException> problems) |
protected void |
Validator.validateGeneralBean(Bean<?> bean,
BeanManagerImpl beanManager) |
void |
Validator.validateInjectionPointForDefinitionErrors(InjectionPoint ij,
Bean<?> bean,
BeanManagerImpl beanManager)
Checks for definition errors associated with a given
InjectionPoint |
void |
Validator.validateInjectionPointForDeploymentProblems(InjectionPoint ij,
Bean<?> bean,
BeanManagerImpl beanManager)
Checks for deployment problems associated with a given
InjectionPoint |
void |
Validator.validateInjectionPointPassivationCapable(InjectionPoint ij,
Bean<?> resolvedBean,
BeanManagerImpl beanManager) |
void |
Validator.validateMetadataInjectionPoint(InjectionPoint ij,
Bean<?> bean,
ValidatorMessage message) |
void |
SpecializationAndEnablementRegistry.vetoSpecializingBean(Bean<?> bean) |
Modifier and Type | Method and Description |
---|---|
void |
ConcurrentBeanDeployer.doAfterBeanDiscovery(List<? extends Bean<?>> beanList) |
void |
BeanDeployer.doAfterBeanDiscovery(List<? extends Bean<?>> beanList) |
void |
Validator.validateBeans(Collection<? extends Bean<?>> beans,
BeanManagerImpl manager) |
void |
ConcurrentValidator.validateBeans(Collection<? extends Bean<?>> beans,
BeanManagerImpl manager) |
Modifier and Type | Method and Description |
---|---|
Bean<X> |
ProcessBeanImpl.getBean() |
Bean<?> |
ProcessAnnotatedTypeEventResolvable.getDeclaringBean() |
Modifier and Type | Method and Description |
---|---|
void |
AfterBeanDiscoveryImpl.addBean(Bean<?> bean) |
protected static <X> void |
ProcessBeanImpl.fire(BeanManagerImpl beanManager,
Bean<X> bean) |
void |
ContainerLifecycleEvents.fireProcessBean(BeanManagerImpl beanManager,
Bean<?> bean) |
protected <T> void |
AfterBeanDiscoveryImpl.processBean(Bean<T> b) |
Constructor and Description |
---|
ProcessBeanImpl(BeanManagerImpl beanManager,
Bean<X> bean,
Annotated annotated) |
Modifier and Type | Method and Description |
---|---|
boolean |
EJBApiAbstraction.isSessionBeanWithContainerManagedTransactions(Bean<?> bean) |
Modifier and Type | Method and Description |
---|---|
Bean<?> |
ForwardingInjectionPoint.getBean() |
Bean<?> |
EmptyInjectionPoint.getBean() |
Modifier and Type | Method and Description |
---|---|
<T> ConstructorInjectionPoint<T> |
InjectionPointFactory.createConstructorInjectionPoint(Bean<T> declaringBean,
Class<?> declaringComponentClass,
EnhancedAnnotatedConstructor<T> constructor,
BeanManagerImpl manager) |
<T> ConstructorInjectionPoint<T> |
InjectionPointFactory.createConstructorInjectionPoint(Bean<T> declaringBean,
EnhancedAnnotatedType<T> type,
BeanManagerImpl manager) |
<T,X> FieldInjectionPoint<T,X> |
InjectionPointFactory.createFieldInjectionPoint(EnhancedAnnotatedField<T,X> field,
Bean<?> declaringBean,
Class<?> declaringComponentClass,
BeanManagerImpl manager)
Creates a new
FieldInjectionPoint and fires the ProcessInjectionPoint event. |
<T,X> MethodInjectionPoint<T,X> |
InjectionPointFactory.createMethodInjectionPoint(EnhancedAnnotatedMethod<T,X> enhancedMethod,
Bean<?> declaringBean,
Class<?> declaringComponentClass,
boolean observerOrDisposer,
BeanManagerImpl manager) |
<T,X> ParameterInjectionPoint<T,X> |
InjectionPointFactory.createParameterInjectionPoint(EnhancedAnnotatedParameter<T,X> parameter,
Bean<?> declaringBean,
Class<?> declaringComponentClass,
BeanManagerImpl manager)
Creates a new
ParameterInjectionPoint and fires the ProcessInjectionPoint event. |
List<Set<FieldInjectionPoint<?,?>>> |
InjectionPointFactory.getFieldInjectionPoints(Bean<?> declaringBean,
EnhancedAnnotatedType<?> type,
BeanManagerImpl manager) |
<X> List<ParameterInjectionPoint<?,X>> |
InjectionPointFactory.getParameterInjectionPoints(EnhancedAnnotatedCallable<?,X,?> callable,
Bean<?> declaringBean,
Class<?> declaringComponentClass,
BeanManagerImpl manager,
boolean observerOrDisposer) |
List<Set<ResourceInjection<?>>> |
ResourceInjectionFactory.getResourceInjections(Bean<?> declaringBean,
EnhancedAnnotatedType<?> type,
BeanManagerImpl manager) |
Constructor and Description |
---|
ConstructorInjectionPoint(EnhancedAnnotatedConstructor<T> constructor,
Bean<T> declaringBean,
Class<?> declaringComponentClass,
InjectionPointFactory factory,
BeanManagerImpl manager) |
MethodInjectionPoint(EnhancedAnnotatedMethod<T,X> enhancedMethod,
Bean<?> declaringBean,
Class<?> declaringComponentClass,
boolean observerOrDisposer,
InjectionPointFactory factory,
BeanManagerImpl manager) |
ProxyClassConstructorInjectionPointWrapper(Bean<T> declaringBean,
Class<?> declaringComponentClass,
EnhancedAnnotatedConstructor<T> weldConstructor,
ConstructorInjectionPoint<T> originalConstructorInjectionPoint,
BeanManagerImpl manager) |
Modifier and Type | Method and Description |
---|---|
Bean<?> |
AbstractInferingInjectionPointAttributes.getBean() |
Modifier and Type | Method and Description |
---|---|
static <T,X> InferingFieldInjectionPointAttributes<T,X> |
InferingFieldInjectionPointAttributes.of(EnhancedAnnotatedField<T,X> field,
Bean<?> bean,
Class<?> declaringComponentClass,
BeanManagerImpl manager) |
static <T,X> ParameterInjectionPoint<T,X> |
SpecialParameterInjectionPoint.of(EnhancedAnnotatedParameter<T,X> parameter,
Bean<?> bean,
Class<?> declaringComponentClass,
BeanManagerImpl manager) |
static <T,X> InferingParameterInjectionPointAttributes<T,X> |
InferingParameterInjectionPointAttributes.of(EnhancedAnnotatedParameter<T,X> parameter,
Bean<?> bean,
Class<?> declaringComponentClass,
BeanManagerImpl manager) |
Constructor and Description |
---|
AbstractInferingInjectionPointAttributes(Bean<?> bean,
Set<Annotation> qualifiers,
Class<?> declaringComponentClass) |
InferingFieldInjectionPointAttributes(EnhancedAnnotatedField<T,X> field,
Bean<?> bean,
Class<?> declaringComponentClass,
BeanManagerImpl manager) |
InferingParameterInjectionPointAttributes(EnhancedAnnotatedParameter<T,X> parameter,
Bean<?> bean,
Class<?> declaringComponentClass,
BeanManagerImpl manager) |
SpecialParameterInjectionPoint(EnhancedAnnotatedParameter<T,X> parameter,
Bean<?> bean,
Class<?> declaringComponentClass,
BeanManagerImpl manager) |
Modifier and Type | Method and Description |
---|---|
Bean<T> |
BeanInjectionTarget.getBean() |
Bean<T> |
BasicInjectionTarget.getBean() |
abstract Bean<T> |
AbstractProducer.getBean()
Returns a
Bean this producer is associated with or null if no such bean exists. |
abstract Bean<T> |
AbstractMemberProducer.getBean() |
Bean<T> |
AbstractDecoratorApplyingInstantiator.getBean() |
abstract Bean<X> |
AbstractMemberProducer.getDeclaringBean() |
Modifier and Type | Method and Description |
---|---|
protected Class<T> |
SubclassedComponentInstantiator.createEnhancedSubclass(AnnotatedType<T> type,
Bean<?> bean) |
protected EnhancedAnnotatedConstructor<T> |
SubclassedComponentInstantiator.initEnhancedSubclass(BeanManagerImpl manager,
EnhancedAnnotatedType<T> type,
Bean<?> bean,
ConstructorInjectionPoint<T> originalConstructorInjectionPoint) |
protected Injector<T> |
BeanInjectionTarget.initInjector(EnhancedAnnotatedType<T> type,
Bean<T> bean,
BeanManagerImpl beanManager) |
protected Injector<T> |
BasicInjectionTarget.initInjector(EnhancedAnnotatedType<T> type,
Bean<T> bean,
BeanManagerImpl beanManager) |
protected Instantiator<T> |
NonProducibleInjectionTarget.initInstantiator(EnhancedAnnotatedType<T> type,
Bean<T> bean,
BeanManagerImpl beanManager,
Set<InjectionPoint> injectionPoints) |
protected Instantiator<T> |
DecoratorInjectionTarget.initInstantiator(EnhancedAnnotatedType<T> type,
Bean<T> bean,
BeanManagerImpl beanManager,
Set<InjectionPoint> injectionPoints) |
protected Instantiator<T> |
BasicInjectionTarget.initInstantiator(EnhancedAnnotatedType<T> type,
Bean<T> bean,
BeanManagerImpl beanManager,
Set<InjectionPoint> injectionPoints)
Returns an instantiator that will be used to create a new instance of a given component.
|
static <T> InterceptionModelInitializer<T> |
InterceptionModelInitializer.of(BeanManagerImpl manager,
EnhancedAnnotatedType<T> annotatedType,
Bean<?> bean) |
Modifier and Type | Method and Description |
---|---|
protected Injector<T> |
SessionBeanInjectionTarget.initInjector(EnhancedAnnotatedType<T> type,
Bean<T> bean,
BeanManagerImpl beanManager) |
protected Instantiator<T> |
SessionBeanInjectionTarget.initInstantiator(EnhancedAnnotatedType<T> type,
Bean<T> bean,
BeanManagerImpl beanManager,
Set<InjectionPoint> injectionPoints) |
Modifier and Type | Method and Description |
---|---|
<T> Bean<T> |
BeanManagerImpl.createBean(BeanAttributes<T> attributes,
Class<T> beanClass,
InjectionTargetFactory<T> injectionTargetFactory) |
<T,X> Bean<T> |
BeanManagerImpl.createBean(BeanAttributes<T> attributes,
Class<X> beanClass,
ProducerFactory<X> producerFactory) |
<T> Bean<T> |
BeanManagerImpl.getBean(Resolvable resolvable) |
protected Bean<X> |
AbstractProducerFactory.getDeclaringBean() |
Bean<?> |
BeanManagerImpl.getPassivationCapableBean(String id) |
<X> Bean<? extends X> |
BeanManagerImpl.resolve(Set<Bean<? extends X>> beans) |
Modifier and Type | Method and Description |
---|---|
Iterable<Bean<?>> |
BeanManagerImpl.getAccessibleBeans() |
List<Bean<?>> |
BeanManagerImpl.getBeans()
The beans registered with the Web Bean manager which are resolvable.
|
Set<Bean<?>> |
BeanManagerImpl.getBeans(InjectionPoint injectionPoint) |
Set<Bean<?>> |
BeanManagerImpl.getBeans(String name) |
Set<Bean<?>> |
BeanManagerImpl.getBeans(Type beanType,
Annotation... qualifiers) |
Set<Bean<?>> |
BeanManagerImpl.getBeans(Type beanType,
Set<Annotation> qualifiers) |
Iterable<Bean<?>> |
BeanTransform.transform(BeanManagerImpl beanManager) |
Modifier and Type | Method and Description |
---|---|
void |
BeanManagerImpl.addBean(Bean<?> bean) |
InjectionTarget<T> |
InjectionTargetFactoryImpl.createInjectionTarget(Bean<T> bean) |
BasicInjectionTarget<T> |
InjectionTargetFactoryImpl.createInjectionTarget(EnhancedAnnotatedType<T> type,
Bean<T> bean,
boolean interceptor) |
<T> Producer<T> |
AbstractProducerFactory.createProducer(Bean<T> bean) |
<T> Producer<T> |
MethodProducerFactory.createProducer(Bean<X> declaringBean,
Bean<T> bean,
DisposalMethod<X,T> disposalMethod)
Producers returned from this method are not validated.
|
<T> Producer<T> |
MethodProducerFactory.createProducer(Bean<X> declaringBean,
Bean<T> bean,
DisposalMethod<X,T> disposalMethod)
Producers returned from this method are not validated.
|
<T> Producer<T> |
FieldProducerFactory.createProducer(Bean<X> declaringBean,
Bean<T> bean,
DisposalMethod<X,T> disposalMethod)
Producers returned from this method are not validated.
|
<T> Producer<T> |
FieldProducerFactory.createProducer(Bean<X> declaringBean,
Bean<T> bean,
DisposalMethod<X,T> disposalMethod)
Producers returned from this method are not validated.
|
abstract <T> Producer<T> |
AbstractProducerFactory.createProducer(Bean<X> declaringBean,
Bean<T> bean,
DisposalMethod<X,T> disposalMethod) |
abstract <T> Producer<T> |
AbstractProducerFactory.createProducer(Bean<X> declaringBean,
Bean<T> bean,
DisposalMethod<X,T> disposalMethod) |
<X> FieldProducerFactory<X> |
BeanManagerImpl.getProducerFactory(AnnotatedField<? super X> field,
Bean<X> declaringBean) |
<X> MethodProducerFactory<X> |
BeanManagerImpl.getProducerFactory(AnnotatedMethod<? super X> method,
Bean<X> declaringBean) |
Object |
BeanManagerImpl.getReference(Bean<?> bean,
Type requestedType,
CreationalContext<?> creationalContext) |
Object |
BeanManagerImpl.getReference(Bean<?> bean,
Type requestedType,
CreationalContext<?> creationalContext,
boolean noProxy) |
Object |
BeanManagerImpl.getReference(InjectionPoint injectionPoint,
Bean<?> resolvedBean,
CreationalContext<?> creationalContext)
Get a reference, registering the injection point used.
|
boolean |
BeanManagerImpl.isBeanEnabled(Bean<?> bean) |
protected void |
BeanManagerImpl.registerBeanNamespace(Bean<?> bean) |
Modifier and Type | Method and Description |
---|---|
void |
BeanManagerImpl.addBeans(Collection<? extends Bean<?>> beans)
Optimization which modifies CopyOnWrite structures only once instead of once for every bean.
|
<X> Bean<? extends X> |
BeanManagerImpl.resolve(Set<Bean<? extends X>> beans) |
Constructor and Description |
---|
AbstractProducerFactory(Bean<X> declaringBean,
BeanManagerImpl manager) |
FieldProducerFactory(AnnotatedField<? super X> field,
Bean<X> declaringBean,
BeanManagerImpl manager) |
MethodProducerFactory(AnnotatedMethod<? super X> method,
Bean<X> declaringBean,
BeanManagerImpl manager) |
Modifier and Type | Method and Description |
---|---|
<T> Bean<T> |
WeldManager.getBean(EjbDescriptor<T> descriptor)
Get the Bean object for the given EJB, or null if Weld was not given this descriptor in the deployment.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractTypeSafeBeanResolver<T extends Bean<?>,C extends Collection<T>> |
Modifier and Type | Field and Description |
---|---|
protected Bean<?> |
ResolvableBuilder.declaringBean |
Modifier and Type | Method and Description |
---|---|
Bean<?> |
ResolvableBuilder.ResolvableImpl.getDeclaringBean() |
Bean<?> |
Resolvable.getDeclaringBean()
Get the declaring the injection point, or null if there is none
|
Bean<?> |
ForwardingResolvable.getDeclaringBean() |
Modifier and Type | Method and Description |
---|---|
Set<Bean<?>> |
AbstractTypeSafeBeanResolver.BeanDisambiguation.load(Set<Bean<?>> from) |
<X> Set<Bean<? extends X>> |
AbstractTypeSafeBeanResolver.resolve(Set<Bean<? extends X>> beans) |
Set<Bean<?>> |
NameBasedResolver.resolve(String name)
Get the possible beans for the given name
|
Set<Bean<?>> |
AbstractTypeSafeBeanResolver.BeanDisambiguation.resolveAlternatives(Set<Bean<?>> alternatives)
If all the beans left are alternatives with a priority, then the container will select the
alternative with the highest priority, and the ambiguous dependency is called resolvable.
|
protected Set<Bean<?>> |
TypeSafeBeanResolver.sortResult(Set<Bean<?>> matched) |
Modifier and Type | Method and Description |
---|---|
static Set<QualifierInstance> |
QualifierInstance.qualifiers(BeanManagerImpl beanManager,
Bean<?> bean) |
ResolvableBuilder |
ResolvableBuilder.setDeclaringBean(Bean<?> declaringBean) |
InterceptorResolvableBuilder |
InterceptorResolvableBuilder.setDeclaringBean(Bean<?> declaringBean) |
Modifier and Type | Method and Description |
---|---|
Set<Bean<?>> |
AbstractTypeSafeBeanResolver.BeanDisambiguation.load(Set<Bean<?>> from) |
<X> Set<Bean<? extends X>> |
AbstractTypeSafeBeanResolver.resolve(Set<Bean<? extends X>> beans) |
Set<Bean<?>> |
AbstractTypeSafeBeanResolver.BeanDisambiguation.resolveAlternatives(Set<Bean<?>> alternatives)
If all the beans left are alternatives with a priority, then the container will select the
alternative with the highest priority, and the ambiguous dependency is called resolvable.
|
protected Set<Bean<?>> |
TypeSafeBeanResolver.sortResult(Set<Bean<?>> matched) |
Constructor and Description |
---|
ResolvableBuilder.ResolvableImpl(Class<?> rawType,
Set<Type> typeClosure,
Map<Class<? extends Annotation>,Annotation> mappedQualifiers,
Bean<?> declaringBean,
Set<QualifierInstance> qualifierInstances,
boolean delegate) |
Constructor and Description |
---|
NameBasedResolver(BeanManagerImpl manager,
Iterable<? extends Bean<?>> allBeans)
Constructor
|
TypeSafeBeanResolver(BeanManagerImpl beanManager,
Iterable<Bean<?>> beans) |
Modifier and Type | Method and Description |
---|---|
protected Bean<T> |
BeanHolder.initialize() |
Modifier and Type | Method and Description |
---|---|
static <T> BeanHolder<T> |
BeanHolder.of(Bean<T> bean) |
Constructor and Description |
---|
BeanHolder(Bean<T> bean) |
Modifier and Type | Method and Description |
---|---|
static <T extends Bean<?>> |
Beans.removeDisabledBeans(Set<T> beans,
BeanManagerImpl beanManager,
SpecializationAndEnablementRegistry registry)
Retains only beans which have deployment type X.
|
Modifier and Type | Method and Description |
---|---|
<T> Bean<T> |
ForwardingBeanManager.createBean(BeanAttributes<T> attributes,
Class<T> beanClass,
InjectionTargetFactory<T> injectionTargetFactory) |
<T,X> Bean<T> |
ForwardingBeanManager.createBean(BeanAttributes<T> attributes,
Class<X> beanClass,
ProducerFactory<X> producerFactory) |
Bean<?> |
DelegatingFieldInjectionPointAttributes.getBean() |
Bean<?> |
ForwardingBeanManager.getPassivationCapableBean(String id) |
<X> Bean<? extends X> |
ForwardingBeanManager.resolve(Set<Bean<? extends X>> beans) |
Modifier and Type | Method and Description |
---|---|
Set<Bean<?>> |
ForwardingBeanManager.getBeans(String name) |
Set<Bean<?>> |
ForwardingBeanManager.getBeans(Type beanType,
Annotation... qualifiers) |
Modifier and Type | Method and Description |
---|---|
static <T> List<Set<MethodInjectionPoint<?,?>>> |
BeanMethods.getInitializerMethods(Bean<?> declaringBean,
EnhancedAnnotatedType<T> type,
BeanManagerImpl manager) |
static <T> T |
Decorators.getOuterDelegate(Bean<T> bean,
T instance,
CreationalContext<T> creationalContext,
Class<T> proxyClass,
InjectionPoint originalInjectionPoint,
BeanManagerImpl manager,
List<Decorator<?>> decorators) |
<X> ProducerFactory<X> |
ForwardingBeanManager.getProducerFactory(AnnotatedField<? super X> field,
Bean<X> declaringBean) |
<X> ProducerFactory<X> |
ForwardingBeanManager.getProducerFactory(AnnotatedMethod<? super X> method,
Bean<X> declaringBean) |
Object |
ForwardingBeanManager.getReference(Bean<?> bean,
Type beanType,
CreationalContext<?> ctx) |
static UnproxyableResolutionException |
Proxies.getUnproxyableTypeException(Type type,
Bean<?> declaringBean) |
static UnproxyableResolutionException |
Proxies.getUnproxyableTypesException(Bean<?> declaringBean) |
static boolean |
Beans.isBeanEnabled(Bean<?> bean,
ModuleEnablement enabled) |
static boolean |
Beans.isBeanProxyable(Bean<?> bean)
Indicates if a bean is proxyable
|
static boolean |
Beans.isPassivatingScope(Bean<?> bean,
BeanManagerImpl manager)
Indicates if a bean's scope type is passivating
|
static boolean |
Beans.isPassivationCapableBean(Bean<?> bean)
Tests if a bean is capable of having its state temporarily stored to secondary storage
|
static boolean |
Beans.isPassivationCapableDependency(Bean<?> bean)
Tests if a bean is capable of having its state temporarily stored to secondary storage
|
static boolean |
Proxies.isTypesProxyable(Bean<?> declaringBean)
Indicates if a set of types are all proxyable
|
Modifier and Type | Method and Description |
---|---|
static boolean |
Beans.isAlternativePresent(Set<Bean<?>> beans)
Check if any of the beans is an alternative
|
<X> Bean<? extends X> |
ForwardingBeanManager.resolve(Set<Bean<? extends X>> beans) |
Modifier and Type | Class and Description |
---|---|
class |
WrappedBeanHolder<T,S extends Bean<T>>
Used within
IsolatedForwardingBean and its subclasses as a value holder. |
Modifier and Type | Class and Description |
---|---|
class |
IsolatedForwardingBean<T>
Delegating implementation of
Bean . |
static class |
IsolatedForwardingBean.Impl<T> |
class |
IsolatedForwardingDecorator<T>
Delegating implementation of
Decorator . |
static class |
IsolatedForwardingDecorator.Impl<T> |
class |
IsolatedForwardingInterceptor<T>
Delegating implementation of
Interceptor . |
static class |
IsolatedForwardingInterceptor.Impl<T> |
class |
SerializableForwardingBean<T> |
Modifier and Type | Method and Description |
---|---|
static <T,S extends Bean<T>> |
WrappedBeanHolder.of(BeanAttributes<T> attributes,
S bean) |
Modifier and Type | Method and Description |
---|---|
protected Bean<T> |
SerializableForwardingBean.delegate() |
protected abstract Bean<T> |
IsolatedForwardingBean.delegate() |
protected Bean<T> |
IsolatedForwardingBean.Impl.delegate() |
Modifier and Type | Method and Description |
---|---|
static <T> SerializableForwardingBean<T> |
SerializableForwardingBean.of(Bean<T> bean) |
Constructor and Description |
---|
SerializableForwardingBean(Bean<T> bean) |
Constructor and Description |
---|
IsolatedForwardingBean.Impl(WrappedBeanHolder<T,Bean<T>> cartridge) |
Copyright © 2013 Seam Framework. All Rights Reserved.