Enable HTTP2 with Tomcat in Spring Boot

1. Overview

HTTP/2 is the successor of the widely used HTTP/1.1 protocol, which improves web performance via the adoption of new functionalities such as multiplexing and header compression.

In this tutorial, we’ll describe how to configure our Spring Boot application to enable HTTP/2 on an embedded Tomcat server.

2. HTTP/2

The hypertext transfer protocol (HTTP) is an application protocol for fetching resources on the Internet. HTTP/1.1 was released in January 1997 and has served the majority of the web for over two decades. This version identified issues that caused slow performance in certain scenarios.

HTTP/2 overcomes the performance issues in HTTP/1.1 with the following characteristics:

• Multiplexing – HTTP/1.1 sends multiple requests using multiple connections; multiplexing allows sending requests over a single connection, reducing resource consumption and latency
• Compressed headers – without compression, it often requires multiple roundtrips to send the header due to the TCP’s slow start; compressing the headers guarantees the header sending in fewer roundtrips and within one for most of the time
• Binary – HTTP/2 sends data in binary format to reduce parsing overhead and have smaller message sizes than HTTP/1.1, which uses text-encoded data

3. Prerequisite

HTTP/2 can run either in cleartext or over TLS. Most web browsers do not support HTTP/2 over cleartext, so we recommend running it over TLS. We’ll first enable SSL on the embedded web server.

Let us generate a keystore to store the keys and certificates used for SSL/TLS and put it in the embedded Tomcat. We’ll run the following keytool in the console to generate it:

$ keytool -genkeypair -alias http2-alias -keyalg RSA -keysize 2048 -storetype PKCS12 -keystore keystore.p12 -validity 3650

The keytool will ask us for a password that we’ll need to add to the Spring Boot configuration later. Once we complete the process, the tool will generate the keystore.p12 file. We’ll copy this file to the resources folder under our Spring Boot application.

Now, we have to add the following properties to the application.yml to enable HTTPS in the embedded Tomcat:

server:
  ssl:
    enabled: true
    key-store: classpath:keystore.p12
    key-store-password: <your-password>
    key-store-type: PKCS12
    key-alias: http2-alias

4. Examining HTTP Protocol Version in Response

By default, Spring Boot embedded Tomcat doesn’t switch on the HTTP/2 protocol to serve requests. Let’s create a simple Spring Boot REST endpoint to verify it:

@RestController
public class Http2Controller {
    @GetMapping("/http2/echo")
    public String getChatbotResponse(@RequestParam String message) {
        return message;
    }
}

This endpoint simply accepts a request parameter message and sends it back in the response body.

Once we start up our application, we can execute the following curl command in the console with the –http2 argument to call the endpoint by HTTP/2:

$ curl -I --http2 http://localhost:8080/http2/echo?message=hello

The -I argument shows us additional information, such as the HTTP protocol version in the response. From the printout, we can see that the application returns:

HTTP/1.1 200

Alternatively, we could use Postman to verify the protocol version. It started supporting the HTTP/2 protocol from version 11.8, where the protocol version for sending the HTTP requests is still HTTP/1.1 default. We can change the protocol version in the settings tab:

Once we send the request, we can find the HTTP protocol version from the raw log in the Postman console:

Both curl and Postman return HTTP/1.1 responses even when we have sent the request in HTTP/2.

5. Enable HTTP/2 in Spring Boot

Now, let us enable HTTP/2 in the embedded Tomcat. There are two ways to enable HTTP/2 in a Spring Boot application.

The first one is via defining a configuration class to add the Http2Protocol class to the Tomcat HTTP connector:

@Configuration
public class Http2Config {
    @Bean
    public WebServerFactoryCustomizer<TomcatServletWebServerFactory> getWebServerFactoryCustomizer() {
        return factory -> {
            Connector httpConnector = new Connector(TomcatServletWebServerFactory.DEFAULT_PROTOCOL);
            httpConnector.setPort(8080);
            factory.addConnectorCustomizers(connector -> connector.addUpgradeProtocol(new Http2Protocol()));
            factory.addAdditionalTomcatConnectors(httpConnector);
        };
    }
}

This configuration class customizes the embedded Tomcat server and enables HTTP/2 support by adding an Http2Protocol upgrade to the HTTP connector.

This configuration opens an additional port, 8080, that runs on HTTP, in addition to the existing port, 8443, running HTTP/2 with SSL. If we don’t want to expose an additional port, we could use the alternative way to enable HTTP/2.

The second one is even simpler. We only have to mark the property server.http2.enabled as true in application.yml:

server:
  http2:
    enabled: true

Once we restart the application after applying either one of them, we can execute the same curl command to query the REST endpoint; we’ll receive the following response showing that HTTP/2 is enabled:

HTTP/2 200

And we’ll see the following response if we send the request again to Postman:

6. Conclusions

HTTP/1.1 has been the dominant protocol for delivering HTTP requests for a long time, while HTTP/2 provides better resource efficiency and reduced latency. It’s a big advancement and makes it a considerable upgrade for modern web applications.

To run a Spring Boot application using the HTTP/2 protocol, we’ll have to enable both the SSL and the HTTP/2 settings in the Spring Boot application.