Java - Learn Java by Examples

How do I use SSL/TLS with Java 11 HttpClient for secure requests?

By Wayan in HttpClient, Java 11 Last modified: May 20, 2025 0 Comment

To use SSL/TLS with Java 11’s HttpClient for secure HTTPS requests, you need to ensure proper configuration of certificates and trust stores. Here’s a detailed step-by-step guide:

1. Default SSL Configuration

By default, the Java 11 HttpClient will handle HTTPS requests securely using the system’s default trust store (java.security settings or cacerts trust store in the JDK).

Here’s how you make a secure request without additional setup:

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 SecureRequestExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();

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

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

Notes:

The default HttpClient uses the default SSLContext for secure connections.
The JDK’s default trust store (cacerts) is used to validate the server’s certificate.

2. Customizing the SSL Context

If you need to use a custom trust store or a client certificate, you can set up a custom SSLContext.

Example with a Custom Trust Store:

package org.kodejava.net.http;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.KeyManagerFactory;
import java.io.FileInputStream;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.security.KeyStore;

public class CustomSSLExample {
    public static void main(String[] args) throws Exception {
        // Path to your custom trust store and password
        String trustStorePath = "path/to/truststore.jks";
        String trustStorePassword = "password";

        // Load the trust store
        KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
        try (FileInputStream trustStream = new FileInputStream(trustStorePath)) {
            trustStore.load(trustStream, trustStorePassword.toCharArray());
        }

        // Initialize TrustManager with the trust store
        TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        trustManagerFactory.init(trustStore);

        // Initialize SSLContext with the trust manager
        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(null, trustManagerFactory.getTrustManagers(), null);

        // Create an HttpClient with the custom SSLContext
        HttpClient client = HttpClient.newBuilder()
                .sslContext(sslContext)
                .build();

        // Make a secure HTTPS request
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://example.com"))
                .GET()
                .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

Explanation:

A custom trust store is loaded and used to validate the server’s certificate against your specific CA.
No client-side certificates are used here.

3. Using Client Certificates

To configure a client certificate, you’ll need a KeyManager in addition to the TrustManager.

Example with Client Certificates:

package org.kodejava.net.http;

import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;
import java.io.FileInputStream;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.security.KeyStore;

public class ClientCertificateExample {
    public static void main(String[] args) throws Exception {
        // Path to your client key store, trust store, and their passwords
        String keyStorePath = "path/to/keystore.jks";
        String keyStorePassword = "keystorePassword";
        String trustStorePath = "path/to/truststore.jks";
        String trustStorePassword = "truststorePassword";

        // Load KeyStore (for client certificate)
        KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
        try (FileInputStream keyStream = new FileInputStream(keyStorePath)) {
            keyStore.load(keyStream, keyStorePassword.toCharArray());
        }

        // Load TrustStore (for server certificate)
        KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
        try (FileInputStream trustStream = new FileInputStream(trustStorePath)) {
            trustStore.load(trustStream, trustStorePassword.toCharArray());
        }

        // Initialize KeyManager
        KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
        keyManagerFactory.init(keyStore, keyStorePassword.toCharArray());

        // Initialize TrustManager
        TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        trustManagerFactory.init(trustStore);

        // Configure SSLContext
        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(keyManagerFactory.getKeyManagers(), trustManagerFactory.getTrustManagers(), null);

        // Create HttpClient
        HttpClient client = HttpClient.newBuilder()
                .sslContext(sslContext)
                .build();

        // Send a secure request
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://example.com"))
                .GET()
                .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

4. Configure the JVM to Use a Custom Trust Store

An alternative to programmatically setting up the SSLContext is to configure the JVM to use a custom trust store at runtime by defining system properties:

-Djavax.net.ssl.keyStore=path/to/keystore.jks
-Djavax.net.ssl.keyStorePassword=keystorePassword
-Djavax.net.ssl.trustStore=path/to/truststore.jks
-Djavax.net.ssl.trustStorePassword=truststorePassword

This will make the custom key store and trust store available globally without modifying any Java code.

Debugging SSL Issues

If you face SSL/TLS-related issues, enable debugging by setting the following JVM option:

-Djavax.net.debug=ssl

This will print detailed information about the SSL handshake.

Summary

Use the default HttpClient for standard HTTPS requests.
Configure a custom SSLContext with TrustManager and/or KeyManager for advanced configurations like custom trust stores or client certificates.
Alternatively, use JVM system properties to configure trust/key stores globally.

How do I use Java 11 HttpClient with a proxy server?

By Wayan in HttpClient, Java 11 Last modified: May 20, 2025 0 Comment

To use Java 11’s HttpClient with a proxy server, you need to configure the proxy using the ProxySelector class. The ProxySelector allows you to specify a proxy through which HTTP requests should pass.

Here’s an example of how you can configure and use HttpClient with a proxy server:

Step-by-Step Example

Example with Proxy Configuration

package org.kodejava.net.http;

import java.io.IOException;
import java.net.*;
import java.net.http.*;
import java.util.List;

public class HttpClientWithProxyExample {

   public static void main(String[] args) {
      // Create a ProxySelector with a specified proxy server
      ProxySelector proxySelector = new ProxySelector() {
         @Override
         public List<Proxy> select(URI uri) {
            // Returning the proxy details
            return List.of(new Proxy(Proxy.Type.HTTP, new InetSocketAddress("proxy.example.com", 8080)));
         }

         @Override
         public void connectFailed(URI uri, SocketAddress sa, IOException ioe) {
            System.err.println("Proxy connection failed: " + ioe.getMessage());
         }
      };

      // Build an HttpClient with the proxy selector
      HttpClient httpClient = HttpClient.newBuilder()
              .proxy(proxySelector)
              .build();

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

      try {
         // Send the request
         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();
      }
   }
}

Key Points in the Example:

ProxySelector Implementation:
- A custom ProxySelector is created, which is capable of specifying a proxy (Proxy.Type.HTTP) and its hostname (proxy.example.com) and port (8080).
Build HttpClient:
- The HttpClient is created using the HttpClient.newBuilder() API, and the proxy method is used to assign the custom ProxySelector.
Send an HTTP Request:
- Create a request using HttpRequest.newBuilder and send the request using HttpClient.send().

Example with Proxy Authentication

If your proxy server requires authentication, you can configure it using the Authenticator class:

package org.kodejava.net.http;

import java.io.IOException;
import java.net.*;
import java.net.http.*;
import java.util.List;

public class HttpClientWithProxyAuthExample {

   public static void main(String[] args) {
      // Set system-wide default authenticator
      Authenticator.setDefault(new Authenticator() {
         @Override
         protected PasswordAuthentication getPasswordAuthentication() {
            if (getRequestorType() == RequestorType.PROXY) {
               return new PasswordAuthentication("proxyUsername", "proxyPassword".toCharArray());
            }
            return null;
         }
      });

      // Create ProxySelector with proxy details
      ProxySelector proxySelector = new ProxySelector() {
         @Override
         public List<Proxy> select(URI uri) {
            return List.of(new Proxy(Proxy.Type.HTTP, new InetSocketAddress("proxy.example.com", 8080)));
         }

         @Override
         public void connectFailed(URI uri, SocketAddress sa, IOException ioe) {
            System.err.println("Proxy connection failed: " + ioe.getMessage());
         }
      };

      // Build the HttpClient with the proxy selector and default authenticator
      HttpClient httpClient = HttpClient.newBuilder()
              .proxy(proxySelector)
              .authenticator(Authenticator.getDefault())
              .build();

      // Create an HTTP Request
      HttpRequest request = HttpRequest.newBuilder()
              .uri(URI.create("http://example.com"))
              .GET()
              .build();

      try {
         // Send HTTP request
         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();
      }
   }
}

Key Points in Proxy Authentication:

Authenticator Class:
- Use Authenticator.setDefault() to set a global proxy authenticator. Override the getPasswordAuthentication() method to return the credentials for the proxy server.
Proxy and Authentication Configuration:
- Combine the ProxySelector and the Authenticator to handle both proxy selection and authentication credentials.

Additional Notes:

Replace "proxy.example.com" with your proxy server’s hostname and 8080 with the proxy’s port number.
Replace proxyUsername and proxyPassword with the credentials required for accessing the proxy server.
For HTTPS requests, ensure the proxy supports secure traffic.

This approach allows you to work with both HTTP and HTTPS requests through a proxy server.

How do I use Java 11 HttpClient with basic authentication?

By Wayan in HttpClient, Java 11 Last modified: May 19, 2025 0 Comment

Using Java 11’s HttpClient with Basic Authentication is straightforward. Below is an example of how to configure and send an HTTP request using Basic Authentication:

Steps:

Encode the Username and Password: Basic Authentication requires the credentials (username and password) to be Base64 encoded in the format username:password.
Set the Authorization Header: Attach the Base64 encoded value as an Authorization header in the request.
Use HttpClient to Send the Request: Use HttpClient to send the request to the desired endpoint.

Here’s an example implementation:

Example Code

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.util.Base64;

public class HttpClientWithBasicAuth {
   public static void main(String[] args) throws Exception {
      // Define the username and password
      String username = "username";
      String password = "password";

      // Encode the credentials in Base64 format
      String auth = username + ":" + password;
      String encodedAuth = Base64.getEncoder().encodeToString(auth.getBytes());
      String authHeader = "Basic " + encodedAuth;

      // Create the HttpClient
      HttpClient client = HttpClient.newBuilder()
              .version(HttpClient.Version.HTTP_2)
              .build();

      // Create the HttpRequest with the Authorization header
      HttpRequest request = HttpRequest.newBuilder()
              .uri(URI.create("https://example.com/api/resource")) // Replace with your endpoint
              .header("Authorization", authHeader)
              .header("Content-Type", "application/json") // Optional, adjust if needed
              .GET() // Use POST, PUT, or DELETE if required
              .build();

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

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

Explanation

Base64 Encoding:
- Concatenate the username and password using : as the separator.
- Encode the concatenated string in Base64 format.
Authorization Header:
- The Authorization header must include Basic followed by the Base64-encoded credentials.
HttpClient Configuration:
- Use HttpClient.newBuilder() to configure HttpClient.
- You can set the HTTP version with .version(HttpClient.Version.HTTP_2).
HttpRequest Building:
- Use HttpRequest.newBuilder() to construct the request.
- Attach the Authorization header to the HTTP request.
- Specify the HTTP method (GET, POST, etc.).
Response Handling:
- Use HttpResponse.BodyHandlers.ofString() to handle the response body as a String.

Output

If the credentials are correct, the HTTP server will process the request and return the desired response. Otherwise, the server will return HTTP 401 Unauthorized.

Notes:

Replace `https://example.com/api/resource` with your actual endpoint.
Ensure that the username and password are handled securely and are not hardcoded in production. Use secure configurations or credential storage mechanisms instead.
Adjust the other headers (e.g., Content-Type) based on your API’s requirements.

How do I upload a file using multipart with Java 11 HttpClient?

By Wayan in HttpClient, Java 11 Last modified: May 19, 2025 0 Comment

To upload a file using the modern HttpClient introduced in Java 11, you can use the multipart/form-data request. The steps involve creating a HttpRequest and sending the file as part of the multipart request body. Below is an example implementation:

Example Code: File Upload with Multipart

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.nio.file.Path;
import java.nio.file.Paths;
import java.util.UUID;

public class FileUploadDemo {
    public static void main(String[] args) throws Exception {
        // File to be uploaded
        Path filePath = Paths.get("path/to/your/file.txt");

        // Create boundary for multipart request
        String boundary = UUID.randomUUID().toString();

        // Build the multipart body
        String body = 
            "--" + boundary + "\r\n" +
            "Content-Disposition: form-data; name=\"file\"; filename=\"" + filePath.getFileName() + "\"\r\n" +
            "Content-Type: text/plain\r\n\r\n" +
            java.nio.file.Files.readString(filePath) + "\r\n" +
            "--" + boundary + "--\r\n";

        // Create HttpClient
        HttpClient client = HttpClient.newHttpClient();

        // Build HttpRequest
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://your-api-endpoint.com/upload"))
                .header("Content-Type", "multipart/form-data; boundary=" + boundary)
                .POST(HttpRequest.BodyPublishers.ofString(body))
                .build();

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

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

Explanation:

Boundary:
- A boundary string (UUID) is specified to separate parts in the multipart/form-data content. It’s used in headers and to indicate where each part starts and ends.
Request Body:
- Each part in the multipart body includes:
  - Content-Disposition: Specifies form-data, name, and file name.
  - Content-Type: MIME type of the file (e.g., text/plain for text files).
  - File content is appended after the headers.
Headers:
- Set the Content-Type header to multipart/form-data with the boundary value.
HttpClient:
- HttpClient sends the HTTP POST request, and BodyPublishers.ofString() sets the request body.

Notes:

Replace "path/to/your/file.txt" with the actual path of the file to upload.
Update "https://your-api-endpoint.com/upload" with the appropriate API endpoint for uploading files.
Adjust the Content-Type for the file if it’s not a plain text file (e.g., "image/png", "application/json").

Considerations for Larger Files:

The above example uses files.readString() to read the file content into memory. For large files, this approach may corrupt memory. Instead, you can use BodyPublishers.ofFile() to stream the file content directly:

HttpRequest.BodyPublisher body = HttpRequest.BodyPublishers.ofFile(filePath);
// Use this body publisher in your POST request

This is more memory-efficient and suitable for uploading large files.

How do I send form data using Java 11 HttpClient?

By Wayan in HttpClient, Java 11 Last modified: May 18, 2025 0 Comment

Sending form data using Java 11 HttpClient is fairly straightforward. The HttpClient can be used to send both POST and GET requests, and form data is generally transmitted in POST requests with the application/x-www-form-urlencoded content type.

Here’s how you can send form data using Java 11’s HttpClient:

Example: Sending Form Data

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.net.http.HttpRequest.BodyPublishers;

public class HttpClientFormExample {
   public static void main(String[] args) throws Exception {
      // Create the HttpClient
      HttpClient httpClient = HttpClient.newHttpClient();

      // Form parameters
      String formData = "param1=value1&param2=value2";

      // Create the HttpRequest
      HttpRequest request = HttpRequest.newBuilder()
              .uri(URI.create("https://example.com/submit-form"))
              .header("Content-Type", "application/x-www-form-urlencoded")
              .POST(BodyPublishers.ofString(formData))  // Set the request body
              .build();

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

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

Steps Explained

Create the HttpClient: The HttpClient object is used to build and send HTTP requests.
```
HttpClient httpClient = HttpClient.newHttpClient();
```
Form Data Encoding: The form data must be encoded in application/x-www-form-urlencoded format, e.g., key1=value1&key2=value2. You’ll need to manually build this format or use a utility method to encode special characters (like +, spaces, &, and =). In simple cases:
```
String formData = "param1=value1&param2=value2";
```
Build the Request:
- Use HttpRequest.newBuilder() to create your request.
- Set the URI for the request.
- Add the Content-Type header for the form data: "application/x-www-form-urlencoded".
- Use .POST() with BodyPublishers.ofString(formData) to send the body of the request.
```
HttpRequest request = HttpRequest.newBuilder()
       .uri(URI.create("https://example.com/submit-form"))
       .header("Content-Type", "application/x-www-form-urlencoded")
       .POST(BodyPublishers.ofString(formData))
       .build();
```
Send the Request: Use the HttpClient.send() method to send the request. Provide the HttpResponse.BodyHandlers.ofString() to handle the response body as a plain string.
```
HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
```

Handle the Response: You can access the HTTP response status code and body.

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

Notes

If the form data contains special characters, you should encode them properly using URLEncoder:

import java.net.URLEncoder;

String param1 = URLEncoder.encode("value1", "UTF-8");
String param2 = URLEncoder.encode("value2", "UTF-8");
String formData = "param1=" + param1 + "&param2=" + param2;

Ensure the target server accepts POST requests with the application/x-www-form-urlencoded content type.

This is all you need to send form data using Java 11’s HttpClient.