Project Eclipse Grizzly

How it works

The HTTP/2 protocol implementation is represented, at least in the server case, a Filter that sits between the HTTP/1.1 Filter and the HTTP server filter. All the Filters upstream to HTTP/2 filter receive HTTP messages for processing, so they are not even aware of HTTP/2 protocol.

Grizzly supports HTTP/2 over plain text and TLS. However, to support HTTP/2 over TLS, you will be required to include a special library on the JVM’s bootclasspath to override the default SSL/TLS handshake implementation with support for Application-Layer Protocol Negotiation Extension. (see https://tools.ietf.org/html/rfc7540#section-3.3 for details on ALPN). Because this requires modifying internal JDK classes, the ALPN implementation is sensitive to version of the Oracle JDK that’s being used. As such, the current Grizzly ALPN implementation requires JDK 1.8.0_(121,131,141). Later versions of JDK8 may work, but if the classes change in a significant way, it will result in a runtime issue.

In order to simplify HttpServer HTTP/2 configuration, there is a HTTP/2AddOn available, which may be registered on the required HttpServer’s NetworkListener like:

HttpServer httpServer = new HttpServer();
NetworkListener listener =
         new NetworkListener("grizzly",
                             NetworkListener.DEFAULT_NETWORK_HOST,
                             PORT);
listener.setSecure(true);

// Include environmental specific SSL configuration.
listener.setSSLEngineConfig(...);

// Create default HTTP/2 configuration and provide it to the AddOn
Http2Configuration configuration = Http2Configuration.builder().build();
Http2AddOn http2Addon = new Http2AddOn(configuration); 

// Register the Addon.
listener.registerAddOn(http2Addon);

httpServer.addListener(listener);

The Http2Configuration class provides the following properties:

HTTP/2 Server Push

Starting with 2.4.0, Grizzly offers support for HTTP/2 server push mechanism https://tools.ietf.org/html/rfc7540#section-8.2.

Quote:
HTTP/2 allows a server to pre-emptively send (or “push”) responses (along with corresponding “promised” requests) to a client in association with a previous client-initiated request. This can be useful when the server knows the client will need to have those responses available in order to fully process the response to the original request.

To support this feature, we’ve provided an API similar to the PushBuilder defined in Servlet 4.0. This mechanism allows the developer to issue a push for an existing static or dynamic resource.

Consider the following example:

final HttpHandler mainHandler = new HttpHandler() {
    @Override
    public void service(final Request request, final Response response) throws Exception {
        final PushBuilder builder = request.newPushBuilder();
        builder.path("/resource1");
        builder.push();
        builder.path("/resource2");
        builder.push();
        response.setCharacterEncoding("UTF-8");
        response.setContentType("text/plain");
        response.getWriter().write("main");
    }
};

final HttpHandler resource1 = new HttpHandler() {
    @Override
    public void service(final Request request, final Response response) throws Exception {
        response.setCharacterEncoding("UTF-8");
        response.setContentType("text/plain");
        response.getWriter().write("resource1");
    }
};

final HttpHandler resource2 = new HttpHandler() {
    @Override
    public void service(final Request request, final Response response) throws Exception {
        response.setCharacterEncoding("UTF-8");
        response.setContentType("text/plain");
        response.getWriter().write("resource2");
    }
};

In the example above, three _HttpHandler_s are defined. The first, mainHandler, pushes two resources to the client prior to sending its own response (NOTE: the push() calls do not block). The runtime will send the HTTP/2 PUSH_PROMISE frame to the peer and then dispatch the request back through the FilterChain for normal request/response processing.

The PushBuilder provides several APIs for generating conditional requests so that content isn’t needlessly pushed to the peer.

Care should be taken that the call to Request.newPushBuilder() will return null if HTTP/2 push has been disabled for this session.

See the org.glassfish.grizzly.http.server.http2.PushBuilder javadocs for more details on what features it provides.