Get started with Spring 5 and Spring Boot 2, through the reference Learn Spring course:

HTTP Client Top

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:

Authors Top

If you have a few years of experience in the Java ecosystem, and you’d like to share that with the community, have a look at our Contribution Guidelines.

Spring Top – Temp

Get started with Spring 5 and Spring Boot 2, through the reference Learn Spring course:

Lightrun – Third Party Code
announcement - icon

Flakiness in REST requests is a common issue. A request can get a 200 OK in one scenario and a 409 next time. Sometimes a request can even succeed and fail intermittently on the same exact request. In short, working over HTTP can be a bit of a mess without solid tooling.

Also, while it’s easy enough to debug these issues locally when developing the application, we’re talking about production here - we can’t afford the downtime while you’re stepping in and out of code. Uptime is kind of the whole point.

With Lightrun, you can get the same level of access you get with a local debugger or profiler - no downtime required. You can add logs, metrics, and snapshots (think breakpoints, but without stopping the running service), in a safe and read-only manner - without redeploying, restarting, or even stopping the running service. Performance and security are maintained throughout the process.

Learn how to debug a live REST API (built with Spring, of course), using Lightrun, in this 5-minute tutorial:

>> Debugging REST Requests in Spring-Based applications using the Lightrun Platform

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()

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 class and the 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:


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 uses a parameter of type HttpUriRequest, which has many subclasses, including HttpGet and HttpPost.

First, we'll create an HttpGet object:

HttpGet request = new HttpGet(DUMMY_URL);

Second, we'll create the client:

CloseableHttpClient client = HttpClients.createDefault();

Then we'll retrieve the response object from the result of the execute method:

CloseableHttpResponse response = client.execute(request);

Finally, we'll 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 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:


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:


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.

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

Spring bottom

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:

REST bottom

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course :

HTTP Client bottom

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:

REST footer banner
Inline Feedbacks
View all comments
Comments are closed on this article!