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

By I Wayan Saryada in HttpClient, Java 11 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:

  1. 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.
  2. 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.
  3. Headers:
    • Set the Content-Type header to multipart/form-data with the boundary value.
  4. 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 I Wayan Saryada in HttpClient, Java 11 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

  1. Create the HttpClient: The HttpClient object is used to build and send HTTP requests. 
    HttpClient httpClient = HttpClient.newHttpClient();
  2. 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";
  3. 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();
  4. 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());
  5. 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

  1. 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;
  2. 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.

How do I follow redirects using Java 11 HttpClient?

By I Wayan Saryada in HttpClient, Java 11 0 Comment

Java 11 introduced a new HttpClient API in the java.net.http package, making it much easier and more flexible to handle HTTP requests and responses. By default, the HttpClient does not follow redirects automatically. However, you can configure it to follow redirects if required.

Here’s how you can configure the HttpClient to follow redirects:

Code 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.net.http.HttpClient.Redirect;

public class FollowRedirectExample {

   public static void main(String[] args) {
      try {
         // Create the HttpClient and configure it to follow redirects
         HttpResponse<String> response;
         try (HttpClient httpClient = HttpClient.newBuilder()
                 .followRedirects(Redirect.ALWAYS) // Configures the client to always follow redirects
                 .build()) {

            // Create an HttpRequest
            HttpRequest request = HttpRequest.newBuilder()
                    .uri(URI.create("https://httpbin.org/redirect-to?url=https://example.com")) // URL that redirects
                    .GET() // HTTP GET request
                    .build();

            // Send the request and get the response
            response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
         }

         // Print the status code and body
         System.out.println("Response Status Code: " + response.statusCode());
         System.out.println("Response Body: " + response.body());
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

Explanation of Key Parts

  1. followRedirects Option:
    • The followRedirects method accepts one of the HttpClient.Redirect enum values:
      • Redirect.NEVER: Never follows redirects. (Default)
      • Redirect.ALWAYS: Always follows redirects.
      • Redirect.NORMAL: Follows redirects for GET and HEAD requests only.
    • In this example, Redirect.ALWAYS is used, which instructs the client to follow all redirects.
  2. Building the Client:
    • HttpClient is created using its builder (HttpClient.newBuilder()).
  3. Making the Request:
    • An HttpRequest is built specifying the URI.
    • You can set methods (GET, POST, etc.), headers, and request configurations as needed.
  4. Handling the Response:
    • The send method executes the request and waits for the response.
    • Use HttpResponse.BodyHandlers.ofString() to handle the response body as a String.

Expected Output

If the redirection succeeds:

Response Status Code: 200
Response Body: <HTML content of https://example.com>

Notes

  • If you set Redirect.NEVER (the default), you will need to handle 3xx responses manually, which include the Location header containing the redirection URL.
  • If an infinite redirection loop exists, the client may fail. You can control this by setting a timeout using HttpClient.Builder.connectTimeout(Duration).

How do I use HttpResponse.BodyHandlers to read responses?

By I Wayan Saryada in HttpClient, Java 11 0 Comment

To read HTTP responses in Java 11 using HttpResponse.BodyHandlers, you use the Java 11 java.net.http package, which introduced the HttpClient API. The HttpResponse.BodyHandlers class provides various static methods to handle the HTTP response body in different formats, such as strings, files, or byte arrays.

Here’s a step-by-step guide to using HttpResponse.BodyHandlers with examples:

Step 1: Create an HttpClient

Start by creating an instance of the HttpClient. It’s used to send an HTTP request and receive an HTTP response.

HttpClient client = HttpClient.newHttpClient();

Step 2: Create an HttpRequest

Build an HTTP request using the HttpRequest class. Specify the URI and HTTP method (like GET, POST).

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

Step 3: Use HttpResponse.BodyHandlers

The HttpResponse.BodyHandlers provides different ways to read and handle the response body.

  1. Reading the Response as a String You can use BodyHandlers.ofString() to read the response body as a String. 
    HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println("Response status code: " + response.statusCode());
System.out.println("Response body: " + response.body());
  2. Reading the Response as a Byte Array If you need the raw bytes of the response, use BodyHandlers.ofByteArray(). 
    HttpResponse<byte[]> response = client.send(request, HttpResponse.BodyHandlers.ofByteArray());
System.out.println("Response status code: " + response.statusCode());
byte[] responseBody = response.body();
System.out.println("Response body length: " + responseBody.length);
  3. Writing the Response Directly to a File To save the HTTP response directly to a file, use BodyHandlers.ofFile(Path). 
    Path filePath = Path.of("response.json");
HttpResponse<Path> response = client.send(request, HttpResponse.BodyHandlers.ofFile(filePath));
System.out.println("Response status code: " + response.statusCode());
System.out.println("Response written to: " + filePath.toAbsolutePath());
  4. Using HttpResponse.BodySubscribers for Custom Processing For advanced use cases, you can use BodyHandlers.fromSubscriber() in combination with BodySubscribers to handle the response body in a custom way.

Step 4: Handle Exceptions

Since the send() method can throw exceptions like IOException and InterruptedException, wrap your code in a try-catch block.

try {
    HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
    System.out.println("Response status code: " + response.statusCode());
    System.out.println("Response body: " + response.body());
} catch (IOException | InterruptedException e) {
    e.printStackTrace();
}

Example: Putting It All Together

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.io.IOException;

public class MainHttpHClient{
    public static void main(String[] args) {
        try (HttpClient client = HttpClient.newHttpClient()) {

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

            try {
                // Using BodyHandler to read response as String
                HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

                System.out.println("Response Status Code: " + response.statusCode());
                System.out.println("Response Body: " + response.body());
            } catch (IOException | InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Common BodyHandlers Methods

Method Description
HttpResponse.BodyHandlers.ofString() Read the response as a String.
HttpResponse.BodyHandlers.ofByteArray() Read the response as a byte[].
HttpResponse.BodyHandlers.ofFile(Path path) Write the response directly to a file.
HttpResponse.BodyHandlers.ofInputStream() Read the response body as an InputStream.
HttpResponse.BodyHandlers.fromSubscriber(BodySubscriber<T>) Custom handling of response body.

Notes:

  1. The HttpClient, HttpRequest, and HttpResponse classes are part of the java.net.http package introduced in Java 11.
  2. This API is asynchronous-capable. For better scalability, you can use the sendAsync() method for non-blocking calls, along with CompletableFuture.

How do I use HttpRequest.BodyPublishers in Java effectively?

By I Wayan Saryada in HttpClient, Java 11 0 Comment

Java 11 introduced the java.net.http package, providing a modern API to work with HTTP. The HttpRequest.BodyPublishers class is part of this package and is used for sending request bodies when creating HTTP requests using HttpClient. Here’s a breakdown of how to use HttpRequest.BodyPublishers effectively in Java 11:

1. Overview of HttpRequest.BodyPublishers

HttpRequest.BodyPublishers is a utility class that provides methods to create body publishers. These publishers are responsible for converting data (strings, files, streams, etc.) into a format suitable for sending as the HTTP request body.

2. Commonly Used Methods

Here are some handy static methods provided by HttpRequest.BodyPublishers:

  • noBody()
    • Sends a request without any body (useful for GET, DELETE, etc.).
    • Example: HttpRequest.BodyPublishers.noBody()
  • ofString(String body)
    • Sends a plain string as the request body.
    • Example: HttpRequest.BodyPublishers.ofString("my-data")
  • ofByteArray(byte[] body)
    • Sends a raw byte array as the request body.
    • Example: HttpRequest.BodyPublishers.ofByteArray(someByteArray)
  • ofFile(Path file)
    • Sends the content of a file as the request body.
    • Example: HttpRequest.BodyPublishers.ofFile(Paths.get("example.txt"))
  • ofInputStream(Supplier<InputStream> streamSupplier)
    • Allows streaming data for large payloads, using an InputStream.
    • Example: HttpRequest.BodyPublishers.ofInputStream(() -> new FileInputStream("largeFile.data"))
  • ofByteArrayConsumer(IntFunction<Optional<byte[]>> consumer)
    • Produces request bodies chunk by chunk (useful for advanced use cases).

3. Practical Examples

a) Simple String Request Body

For a POST request with a plain text payload:

package org.kodejava.net.http;

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

public class HttpClientDemo {
    public static void main(String[] args) throws Exception {
        HttpResponse<String> response;
        try (HttpClient client = HttpClient.newHttpClient()) {
            HttpRequest request = HttpRequest.newBuilder()
                    .uri(URI.create("https://example.com/api"))
                    .POST(HttpRequest.BodyPublishers.ofString("Hello, World!"))
                    .header("Content-Type", "text/plain")
                    .build();

            response = client.send(request, HttpResponse.BodyHandlers.ofString());
        }
        System.out.println("Response code: " + response.statusCode());
        System.out.println("Response body: " + response.body());
    }
}

b) Sending File as Request Body

This example uploads content from a file:

package org.kodejava.net.http;

import java.net.http.*;
import java.net.URI;
import java.nio.file.Paths;

public class FileUploadExample {
    public static void main(String[] args) throws Exception {
        HttpResponse<String> response;
        try (HttpClient client = HttpClient.newHttpClient()) {
            HttpRequest request = HttpRequest.newBuilder()
                    .uri(URI.create("https://example.com/upload"))
                    .POST(HttpRequest.BodyPublishers.ofFile(Paths.get("example.txt")))
                    .header("Content-Type", "text/plain")
                    .build();

            response = client.send(request, HttpResponse.BodyHandlers.ofString());
        }
        System.out.println("Response code: " + response.statusCode());
    }
}

c) Using InputStream for Large Files

For large files, using InputStream can be more memory-efficient:

package org.kodejava.net.http;

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

public class StreamUploadExample {
    public static void main(String[] args) throws Exception {
        HttpResponse<String> response;
        try (HttpClient client = HttpClient.newHttpClient()) {
            HttpRequest request = HttpRequest.newBuilder()
                    .uri(URI.create("https://example.com/upload"))
                    .POST(HttpRequest.BodyPublishers.ofInputStream(() -> {
                        try {
                            return new FileInputStream("large-file.data");
                        } catch (Exception e) {
                            throw new RuntimeException(e);
                        }
                    }))
                    .header("Content-Type", "application/octet-stream")
                    .build();

            response = client.send(request, HttpResponse.BodyHandlers.ofString());
        }
        System.out.println("Response code: " + response.statusCode());
    }
}

4. Best Practices

  • Choose the Right BodyPublisher: Pick the appropriate method for your data type:
    • Use ofString for small text payloads.
    • Use ofFile for files.
    • Use ofInputStream for large data to avoid memory issues.
  • Set Proper Headers: Use Content-Type and other relevant headers to ensure the server can interpret the body correctly.
  • Error Handling: Handle potential IO or HTTP communication exceptions gracefully.
  • Streaming for Large Data: When sending large amounts of data, consider using ofInputStream instead of loading the entire data into memory at once.

5. Advantages of HttpRequest.BodyPublishers

  • Ease of Use: Simplifies working with different types of data (strings, files, streams, etc.).
  • Memory Efficiency: Supports streaming for large data payloads.
  • Modern API: Works seamlessly with the HttpClient introduced in Java 11.

By combining the capabilities of HttpRequest.BodyPublishers with other features of the Java 11 HTTP Client API, you can efficiently send HTTP requests tailored to your application’s needs.