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.

In this tutorial, we'll implement a simple Java application applying hexagonal architecture.

Hexagonal Architecture

Hexagonal architecture (a.k.a. Ports and Adapters Architecture) is a design pattern that isolates the core domain logic from all other application components.

As a result, the business core will communicate with other parts of the application through ports and adapters. This way, we can change the underlying technologies without having to change the application core.

Let's move on to the actual implementation of this architecture.

Implementation Using Java

We're going to build a small PhoneBook application with an add operation to show how to organize code around ports and adapters.

We can divide our application into three layers; domain (internal component), application (external component), and infrastructure (external component).

Domain Layer

The domain layer defines the inside of the application and provides ports to communicate with the application's use cases.

Firstly, we should create a PhoneBook class:

public class PhoneBook {

    private Long id;
    private List numbers;

    public PhoneBook(Long id, List numbers) {
        this.id = id;
        this.numbers = numbers;
    }

    public void addNumber(String number) {
        numbers.add(number);
    }

    // standard setters and getters
}

Anything related to our business logic will go through this class. Additionally, PhoneBook is responsible for adding a phone number.

Secondly, we should define the incoming ports. These are used by external components to interact with our application.

Let's create a port for the add use case:

public interface AddPhoneNumberPort {
    void add(Long id, String number);
}

Thirdly, we should define our outgoing ports. These are used by the domain to interact with the storage.

In this example, we can define two ports: the first one for Load and the second one for Save.

public interface LoadPhoneBookPort {
    Optional load(Long id);
}

public interface SavePhoneBookPort {
    void save(PhoneBook phoneBook);
}

Lastly, we should implement the PhoneBookAddService to tie all the pieces together.

Notice how the service implements the incoming port in which it uses the outgoing ports.

public class PhoneBookAddService implements AddPhoneNumberPort {

    private LoadPhoneBookPort loadPhoneBookPort;
    private SavePhoneBookPort savePhoneBookPort;

    // constructor

    @Override
    public void add(Long id, String number) {
        PhoneBook phoneBook = loadPhoneBookPort.load(id).orElse(new PhoneBook(id, new ArrayList<>()));

        phoneBook.addNumber(number);

        savePhoneBookPort.save(phoneBook);
    }
}

On the add method, it uses the LoadPhoneBookPort port to fetch the PhoneBook from the storage. Then, it performs the changes in the domain model. And finally, it saves those changes through the SavePhoneBookPort port.

Infrastructure Layer

In this section, we need to provide implementations for the defined ports to help retrieve and save the data. We call these adapters.

Firstly, we should define a repository class that will be used later by the adapters:

public class PhoneBookRepository {

    List phoneBooks = new ArrayList<>();

    public void save(PhoneBook phoneBook) {
        phoneBooks.add(phoneBook);
    }

    public Optional load(Long id) {
        return phoneBooks.stream().filter(phoneBook -> phoneBook.getId().equals(id)).findFirst();
    }
}

Secondly, we should implement the adapters and use the repository.

Briefly, they load and save PhoneBook by calling the load and save methods of the repository class.

public class LoadPhoneBookAdapter implements LoadPhoneBookPort {

    private PhoneBookRepository phoneBookRepository;

    // constructor

    @Override
    public Optional load(Long id) {
        return phoneBookRepository.load(id);
    }
}

public class SavePhoneBookAdapter implements SavePhoneBookPort {

    private PhoneBookRepository phoneBookRepository;

    // constructor

    @Override
    public void save(PhoneBook phoneBook) {
        phoneBookRepository.save(phoneBook);
    }
}

Application Layer

In this section, we'll implement the application layer. We'll use the adapters for the outside entities to interact with the domain.

Therefore, let's create a PhoneBookApplication:

public class PhoneBookApplication {
    private AddPhoneNumberPort addPhoneNumberService;

    private PhoneBookRepository phoneBookRepository;

    private SavePhoneBookPort savePhoneBookAdapter;
    private LoadPhoneBookPort loadPhoneBookAdapter;

    public static void main(String[] args) {
        new PhoneBookApplication().init();
    }

    public void init() {
        phoneBookRepository = new PhoneBookRepository();

        savePhoneBookAdapter = new SavePhoneBookAdapter(phoneBookRepository);
        loadPhoneBookAdapter = new LoadPhoneBookAdapter(phoneBookRepository);

        addPhoneNumberService = new PhoneBookAddService(loadPhoneBookAdapter, savePhoneBookAdapter);
        addPhoneNumberService.add(100L, "064502131");
    }
}

Conclusion

In this article, we've learned how to implement the hexagonal architecture in Java.

As always, the code for these examples is available over on GitHub.