Java 11 introduced the HttpClient API as part of java.net.http. By default, the HttpClient implementation provides connection pooling, so you don’t usually need to manually enable or build it. However, you do need to configure it effectively to manage connection pooling and ensure it aligns with your performance and scalability requirements.

Here’s how you can implement and configure connection pooling in Java 11’s HttpClient:

---

1. Default Connection Pooling in Java 11 HttpClient

The HttpClient is built with connection pooling enabled by default. When you create an instance of HttpClient, it manages multiple connections automatically across requests to the same host. However, connection pooling behavior is controlled via the HttpClient.Builder.

---

2. Configure Connection Pooling Options

You can configure the pooling behavior through settings like timeouts and thread handling. Use the builder pattern to fine-tune:

Example:

package org.kodejava.net.http;

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

public class HttpClientConnectionPoolingExample {

    public static void main(String[] args) throws Exception {
        // Create a custom HttpClient with connection pooling
        HttpClient httpClient = HttpClient.newBuilder()
                // Set connection timeout
                .connectTimeout(Duration.ofSeconds(10))
                // Use a custom Executor (optional - controls the threads for async requests)
                .executor(java.util.concurrent.Executors.newFixedThreadPool(10))
                // Enable HTTP/2 (default, but can be set explicitly)
                .version(HttpClient.Version.HTTP_2)
                .build();

        // Create an HTTP request
        HttpRequest request = HttpRequest.newBuilder()
                .uri(new URI("https://jsonplaceholder.typicode.com/posts"))
                .GET() // Optional, as GET is the default
                .build();

        // Perform the request
        HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());

        // Print the response
        System.out.println("Response Code: " + response.statusCode());
        System.out.println("Response Body: " + response.body());
    }
}

---

3. Key Concepts for Connection Pooling

• Reusing HttpClient Instances
  Always reuse a single HttpClient instance across your application, especially for frequent HTTP calls. Each HttpClient has its own connection pool, so creating new instances unnecessarily can result in poor resource management and lack of reuse.
• Setting a Custom Executor
  By default, the HttpClient uses a default Executor for asynchronous requests. You can configure a custom thread pool (using java.util.concurrent.Executors) for better control over the number of threads used by your application.
• Testing and Handling Timeouts
  Always set reasonable timeouts for connections and requests to avoid blocking indefinitely when the server is slow or unreachable.
• Setting Keep-Alive
  The connection pooling mechanism uses HTTP/1.1 or HTTP/2’s persistent connections to keep sockets alive. You don’t need to manually configure Keep-Alive as it’s handled internally by the HttpClient.

Example of Keep-Alive Headers:

If necessary, you can include a custom header in requests to explicitly control Keep-Alive durations:

HttpRequest request = HttpRequest.newBuilder()
        .uri(new URI("https://example.com"))
        .header("Connection", "keep-alive")
        .build();

---

4. Advanced: Tuning JVM System Properties

The HttpClient supports additional tuning using JVM system properties. For example, you can configure maximum connections per route, or total connections, if necessary.

Examples of commonly used JVM properties:

-Dsun.net.httpclient.defaultConnectTimeout=10000
-Dsun.net.httpclient.defaultReadTimeout=10000
-Djdk.httpclient.allowRestrictedHeaders=connection,keep-alive

---

5. Asynchronous Requests with Connection Pooling

If you perform a large number of requests and need high concurrency, leveraging asynchronous handling (sendAsync) is a good practice:

Example:

package org.kodejava.net.http;

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.concurrent.CompletableFuture;

public class AsyncHttpClientDemo {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(10))
                .executor(java.util.concurrent.Executors.newFixedThreadPool(10))
                .build();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://jsonplaceholder.typicode.com/posts"))
                .GET()
                .build();

        // Send Async request
        CompletableFuture<HttpResponse<String>> responseFuture =
                client.sendAsync(request, HttpResponse.BodyHandlers.ofString());

        // Process the response asynchronously
        responseFuture.thenAccept(response -> {
            System.out.println("Status Code: " + response.statusCode());
            System.out.println("Response Body: " + response.body());
        }).join(); // Optional: Blocks until complete
    }
}

---

Summary

• Java 11’s HttpClient comes with built-in support for connection pooling.
• Always reuse HttpClient instances to automatically take advantage of the pool.
• Tune parameters such as connectTimeout, executor, and HTTP versions.
• Use asynchronous APIs (sendAsync) with custom executors for better concurrency.
• Avoid creating too many HttpClient instances to prevent fragmentation.

This approach ensures that connection pooling is effectively implemented without the need for third-party libraries.