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 has provided the HttpURLConnection API. This includes only basic features and is known for not being very user-friendly.

With JDK 11, Java introduced the new and improved HttpClient API to handle HTTP communication. We’ll discuss these libraries, as well as check out alternatives, such as the Apache HttpClient and Spring Rest Template.

2. HttpClient

As previously mentioned, 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. 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’ll 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 it 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 an HttpURLConnection. This object allows us to add headers or check the response code.

Next, we’ll 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 learn 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.client5</groupId>
 <artifactId>httpclient5</artifactId>
 <version>5.2</version>
</dependency>

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

CloseableHttpClient provides an execute method to send and receive data. This method makes use of 2 parameters. The first parameter is of type HttpUriRequest, which has many subclasses, including HttpGet and HttpPost. The second parameter is of type HttpClientResponseHandler, which generates a response object from a ClassicHttpResponse.

First, we’ll create an HttpGet object:

HttpGet request = new HttpGet(DUMMY_URL);

Second, we’ll create the client:

CloseableHttpClient client = HttpClients.createDefault();

Finally, we’ll retrieve the response object from the result of the execute method:

String response = client.execute(request, new BasicHttpClientResponseHandler());
logger.debug("Response -> {}", response);

Here we have used BasicHttpClientResponseHandler, which returns the response body as String.

5. Spring RestTemplate

In this section, we’ll demonstrate how to use Spring RestTemplate to read an HTTP response body as a string. We must note that RestTemplate is now deprecated. As such, we should consider using Spring WebClient, as described in the next section.

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 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, we’ll create an instance of RestTemplate:

RestTemplate restTemplate = new RestTemplate();

Then we’ll get the response object by calling the method getForObject(), and 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. Spring WebClient

Finally, we’ll see how to use Spring WebClient, the reactive, non-blocking solution replacing Spring RestTemplate.

We can use this library by adding the spring-boot-starter-webflux dependency to our Maven project:

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

The simplest way to perform an HTTP Get request is to use the create method:

WebClient webClient = WebClient.create(DUMMY_URL);

The simplest way to perform an HTTP Get request is to call the get and retrieve methods. Then we’ll use the bodyToMono method with the String.class type to extract the body as a single String instance:

Mono<String> body = webClient.get().retrieve().bodyToMono(String.class);

Finally, we’ll call the block method to tell the web flux to wait until the whole body stream is read and copied in the String result:

String s = body.block();

7. Conclusion

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