All Classes and Interfaces
Class
Description
Abstract skeleton implementation of a
MultivaluedMap that is backed
by a [key, multi-value] store represented as a Map<K, List<V>>.
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.
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.
Represents a field of a Java class.
Represents a member of a Java type.
Represents a method of a Java type.
Represents a parameter of a method or constructor.
Represents a Java class or interface.
Supports inline instantiation of annotation type instances.
The built-in qualifier type.
Defines the components of a JAX-RS application and supplies additional
meta-data.
Identifies the application path that serves as the base URI
for all resource URIs provided by
Path.
Specifies that a bean is application scoped.
Designates an interceptor method that receives a callback when
the target class constructor is invoked.
Defines an interceptor method that interposes on business methods.
Defines an interceptor method that interposes on timeout methods.
Wrap the execution and invoke it asynchronously.
Uniform interface for asynchronous invocation of HTTP methods.
An injectable JAX-RS asynchronous response that provides means for asynchronous server side
response processing.
A runtime exception indicating a
bad client request.
Represents an enabled bean.
The BeanAttributes interface exposes the basic attributes of a bean.
Allows a portable extension to interact directly with the container.
The annotation that may be used to inject custom JAX-RS "parameter aggregator" value object
into a resource class field, property or resource method parameter.
This event type is thrown by the container before the bean discovery process begins.
The type of the final event the container fires after it has finished processing requests and destroyed all contexts.
Define bulkhead policy to limit the number of the concurrent calls to an instance.
The exception should be thrown when Bulkhead implementation throws an exception,
e.g.
Indicates that the container has rejected a request because a concurrent request is associated with the same conversation
context.
An abstraction for the value of a HTTP Cache-Control response header.
Provides access to the current container.
Interface implemented by a CDI provider to provide access to the current container
Define the Circuit Breaker policy
The exception should be thrown when circuit breaker is open.
Annotation used to signify an injection point for a
ClaimValue from
a JsonWebTokenThis enum represents the standardized claims that the MP-JWT specification allows for in terms of interoperability.
A representation of a claim in a
JsonWebTokenClient is the main entry point to the fluent API used to build and execute client
requests in order to consume responses returned.
Main entry point to the client API used to bootstrap
Client
instances.A base runtime application exception indicating a client request error
(HTTP
4xx status codes).Client request filter context.
An extension interface implemented by client request filters.
Client response filter context.
An extension interface implemented by client response filters.
A request processing callback that receives request processing completion events.
Resolves the property value by searching through all configured
ConfigSources.Builder for manually creating an instance of a
Config.Binds the injection point with a configured value.
This is the central class to access a
Config.This class is not intended to be used by end-users but for
portable container integration purpose only.
Implement this interfaces to provide a ConfigSource.
Implement this interfaces to provide multiple ConfigSources.
Represents a client or server-side configurable context in JAX-RS.
A configuration state associated with a
configurable JAX-RS context.Asynchronous request processing lifecycle callback that receives connection
related
asynchronous response lifecycle events.Indicates the run-time context in which an annotated JAX-RS provider
is applicable.
Defines the media types that the methods of a resource class or
MessageBodyReader can accept.Container request filter context.
An extension interface implemented by container request filters.
Container response filter context.
An extension interface implemented by container response filters.
Provides an operation for obtaining contextual instances with a particular scope of any contextual type.
This annotation is used to inject information into a class
field, bean property or method parameter.
Indicates a problem relating to context management.
Indicates that a context is not active.
Contract for a provider that supplies context information to resource
classes and other providers.
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.
Interface for converting configured values from String to any Java type.
Represents the value of a HTTP cookie, transferred in a request.
Binds the value of a HTTP cookie to a resource method parameter,
resource class field, or resource class bean property.
An annotation for marking a method, constructor, or class as counted.
An incrementing and decrementing counter metric.
An interface for metric types which have counts.
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.
Annotation used to define a container
DataSource and
be registered with JNDI.Declares one or more
DataSourceDefinition annotations.Used by application to declare roles.
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.
Defines the default value of request meta-data that is bound using one of the
following annotations:
PathParam,
QueryParam,
MatrixParam,
CookieParam,
FormParam,
or HeaderParam.
Thrown when a definition error occurs.
Identifies the delegate injection point of a decorator.
Indicates that the annotated method responds to HTTP DELETE requests.
Specifies that no security roles are allowed to invoke the specified
method(s) - i.e that the methods are to be excluded from execution in
the J2EE container.
Specifies that a bean belongs to the dependent pseudo-scope.
Thrown when a deployment problem occurs.
The
@Destroyed qualifier.
Identifies the disposed parameter of a disposer method.
A JAX-RS meta-provider for dynamic registration of post-matching providers
during a JAX-RS application setup at deployment time.
Disables automatic decoding of parameter values bound using
QueryParam,
PathParam, FormParam or MatrixParam.Encapsulates message entity including the associated variant information.
An abstraction for the value of a HTTP Entity Tag, used as the value
of an ETag response header.
Allows the application to fire events of a particular type.
Provides access to metadata about an observed event payload.
Contract for a provider that maps Java exceptions to
Response.Used to exclude class-level interceptors for a
lifecycle callback, business, or timeout method of a target class,
or a constructor of a target class.
Used to exclude default interceptors for a target class or
a lifecycle callback, business, or timeout method of a target class,
or a constructor of a target class.
The execution context for the method being executed.
Service interface implemented by extensions.
The fallback annotation to define the fallback handler class so that
a failure can be handled properly.
Create a default class so the value is not required to be set all the time.
The handler instance used by the container to service a fallback invocation is a non-contextual
instance created using the CDI SPI.
The exception should be thrown when the definition of any Fault Tolerance annotations is invalid.
The exception should be thrown when the maximum retries is reached or overall retry duration is reached,
circuit breaker is open, timeout occurred.
A feature extension contract.
A configurable context passed to
Feature and DynamicFeature
instances by JAX-RS runtime during the phase of their configuration.A runtime exception indicating that an access to a resource requested by
a client has been
forbidden
by the server.Represents the the HTML form data request entity encoded using the
"application/x-www-form-urlencoded" content type.Binds the value(s) of a form parameter contained within a request entity body
to a resource method parameter.
An annotation for marking a method or field as a gauge.
A gauge metric is an instantaneous reading of a particular value.
The Generated annotation is used to mark source code that has been generated.
Represents a message entity of a generic type
T.Represents a generic message entity type
T.Indicates that the annotated method responds to HTTP GET requests.
Indicates that the annotated method responds to HTTP HEAD requests.
Binds the value(s) of a HTTP header to a resource method parameter,
resource class field, or resource class bean property.
Created by hbraun on 24.08.17.
The health check procedure interface.
The response to a health check invocation.
A builder to construct a health procedure response.
Reserved for implementors as means to supply their own HealthCheckResponseBuilder.
A metric which calculates the distribution of a value.
An injectable interface that provides access to HTTP header information.
Associates the name of a HTTP method with an annotation.
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.
The
@Initialized qualifier.Identifies injectable constructors, methods, and fields.
Provides access to metadata about an injection point.
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.
Allows the application to dynamically obtain instances of beans with a specified combination of required type and qualifiers.
An interceptor may inject metadata about the bean it is intercepting.
Identifies the kind of lifecycle callback, EJB timeout method or business method interception.
Represents an enabled interceptor.
Specifies that a class is an interceptor.
Priorities that define the order in which interceptors are
invoked.
Specifies that an annotation type is an interceptor binding type.
Context shared by message body interceptors that can be used to wrap
calls to
MessageBodyReader.readFrom(java.lang.Class<T>, java.lang.reflect.Type, java.lang.annotation.Annotation[], javax.ws.rs.core.MediaType, javax.ws.rs.core.MultivaluedMap<java.lang.String, java.lang.String>, java.io.InputStream) and
MessageBodyWriter.writeTo(T, java.lang.Class<?>, java.lang.reflect.Type, java.lang.annotation.Annotation[], javax.ws.rs.core.MediaType, javax.ws.rs.core.MultivaluedMap<java.lang.String, java.lang.Object>, java.io.OutputStream).Declares an ordered list of interceptors for a target class,
a method or a constructor of a target class.
A runtime exception indicating an
internal server error.A client request invocation.
A client request invocation builder.
Callback that can be implemented to receive the asynchronous processing
events from the invocation processing.
Exposes context information about the intercepted invocation and operations
that enable interceptor methods to control the behavior of the invocation chain.
Factory class for creating JSON processing objects.
JsonArray represents an immutable JSON array
(an ordered sequence of zero or more values).A builder for creating
JsonArray models from scratch.Factory to create
JsonObjectBuilder and JsonArrayBuilder
instances.JsonException indicates that some exception happened during
JSON processing.JsonGenerationException indicates an incorrect JSON is
being generated.Writes JSON data to an output source in a streaming way.
Factory to create
JsonGenerator instances.Provides the location information of a JSON event in an input source.
An immutable JSON number value.
JsonObject class represents an immutable JSON object value
(an unordered collection of zero or more name/value pairs).A builder for creating
JsonObject models from scratch.Provides forward, read-only access to JSON data in a streaming way.
An event from
JsonParser.Factory for creating
JsonParser instances.JsonParsingException is used when an incorrect JSON is
being parsed.Service provider for JSON processing objects.
Factory to create
JsonReader instances.An immutable JSON string value.
JsonValue represents an immutable JSON value.Indicates the type of a
JsonValue object.A read-only interface for the the claims required by Eclipse MicroProfile
conforming tokens.
Factory to create
JsonWriter instances.Class representing hypermedia links.
Builder class for hypermedia links.
An implementation of JAXB
XmlAdapter
that maps the JAX-RS Link type to a value that can be
marshalled and unmarshalled by JAXB.Value type for
Link that can be marshalled and
unmarshalled by JAXB.A security annotation describing the authentication method, and the associated realm name that
should be used for this application.
The ManagedBean annotation marks a POJO (Plain Old Java Object) as a
ManagedBean.A ManagedBean supports a small set of basic services such as
resource injection, lifecycle callbacks and interceptors.
Binds the value(s) of a URI matrix parameter to a resource method parameter,
resource class field, or resource class bean property.
An abstraction for a media type.
Contract for a provider that supports the conversion of a stream to a
Java type.
Contract for a provider that supports the conversion of a Java type to a
stream.
Bean holding the metadata of one single metric.
A meter metric which measures mean throughput and one-, five-, and fifteen-minute
exponentially-weighted moving average throughputs.
An annotation for marking a method, constructor, or class as metered.
An object which maintains mean and exponentially-weighted rate.
An annotation requesting that a metric be injected or registered.
A tag interface to indicate that a class is a metric.
A filter used to determine whether or not a metric should be reported, among other things.
The registry that stores metrics and their metadata.
An enumeration representing the scopes of the MetricRegistry
An enumeration representing the different types of metrics.
Standard units constants for metric's
Metadata.
The built-in stereotype intended for use with beans that define the model layer of an MVC web application architecture such
as JSF.
A hash table based implementation of
MultivaluedMap interface.A map of key-values pairs.
Meta-annotation used to create name binding annotations for filters
and interceptors.
String-based qualifier.
The
New qualifier was deprecated in CDI 1.1.Used to create a new HTTP cookie, transferred in a response.
An I/O exception thrown by
MessageBodyReader implementations
when reading a zero-length message content to indicate that the message body reader
is not able to produce an instance representing an zero-length message content.
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.
Indicates that the conversation context could not be restored.
Specifies that an annotation type is a normal scope type.
A runtime exception indicating that a client request is
not acceptable
by the server.A runtime exception indicating a client requesting a resource method that is
not allowed.A runtime exception indicating request authorization failure caused by one of the following
scenarios:
a client did not send the required authorization credentials to access the requested resource,
i.e.
A runtime exception indicating a resource requested by a client was
not found on the server.A runtime exception indicating that the client request entity media type is
not supported.
Indicates that a checked exception was thrown by an observer method during event notification.
Represents an observer method of an enabled
bean.
Identifies the event parameter of an observer method.
Indicates that the annotated method responds to HTTP OPTIONS requests.
Defines a contract for a delegate responsible for converting between a
String form of a message parameter value and the corresponding custom
Java type T.Mandates that a conversion of any
default value delegated
to a parameter converter annotated with @Lazy
annotation SHOULD occur only once the value is actually required (e.g.Contract for a provider of
ParamConverter instances.Indicates that a custom implementation of
Bean or
Contextual is passivation capable.Identifies the URI path that a resource class or class method will serve
requests for.
Binds the value of a URI template parameter or a path segment
containing the template parameter to a resource method parameter, resource
class field, or resource class
bean property.
Represents a URI path segment and any associated matrix parameters.
Specifies that all security roles are allowed to invoke the specified
method(s) i.e that the specified method(s) are "unchecked".
Indicates that the annotated method responds to HTTP POST requests.
The PostConstruct annotation is used on a method that needs to be executed
after dependency injection is done to perform any initialization.
The PreDestroy annotation is used on methods as a callback notification to
signal that the instance is in the process of being removed by the
container.
Global binding annotation that can be applied to a
container request filter to indicate that such filter should be applied globally
on all resources in the application before the actual resource matching occurs.A collection of built-in priority constants for the JAX-RS components that are supposed to be
ordered based on their
javax.annotation.Priority class-level annotation value when used
or applied by JAX-RS runtime.The Priority annotation can be applied to classes to indicate
in what order the classes should be used.
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.A base JAX-RS runtime processing exception.
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 managed bean declared using
javax.annotation.ManagedBean, 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 every managed bean declared using
javax.annotation.ManagedBean, 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).
Provides a generic operation for producing an instance of a type.
An
ProducerFactory can create an Producer for a given bean.
Identifies a producer method or field.
Defines the media type(s) that the methods of a resource class or
MessageBodyWriter can produce.Provides instances of
T.Marks an implementation of an extension interface that should be discoverable
by JAX-RS runtime during a provider scanning phase.
An injectable interface providing runtime lookup of provider instances.
Indicates that the annotated method responds to HTTP PUT requests.
Identifies qualifier annotations.
Binds the value(s) of a HTTP query parameter to a resource method parameter,
resource class field, or resource class bean property.
Interface for message body reader interceptors that wrap around calls
to
MessageBodyReader.readFrom(java.lang.Class<T>, java.lang.reflect.Type, java.lang.annotation.Annotation[], javax.ws.rs.core.MediaType, javax.ws.rs.core.MultivaluedMap<java.lang.String, java.lang.String>, java.io.InputStream).Context class used by
ReaderInterceptor
to intercept calls to (@link javax.ws.rs.ext.MessageBodyReader#readFrom}.
Distinguishes conditional observer methods from observer methods which are
always notified.
A runtime application exception indicating a request redirection
(HTTP
3xx status codes).Qualifies the type of Metric Registry to inject.
An injectable helper for request processing, all methods throw an
IllegalStateException if called outside the scope of a request
(e.g.
Specifies that a bean is request scoped.
The Resource annotation marks a resource that is needed
by the application.
The two possible authentication types for a resource.
The resource context provides access to instances of resource classes.
An injectable class to access the resource class and resource method
matched by the current request.
This class is used to allow multiple resources declarations.
Defines the contract between a returned instance and the runtime when
an application needs to provide meta-data to the runtime.
A class used to build Response instances that contain metadata instead
of or in addition to an entity.
Commonly used status codes defined by HTTP, see
{@link <a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10">HTTP/1.1 documentation}
for the complete list.
An enumeration representing the class of status code.
Base interface for statuses used in responses.
JAX-RS client-side runtime processing exception thrown to indicate that
response processing has failed (e.g.
The Retry annotation to define the number of the retries and the fallback method on reaching the
retry counts.
Specifies the list of roles permitted to access method(s) in an application.
Defines the identity of the application during execution in a J2EE
container.
Implementations of JAX-RS provide a concrete subclass of RuntimeDelegate and
various JAX-RS API methods defer to methods of RuntimeDelegate for their
functionality.
Defines the contract for a delegate that is responsible for
converting between the String form of a HTTP header and
the corresponding JAX-RS type
T.Enumeration of JAX-RS runtime types.
An object which samples values.
Identifies scope annotations.
An injectable interface that provides access to security related
information.
A base runtime application exception indicating a server error
(HTTP
5xx status codes).A runtime exception indicating that the requested resource
cannot be served.Identifies the kind of EJB session bean.
Specifies that a bean is session scoped.
Identifies a type that the injector only instantiates once.
A statistical snapshot of a
Snapshot.
Indicates that a bean directly specializes another bean.
Specifies that an annotation type is a stereotype.
A type that may be used as a resource method return value or as the entity
in a
Response when the application wishes to stream the output.Inject a suspended
AsyncResponse into a parameter of an invoked
JAX-RS resource or sub-resource method.Uniform interface for synchronous invocation of HTTP methods.
An annotation for marking a method, constructor, or class as timed.
The annotation to define a method execution timeout.
The exception should be thrown when timeout is reached.
Asynchronous response suspend time-out handler.
A timer metric which aggregates timing durations and provides duration statistics, plus
throughput statistics via
Meter.A timing context.
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.
Restricts the bean types of a bean.
Supports inline instantiation of objects that represent parameterized types with actual type parameters.
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.
URI template-aware utility class for building URIs from their components.
A runtime exception thrown by
UriBuilder.build(Object...) methods when
a URI cannot be constructed based on the current state of the
builder.An injectable interface that provides access to application and request
URI information.
Abstraction for a resource representation variant.
A builder for a list of representation variants.
Veto the processing of the class.
Runtime exception for applications.
A resource target identified by the resource URI.
WithAnnotations may be applied to any portable extension observer method with an event parameter type of
ProcessAnnotatedType to filter the events delivered.Interface for message body writer interceptors that wrap around calls
to
MessageBodyWriter.writeTo(T, java.lang.Class<?>, java.lang.reflect.Type, java.lang.annotation.Annotation[], javax.ws.rs.core.MediaType, javax.ws.rs.core.MultivaluedMap<java.lang.String, java.lang.Object>, java.io.OutputStream).