Modern HTTP Client (Java 11)

Java 11 introduced a modern HTTP Client API that makes HTTP communication much simpler, cleaner, and more powerful compared to the old HttpURLConnection.

In this guide, you will learn how to use HttpClient, HttpRequest, and HttpResponse to send synchronous and asynchronous requests and work with JSON APIs.

What is Java 11 HTTP Client?

The Java 11 HTTP Client is a modern API available in the java.net.http package used to send HTTP requests and handle responses.

In simple words: It is a new and improved way to call APIs in Java with less code and better performance.

• Introduced in Java 11 as a replacement for HttpURLConnection .
• Supports synchronous and asynchronous communication.
• Works well with modern APIs (JSON-based services).
• Provides cleaner and more readable code.

👉 It simplifies HTTP communication and is widely used in modern Java applications.

Why Use Modern HTTP Client?

Problems with old HttpURLConnection:

• Too much boilerplate code (more lines for simple tasks).
• Hard to manage input/output streams.
• Less flexible for modern API use cases.

👉 Solution:

• Cleaner and more readable syntax.
• Built-in support for asynchronous requests.
• Better performance and efficiency.
• Easier handling of APIs and JSON responses.

Key Classes in HTTP Client API

1. HttpClient

• Used to send HTTP requests
• Acts as the main entry point for making requests

2. HttpRequest

• Represents HTTP request
• Contains URL, headers, and request method

3. HttpResponse

• Represents server response
• Contains status code and response body

Creating HttpClient

import java.net.http.HttpClient;

HttpClient client = HttpClient.newHttpClient();

👉 Creates a default HTTP client instance used to send requests.

Synchronous Request (Blocking)

Example: GET Request

import java.net.URI;
import java.net.http.*;

public class SyncExample {
    public static void main(String[] args) throws Exception {

        HttpClient client = HttpClient.newHttpClient();

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

        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        System.out.println("Status: " + response.statusCode());
        System.out.println("Body: " + response.body());
    }
}

Explanation

• newHttpClient() → Creates HTTP client.
• HttpRequest.newBuilder() → Builds the request.
• .GET() → Sets request method as GET.
• send() → Sends request and waits for response.
• BodyHandlers.ofString() → Converts response body into string.

👉 This is called synchronous because the program waits until the response is received before moving to the next step.

Asynchronous Request (Non-Blocking)

Example: Async GET

import java.net.URI;
import java.net.http.*;
import java.util.concurrent.CompletableFuture;

public class AsyncExample {
    public static void main(String[] args) throws Exception {

        HttpClient client = HttpClient.newHttpClient();

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

        CompletableFuture<HttpResponse<String>> future =
                client.sendAsync(request, HttpResponse.BodyHandlers.ofString());

        future.thenApply(HttpResponse::body)
              .thenAccept(System.out::println)
              .join();
    }
}

Explanation

• sendAsync() → Sends request without blocking the main thread.
• Returns CompletableFuture → Represents future result.
• thenApply() → Processes the response (extracts body).
• thenAccept() → Consumes and prints the result.
• join() → Waits for completion (optional, for demo).

👉 Useful for high-performance and concurrent applications where multiple requests run in parallel without waiting.

POST Request Example

import java.net.URI;
import java.net.http.*;

public class PostExample {
    public static void main(String[] args) throws Exception {

        HttpClient client = HttpClient.newHttpClient();

        String json = "{\\"title\\":\\"Java\\",\\"body\\":\\"HTTP Client\\",\\"userId\\":1}";

        HttpRequest request = HttpRequest.newBuilder()
                .uri(new URI("<https://jsonplaceholder.typicode.com/posts>"))
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(json))
                .build();

        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        System.out.println(response.body());
    }
}

Explanation

• newHttpClient() → Creates HTTP client.
• HttpRequest.newBuilder() → Builds the request.
• .header("Content-Type", "application/json") → Sets request content type.
• .POST(BodyPublishers.ofString(json)) → Sends JSON data in request body.
• send() → Sends request and waits for response.
• BodyHandlers.ofString() → Converts response to string.

👉 Used to send data to server (API) in JSON format.

Handling JSON APIs

Most modern APIs return data in JSON format, which is easy to read and widely used in web services.

Example Response

{
  "id": 1,
  "title": "Java",
  "body": "HTTP Client"
}

👉 This response represents structured data returned by a server.

Parsing JSON (Basic)

To work with JSON in Java, you need to convert it into Java objects. This process is called parsing.

You can use libraries like:

• Jackson
• Gson

Example (concept):

// Using Gson
Gson gson = new Gson();
MyObject obj = gson.fromJson(response.body(), MyObject.class);

Explanation

• Gson → Library used to handle JSON data.
• fromJson() → Converts JSON string into Java object.
• response.body() → Contains JSON response from API.
• MyObject.class → Target Java class for mapping JSON fields.

👉 JSON data from API is converted into a Java object so you can easily access its fields like id, title, etc.

Common HTTP Methods Supported

• GET → Fetch data from server.
• POST → Send data to server.
• PUT → Update existing data.
• DELETE → Remove data from server.

👉 These methods define how a client interacts with server resources.

Real-World Use Cases

• Calling REST APIs (fetching or sending data).
• Microservices communication (service-to-service calls).
• Payment gateway integration (processing transactions).
• Data fetching from external APIs (third-party services).
• Backend services (Spring Boot applications).

👉 HTTP methods are widely used for communication between client and server in modern applications.

Advantages of Java 11 HTTP Client

• Clean and modern API (less boilerplate code).
• Supports asynchronous programming (sendAsync).
• Better performance compared to older APIs.
• Built-in support for HTTP/2.
• Easy to use and more readable.

Limitations

• Requires Java 11 or higher.
• JSON parsing requires external libraries (like Gson, Jackson).
• Slight learning curve for asynchronous programming.

Common Mistakes to Avoid

• Not handling exceptions properly.
• Forgetting to set headers (e.g., Content-Type).
• Blocking asynchronous calls incorrectly (using .join() unnecessarily).
• Ignoring HTTP response status code.

Conclusion

Modern HTTP Client in Java makes API communication simple, clean, and powerful.

• Uses HttpClient, HttpRequest, and HttpResponse.
• Supports both synchronous and asynchronous requests.
• Works efficiently with JSON-based APIs.

👉 It is the recommended approach for handling HTTP communication in modern Java applications.