Boost Your Java Apps with HTTP/3: Faster Web Communication Explained

HTTP/3 Introduction

HTTP/3 is the latest evolution of the Hypertext Transfer Protocol, retaining request/response semantics but using a different encoding and session management.

Why is HTTP/3 faster than HTTP/2?

Because it replaces TCP with the faster QUIC protocol at the TLS layer.

What is the underlying QUIC protocol?

QUIC establishes multiplexed connections using UDP, improving performance for connection‑oriented network applications.

How QUIC improves over TCP in the TLS layer

In HTTP/2, packet loss on a TCP connection delays all streams; QUIC allows independent delivery of streams, reducing latency and congestion.

Several Java implementations of QUIC/HTTP3 exist, such as Kwik, Quiche4j, Flupke, and Jetty.

Why use Jetty‑based client/server classes?

Most browsers support HTTP/3, but many web servers do not yet; Jetty implements HTTP/3 for both client and server, though its API can be verbose.

What are Kwik and Flupke?

Kwik is a pure‑Java implementation of the QUIC protocol (RFC 9000) providing client and server capabilities. Flupke builds on Kwik to offer a Java HTTP/3 library, simplifying usage.

Benchmarking HTTP/2 vs HTTP/3

Sample Java code using the standard HttpClient for HTTP/2 and the Flupke Http3Client for HTTP/3 demonstrates faster response times with HTTP/3.

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.List;

public class AnachronisticHttpBenchmark {
    public static void main(String[] args) throws Exception {
        List<String> urls = List.of(
            "https://reutersinstitute.politics.ox.ac.uk/digital-news-report/2024/dnr-executive-summary",
            "https://www.nytimes.com/2024/12/26/briefing/the-year-in-news.html",
            "https://www.heraldnet.com/news/the-top-10-most-read-herald-stories-of-2024",
            "https://www.cbsnews.com/news/top-news-headlines-of-2024-month-by-month",
            "https://www.cfr.org/article/ten-most-significant-world-events-2024"
        );

        HttpClient client = HttpClient.newBuilder()
                .followRedirects(HttpClient.Redirect.NORMAL)
                .connectTimeout(Duration.ofSeconds(10))
                .build();

        for (String url : urls) {
            HttpRequest request = HttpRequest.newBuilder()
                    .uri(URI.create(url))
                    .GET()
                    .build();

            long startTime = System.nanoTime();
            HttpResponse<byte[]> response = client.send(request, HttpResponse.BodyHandlers.ofByteArray());
            long endTime = System.nanoTime();

            long durationMillis = (endTime - startTime) / 1_000_000;
            int responseSizeBytes = response.body().length;

            System.out.printf("URL: %s%n", url);
            System.out.printf("Status: %d%n", response.statusCode());
            System.out.printf("Response Time: %d ms%n", durationMillis);
            System.out.printf("Response Size: %d bytes%n", responseSizeBytes);
            System.out.println("=".repeat(60));
        }
    }
}

import tech.kwik.flupke.Http3Client;
import tech.kwik.flupke.Http3ClientBuilder;
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.List;

public class Sample {
    public static void main(String[] args) throws IOException, InterruptedException {
        List<String> urls = List.of(
            "https://reutersinstitute.politics.ox.ac.uk/digital-news-report/2024/dnr-executive-summary",
            "https://www.nytimes.com/2024/12/26/briefing/the-year-in-news.html",
            "https://www.heraldnet.com/news/the-top-10-most-read-herald-stories-of-2024/",
            "https://www.cbsnews.com/news/top-news-headlines-of-2024-month-by-month",
            "https://www.cfr.org/article/ten-most-significant-world-events-2024"
        );
        try {
            for (String url : urls) {
                HttpRequest request = HttpRequest.newBuilder()
                        .uri(URI.create(url))
                        .header("User-Agent", "Flupke http3 library")
                        .timeout(Duration.ofSeconds(1000))
                        .build();

                // Easiest way to create a client with default configuration
                HttpClient defaultClient = Http3Client.newHttpClient();
                HttpClient client = ((Http3ClientBuilder) Http3Client.newBuilder())
                        .connectTimeout(Duration.ofSeconds(1000))
                        .build();

                long start = System.currentTimeMillis();
                HttpResponse<String> httpResponse = client.send(request, HttpResponse.BodyHandlers.ofString());
                long end = System.currentTimeMillis();
                int responseSizeBytes = httpResponse.body().length();
                reportResult(httpResponse, end - start);
            }
        } catch (IOException e) {
            System.err.println("Request failed: " + e.getMessage());
        } catch (InterruptedException e) {
            System.err.println("Request interrupted: " + e.getMessage());
        }
    }

    private static void reportResult(HttpResponse<String> httpResponse, long duration) throws IOException {
        System.out.printf("Status: %d%n", httpResponse.statusCode());
        System.out.printf("Response Size: %d bytes%n", httpResponse.body().length());
        System.out.println("Request completed in " + duration + " ms");
        System.out.println("=".repeat(60));
    }
}

Results show consistently lower latency and fewer TCP connections when using HTTP/3, leveraging UDP and reduced WAIT states.

Conclusion: HTTP/3 reduces network resource usage and latency compared to HTTP/2 and HTTP/1, leading to faster web communication.