To create a reusable HttpClient instance in Java 11, you should utilize the HttpClient class introduced in Java 11. This class is designed to handle HTTP requests and responses, and when properly configured, it is optimized for reuse throughout your application. Here’s how:

Key Concepts:

1. Thread Safety:
   • HttpClient is immutable and thread-safe. You can create an instance once and reuse it across multiple threads.
2. Default Settings:
   • An HttpClient instance stores configuration such as connection timeouts, redirects handling, and more. These are defined during its creation via the HttpClient.Builder.
3. Reuse Encouraged:
   • Rather than creating new HttpClient objects every time, reuse the same instance to improve performance and resource management.

---

Code Example for Reusable HttpClient Instance

Here’s how you can create and reuse an HttpClient instance:

package org.kodejava.net.http;

import java.net.http.HttpClient;
import java.time.Duration;

public class HttpClientProvider {
   // Create a static, reusable instance of HttpClient
   private static final HttpClient HTTP_CLIENT = HttpClient.newBuilder()
           .version(HttpClient.Version.HTTP_2) // Use HTTP/2 or HTTP/1.1
           .connectTimeout(Duration.ofSeconds(10)) // Set connection timeout
           .build();

   // Method to access the reusable HttpClient instance
   public static HttpClient getHttpClient() {
      return HTTP_CLIENT;
   }
}

---

Usage Example

Here’s how you can use the reusable HttpClient in your application:

package org.kodejava.net.http;

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

public class HttpClientReusableExample {
   public static void main(String[] args) {
      HttpClient httpClient = HttpClientProvider.getHttpClient();

      try {
         // Create an HttpRequest
         HttpRequest request = HttpRequest.newBuilder()
                 .uri(URI.create("https://example.com"))
                 .GET()
                 .build();

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

         System.out.println("Response status code: " + response.statusCode());
         System.out.println("Response body: " + response.body());
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

---

Advantages of Reusing HttpClient

1. Performance:
   • Reusing a single instance avoids the overhead of repeatedly creating and tearing down underlying network resources.
2. Connection Pooling:
   • HttpClient maintains a connection pool under the hood, which improves efficiency for multiple network requests to the same or different endpoints.
3. Thread-Safety:
   • Since HttpClient is fully thread-safe, it can be shared among many threads without conflict.
4. Centralized Configuration:
   • Store your client configuration (e.g., timeouts, protocols) in one place, making it easier to ensure consistent behavior across requests.

---

Notes

• Always reuse the HttpClient for multiple requests unless you have a very specific reason to create a new instance, such as requiring a unique configuration for a particular request or batch of requests.
• Consider setting up a factory or provider class (as shown above) for centralized management of the HttpClient instance in larger applications.