| 
 | ||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES | |||||||||
See:
          Description
| Interface Summary | |
|---|---|
| AfterBeanDiscovery | The event type of the second event fired by the container when it has fully
 completed the bean discovery process, validated that there are no definition
 errors relating to the discovered beans, and registered BeanandObserverMethodobjects for the discovered
 beans, but before detecting deployment problems. | 
| AfterDeploymentValidation | The event type of the third event fired by the container after it has validated that there are no deployment problems and before creating contexts or processing requests. | 
| Annotated | Represents a Java program element that can be annotated. | 
| AnnotatedCallable<X> | Represents a callable member of a Java type. | 
| AnnotatedConstructor<X> | Represents a constructor of a Java class. | 
| AnnotatedField<X> | Represents a field of a Java class. | 
| AnnotatedMember<X> | Represents a member of a Java type. | 
| AnnotatedMethod<X> | Represents a method of a Java type. | 
| AnnotatedParameter<X> | Represents a parameter of a method or constructor. | 
| AnnotatedType<X> | Represents a Java class or interface. | 
| Bean<T> | Represents an enabled bean. | 
| BeanManager | Allows a portable extension to interact directly with the container. | 
| BeforeBeanDiscovery | This event type is thrown by the container before the bean discovery process begins. | 
| BeforeShutdown | The type of the final event the container fires after it has finished processing requests and destroyed all contexts. | 
| Decorator<T> | Represents an enabled decorator. | 
| Extension | Service interface implemented by extensions. | 
| InjectionPoint | Provides access to metadata about an injection point. | 
| InjectionTarget<T> | Provides operations for performing dependency injection and lifecycle callbacks on an instance of a type. | 
| Interceptor<T> | Represents an enabled interceptor. | 
| ObserverMethod<T> | Represents an observer method of an enabled bean. | 
| PassivationCapable | Indicates that a custom implementation of BeanorContextualis passivation capable. | 
| ProcessAnnotatedType<X> | The container fires an event of this type for each Java class or interface it discovers in a bean archive, before it reads the declared annotations. | 
| ProcessBean<X> | The container fires an event of this type for each enabled bean, interceptor 
 or decorator deployed in a bean archive, before registering the Beanobject. | 
| ProcessInjectionTarget<X> | The container fires an event of this type for every Java EE component class supporting 
 injection that may be instantiated by the container at runtime, including every
 managed bean declared using javax.annotation.ManagedBean, EJB session 
 or message-driven bean, enabled bean, enabled interceptor or enabled decorator. | 
| ProcessManagedBean<X> | The container fires an event of this type for each enabled managed bean,
 before registering the Beanobject. | 
| ProcessObserverMethod<T,X> | The container fires an event of this type for each
 observer method 
 of each enabled bean, before registering the ObserverMethodobject. | 
| ProcessProducer<T,X> | The container fires an event of this type for each producer method or field of each enabled bean, including resources. | 
| ProcessProducerField<T,X> | The container fires an event of this type for each enabled producer field, 
 before registering the Beanobject. | 
| ProcessProducerMethod<T,X> | The container fires an event of this type for each enabled producer method, 
 before registering the Beanobject. | 
| ProcessSessionBean<X> | The container fires an event of this type for each enabled session bean,
 before registering the Beanobject. | 
| Producer<T> | Provides a generic operation for producing an instance of a type. | 
| Enum Summary | |
|---|---|
| InterceptionType | Identifies the kind of lifecycle callback, EJB timeout method or business method interception. | 
| SessionBeanType | Identifies the kind of EJB session bean. | 
The portable extension integration SPI.
A portable extension may integrate with the container by:
Portable extensions sometimes interact directly with the container 
 via programmatic API call. The interface 
 BeanManager provides operations 
 for obtaining contextual references for beans, along with many other 
 operations of use to portable extensions.
During the application initialization process, the container fires a series of events, allowing portable extensions to integrate with the container initialization process. Observer methods of these events must belong to extensions declared in META-INF/services.
Lifecycle events include
 BeforeBeanDiscovery,
 AfterBeanDiscovery,
 AfterDeploymentValidation and
 BeforeShutdown.
The interfaces 
 Bean,
 Decorator,
 Interceptor and
 ObserverMethod
 define everything the container needs to manage instances of 
 a bean, interceptor, decorator or observer method.
An instance of Bean exists for every  
 enabled bean. A portable 
 extension may add support for new kinds of beans by implementing 
 Bean, observing the event
 AfterBeanDiscovery event 
 registering beans with the container. An instance of 
 ObserverMethod exists for every 
 observer method of every 
 enabled bean. A portable extension may add observers by implementing 
 ObserverMethod and 
 registering an instance with the container.
A portable extension may be notified of the existence of an
 enabled bean by observing the container lifecycle event type 
 ProcessBean or one of its 
 subtypes,
 or of the existence of an observer method of an enabled bean by 
 observing the event type
 ProcessObserverMethod.
A portable extension may provide an alternative metadata source, such as configuration by XML.
Annotated
 and its subtypes allow a portable extension to specify 
 metadata that overrides the annotations that exist on a 
 bean class. The portable extension is responsible for 
 implementing the interfaces, thereby exposing the metadata 
 to the container. The container must use the operations of 
 Annotated and its subinterfaces to discover program 
 element types and annotations, instead of directly calling the 
 Java Reflection API.
A portable extension provides its metadata to the 
 container by observing the event 
 ProcessAnnotatedType and 
 wrapping the AnnotatedType.
Producer and
 InjectionTarget abstract the 
 basic lifecycle of (contextual or non-contextual) container managed 
 objects, including instantiation and destruction, dependency injection 
 and lifecycle callbacks.
 
 An instance of InjectionTarget 
 may be 
 obtained from the BeanManager,
 allowing a portable extension to request these container services for
 objects under the control of the portable extension.
Furthermore, a portable extension may replace the implementation
 of InjectionTarget or
 Producer used by the container
 with its own implementation by observing the events
 ProcessInjectionTarget or
 ProcessProducer.
javax.enterprise.inject, 
javax.enterprise.context.spi| 
 | ||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES | |||||||||