# Class HttpHandlers

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

public final class HttpHandlers extends Object
Implementations of `HttpHandler` that implement various useful handlers, such as a static response handler, or a conditional handler that complements one handler with another.

The factory method `of(int, Headers, String)` provides a means to create handlers with pre-set static response state. For example, a `jsonHandler` that always returns 200 with the same json:

        HttpHandlers.of(200,
                        Headers.of("Content-Type", "application/json"),
                        Files.readString(Path.of("some.json")));

or a `notAllowedHandler` that always replies with 405 - Method Not Allowed, and indicates the set of methods that are allowed:

        HttpHandlers.of(405, Headers.of("Allow", "GET"), "");

The functionality of a handler can be extended or enhanced through the use of `handleOrElse`, which allows to complement a given handler. For example, complementing a `jsonHandler` with notAllowedHandler:

        Predicate<Request> IS_GET = r -> r.getRequestMethod().equals("GET");
        var handler = HttpHandlers.handleOrElse(IS_GET, jsonHandler, notAllowedHandler);

The above handleOrElse `handler` offers an if-else like construct; if the request method is "GET" then handling of the exchange is delegated to the `jsonHandler`, otherwise handling of the exchange is delegated to the `notAllowedHandler`.

Since:
  18

## Method Summary

Modifier and Type
Method
Description
`static HttpHandler`
`handleOrElse(Predicate<Request> handlerTest, HttpHandler handler, HttpHandler fallbackHandler)`
Complements a conditional `HttpHandler` with another handler.
`static HttpHandler`
`of(int statusCode, Headers headers, String body)`
Returns an `HttpHandler` that sends a response comprising the given `statusCode`, `headers`, and `body`.

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

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

## Method Details

### handleOrElse

public static HttpHandler handleOrElse(Predicate<Request> handlerTest, HttpHandler handler, HttpHandler fallbackHandler)
Complements a conditional `HttpHandler` with another handler.

This method creates a handleOrElse handler; an if-else like construct. Exchanges who's request matches the `handlerTest` predicate are handled by the `handler`. All remaining exchanges are handled by the `fallbackHandler`.

Example of a nested handleOrElse handler:

        Predicate<Request> IS_GET = r -> r.getRequestMethod().equals("GET");
        Predicate<Request> WANTS_DIGEST =  r -> r.getRequestHeaders().containsKey("Want-Digest");

        var h1 = new SomeHandler();
        var h2 = HttpHandlers.handleOrElse(IS_GET, new SomeGetHandler(), h1);
        var h3 = HttpHandlers.handleOrElse(WANTS_DIGEST.and(IS_GET), new SomeDigestHandler(), h2);

The `h3` handleOrElse handler delegates handling of the exchange to `SomeDigestHandler` if the "Want-Digest" request header is present and the request method is `GET`, otherwise it delegates handling of the exchange to the `h2` handler. The `h2` handleOrElse handler, in turn, delegates handling of the exchange to `SomeGetHandler` if the request method is `GET`, otherwise it delegates handling of the exchange to the `h1` handler. The `h1` handler handles all exchanges that are not previously delegated to either `SomeGetHandler` or `SomeDigestHandler`.

Parameters:
  `handlerTest` - a request predicate
  `handler` - a conditional handler
  `fallbackHandler` - a fallback handler
Returns:
  a handler
Throws:
  `NullPointerException` - if any argument is null

### of

public static HttpHandler of(int statusCode, Headers headers, String body)
Returns an `HttpHandler` that sends a response comprising the given `statusCode`, `headers`, and `body`.

This method creates a handler that reads and discards the request body before it sets the response state and sends the response.

`headers` are the effective headers of the response. The response body bytes are a `UTF-8` encoded byte sequence of `body`. The response headers are sent with the given `statusCode` and the body bytes' length (or `-1` if the body is empty). The body bytes are then sent as response body, unless the body is empty, in which case no response body is sent.

Parameters:
  `statusCode` - a response status code
  `headers` - a headers
  `body` - a response body string
Returns:
  a handler
Throws:
  `IllegalArgumentException` - if statusCode is not a positive 3-digit integer, as per rfc2616, section 6.1.1
  `NullPointerException` - if headers or body are null