All Classes and Interfaces

Class
Description
Abstract supplier to provide CDI components obtained from CDI bean manager.
Abstract chainable linear acceptor.
An abstract provider for T[], Collection<T>, and its subtypes as long as they have the public default constructor or are interfaces implemented by one the following classes: ArrayList LinkedList HashSet TreeSet Stack T must be a JAXB type annotated with XmlRootElement.
This is to allow customized JAXB collections checking.
Convenience class to allow implementing only a subset of container liefecycle listener callback method(s).
Abstract entity provider model.
Abstract Configurator which initializes and register ExecutorServiceProvider and ScheduledExecutorServiceProvider.
 
Abstract base class for form entity types marshalling & un-marshalling support.
An abstract provider for JAXBElement.
A base class for implementing JAXB-based readers and writers.
Abstract entity provider (reader and writer) base class.
This class provides partial default implementation of ResourceFinder.
Abstract implementation of resource model visitor containing empty implementations of interface methods.
An abstract provider for JAXB types that are annotated with XmlRootElement or XmlType.
An abstract implementation of RuntimeDelegate that provides support common to the client and server.
Default implementation of reactive invoker.
Simple ServiceFinder configuration.
Abstract thread pool executor provider.
An acceptable language tag.
An acceptable media type.
An acceptable token.
Annotated method representation.
Annotated method representation.
 
A visitor to visit a Java annotation.
Configuration options specific to the Client API that utilizes Apache5ConnectorProvider.
Strategy that defines the way the Apache client releases resources.
Strategy that aborts Apache HttpRequests for the case of Chunked Stream, closes the stream, and response next.
Connector provider for Jersey connectors that utilize Apache HTTP Client to send and receive HTTP request and responses.
A callback interface used to configure HttpClientBuilder.
Configuration options specific to the Client API that utilizes ApacheConnectorProvider.
/** Strategy that defines the way the Apache client releases resources.
Strategy that aborts Apache HttpRequests for the case of Chunked Stream, closes the stream, and response next.
Strategy that closes the response and content stream next.
Connector provider for Jersey connectors that utilize Apache HTTP Client to send and receive HTTP request and responses.
A callback interface used to configure HttpClientBuilder.
Java class for anonymous complex type.
This class is designed to combine the Application instance with any other external metadata that might be required to describe the application.
A simple holder class that stores a type and binary content to be used to return extra metadata with
An event informing about application lifecycle changes.
The type of the event that identifies on which lifecycle change the event is triggered.
Jersey specific provider that listens to application events.
Jersey server-side application handler.
Monitoring configuration of an application.
Application MX Bean.
Asynchronous connector response processing callback contract.
Injectable asynchronous processing context that can be used to control various aspects of asynchronous processing of a single request.
Asynchronous processing context state.
Utilized by the Servlet container response writer to deal with the container async features.
Factory to create AsyncContextDelegate to deal with asynchronous features added in Servlet version 3.0.
Servlet 3.x container response writer async extension and related extension factory implementation.
A non standard class, field, method or Code attribute, as defined in the Java Virtual Machine Specification (JVMS).
Configurator which initializes and register AutoDiscoverable instances into InjectionManager and BootstrapBag.
Injection qualifier that can be used to inject a ScheduledExecutorService instance used by Jersey to execute background timed/scheduled tasks.
BackgroundScheduler annotation literal.
Base64 encoding util class.
Base JSON marshaller implementation class.
Base JSON marshaller implementation class.
Helper class to register a Bean into CDI BeanManager.
Marker of a public Jersey API that is still in "beta" non-final version.
Specifies the binding between a URI template parameter and a bean property.
A mutable model representing a body part nested inside a MIME MultiPart entity.
Proxy class representing the entity of a BodyPart when a MultiPart entity is received and parsed.
A holder that is used only during Jersey bootstrap to keep the instances of the given types and then use them during the bootstrap.
Configurator which contains two methods, BootstrapConfigurator.init(InjectionManager, BootstrapBag) contains InjectionManager into which only registering services make sense because injection manager has not been completed yet and BootstrapConfigurator.postInit(InjectionManager, BootstrapBag) in which InjectionManager has been already completed and is able to create and provide services.
Utility for creating boundary parameters.
Used for broadcasting response chunks to multiple ChunkedOutput instances.
Listener interface that can be implemented to listen to events fired by Broadcaster object.
Default Jersey byte array entity provider (reader and writer).
A dynamically extensible vector of bytes.
Processes a provided class and selects the valid constructor with the largest number of parameters.
Caching connector provider.
Jersey CDI integration implementation.
Auxiliary annotation for mocked beans used to cover Jersey/HK2 injected injection points.
Implementation of the request context.
CDI Request scope implementation using Weld-specific BoundRequestContext which allows pass on storage for request-scoped objects.
Implementation of InjectionManager that starts CDI SE container, scans all users bean according to beans.xml file and register Jersey's internal beans using SeBeanRegisterExtension extension.
SPI implementation of InjectionManagerFactory which provides a new instance of CDI InjectionManager.
Implementation of ComponentProvider for Jersey Server
Common CDI utility methods.
Linear acceptor that can be composed into a chain.
Response entity type used for receiving messages in "typed" chunks.
Used for sending messages in "typed" chunks.
Used for writing ChunkedOutput.
Chunk data parser.
A parser to make a ClassVisitor visit a ClassFile structure, as defined in the Java Virtual Machine Specification (JVMS).
Exception thrown when the constant pool of a class produced by a ClassWriter is too large.
A visitor to visit a Java class.
A ClassVisitor that generates a corresponding ClassFile structure, as defined in the Java Virtual Machine Specification (JVMS).
Injection qualifier that can be used to inject an ExecutorService instance used by Jersey client runtime to execute asynchronous client requests.
ClientAsyncExecutor annotation literal.
Injection qualifier that can be used to inject an ScheduledExecutorService instance used by Jersey client runtime to schedule background tasks.
ClientBackgroundScheduler annotation literal.
Meta-annotation that provides a facility for creating bindings between an @Uri-injectable WebTarget instances and clients (and their configurations) that are used to create the injected web target instances.
A holder that is used only during Jersey bootstrap to keep the instances of the given types and then use them during the bootstrap.
Implementations of this interface will be notified when new ClientBuilder instances are being constructed.
Jersey externalized implementation of client-side JAX-RS configurable contract.
Executor for client async processing and background task scheduling.
Jersey client lifecycle listener contract.
Jersey client implementation configuration properties.
Default client Proxy information internal object.
Jersey client request context.
Jersey client response context.
This is a representation of a @{link ProcessingException} containing a @{link ClientResponse} instance.
A closeable service to add instances of Closeable that are required to be closed.
This class collects errors, and can then also produce a MultiException from those errors if necessary.
A committing output stream with optional serialized entity buffering functionality which allows measuring of the entity size.
Common immutable Configuration implementation for server and client.
Common (server/client) Jersey configuration properties.
A MessageBodyReader may implement this interface to signal that reading from the underlying input stream can be fully completed.
An internal Jersey container for custom component classes and instances.
A resource model validator that checks the given resource model.
Component provider interface to allow custom management of 3rd party components life-cycle and dependency injection.
Component provider interface to allow custom management of 3rd party components life-cycle and dependency injection.
Jersey specific MOXyJsonProvider that can be configured via ContextResolver<JsonMoxyConfiguration> instance.
ConfigurationModel<CONFIG extends org.eclipse.microprofile.config.Config>
Generic class which implements default properties provider's logic and wraps not used methods from ExtConfig
 
Client transport connector extension contract.
Connector extension interface to extend existing connector's functionality.
Jersey client connector provider contract.
A constant whose value is computed at runtime, with a bootstrap method.
Model component that is able to consume media types.
Jersey container service contract.
Exception thrown by the container components in to notify Jersey runtime about any errors.
Factory for creating specific HTTP-based containers.
Classes implementing this contract receive container life-cycle notification events.
Function that can be put to an acceptor chain to properly initialize MessageBodyWorkers instance on a current request and response.
Service-provider interface for creating container instances.
Jersey container request context.
Jersey container response context.
A suspendable, request-scoped I/O container response writer.
Time-out handler can be registered when the container response writer gets suspended.
Utility methods used by container implementations.
A content disposition header.
Builder to build content disposition.
Standard contract for plugging in content encoding support.
Injection resolver for @Context injection annotation.
Injection resolver for @Context injection annotation.
Context injection resolver binder.
Context injection resolver binder.
A factory implementation for managing ContextResolver instances.
Configurator which initializes and register ContextResolvers instance into InjectionManager and BootstrapBag.
An injectable interface providing look-up for ContextResolver<T> provider instances.
Used to annotate SPI provider contracts recognized by Jersey (in addition to the JAX-RS providers).
Jersey contract provider model.
Contract provider model builder.
Request Cookie header delegate provider.
Cookies parser.
Simple client-side filter that adds X-Requested-By headers to all state-changing request (i.e.
Simple server-side request filter that implements CSRF protection as per the Guidelines for Implementation of REST by NSA (section IV.F) and section 4.3 of this paper.
Feature to provide the single-line registration of custom providers.
Provider for marshalling/un-marshalling of application/octet-stream entity type to/from a DataSource instance.
Modified from javax.mail.util.ByteArrayDataSource A DataSource backed by a byte array.
A feature to enable the declarative linking functionality.
Entity Data provider based on Jackson JSON provider.
Default implementation for JerseyObservationConvention.
Default implementation for JerseyTagsProvider.
This enum represents file extension and MIME types of commonly used file.
Default SSLContext provider.
Deflate encoding support.
Implementation of InjectionManager that is able to delay service's registration and injection to DelayedHk2InjectionManager.completeRegistration() phase.
A listener contract that allows any registered implementation class to receive application destroy events.
Java class for anonymous complex type.
Thread-scoped injection provider of document builder factories.
Provider for marshalling/un-marshalling XML document instances.
Registers JAX-RS DynamicFeature which are listed as SPIs for registration.
Feature that configures support for content encodings on the client side.
Client filter adding support for content encoding.
Container filter that supports encoding-based content negotiation.
Entity input stream customized for entity message processing: contains EntityInputStream.isEmpty() method. EntityInputStream.close() method throws Jersey-specific runtime exception in case of an IO error.
Reader supporting List<EntityPart> Make sure GenericEntity class is used when reading the EntityParts.
Writer supporting List<EntityPart> Make sure GenericEntity class is used when sending the EntityParts.
Errors utility used to file processing messages (e.g.
Generic error message.
Error message exception.
Inbound Server-Sent Events channel.
EventSource listener that can be registered to listen for newly received InboundEvent notifications.
Outbound Server-Sent Events channel.
Private event processor task responsible for connecting to the SSE stream and processing incoming SSE events as well as handling any connection issues.
Used to signal that the EventProcessor reached terminal stage.
Event processor state, which is shared with the owner (to be able to control bootstrap and shutdown).
Client for reading and processing incoming Server-Sent Events.
Jersey EventSource builder class.
Exception mappers implementation that aggregates exception mappers and server as the main entry point for exception mapper instance lookup.
Configurator which initializes and register ExceptionMappers instance into InjectionManager and BootstrapBag.
MXBean interface of the exception mapper statistics.
Provides lookup of ExceptionMapper instances that can be used to map exceptions to responses.
Monitoring statistics of exception mapper executions.
Monitoring statistics of execution of one target.
A utility class with a methods for handling executor injection registration and proper disposal.
An extension contract for providing pluggable executor service providers to be used by Jersey client or server runtime whenever a specific executor service is needed to execute a Jersey runtime processing task.
 
Utility class to check whether it's possible to send the Expect header within request.
Extended common runtime configuration.
This annotation can mark resource classes or resource methods that should be considered as extended resources.
Jersey extension of ResourceContext.
Extensions to UriInfo.
Model of configuration for external properties.
Provider interface for external (SPI) providers to provide their configuration properties implementations Priority of providers can be adjusted by Priority annotation or just alphabetically (if no Provider annotation is found)
 
Wrapper for externally provided request context data.
This is to allow integration with other DI providers that define their own request scope.
Registers JAX-RS Feature which are listed as SPIs for registration.
Wrapper of FeatureContext that can supply instance of injection manager.
This supplier is used to set the features on the instances of the supported classes:
A visitor to visit a Java field.
An extension of FormDataBodyPart for associating File File as a body part entity.
Provider for marshalling/un-marshalling of application/octet-stream entity type to/from a File instance.
Entity Data Filtering provider based on Jackson JSON provider.
Entity Data Filtering provider based on MOXy JSON provider.
Provides an access to context path from the filter configuration.
Provide all configured context paths (url mappings) of the application deployed using filter.
Subclass of BodyPart with specialized support for media type multipart/form-data.
A form-data content disposition header.
Builder to build form data content disposition.
Subclass of MultiPart with specialized support for media type multipart/form-data.
Binds the named body part(s) of a "multipart/form-data" request entity body to a resource method parameter.
A parameter-based exception for errors with FormDataParam.
Feature providing support for FormDataParam parameter injection.
Provider for marshalling/un-marshalling of application/x-www-form-urlencoded entity type to/from multi-valued map instance.
Provider for marshalling/un-marshalling of application/x-www-form-urlencoded entity type to/from JAX-RS Form instance.
An implementation of GenericArrayType for those times we need to create this on the fly.
Supplier to provide CDI managed components where there is no clear mapping between the CDI and scopes.
Generic injection manager store that allows multiple injection managers to run in parallel.
Java class for anonymous complex type.
Connector provider for Jersey connectors that utilize Grizzly Asynchronous HTTP Client to send and receive HTTP request and responses.
A customization SPI for the async client instance underlying Grizzly connectors.
A customization SPI for the async client request instances.
Jersey Container implementation based on Grizzly HttpHandler.
Container provider for containers based on Grizzly HttpHandler.
Factory for creating Grizzly Http Server.
Server provider for servers based on Grizzly HttpServer.
Factory for creating and starting Grizzly 2 HttpServer instances for deploying a Servlet.
GZIP encoding support.
A reference to a field or a method.
Abstraction for a resource handler class constructor.
A provider that supports the conversion of an HTTP header, of type T, to and from a String.
Server side request filter used for propagation of request headers to server client request.
Utility class supporting the processing of message headers.
Processing exception indicating that an attempt to read a value of a header failed.
Context that contains header problems causing this exception (e.g.
AbstractBinder that registers all components needed for a proper bootstrap of Jersey based on HK2 framework.
Helper SPI to help specify Jersey HK2 custom bound types that should be HK2-injectable into CDI components.
Factory which is able to create InjectionManager instance using service loading and automatically initialize injection manager using parent or immediately registers binder.
Factory that provides injection of the referenced instance.
 
Implementation of the request scope instance.
An OAuth signature method that implements HMAC-SHA1.
Features that provides Http Basic and Digest client authentication (based on RFC 2617).
Extension of HttpAuthenticationFeature.Builder that builds the http authentication feature configured for basic authentication.
Builder that creates instances of HttpAuthenticationFeature.
Extension of HttpAuthenticationFeature.Builder that builds the http authentication feature configured in universal mode that supports basic and digest authentication.
Helper class for HTTP specified date formats.
An abstract pull-based reader of HTTP headers.
TODO javadoc.
Additional HTTP headers that are not listed in Jakarta REST HttpHeaders.
A pre-matching filter to support HTTP method replacing of a POST request to a request utilizing another HTTP method for the case where proxies or HTTP servers would otherwise block that HTTP method.
Enumeration representing possible sources of information about the method overriding the filter should look for.
Java class for HTTPMethods.
Default client transport connector using HttpURLConnection.
Default Jersey client connector provider that provides connector instances which delegate HTTP requests to HttpURLConnection for processing.
A factory for HttpURLConnection instances.
Implementation of InjectionManager that is able to register and inject services.
Immutable runtime configuration.
Inbound event.
This provider is executed if no headers found for propagation from inbound request via normal propagation mechanism.
Base inbound message context implementation.
Java class for anonymous complex type.
Interface that is used to indicate that the instance provides an Inflector.
Inflector provider resource model component.
A generic interface for transforming data into a result.
Initializable Jersey client-side component.
Class analyzer that ignores given injection points.
Extension of InjectionManagerProvider which contains helper static methods that extract InjectionManager from client specific JAX-RS components.
Utility class with static methods that extract injection manager from various JAX-RS components.
This class wraps the jersey class InjectionResolver to make HK2 version of this provided functionality.
Utility class for processing of an injection.
Specifies a link injection target in a returned representation bean.
 
Styles of URI supported
 
Specifies on a field that should be ignored by Link recursive introspection.
Used to request the addition of a set of links, can be used for both link headers on a Class or injection into a List or Link[] property.
 
This class is used as a bridge between HK2 Factory and JDK Supplier.
Internal common (server/client) Jersey configuration properties.
Jersey internal server-side configuration properties.
Thrown to indicate that the OAuth secret supplied is invalid or otherwise unsupported.
A common interface for invocable resource components.
Implementations of this interface will be notified when a new Invocation.Builder is created.
An Invocation.Builder subset of setter methods.
AutoDiscoverable registering JacksonFeature if the feature is not already registered.
Feature used to register Jackson JSON providers.
Feature adding support for Entity Data Filtering into Jackson media module.
 
Provides configuration properties for a JavaNetHttpConnector.
Provides a Jersey client Connector, which internally uses Java's HttpClient.
A provider class for a Jersey client Connector using Java's HttpClient.
JAXB ForcedAutoDiscoverable that registers all necessary JAXB features into the injection manager directly.
Binder for JAX-B message body workers.
Binder for JAXB parameter converter.
String reader provider producing param converter provider that support conversion of a string value into a JAXB instance.
Root element JAXB param converter.
Jersey implementation of JAX-RS Providers contract.
Configurator which initializes and registers Providers instance into InjectionManager and BootstrapBag.
 
Configuration options specific to JdkConnector.
 
Jersey Container implementation based on Java SE HttpServer.
Container provider for containers based on lightweight Java SE HTTP Server's HttpHandler.
Factory for creating JDK HttpServer instances to run Jersey applications.
Server provider for servers based on JDK HttpServer.
Jersey-specific abstract class which implements Bean interface.
Netty ChunkedInput implementation which also serves as an output stream to Jersey ContainerResponseContext.
Implementation of the ClassAnalyzer that supports selection of the constructor with largest number of parameters as defined in and required by JAX-RS specification.
Binder for the JAX-RS compliant class analyzer implementation.
Jersey implementation of JAX-RS Client contract.
Jersey provider of JAX-RS client builder.
Implementation of Reactive Invoker for CompletionStage.
Class that creates a new instance using the provided constructor, selects and injects the values.
A ReceiverContext for Jersey.
Jersey implementation of EntityPart.Builder.
Jersey implementation of HK2 Error Service to provide improved reporting of HK2 issues, that may be otherwise hidden (ignored).
Binder for the Jersey implementation of HK2 ErrorService contract.
 
Wrapper for InjectionTarget that implements the functionality of injecting using JAX-RS annotations into provided instances.
Jersey implementation of JAX-RS client-side request invocation contract.
Jersey-specific client invocation builder.
Jersey implementation of JAX-RS Link contract.
Jersey implementation of JAX-RS Link.Builder contract.
Provides names and KeyValues for Jersey request observations.
An ObservationDocumentation for Jersey.
Built-in Jersey-specific priority constants to be used along with Priorities where finer-grained categorization is required.
Uncaught exception handler that can be used by various Jersey request processing thread pools uncaught exceptions.
Class working with JAX-RS/Jersey types injected using Context annotation and all other types which can be injected using using other *Param annotations.
JerseyQueryParamStyle is used to specify the desired format of query param when multiple values are sent for the same parameter.
Jersey implementation of JAX-RS resource context.
 
Jersey implementation of SeBootstrap.Configuration implementing arbitrary methods for acquiring the configuration settings.
 
ServletContainerInitializer implementation used for Servlet 3.x deployment.
SseEventSource implementation.
SseEventSource.Builder implementation.
Public SseEventSource.Builder implementation.
Factory methods for Tags associated with a request-response exchange that is handled by Jersey server.
Provides Tags for Jersey request metrics.
A Jersey implementation of UriBuilder.
Use this to annotate types included in Jersey libraries that are to be CDI managed as defined by the CdiComponentProvider
Jersey implementation of JAX-RS client target contract.
An immutable configuration of JSON notation and options.
Builder class for constructing JettisonConfig options
Builder class for constructing JettisonConfig options for the JettisonConfig.Notation.MAPPED_JETTISON convention.
Enumeration of supported JSON notations.
An interface declaring a JSON configuration is available.
Feature used to register Jettison JSON providers.
An adaption of JAXBContext that supports marshalling and unmarshalling of JAXB beans using the JSON format.
JSON JAXB marshaller.
JSON JAXB unmarshaller.
A JSON marshaller responsible for serializing Java content trees, defined by JAXB, to JSON data.
A JSON unmarshaller responsible for deserializing JSON data to a Java content tree, defined by JAXB.
Configuration options specific to the Client API that utilizes JettyConnectorProvider.
A Connector that utilizes the Jetty HTTP Client to send and receive HTTP request and responses.
A ConnectorProvider for Jersey connector instances that utilize the Jetty HTTP Client to send and receive HTTP request and responses.
A contract that allows for an optional registration of user predefined Jetty HttpClient that is consequently used by JettyConnector
Jetty HttpClient supplier to be registered into Jersey configuration to be used by JettyConnector.
Jersey Container implementation based on Jetty Handler.
Factory for creating and starting Jetty server handlers.
Container provider for containers based on Jetty Server Handler.
Server provider for servers based on Jetty Server.
ForcedAutoDiscoverable registering JsonBindingFeature if the feature is not already registered.
Feature used to register JSON-B providers.
Entity provider (reader and writer) for JSONB.
Annotation can be used to define the JavaScript callback function name if the valid JSONP format is requested as an acceptable media type of this request.
AutoDiscoverable registering JsonProcessingFeature if this feature is not already registered.
Feature used to register JSON-P providers.
A WriterInterceptor implementation for JSONP format.
AutoDiscoverable registering KryoFeature if the feature is not already registered.
Feature used to register Kryo providers.
The KryoMessageBodyProvider expects a ContextResolver<Kryo> registered.
A position in the bytecode of a method.
A language tag.
Java class for anonymous complex type.
Provider for Link Headers.
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
Defines string formatting method for each constant in the resource file
This feature enables logging request and/or response on client-side and/or server-side depending on the context's RuntimeType.
Builder class for logging feature configuration.
Verbosity determines how detailed message will be logged.
Auto-discoverable class that registers LoggingFeature based on configuration properties.
Indicates that the resource method to which the annotation has been applied should be executed on a separate thread managed by an internal Jersey executor service.
Injection qualifier that can be used to inject an ExecutorService instance used by Jersey to execute managed asynchronous requests.
ManagedAsyncExecutor annotation literal.
Invokes PreDestroy methods on all registered objects, when the injection manager is shut down.
Interceptor that wraps specific exceptions types thrown by wrapped interceptors and by message body readers and writers into a mappable exception.
Binder registering the Exception Wrapper Interceptor (used on the client side).
Properties delegate backed by a Map.
A matching entity tag.
An interface which allows developers implement their own media type predictor.
Header delegate provider for MediaType.
Common media types and functionality.
A factory for managing MessageBodyReader, MessageBodyWriter instances.
Configurator which initializes and register MessageBodyWorkers instance into InjectionManager and BootstrapBag.
Jersey exception signaling that error occurred during reading or writing message body (entity).
Jersey processing exception signaling that no appropriate MessageBodyReader or MessageBodyWriter was found.
An injectable interface providing lookup of MessageBodyReader and MessageBodyWriter instances.
Jersey configuration properties for message & entity processing.
Utility class with message related methods.
Binding definitions for the default set of message related providers (readers, writers, header delegates).
Header delegate provider injection binder.
Message body providers injection binder.
Java class for anonymous complex type.
Resource method handler model.
Iterable list of methods on a single class with convenience getters for additional method information.
Method list filter.
Exception thrown when the Code attribute of a method produced by a ClassWriter is too large.
A visitor to visit a Java method.
The Micrometer ApplicationEventListener which registers RequestEventListener for instrumenting Jersey server requests.
RequestEventListener recording timings for Jersey server requests.
Utility to transform error messages to ResourceModelIssues.
Common model helper methods.
Contract for a model processors that processes resource models during application initialization and resource returned by sub resource locators.
Helper class with methods supporting processing resource model by model processors.
Method bean containing basic information about enhancing resource method.
Resource model validation exception.
A visitor to visit a Java module.
Monitoring statistics return statistic information about application run like number of requests received, duration of request processing, number of successfully processed requests, statistical information about execution of methods and resources, information about matching.
A Jersey specific provider that listens to monitoring statistics.
Feature adding support for Entity Data Filtering into MOXy media module.
AutoDiscoverable registering MoxyJsonFeature if this feature is not already registered.
Configuration class for MOXy JSON provider.
Feature used to register MOXy JSON providers.
Feature used to register MOXy XML providers.
Common tracing events.
This exception can contain multiple other exceptions.
A mutable model representing a MIME MultiPart entity.
Feature used to register Multipart providers.
Automatic registration of MultiPartFeature.
Convenience MediaType (and associated String) manifest constants.
Injectable JavaBean containing the configuration parameters for jersey-multipart as used in this particular application.
MessageBodyReader implementation for MultiPart entities.
MessageBodyReader implementation for MultiPart entities.
Provider MessageBodyWriter implementation for MultiPart entities.
Simple map based implementation of the ResourceLinkContributionContext.
This implementation of the resource mapping context assumed resources are of a simple type with a statically defined structure.
Model component that can be name bound.
This is an implementation of the Named annotation.
Configuration options specific to the Client API that utilizes NettyConnectorProvider.
Netty provider for Jersey connectors.
The Entity Writer is used to write entity in Netty.
 
 
Type of the entity writer.
Input stream which servers as Request entity input.
Response Set-Cookie header delegate provider.
A "dev/null" output stream - an output stream implementation that discards all the data written to it.
A data structure class that represents OAuth protocol parameters.
Interface to be implemented as a wrapper around an HTTP request, so that digital signature can be generated and/or verified.
Contains the secrets used to generate and/or verify signatures.
Injectable class used for processing an OAuth signature (signing or verifying).
Thrown to indicate that an OAuth exception occurred.
Feature enabling OAuth signature support.
An interface representing the OAuth signature method.
This object contains factory methods for each Java content interface and Java element interface generated in the com.sun.research.ws.wadl package.
The Micrometer ApplicationEventListener which registers RequestEventListener for instrumenting Jersey server requests with observations.
RequestEventListener recording observations for Jersey server requests.
The JVM opcodes, access flags and array type codes.
Retrieves stored span from the ClientRequestContext and adds response details to the tracing info.
A feature that enables OpenTracing support on server and client.
OpenTracing Jersey event logging verbosity.
Utility methods for Jersey OpenTracing integration.
Java class for anonymous complex type.
Model processor enhancing resource model and sub resources by default OPTIONS methods defined by JAX-RS specification.
Utility class to deal with OSGi runtime specific behavior.
Representation of a single outbound SSE event.
Used for creating OutboundEvent instances.
An outbound JAX-RS response message.
Outbound JAX-RS Response.ResponseBuilder implementation.
Base outbound message context implementation.
The callback interface which is used to get the terminal output stream into which the entity should be written and to inform the implementation about the entity size.
Java class for anonymous complex type.
 
Method parameter model.
Bean Parameter class represents a parameter annotated with BeanParam which in fact represents additional set of parameters.
 
A factory service to found in a runtime to be used to instantiate the given Parameter class.
 
 
Parameter injection sources type.
Used in the resource model to capture information on method parameters.
A general parameterized header.
Simple implementation of ParameterizedType.
Provider that converts the an object of a custom Java type values to String / Collection<String>> type
Provider of parameter updater.
Utility methods for retrieving values or value providers for the parameterized resource model components.
An abstract extension of WebApplicationException for the class of parameter-based exceptions.
A parameter exception for errors with CookieParam.
A parameter exception for errors with FormParam.
A parameter exception for errors with HeaderParam.
A URI-parameter-based exception for errors with MatrixParam.
A URI-parameter-based exception for errors with PathParam.
A URI-parameter-based exception for errors with QueryParam.
An abstract parameter exception for the class of URI-parameter-based exceptions.
A meta-annotation that identifies an annotation as a parameter-based annotation.
Java class for ParamStyle.
Extends Supplier interface with Parameter.Source information.
 
A path pattern that is a regular expression generated from a URI path template.
The set of right hand path patterns that may be appended to a path pattern.
A URI template for a URI path.
A pattern for matching a string against a regular expression and returning capturing group values for any capturing groups present in the expression.
Persistence unit injection binder.
An OAuth signature method that implements Plaintext.
The interceptor of a client request invocation that is executed after the request invocation itself, i.e.
The context providing information when the Throwable (typically, the RuntimeException) is caught.
The interceptor of a client request invocation that is executed before the invocation itself, i.e.
 
Injectable encapsulating class containing processing providers like filters, interceptors, name bound providers, dynamic features.
 
Model component that is able to produce media types.
TODO: javadoc.
Resolver of a property value for the specified property name from the request-specific property bag, or the global runtime configuration.
This supplier is used to set the properties on the instances of the supported classes:
Use this on resource methods to contribute links to a representation.
Special interface to indicate that the target should be inherited from the annotated annotation.
 
Utility to work with ProvideLink annotations.
Container for repeatable annotation, see ProvideLink for details.
 
Quality factor for acceptable header types represented as a "parts per thousand" (i.e.
Quality parameter constants.
A quality source media type.
Comparator used to sort types by their priorities defined by theirs binding priority set during the configuration phase (Configuration) in ranked provider.
Defines which ordering should be used for sorting.
Jersey ranked provider model.
Represents reader interceptor chain executor for both client and server side.
 
A utility class for reading and writing using byte and character streams.
A visitor to visit a record component.
This Exception is used only if ClientProperties.FOLLOW_REDIRECTS is set to true.
This Exception is used only if ClientProperties.FOLLOW_REDIRECTS is set to true.
Backwards compatibility ContextResolver.
Provider for marshalling/un-marshalling of graphical image data represented as image/*, application/x-www-form-urlencoded entity types to rendered and from rendered or buffered image instance.
Java class for anonymous complex type.
Java class for anonymous complex type.
Exception thrown by security request authentication.
Class is able to communicate with RequestScope and provide request-scoped descriptors to HK2 DI provider to create or destroy instances.
Wrapper for externally provided request context data.
Request scope injection binder.
Defines values for the ClientProperties.REQUEST_ENTITY_PROCESSING property.
An event informing about details of a request processing.
Describes the origin of the exception.
The type of the event which describes in which request processing phase the event is triggered.
Non-registrable provider that listens to request events.
Auto discoverable feature to bind into jersey runtime.
Function that can be put to an acceptor chain to properly initialize the client-side request-scoped processing injection for the current request and response exchange.
Scopes a single request/response processing execution on a single thread.
Configurator which initializes and register RequestScope instance int InjectionManager and BootstrapBag.
CDI Class Bean represents CdiRequestScope.
Request scope binding annotation.
Supplier to provide CDI managed components that should be mapped into Jersey request scope.
Custom initialization provider that is guaranteed to be run from within an active request scope.
Java class for anonymous complex type.
Model of a single resource component.
Resource model component builder.
The resource configuration for configuring a web application.
An interface used for finding and opening (loading) new resources.
The ResourceLinkContributionContext provides access for link contributions from other sources to an entity.
This service tries to work out the UriTemplate required for a particular resource class.
 
Model of a method available on a resource.
Resource method model builder.
Resource method classification based on the recognized JAX-RS resource method types.
A resource method dispatcher responsible for consuming a JAX-RS request by invoking the configured resource method on a given resource instance and returning the method invocation result in a form of a JAX-RS response.
Provider interface for creating a resource method dispatcher instances.
A resource method dispatcher provider factory.
Provides the invocation handler instances designated to handle invocations of the supplied invocable resource methods.
Server-side request-response inflector for invoking methods of annotation-based resource classes.
Resource method invoker helper.
Configurator which initializes and register ResourceMethodDispatcher instance into BootstrapBag.
MXBean interface of resource method MXBeans.
Monitoring statistics an of an execution of the resource method.
Resource model of the deployed application which contains set of root resources.
Builder used to create resource model instances.
Marker interface for all abstract resource model components, so that they can be traversed using a visitor pattern.
Configurator which binds providers and resources into InjectionManager.
Resource model validity issue.
Following the visitor pattern, this interface allows implementing processors traversing all abstract model components present in a given model.
MXBean interface of resource MXBeans.
Java class for anonymous complex type.
Monitoring statistics of the resource.
Java class for anonymous complex type.
Java class for anonymous complex type.
Exception thrown by security response authentication.
Contract for a provider that maps response processing errors to Response.
MXBean interface of response MXBean.
Monitoring statistics of responses produced by application.
This is a list of Hypertext Transfer Protocol (HTTP) response status codes.
4xx client error status codes - the request contains bad syntax or cannot be fulfilled.
1xx informational status codes - request received, continuing process
3xx redirection status codes - further action must be taken in order to complete the request.
5xx server error status codes - the server failed to fulfill an apparently valid request.
2xx success status codes - the action was successfully received, understood, and accepted.
An internal implementation of ContainerResponseWriter for Servlet containers.
Filters out all interfaces annotated with RegisterRestClient and creates new Producer from each of these selected interfaces.
A DynamicFeature supporting the jakarta.annotation.security.RolesAllowed, jakarta.annotation.security.PermitAll and jakarta.annotation.security.DenyAll on resource methods and sub-resource methods.
Marker interface for all resource model components that contain path information usable for routing.
An OAuth signature method that implements RSA-SHA1.
RuntimeDelegate Decorator that changes behaviour due to provided runtime information.
Default implementation of JAX-RS RuntimeDelegate.
Server-side implementation of JAX-RS RuntimeDelegate.
Runtime resource is a group of resources with the same path regular expression.
Runtime Resource model contains structured information about runtime resources.
Runtime resource model validator validating ambiguity of resource methods.
Thread-scoped injection provider of SAX parser factories.
An extension contract for providing pluggable scheduled executor service providers to be used by Jersey client or server runtime whenever a specific scheduler is needed to schedule execution of a Jersey runtime processing task.
Default implementation of the Jersey scheduled executor service provider SPI.
Scoped Jersey application model component.
Secure SAX parser factory wrapper.
A holder that is used only during Jersey bootstrap to keep the instances of the given types and then use them during the bootstrap.
Server-side application configuration.
Enable auto-discoverable of certain server filters.
Jersey server-side configuration properties.
Server-side request processing runtime.
Server side tracing events.
Error thrown when something goes wrong while looking up service providers.
A simple service-provider lookup mechanism.
The default service iterator provider that looks up provider classes in META-INF/services files.
Supports iteration of provider instances or classes.
Simple ServiceFinder injection binder.
A Servlet or Filter for deploying root resource classes.
Factory class to get all "registered" implementations of ServletContainerProvider.
Jersey servlet container configuration properties.
Common severity.
Jersey Container implementation based on Simple framework Container.
Factory for creating and starting Simple server containers.
Container provider for containers based on Simple HTTP Server Container.
Server provider for servers based on Simple framework SimpleServer.
Simple server facade providing convenient methods to obtain info about the server (i.e.
Tracing at a very low level can be performed with a TraceAnalyzer.
 
 
Collection of XML source providers.
Provider for marshalling/un-marshalling DOMSource instances.
Provider for un-marshalling SAXSource instances.
Provider for marshaling Source instances.
Provider for un-marshalling StreamSource instances.
Jersey AutoDiscoverable responsible for registering SseFeature.
Binds implementations to interfaces for injection of SSE-related injectables.
Used for broadcasting SSE to multiple EventOutput instances.
 
ValueParamProvider for binding SseEventSink to its implementation.
A SseEventSubscription represents a one-to-one life-cycle of a Subscriber subscribing to a SseEventPublisher.
 
A JAX-RS feature that enables Server-Sent Events support.
 
 
Utility class, which helps to configure SSLContext instances.
The class that builds SSLContext for the client from keystore, truststore.
Data processing stage that can be used to create dynamic data processing chains.
Linear stage chain builder.
Data processing stage continuation.
A stage-related collection of utility methods.
Linked linear stage implementation.
Factory for producing custom JAX-RS response status type instances.
Factory for creating JSON-enabled StAX readers and writers.
Represents an InputStream based file submission as a part of the multipart/form-data.
Message body writer that supports streaming output marshalling.
Internal string builder utilities for building HTTP header values.
Security context that allows establishing a subject before a resource method or a sub-resource locator is called.
This class is able to find the Supplier of the particular type and use this Supplier to create a new instance.
Creates an implementation of Bean interface using Jersey's SupplierInstanceBinding.
Jersey model component that is suspendable and may hold suspend-related information.
A proxy invocation handler that delegates all methods to a thread local instance.
A proxy invocation handler that delegates all methods to a thread local instance from JNDI.
Client thread pool configuration, which might be used to customize client thread pool.
Default implementation of the Jersey executor service provider SPI.
Monitoring statistics of execution of any target (resource, resource method, application).
A token.
Delegating properties delegate backed by another PropertiesDelegate with implemented "cache" or direct reference to tracing support related classes (e.g.
Enumeration of possible values of property ServerProperties.TRACING.
Low level Tracing support API.
Type of event.
Level of tracing message.
Utilities for tracing support.
Thread-scoped injection provider of transformer factories.
A Java field or method type.
The path to a type argument, wildcard bound, array element type, or static inner type within an enclosing type.
A reference to a type appearing in a class, field or method declaration, or on an instruction.
Thrown to indicate that the OAuth signature method requested is not supported.
Injects a resource target pointing at a resource identified by the resolved URI into a method parameter, class field or a bean property.
Utility class for validating, encoding and decoding components of a URI.
The URI component type.
A URI-based content negotiation filter mapping a dot-declared suffix in URI to media type that is the value of the Accept header or a language that is the value of the Accept-Language header.
This class represents a part of the uri as parsed by the UriTemplateParser.
A URI template.
A URI template parser that parses JAX-RS specific URI templates.
 
Utility class.
Utility class.
Interceptor for method validation processing.
Context for resource method validation interception processing (see ValidationInterceptor).
Parameter value factory SPI.
Enumeration of priorities for providers (e.g.
Priorities are intended to be used as a means to determine the order in which objects are considered whether they are suitable for a particular action or not (e.g.
An implementation of VariantListBuilder.
Utility for selecting variant that best matches request from a list of variants.
Utility class for reading build.properties file.
A context to obtain WADL-based information.
WADL application context implementation.
AutoDiscoverable registering WadlFeature if this feature is not already registered.
This class implements the algorithm how the wadl is built for one or more Resource classes.
Feature enabling WADL processing.
A WadlGenerator creates artifacts related to wadl.
And internal storage object to store the grammar definitions and any type resolvers that are created along the way.
Call back interface that the created external grammar can use to allow other parts of the code to attach the correct grammar information.
Provides a configured WadlGenerator with all decorations (the default wadl generator decorated by other generators).
 
Loads a WadlGeneratorConfig and provides access to the WadlGenerator provided by the loaded WadlGeneratorConfig.
If no WadlGeneratorConfig is provided, the default WadlGenerator will be loaded.
This is the model for the definition of wadl generators via configuration properties.
The properties refer to the properties of the WadlGenerator implementation with the specified WadlGeneratorDescription.getGeneratorClass().
This WadlGenerator creates the basic wadl artifacts.
Created on: Jun 16, 2008
WADL model processor which enhance resource model by WADL related resources (like "/application.wadl").
OPTIONS resource method handler that serves resource WADL.
 
Utils for wadl processing.
An common Jersey web component that may be extended by a Servlet and/or Filter implementation, or encapsulated by a Servlet or Filter implementation.
The Web configuration for accessing initialization parameters of a Web component and the ServletContext.
The web configuration type.
A filter based web config.
Jersey service contract for self-contained servers.
Factory for creating specific HTTP servers.
Service-provider interface for creating server instances.
A servlet based web config.
An implementation of InjectionTarget that just wraps the provided InjectionTarget because of additional features in an injection phase.
Represents writer interceptor chain executor for both client and server side.
Base XML-based message body provider for collections of JAXB beans.
JAXB provider for marshalling/un-marshalling collections from/to entities of application/xml media type.
JAXB provider for marshalling/un-marshalling collections from/to entities of <type>/<sub-type>+xml media types.
JAXB provider for marshalling/un-marshalling collections from/to entities of text/xml media type.
Allows to specify XML header for XML output produced by a resource method it is attached to.
Thread-scoped injection provider of transformer factories.
Base XML-based message body provider for JAXB element instances.
Provider for marshalling/un-marshalling JAXB elements from/to entities of application/xml media type.
Provider for marshalling/un-marshalling JAXB elements from/to entities of <type>/<sub-type>+xml media types.
Provider for marshalling/un-marshalling JAXB elements from/to entities of text/xml media type.
Base XML-based message body provider for JAXB root elements and types.
Provider for marshalling/un-marshalling JAXB root element and type instances from/to entities of application/xml media type.
Provider for marshalling/un-marshalling JAXB root element and type instances from/to entities of <type>/<sub-type>+xml media types.
Provider for marshalling/un-marshalling JAXB root element and type instances from/to entities of text/xml media type.
Base XML-based message body reader for JAXB beans.
Provider for un-marshalling entities of application/xml media type into JAXB beans using JAXB unmarshaller.
Provider for un-marshalling entities of <type>/<sub-type>+xml media types into JAXB beans using JAXB unmarshaller.
Provider for un-marshalling entities of text/xml media type into JAXB beans using JAXB unmarshaller.