To set and read custom HTTP headers using HttpURLConnection in Java, you can make use of its methods setRequestProperty to set headers and getHeaderField to read them.

Here’s how you can do it:

Setting Custom HTTP Headers

You can set custom HTTP headers on a request using the setRequestProperty method. For example:

package org.kodejava.net;

import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class HttpHeadersExample {
   public static void main(String[] args) {
      try {
         URL url = new URL("https://example.com/api");
         HttpURLConnection connection = (HttpURLConnection) url.openConnection();

         // Set HTTP method (GET, POST, etc.)
         connection.setRequestMethod("GET");

         // Set custom HTTP headers
         connection.setRequestProperty("Custom-Header", "HeaderValue");
         connection.setRequestProperty("User-Agent", "MyCustomAgent");

         // Optional: Add request body (for POST or PUT)
         connection.setDoOutput(true);
         try (OutputStream os = connection.getOutputStream()) {
            os.write("Request Body".getBytes());
            os.flush();
         }

         int responseCode = connection.getResponseCode();
         System.out.println("Response Code: " + responseCode);

         // Close the connection
         connection.disconnect();

      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

Reading Response Headers

You can read response headers using the getHeaderField and getHeaderFieldKey methods.

package org.kodejava.net;

import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Map;

public class ReadHttpHeadersExample {
   public static void main(String[] args) {
      try {
         URL url = new URL("https://example.com/api");
         HttpURLConnection connection = (HttpURLConnection) url.openConnection();
         connection.setRequestMethod("GET");

         // Read all headers
         System.out.println("Headers:");
         for (int i = 0;; i++) {
            String headerKey = connection.getHeaderFieldKey(i);
            String headerValue = connection.getHeaderField(i);

            if (headerKey == null && headerValue == null) {
               break; // No more headers
            }
            System.out.println(headerKey + ": " + headerValue);
         }

         connection.disconnect();

      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

Explanation

1. Setting Headers
   • Use setRequestProperty(String key, String value) to set a custom header.
   • For example, connection.setRequestProperty("Authorization", "Bearer token") for setting an Authorization header.
2. Sending a Request Body
   • If you want to send a POST or PUT request with custom headers, you need to write a body to the request through the OutputStream.
3. Reading Headers
   • Use getHeaderFieldKey(int) to retrieve the header key and getHeaderField(int) to get its value.
   • You can loop through headers until both the key and value are null, indicating no more headers.
4. Common Use-Cases
   • Assigning client information via User-Agent.
   • Sending authentication tokens via Authorization.
   • Using custom headers like X-Custom-Header.

Example Output for Reading Headers:

When you print headers, you may see something like:

Headers:
null: HTTP/1.1 200 OK
Date: Mon, 23 Oct 2023 10:30:00 GMT
Content-Type: application/json
Content-Length: 123
Server: Apache

This shows both standard headers and any custom headers returned by the server.

By combining the above methods, you can handle both setting and reading custom HTTP headers programmatically in Java using HttpURLConnection.

To implement a simple HTTP client using HttpURLConnection in Java, you can follow the steps below. HttpURLConnection is part of the java.net package and is used to communicate with HTTP servers. Here’s how to create a basic HTTP client:

Steps

1. Create a URL Object: Specify the target URI as a URL object.
2. Open a Connection: Use the openConnection() method of the URL object to obtain an HttpURLConnection.
3. Set Request Properties: Configure request types (GET, POST, etc.), headers, and other properties.
4. Send the Request: Connect to the server and send the request.
5. Read the Response: Read the server’s response using an input stream.
6. Handle Exceptions: Properly handle IO or network exceptions.
7. Close Resources: Always close connection and streams properly.

Example Code: HTTP GET Request

Here’s an example of an HTTP GET request using HttpURLConnection:

package org.kodejava.net;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class SimpleHttpClient {
    public static void main(String[] args) {
        String urlString = "https://jsonplaceholder.typicode.com/posts/1"; // Example API endpoint
        HttpURLConnection connection = null;

        try {
            // Create URL object
            URL url = new URL(urlString);

            // Open connection
            connection = (HttpURLConnection) url.openConnection();

            // Set the request method to GET
            connection.setRequestMethod("GET");

            // Set request headers (optional)
            connection.setRequestProperty("Accept", "application/json");

            // Connect to the server (optional as getInputStream implies connect())
            connection.connect();

            // Validate the response code
            int responseCode = connection.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_OK) { // HTTP 200
                // Read the response
                BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
                String line;
                StringBuilder response = new StringBuilder();
                while ((line = reader.readLine()) != null) {
                    response.append(line);
                }
                reader.close();

                // Print the response
                System.out.println("Response: " + response.toString());
            } else {
                System.out.println("HTTP Error: " + responseCode);
            }
        } catch (Exception e) {
            e.printStackTrace(); // Handle exceptions
        } finally {
            if (connection != null) {
                connection.disconnect(); // Close the connection
            }
        }
    }
}

Example Code: HTTP POST Request

Below is an example of sending data via an HTTP POST request:

package org.kodejava.net;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;

public class SimpleHttpPostClient {
    public static void main(String[] args) {
        String urlString = "https://jsonplaceholder.typicode.com/posts"; // Example API endpoint
        HttpURLConnection connection = null;

        try {
            // Create URL object
            URL url = new URL(urlString);

            // Open connection
            connection = (HttpURLConnection) url.openConnection();

            // Set the request method to POST
            connection.setRequestMethod("POST");

            // Set request headers
            connection.setRequestProperty("Content-Type", "application/json; utf-8");
            connection.setRequestProperty("Accept", "application/json");

            // Enable writing output to the connection
            connection.setDoOutput(true);

            // JSON body for the POST request
            String jsonInputString = "{\"title\": \"foo\", \"body\": \"bar\", \"userId\": 1}";

            // Write data to output stream
            try (OutputStream os = connection.getOutputStream()) {
                byte[] input = jsonInputString.getBytes(StandardCharsets.UTF_8);
                os.write(input, 0, input.length);
            }

            // Validate the response code
            int responseCode = connection.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_CREATED) { // HTTP 201
                // Read the response
                BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
                String line;
                StringBuilder response = new StringBuilder();
                while ((line = reader.readLine()) != null) {
                    response.append(line);
                }
                reader.close();

                // Print the response
                System.out.println("Response: " + response.toString());
            } else {
                System.out.println("HTTP Error: " + responseCode);
            }
        } catch (Exception e) {
            e.printStackTrace(); // Handle exceptions
        } finally {
            if (connection != null) {
                connection.disconnect(); // Close the connection
            }
        }
    }
}

Key Points to Consider:

1. Thread Safety: HttpURLConnection is not thread-safe, so don’t use it across multiple threads.
2. Time-Outs: Always configure connection and read timeouts using setConnectTimeout() and setReadTimeout() to avoid hanging requests.
3. Resource Management: Always close streams and disconnect the connection to release resources properly.
4. Error Handling: Handle different HTTP error codes (4xx, 5xx) gracefully.

For production-ready applications, you might want to consider alternatives like the Apache HttpClient or the Java HttpClient introduced in Java 11, which provides a modern and simpler API.