org.glassfish.jersey.server

## Class ApplicationHandler

- java.lang.Object
- - org.glassfish.jersey.server.ApplicationHandler

All Implemented Interfaces:
  ContainerLifecycleListener

    public final class ApplicationHandler
    extends Object
    implements ContainerLifecycleListener

Jersey server-side application handler.

Container implementations use the `ApplicationHandler` API to process requests by invoking the `handle(request)` method on a configured application handler instance.

`ApplicationHandler` provides two implementations of `config` that can be injected into the application classes. The first is `resource config` which implements `Configuration` itself and is configured by the user. The resource config is not modified by this application handler so the future reloads of the application is not disrupted by providers found on a classpath. This config can be injected only as `ResourceConfig` or `Application`. The second one can be injected into the `Configuration` parameters / fields and contains info about all the properties / provider classes / provider instances from the resource config and also about all the providers found during processing classes registered under `server properties`. After the application handler is initialized both configurations are marked as read-only.

Application handler instance also acts as an aggregate `ContainerLifecycleListener` instance for the associated application. It aggregates all the registered container lifecycle listeners under a single, umbrella listener, represented by this application handler instance, that delegates all container lifecycle listener method calls to all the registered listeners. Jersey `containers` are expected to invoke the container lifecycle methods directly on the active `ApplicationHandler` instance. The application handler will then make sure to delegate the lifecycle listener calls further to all the container lifecycle listeners registered within the application. Additionally, invoking the `ContainerLifecycleListener.onShutdown(Container)` method on this application handler instance will release all the resources associated with the underlying application instance as well as close the application-specific `injection manager`.

Author:
  Pavel Bucek, Jakub Podlesak, Marek Potociar, Libor Kramolis
See Also:
  `ResourceConfig`, `Configuration`, `ContainerProvider`

### Constructor Summary

Constructors
Constructor and Description
`ApplicationHandler()` Create a new Jersey application handler using a default configuration.
`ApplicationHandler(jakarta.ws.rs.core.Application application)` Create a new Jersey server-side application handler configured by an instance of a `JAX-RS Application sub-class`.
`ApplicationHandler(jakarta.ws.rs.core.Application application, org.glassfish.jersey.internal.inject.Binder customBinder)` Create a new Jersey server-side application handler configured by an instance of a `ResourceConfig` and a custom `Binder`.
`ApplicationHandler(jakarta.ws.rs.core.Application application, org.glassfish.jersey.internal.inject.Binder customBinder, Object parentManager)` Create a new Jersey server-side application handler configured by an instance of a `ResourceConfig`, custom `Binder` and a parent used by `InjectionManager`.
`ApplicationHandler(Class<? extends jakarta.ws.rs.core.Application> jaxrsApplicationClass)` Create a new Jersey server-side application handler configured by a `JAX-RS Application (sub-)class`.

### Method Summary

All Methods Instance Methods Concrete Methods
`Future<ContainerResponse>` `apply(ContainerRequest requestContext)` Invokes a request and returns the `response future`.
`Future<ContainerResponse>` `apply(ContainerRequest request, OutputStream outputStream)` Invokes a request and returns the `response future`.
`ResourceConfig` `getConfiguration()` Get the application configuration.
`org.glassfish.jersey.internal.inject.InjectionManager` `getInjectionManager()` Returns `InjectionManager` relevant to current application.
`void` `handle(ContainerRequest request)` The main request/response processing entry point for Jersey container implementations.
`void` `onReload(Container container)` Invoked when the `container` has been reloaded.
`void` `onShutdown(Container container)` Invoke at the `container` shut-down.
`void` `onStartup(Container container)` Invoked at the `container` start-up.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Constructor Detail

#### ApplicationHandler

    public ApplicationHandler()

Create a new Jersey application handler using a default configuration.

#### ApplicationHandler

    public ApplicationHandler(Class<? extends jakarta.ws.rs.core.Application> jaxrsApplicationClass)

Create a new Jersey server-side application handler configured by a `JAX-RS Application (sub-)class`.

Parameters:
  `jaxrsApplicationClass` - JAX-RS `Application` (sub-)class that will be instantiated and used to configure the new Jersey application handler.

#### ApplicationHandler

    public ApplicationHandler(jakarta.ws.rs.core.Application application)

Create a new Jersey server-side application handler configured by an instance of a `JAX-RS Application sub-class`.

Parameters:
  `application` - an instance of a JAX-RS `Application` (sub-)class that will be used to configure the new Jersey application handler.

#### ApplicationHandler

    public ApplicationHandler(jakarta.ws.rs.core.Application application,
                              org.glassfish.jersey.internal.inject.Binder customBinder)

Create a new Jersey server-side application handler configured by an instance of a `ResourceConfig` and a custom `Binder`.

Parameters:
  `application` - an instance of a JAX-RS `Application` (sub-)class that will be used to configure the new Jersey application handler.
  `customBinder` - additional custom bindings used to configure the application's.

#### ApplicationHandler

    public ApplicationHandler(jakarta.ws.rs.core.Application application,
                              org.glassfish.jersey.internal.inject.Binder customBinder,
                              Object parentManager)

Create a new Jersey server-side application handler configured by an instance of a `ResourceConfig`, custom `Binder` and a parent used by `InjectionManager`.

Parameters:
  `application` - an instance of a JAX-RS `Application` (sub-)class that will be used to configure the new Jersey application handler.
  `customBinder` - additional custom bindings used during `InjectionManager` creation.
  `parentManager` - parent used in `InjectionManager` for a specific DI provider.

### Method Detail

#### apply

    public Future<ContainerResponse> apply(ContainerRequest requestContext)

Invokes a request and returns the `response future`.

Parameters:
  `requestContext` - request data.
Returns:
  response future.

#### apply

    public Future<ContainerResponse> apply(ContainerRequest request,
                                           OutputStream outputStream)

Invokes a request and returns the `response future`.

Parameters:
  `request` - request data.
  `outputStream` - response output stream.
Returns:
  response future.

#### handle

    public void handle(ContainerRequest request)

The main request/response processing entry point for Jersey container implementations.

The method invokes the request processing of the provided `container request context` and uses the `container response writer` to suspend & resume the processing as well as write the response back to the container.

The the `security context` stored in the container request context is bound as an injectable instance in the scope of the processed request context. Also, any `custom scope injections` are initialized in the current request scope.

Parameters:
  `request` - container request context of the current request.

#### getInjectionManager

    public org.glassfish.jersey.internal.inject.InjectionManager getInjectionManager()

Returns `InjectionManager` relevant to current application.

Returns:
  `InjectionManager` instance.
Since:
  2.26

#### getConfiguration

    public ResourceConfig getConfiguration()

Get the application configuration.

Returns:
  application configuration.

#### onStartup

    public void onStartup(Container container)

Description copied from interface: `ContainerLifecycleListener`
Invoked at the `container` start-up. This method is invoked even when application is reloaded and new instance of application has started.

Specified by:
  `onStartup` in interface `ContainerLifecycleListener`
Parameters:
  `container` - container that has been started.

#### onReload

    public void onReload(Container container)

Description copied from interface: `ContainerLifecycleListener`
Invoked when the `container` has been reloaded.

Specified by:
  `onReload` in interface `ContainerLifecycleListener`
Parameters:
  `container` - container that has been reloaded.

#### onShutdown

    public void onShutdown(Container container)

Description copied from interface: `ContainerLifecycleListener`
Invoke at the `container` shut-down. This method is invoked even before the application is being stopped as a part of reload.

Specified by:
  `onShutdown` in interface `ContainerLifecycleListener`
Parameters:
  `container` - container that has been shut down.