What does Provider in JAX-RS mean?

Providers are a simply a way of extending and customizing the JAX-RS runtime. You can think of them as plugins that (potentially) alter the behavior of the runtime, in order to accomplish a set of (program defined) goals.

Providers are not the same as resources classes, they exist, conceptually, at a level in-between resources classes and the JAX-RS implementation. If it helps, you can think of them in the same light as device drivers (existing between user and kernel space). This is a broad generalization.

There are three classes of providers defined by the current JAX-RS specification. The commonality between them is that all providers must be identified by the @Provider annotation and follow certain rules for constructor declaration. Apart from that, different provider types may have additional annotations, and will implement different interfaces.

Entity Providers

These providers control the mapping of data representations (like XML, JSON, CSV) to their Java object equivalents.

Context Providers

These providers control the context that resources can access via @Context annotations.

Exception Providers

These providers control the mapping of Java exceptions to a JAX-RS Response instance.

Your runtime will come with a number of predefined providers that will be responsible for implementing a base level of functionality (e.g for mapping to and from XML, translating the most common exceptions etc etc). You can also create your own providers as needed.

The JAX-RS specification is a good reference for reading up on these different provider types and what they do (see Chapter 4).

The @Provider annotation is used for anything that is of interest to the JAX-RS runtime, such as MessageBodyReader and MessageBodyWriter. For HTTP requests, the MessageBodyReader is used to map an HTTP request entity body to method parameters. On the response side, a return value is mapped to an HTTP response entity body by using a MessageBodyWriter. If the application needs to supply additional metadata, such as HTTP headers or a different status code, a method can return a Response that wraps the entity and that can be built using Response.ResponseBuilder.

@Provider annotation gives you the ability to examine incoming and outgoing messages at the raw XML level, and in this way Provider is the counterpart to Dispatch on the client.

To do certain activities such as Filtering-Request/Response, Exception Handling, the JAX-RS has its own default implementation logic.However, it allows users to provider thier own implementation as well.

To provide our own implementation we need to implement the appropriate classes by specifying them with @Provider annotation.

JAX-RS will do a round of scanning to find the existance of any such user-defined implementation by seaching for @Provider annotation.

For example:

...@Providerpublic class AppExceptionMapper implements ExceptionMapper<Throwable> {......@Provider@PreMatchingpublic class RESTRequestResponseFilter implements ContainerRequestFilter, ContainerResponseFilter {...