Converting a cURL Request to an HTTP Request in Java

1. Introduction

When we work with APIs, we often start by testing our requests with cURL. cURL is a command-line tool that helps us send HTTP requests easily. In this tutorial, we’ll walk through a few ways to translate cURL into an HTTP request in Java.

2. Understand the cURL Command

Let’s start with a typical cURL command:

curl -X POST "http://example.com/api" \
  -H "Content-Type: application/json" \
  -d '{"key1":"value1", "key2":"value2"}'

This command sends a POST request to the URL http://example.com/api with the following characteristics:

• -X POST: Specifies the HTTP method, using POST to send data to the server
• -H “Content-Type: application/json”: Adds a header to indicate that the request body is in the JSON format
• –d ‘{“key1″:”value1”, “key2″:”value2”}’: Provides the payload (request body) as a JSON string containing two key-value pairs

While cURL is great for testing endpoints, converting these commands into Java code makes our API calls reusable, testable, and better at handling errors in real projects. We can achieve this using several different libraries and tools available in Java.

3. Java’s Built-in HttpURLConnection

One of the simplest ways to make HTTP requests in Java is by using the HttpURLConnection class, which comes built into the Java standard library. This method is straightforward and requires no extra dependencies.

Below is an example of how we can convert the earlier cURL command into a Java HTTP request using HttpURLConnection:

String sendPostWithHttpURLConnection(String targetUrl) {
    StringBuilder response = new StringBuilder();
    try {
        URL url = new URL(targetUrl);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Content-Type", "application/json; utf-8");
        conn.setRequestProperty("Accept", "application/json");
        conn.setDoOutput(true);

        String jsonInputString = "{\"key1\":\"value1\", \"key2\":\"value2\"}";

        try (OutputStream os = conn.getOutputStream()) {
            byte[] input = jsonInputString.getBytes("utf-8");
            os.write(input, 0, input.length);
        }

        int code = conn.getResponseCode();
        logger.info("Response Code: " + code);

        try (BufferedReader br = new BufferedReader(
          new InputStreamReader(conn.getInputStream(), "utf-8"))) {
            String responseLine;
            while ((responseLine = br.readLine()) != null) {
                response.append(responseLine.trim());
            }
        }
    } catch (Exception e) {
        // handle exception
    }
    return response.toString();
}

We start by setting up the connection using the URL class to create a URL object and then opening a connection with HttpURLConnection. Next, we set the request method to POST and add the headers using setRequestProperty() to specify that our request body is JSON and that we expect a JSON response. 

Once the request is sent, we get the response code from the server and read the response using a BufferedReader, appending each line to a StringBuilder.

Below is a simple test case that asserts a non-null response when a valid POST request is sent:

String targetUrl = mockWebServer.url("/api").toString();
String response = CurlToHttpRequest.sendPostWithHttpURLConnection(targetUrl);

assertNotNull(response);
assertFalse(response.isEmpty());
assertEquals("{\"message\": \"Success\"}", response);

4. Apache HttpClient

Apache HttpClient is a robust and popular library for making HTTP requests. It offers more control and flexibility than the built-in HttpURLConnection.

First, we add its dependency to our pom.xml:

<dependency>
    <groupId>org.apache.httpcomponents.client5</groupId>
    <artifactId>httpclient5</artifactId>
    <version>5.4.2</version>
</dependency>

Here’s how we can convert the cURL request using Apache HttpClient:

String sendPostRequestUsingApacheHttpClient(String targetUrl) {
    String result = "";
    try (CloseableHttpClient client = HttpClients.createDefault()) {
        HttpPost httpPost = new HttpPost(targetUrl);
        httpPost.setHeader("Content-Type", "application/json");

        String jsonInput = "{\"key1\":\"value1\", \"key2\":\"value2\"}";

        StringEntity entity = new StringEntity(jsonInput);
        httpPost.setEntity(entity);

        try (CloseableHttpResponse response = client.execute(httpPost)) {
            result = EntityUtils.toString(response.getEntity());
            logger.info("Response Code: " + response.getStatusLine().getStatusCode());
        }
    } catch (Exception e) {
        // handle exception
    }
    return result;
}

In this example, we create a CloseableHttpClient instance and use it to execute a POST request to the target URL. We set the Content-Type header to indicate that we’re sending JSON data. The JSON payload is wrapped in a StringEntity and attached to the HttpPost request. After executing the request, we convert the response entity into a string.

Apache HttpClient gives us the ability to customize many aspects of the HTTP communication. We can easily adjust connection timeouts, manage connection pools, add interceptors for logging or authentication, and handle retries or redirects.

Below is an example that shows how we can customize the Apache HttpClient to set connection timeouts and add an interceptor for logging request details:

String sendPostRequestUsingApacheHttpClientWithCustomConfig(String targetUrl) {
    String result = "";

    // Create custom configuration for connection and response timeouts.
    RequestConfig config = RequestConfig.custom()
      .setConnectTimeout(Timeout.ofSeconds(10))
      .setResponseTimeout(Timeout.ofSeconds(15))
      .build();

    // Create a custom HttpClient with a logging interceptor.
    CloseableHttpClient client = HttpClientBuilder.create()
      .setDefaultRequestConfig(config)
      .addRequestInterceptorFirst(new HttpRequestInterceptor() {
        @Override
        public void process(HttpRequest request, EntityDetails entity, HttpContext context) {
            logger.info("Request URI: " + request.getRequestUri());
            logger.info("Request Headers: " + request.getHeaders());
        }
      })
      .build();

    try {
        HttpPost httpPost = new HttpPost(targetUrl);
        httpPost.setHeader("Content-Type", "application/json");

        String jsonInput = "{\"key1\":\"value1\", \"key2\":\"value2\"}";
        StringEntity entity = new StringEntity(jsonInput);
        httpPost.setEntity(entity);

        try (CloseableHttpResponse response = client.execute(httpPost)) {
            result = EntityUtils.toString(response.getEntity());
            logger.info("Response Code: " + response.getCode());
        }
    } catch (Exception e) {
        // Handle exception appropriately
    } finally {
        // close the client and handle exception
    }
    return result;
}

In this customized approach, we first create a RequestConfig to set the connection timeout to 10 seconds and the response timeout to 15 seconds.

Additionally, we add a request interceptor that logs the request URI and headers before the request is executed. This interceptor provides valuable insight into the request details, which can be useful for debugging or monitoring.

5. OkHttp

OkHttp is a modern HTTP client by Square, known for its ease of use and excellent performance. It supports HTTP/2 and is widely used in both Android and Java applications.

Let’s add the dependency into our pom.xml:

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.12.0</version>
</dependency>

Here is how we can convert our cURL request to an HTTP request using OkHttp:

String sendPostRequestUsingOkHttp(String targetUrl) {
    OkHttpClient client = new OkHttpClient();

    MediaType JSON = MediaType.get("application/json; charset=utf-8");

    String jsonInput = "{\"key1\":\"value1\", \"key2\":\"value2\"}";
    RequestBody body = RequestBody.create(jsonInput, JSON);
    Request request = new Request.Builder()
      .url(targetUrl)
      .post(body)
      .build();

    String result = "";
    try (Response response = client.newCall(request).execute()) {
        logger.info("Response Code: " + response.code());
        result = response.body().string();
    } catch (Exception e) {
        // handle exception
    }
    return result;
}

In this code, we define a RequestBody to hold the JSON payload and specify its content type. Next, we use Request.Builder() to set the target URL, HTTP method (POST), request body, and headers.

Finally, we execute the request using client.newCall(request).execute(), handling any exceptions that may occur.

6. Spring’s WebClient

In addition, when using the Spring framework, WebClient is a high-level client that simplifies HTTP requests. It’s a modern, non-blocking HTTP client and it’s the recommended way to make HTTP requests in Spring applications.

Let’s convert our cURL example to use WebClient:

String sendPostRequestUsingWebClient(String targetUrl) {
    WebClient webClient = WebClient.builder()
      .baseUrl(targetUrl)
      .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
      .build();

    String jsonInput = "{\"key1\":\"value1\", \"key2\":\"value2\"}";

    return webClient.post()
      .bodyValue(jsonInput)
      .retrieve()
      .bodyToMono(String.class)
      .doOnNext(response -> logger.info("Response received from WebClient: " + response))
      .block(); 
}

In this example, we create a WebClient instance with the target URL and set the Content-Type header to application/json. Then, we use bodyValue(jsonInput) to attach the JSON payload. Additionally, we add the block() to ensure the method executes synchronously and returns the response.

Alternatively, if we’re working in an asynchronous or reactive application, we can remove the block() method and return Mono<String> instead of a String.

7. Conclusion

In this article, we explored how to translate a simple cURL command into Java code using various libraries and tools. HttpURLConnection is great for simple use cases where we want to avoid external dependencies. Apache HttpClient is ideal for applications that need fine-grained control over HTTP requests.

Additionally, OkHttp is a modern HTTP client that’s known for its performance and is ideal for microservices or Android development. Spring WebClient is best for reactive applications, particularly within a Spring ecosystem.