Interface | Description |
---|---|
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
Bean and
ObserverMethod objects 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
Bean or
Contextual
is 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
Bean object. |
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
Bean object. |
ProcessObserverMethod<T,X> |
The container fires an event of this type for each
observer method
of each enabled bean, before registering the
ObserverMethod object. |
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
Bean object. |
ProcessProducerMethod<T,X> |
The container fires an event of this type for each enabled producer method,
before registering the
Bean object. |
ProcessSessionBean<X> |
The container fires an event of this type for each enabled session bean,
before registering the
Bean object. |
Producer<T> |
Provides a generic operation for producing an instance of a type.
|
Enum | Description |
---|---|
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
.
Copyright © 2018 JBoss by Red Hat. All rights reserved.