Reading an HTTP Response Body as a String in Java

1. Introduction

In this tutorial, we'll explore several libraries for reading an HTTP response body as a string in Java. Since the first versions, Java provided the HttpURLConnection API. This includes only basic features and is known for not being very user-friendly.

With the release of JDK 11, Java introduced the new and improved HttpClient API to handle HTTP communication. We'll cover these libraries, and we'll check some alternatives such as the Apache HttpClient and the Spring Rest Template.

2. HttpClient

As we mentioned before, HttpClient was added to Java 11. It allows us to access resources over the network. But, unlike HttpURLConnection, HttpClient supports HTTP/1.1 and HTTP/2. Moreover, it provides both synchronous and asynchronous request types.

HttpClient offers a modern API with a lot of flexibility and powerful features. Mainly, this API consists of three core classes: HttpClient, HttpRequest, and HttpResponse.

HttpResponse describes the result of an HttpRequest call. HttpResponse isn't created directly and is made available when the body has been fully received.

To read a response body as a String, we'll first need to create simple client and request objects:

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create(DUMMY_URL))
    .build();

Then, we simply use BodyHandlers and call the method ofString() to return the response:

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

3. HttpURLConnection

HttpURLConnection is a lightweight HTTP client used to access resources via the HTTP or HTTPS protocol and allows us to create an InputStream. Once we obtain the InputStream, we can read it like a normal local file.

In Java, the main classes we can use to access the Internet are the java.net.URL class and the java.net.HttpURLConnection class. First, we'll use the URL class to point to a web resource. Then, we can access it by using the HttpURLConnection class.

To get the response body from a URL as a String, we should first create an HttpURLConnection using our URL:

HttpURLConnection connection = (HttpURLConnection) new URL(DUMMY_URL).openConnection();

The new URL(DUMMY_URL).openConnection() returns a HttpURLConnection. This object allows us to add headers or checking the response code.

Next, let's get the InputStream from the connection object:

InputStream inputStream = connection.getInputStream();

Finally, we need to convert the InputStream to a String.

4. Apache HttpClient

In this section, we'll see how to use the Apache HttpClient for reading an HTTP response body as a string.

To use this library, we'll need to add its dependency to our Maven project:

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.12</version>
</dependency>

We can retrieve and send data via the CloseableHttpClient class. To create an instance of it with default configuration we can use the HttpClients.createDefault().

CloseableHttpClient provides an execute method to send and receive data. This method uses a parameter of type HttpUriRequest, which has many subclasses including HttpGet and HttpPost.

Let's first create an HttpGet object:

HttpGet request = new HttpGet(DUMMY_URL);

Second, let's create the client:

CloseableHttpClient client = HttpClients.createDefault();

Third, we retrieve the response object from the result of the execute method:

CloseableHttpResponse response = client.execute(request);

Finally, we return the response body by converting the response entity to a String:

HttpEntity entity = response.getEntity();
String result = EntityUtils.toString(entity);

5. Spring RestTemplate

In this section, we'll see how to use Spring RestTemplate for reading an HTTP response body as a string.

The RestTemplate class is an essential tool provided by Spring that offers a simple template for making client-side HTTP operations over underlying HTTP client libraries such as the JDK HttpURLConnection, Apache HttpClient, and others.

RestTemplate provides some useful methods for creating HTTP requests and handling responses.

We can use this library by first adding some dependencies to our Maven project:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>${spring-boot.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <version>${spring-boot.version}</version>
    <scope>test</scope>
</dependency>

To make a web request and return the response body as a string, let's first create an instance of RestTemplate:

RestTemplate restTemplate = new RestTemplate();

Second, we get the response object by calling the method getForObject(), passing in the URL and desired response type — we'll use String.class in our example:

String response = restTemplate.getForObject(DUMMY_URL, String.class);

6. Conclusion

In this article, we’ve seen how to use several libraries for reading an HTTP response body as a String.

As usual, the complete code is available over on GitHub.

The post Reading an HTTP Response Body as a String in Java first appeared on Baeldung.