All Classes and Interfaces
Class
Description
The container provides a built in interceptor that may be used to annotate classes and methods to indicate
that a request context should be activated when this method is invoked.
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.
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.
This event type is thrown by the container after type discovery is complete.
Provides an operation for obtaining and destroying contextual instances with a particular scope of any contextual type.
Specifies that a bean is an alternative.
Supports inline instantiation of the
Alternative annotation.
Indicates that multiple beans match a certain combination of required type and required qualifiers and are eligible for
injection into a certain class.
Represents a Java program element that can be annotated.
Represents a callable member of a Java type.
Represents a constructor of a Java class.
This interface is part of the
AnnotatedTypeConfigurator SPI and helps defining an AnnotatedConstructor
Represents a field of a Java class.
This interface is part of the
AnnotatedTypeConfigurator SPI and helps defining an AnnotatedField
Represents a member of a Java type.
Represents a method of a Java type.
This interface is part of the
AnnotatedTypeConfigurator SPI and helps defining an AnnotatedMethod
Represents a parameter of a method or constructor.
This interface is part of the
AnnotatedTypeConfigurator SPI and helps defining an AnnotatedParameter
Represents a Java class or interface.
This API is a helper to configure a new
AnnotatedType instance.Builder for annotations of given type.
Supports instantiating
AnnotationBuilder.An annotation instance, typically obtained from an
AnnotationTarget.
Supports inline instantiation of annotation type instances.
The value of an annotation member.
The kind of the annotation member value.
An annotation target is anything that can be annotated.
The built-in qualifier type.
Supports inline instantiation of the
Any qualifier.
Specifies that a bean is application scoped.
Supports inline instantiation of the
ApplicationScoped annotation.An array type is created from a component type.
Represents an enabled bean.
The BeanAttributes interface exposes the basic attributes of a bean.
This API is an helper to configure a new
BeanAttributes instance.This API is an helper to configure a new
Bean instance.BeanContainer is a superclass of BeanManager containing capabilities that are portable across
all CDI environments.Beans are:
managed beans
beans defined by producer methods
beans defined by producer fields
synthetic beans
Managed beans are also known as class-based beans, while beans defined by producer methods
and producer fields are together also known as producer-based beans.
Allows a portable extension to interact directly with the container.
This event type is thrown by the container before the bean discovery process begins.
An event with this qualifier is fired when a context is about to be destroyed, i.e.
Supports inline instantiation of the
BeforeDestroyed qualifier.
The type of the final event the container fires after it has finished processing requests and destroyed all contexts.
Build compatible extensions are service providers for this interface, as defined in
ServiceLoader.Service provider interface for various services needed by
BuildCompatibleExtension implementations.An internal helper to resolve
BuildServices implementations.
Indicates that the container has rejected a request because a concurrent request is associated with the same conversation
context.
Provides access to the current container.
Interface implemented by a CDI provider to provide access to the current container
Allows adding annotations to and removing annotations from a class.
A class.
A class type, including interface types, enum types, annotation types and record types.
Provides an operation for obtaining contextual instances with a particular scope of any contextual type.
Indicates a problem relating to context management.
Indicates that a context is not active.
Defines operations to create and destroy contextual instances of a certain type.
Allows the application to manage the conversation context by marking
the current conversation as transient or long-running, specifying a conversation identifier, or setting the conversation
timeout.
Specifies that a bean is conversation scoped.
Supports inline instantiation of the
ConversationScoped annotation.
Provides operations that are used by the
Contextual implementation during instance
creation and destruction.
Indicates that a checked exception was thrown during creation of a bean.
Allows adding annotations to and removing annotations from a declaration.
A declaration is an element of a program source code.
The declaration kind: package, class, method, parameter, field, record component.
A decorator may inject metadata about the bean it is decorating
Specifies that a class is a decorator.
Represents an enabled decorator.
The default qualifier type.
Supports inline instantiation of the
Default qualifier.
Thrown when a definition error occurs.
Identifies the delegate injection point of a decorator.
Specifies that a bean belongs to the dependent pseudo-scope.
Supports inline instantiation of the
Dependent annotation.
Thrown when a deployment problem occurs.
An event with this qualifier is fired when a context is destroyed, i.e.
Supports inline instantiation of the
Destroyed qualifier.1st phase of build compatible extension execution.
Disposer methods may exist for producer-based beans.
Identifies the disposed parameter of a disposer method.
A
BeanManager that allows integrators to obtain Unified EL objects that are
integrated with the CDI container as described in the Jakarta EE Platform specification.2nd phase of build compatible extension execution.
Allows the application to fire events of a particular type.
Represents a context of a fired event.
Provides access to metadata about an observed event payload.
Service interface implemented by extensions.
Allows adding annotations to and removing annotations from a field.
A field, declared in some class.
Indicates that a producer method returned a null value or a producer field contained a null value, and the scope of the
producer method or field was not
Dependent.An event with this qualifier is fired when a context is initialized, i.e.
Supports inline instantiation of the
Initialized qualifier.Indicates a problem relating to dependency injection.
Provides access to metadata about an injection point.
This API is an helper to configure an existing
InjectionPoint instance.An injection point defined on some bean.
Provides operations for performing dependency injection and lifecycle callbacks on an
instance of a type.
An
InjectionTargetFactory can create an InjectionTarget for a given bean.Supports inline instantiation of the
Inject annotation.
Allows the application to dynamically obtain instances of beans with a specified combination of required type and qualifiers.
This interface represents a contextual reference handle.
An interceptor may inject metadata about the bean it is intercepting.
InterceptionFactory allows to create a wrapper instance whose method invocations are intercepted by method
interceptors and forwarded to a provided instance.
Identifies the kind of lifecycle callback, EJB timeout method or business method interception.
Represents an enabled interceptor.
Interceptors are managed beans annotated
@Interceptor.An invoker allows indirect invocation of its target method on an instance of its target
bean.
Builder of
Invokers.Factory for
InvokerBuilders.Opaque token that stands in for an invoker registered using
InvokerFactory.createInvoker(BeanInfo, MethodInfo)
and InvokerBuilder.build().Allows logging and producing errors during build compatible extension
execution.
Allows registering custom CDI meta-annotations: qualifiers, interceptor bindings,
stereotypes, and scopes.
Allows adding annotations to and removing annotations from a method.
A method or a constructor, declared in some class.
The built-in stereotype intended for use with beans that define the model layer of an MVC web application architecture such
as JSF.
Supports inline instantiation of the
Named qualifier.
Excludes a member of an annotation type (such as a qualifier type or
interceptor binding type) from consideration when the container compares
two annotation instances.
Supports inline instantiation of the
Nonbinding annotation.
Indicates that the conversation context could not be restored.
Specifies that an annotation type is a normal scope type.
Notification options are used to configure observer notification.
Notification options builder.
Indicates that a checked exception was thrown by an observer method during event notification.
Observers are:
observer methods
synthetic observers
Observer methods directly correspond to a method declaration in program source code.
Represents an observer method of an enabled
bean.
An
ObserverMethodConfigurator can configure an ObserverMethod.Represents an operation that accepts a context of a fired event.
Identifies the event parameter of an observer method.
Identifies the event parameter of an asynchronous observer method.
A package, possibly annotated in
package-info.java.Allows adding annotations to and removing annotations from a method parameter.
A method parameter or a constructor parameter, declared in some method
or constructor.
A parameterized type.
A
String-keyed parameter map.Indicates that a custom implementation of
Bean or
Contextual is passivation capable.Primitive types are:
boolean
byte
short
int
long
float
double
char
The primitive type kind: boolean, byte, short, int, long, float, double, char
This interface allows some SPI implementation to change their priority programmatically.
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.
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.
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.
The container fires an event of this type for every injection point of every Java EE component class supporting injection
that may be instantiated by the container at runtime, including every EJB session or message-driven bean, enabled
bean, enabled interceptor or enabled decorator.
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 EJB session or message-driven bean, enabled bean, enabled interceptor or
enabled decorator.
The container fires an event of this type for each enabled managed bean, before registering the
Bean object.
The container fires an event of this type for each observer method of each
enabled bean, before registering the
ObserverMethod object.
The container fires an event of this type for each producer method or field of
each enabled bean, including resources.
The container fires an event of this type for each enabled producer field, before registering the
Bean object.
The container fires an event of this type for each enabled producer method, before registering the
Bean object.
The container fires an event of this type for each enabled session bean, before registering the
Bean object.
The container fires an event of this type for each Java class or interface added by
BeforeBeanDiscovery.addAnnotatedType(AnnotatedType, String) or
AfterTypeDiscovery.addAnnotatedType(AnnotatedType, String)
The container fires an event of this type for each custom bean implementation added through
AfterBeanDiscovery.addBean() or AfterBeanDiscovery.addBean(Bean), before registering the
Bean object.
The container fires an event of this type for each custom implementation of
ObserverMethod added through
AfterBeanDiscovery.addObserverMethod(ObserverMethod) or AfterBeanDiscovery.addObserverMethod(), before
registering the ObserverMethod object.
Provides a generic operation for producing an instance of a type.
A
ProducerConfigurator can configure a Producer.
An
ProducerFactory can create an Producer for a given bean.
Identifies a producer method or field.
Supports inline instantiation of the
Qualifier annotation.
Distinguishes conditional observer methods from observer methods which are
always notified.
A record component, declared in some record.
3rd phase of build compatible extension execution.
The CDI container provides a built in instance of RequestContextController that is dependent scoped for the purposes
of activating and deactivating.
Specifies that a bean is request scoped.
Supports inline instantiation of the
RequestScoped annotation.Indicates a problem relating to typesafe resolution.
Allows adding additional classes to the set of types discovered during type discovery.
A scope of a bean.
Provides access to the current container in Java SE.
A CDI container initializer for Java SE.
Identifies the kind of EJB session bean.
Specifies that a bean is session scoped.
Supports inline instantiation of the
SessionScoped annotation.Supports inline instantiation of the
Singleton annotation.If a build compatible extension is annotated
@SkipIfPortableExtensionPresent, it is ignored when the CDI container
can execute portable extensions and determines that a portable extension
of given class is present.
Indicates that a bean directly specializes another bean.
Supports inline instantiation of the
Specializes annotation.
Specifies that an annotation type is a stereotype.
A stereotype.
4th phase of build compatible extension execution.
Builder for synthetic beans.
Creation function for a synthetic bean defined by
SyntheticBeanBuilder.Destruction function for a synthetic bean defined by
SyntheticBeanBuilder.Allows registering synthetic beans and observers.
The event notification function for a synthetic observer defined by
SyntheticObserverBuilder.Builder for synthetic observers.
Distinguishes the various kinds of transactional observer methods from regular
observer methods which are notified immediately.
If a parameter annotated with
@TransientReference resolves to a dependent scoped bean, then the bean will
be
destroyed after the invocation completes.Supports inline instantiation of the
TransientReference annotation.A type is used in a program source code, but does not have to be declared anywhere.
The type kind: void, primitive, class, array, parameterized type, type variable, wildcard type
Restricts the bean types of a bean.
Supports inline instantiation of the
Typed annotation.
Supports inline instantiation of objects that represent parameterized types with actual type parameters.
Factory for types.
Type variables represent type parameters declared on generic classes or methods.
Helper class for injecting and calling lifecycle callbacks unmanaged instances for use by framework and library integrators.
Represents a non-contextual instance.
Indicates that a contextual reference for a bean with a normal scope and a certain bean type cannot be obtained because the
bean type cannot be proxied by the container.
Indicates that no bean matches a certain combination of required type and required qualifiers and is eligible for injection
into a certain class.
5th phase of build compatible extension execution.
Veto the processing of the class.
Supports inline instantiation of the
Vetoed annotation.The
void pseudo-type.A wildcard type.
WithAnnotations may be applied to any portable extension observer method with an event parameter type of
ProcessAnnotatedType to filter the events delivered.