Module jdk.httpserver
Package com.sun.net.httpserver

# Class Filter

java.lang.Object
com.sun.net.httpserver.Filter

public abstract class Filter extends Object
A filter used to pre- and post-process incoming requests. Pre-processing occurs before the application's exchange handler is invoked, and post-processing occurs after the exchange handler returns. Filters are organised in chains, and are associated with `HttpContext` instances.

Each `Filter` in the chain, invokes the next filter within its own `doFilter(HttpExchange, Chain)` implementation. The final `Filter` in the chain invokes the applications exchange handler.

Since:
  1.6

## Nested Class Summary

Nested Classes
Modifier and Type
Class
Description
`static class`
`Filter.Chain`
A chain of filters associated with a `HttpServer`.

## Constructor Summary

Constructors
Modifier
Constructor
Description
`protected`
`Filter()`
Constructor for subclasses to call.

## Method Summary

Modifier and Type
Method
Description
`static Filter`
`afterHandler(String description, Consumer<HttpExchange> operation)`
Returns a post-processing `Filter` with the given description and operation.
`static Filter`
`beforeHandler(String description, Consumer<HttpExchange> operation)`
Returns a pre-processing `Filter` with the given description and operation.
`abstract String`
`description()`
Returns a short description of this `Filter`.
`abstract void`
`doFilter(HttpExchange exchange, Filter.Chain chain)`
Asks this filter to pre/post-process the given exchange.

### Methods declared in class java.lang.Object

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

## Constructor Details

### Filter

protected Filter()
Constructor for subclasses to call.

## Method Details

### doFilter

public abstract void doFilter(HttpExchange exchange, Filter.Chain chain) throws IOException
Asks this filter to pre/post-process the given exchange. The filter can:

- Examine or modify the request headers.
- Filter the request body or the response body, by creating suitable filter streams and calling `HttpExchange.setStreams(InputStream, OutputStream)`.
- Set attribute objects in the exchange, which other filters or the exchange handler can access.
- Decide to either:
  1. Invoke the next filter in the chain, by calling `Filter.Chain.doFilter(HttpExchange)`.
  2. Terminate the chain of invocation, by not calling `Filter.Chain.doFilter(HttpExchange)`.
- If option 1. above is taken, then when doFilter() returns all subsequent filters in the Chain have been called, and the response headers can be examined or modified.
- If option 2. above is taken, then this Filter must use the HttpExchange to send back an appropriate response.

Parameters:
  `exchange` - the `HttpExchange` to be filtered
  `chain` - the `Chain` which allows the next filter to be invoked
Throws:
  `IOException` - may be thrown by any filter module, and if caught, must be rethrown again
  `NullPointerException` - if either exchange or chain are `null`

### description

public abstract String description()
Returns a short description of this `Filter`.

Returns:
  a `String` describing the `Filter`

### beforeHandler

public static Filter beforeHandler(String description, Consumer<HttpExchange> operation)
Returns a pre-processing `Filter` with the given description and operation.

The `operation` is the effective implementation of the filter. It is executed for each `HttpExchange` before invoking either the next filter in the chain or the exchange handler (if this is the final filter in the chain). Exceptions thrown by the `operation` are not handled by the filter.

API Note:
  A beforeHandler filter is typically used to examine or modify the exchange state before it is handled. The filter `operation` is executed before `Filter.Chain.doFilter(HttpExchange)` is invoked, so before any subsequent filters in the chain and the exchange handler are executed. The filter `operation` is not expected to handle the request or send response headers, since this is commonly done by the exchange handler.

  Example of adding the `"Foo"` response header to all responses:

           var filter = Filter.beforeHandler("Add response header Foo",
                       e -> e.getResponseHeaders().set("Foo", "Bar"));
           httpContext.getFilters().add(filter);

Parameters:
  `description` - the string to be returned from `description()`
  `operation` - the operation of the returned filter
Returns:
  a filter whose operation is invoked before the exchange is handled
Throws:
  `NullPointerException` - if any argument is null
Since:
  17

### afterHandler

public static Filter afterHandler(String description, Consumer<HttpExchange> operation)
Returns a post-processing `Filter` with the given description and operation.

The `operation` is the effective implementation of the filter. It is executed for each `HttpExchange` after invoking either the next filter in the chain or the exchange handler (if this filter is the final filter in the chain). Exceptions thrown by the `operation` are not handled by the filter.

API Note:
  An afterHandler filter is typically used to examine the exchange state rather than modifying it. The filter `operation` is executed after `Filter.Chain.doFilter(HttpExchange)` is invoked, this means any subsequent filters in the chain and the exchange handler have been executed. The filter `operation` is not expected to handle the exchange or send the response headers. Doing so is likely to fail, since the exchange has commonly been handled before the `operation` is invoked. More specifically, the response may be sent before the filter `operation` is executed.

  Example of adding a filter that logs the response code of all exchanges:

           var filter = Filter.afterHandler("Log response code", e -> log(e.getResponseCode());
           httpContext.getFilters().add(filter);

  Example of adding a sequence of afterHandler filters to a context:
  The order in which the filter operations are invoked is reverse to the order in which the filters are added to the context's filter-list.

           var a1Set = Filter.afterHandler("Set a1", e -> e.setAttribute("a1", "some value"));
           var a1Get = Filter.afterHandler("Get a1", e -> doSomething(e.getAttribute("a1")));
           httpContext.getFilters().addAll(List.of(a1Get, a1Set));

  The operation of `a1Get` will be invoked after the operation of `a1Set` because `a1Get` was added before `a1Set`.

Parameters:
  `description` - the string to be returned from `description()`
  `operation` - the operation of the returned filter
Returns:
  a filter whose operation is invoked after the exchange is handled
Throws:
  `NullPointerException` - if any argument is null
Since:
  17