Calling Microservices in Java: Part 1

Introduction

When building applications that need to communicate with other parts of the system (such as microservices), Java developers have access to various tools and techniques for their integration tasks. This article will guide you through different methods of calling microservices in Java, ranging from basic approaches to more advanced ones, while sharing best practices and common pitfalls to avoid.

1. Basic HTTP Requests with HttpURLConnection

The most fundamental way to call a microservice in Java is using the `HttpURLConnection` class. This allows your application to send HTTP requests and receive responses directly.

Example:

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class SimpleServiceCaller {
    public static String callService(String serviceUrl) throws Exception {
        URL url = new URL(serviceUrl);
        HttpURLConnection con = (HttpURLConnection) url.openConnection();
        con.setRequestMethod("GET");

        try (BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()))) {
            String inputLine;
            StringBuilder response = new StringBuilder();
            while ((inputLine = in.readLine()) != null) {
                response.append(inputLine);
            }
            return response.toString();
        } finally {
            con.disconnect();
        }
    }
}

Advantages:

• Simple and doesn’t require additional libraries.
• Suitable for smaller applications or infrequent service calls.

Disadvantages:

• Lacks advanced features like connection pooling, automatic retries, and sophisticated error handling.
• Manual management of HTTP connections can lead to potential errors and verbose code.

2. Using Apache HttpClient

Apache HttpClient is a more robust library for making HTTP calls. It supports advanced features such as connection pooling, authentication, and proxy handling.

Example:

import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.util.EntityUtils;

public class ApacheHttpClientExample {
    public static String callService(String serviceUrl) throws Exception {
        try (CloseableHttpClient client = HttpClients.createDefault()) {
            HttpGet request = new HttpGet(serviceUrl);
            return client.execute(request, httpResponse -> 
                EntityUtils.toString(httpResponse.getEntity()));
        }
    }
}

Advantages:

• Efficiently handles complex HTTP interactions.
• Connection pooling improves performance for multiple requests.

Disadvantages:

• Increases complexity and requires additional library dependencies.
• Requires manual configuration for advanced error handling and resilience patterns.

3. Using Spring’s RestTemplate and WebClient

For Spring-based applications, `RestTemplate` and `WebClient` provide convenient options for making HTTP calls.

Example with RestTemplate:

import org.springframework.web.client.RestTemplate;

public class RestTemplateExample {
    private static final RestTemplate restTemplate = new RestTemplate();

    public static String callService(String serviceUrl) {
        return restTemplate.getForObject(serviceUrl, String.class);
    }
}

Example with WebClient:

import org.springframework.web.reactive.function.client.WebClient;

public class WebClientExample {
    private static final WebClient webClient = WebClient.create();

    public static String callService(String serviceUrl) {
        return webClient.get()
                        .uri(serviceUrl)
                        .retrieve()
                        .bodyToMono(String.class)
                        .block();  // Blocks for the response
    }
}

Advantages:

• Seamless integration within Spring applications.
• `WebClient` supports modern, reactive programming paradigms.

Disadvantages:

• It is tightly coupled with the Spring ecosystem.
• `RestTemplate` is being phased out in favor of `WebClient`.

4. Using Feign for Declarative REST Clients

Feign allows you to create declarative HTTP clients by defining interfaces.

Example:

@FeignClient(name = "todoService", url = "https://jsonplaceholder.typicode.com")
public interface TodoService {

    @GetMapping("/todos/{id}")
    Todo getTodo(@PathVariable("id") int id);
}

Advantages:

• Simplifies code with its declarative approach.
• Integrates well with Spring Cloud and other modern Java frameworks.

Disadvantages:

• Less fine-grained control over HTTP request details.
• Requires additional Feign dependencies.

Best Practices and Common Pitfalls

• Implement connection pooling: Enhances performance for multiple requests.
• Robust error handling: Implement retries, timeouts, and circuit breakers for improved resilience.
• Use mature libraries: Prefer well-maintained libraries like Apache HttpClient or WebClient over manual HTTP connection management.
• Monitor HTTP traffic: Log requests and responses for easier debugging and performance optimization.
• Secure communications: Always use HTTPS and implement proper authentication methods.
• Handle rate limiting: Implement backoff strategies to respect service rate limits.
• Deserialize responses carefully: Use appropriate deserialization techniques to handle JSON responses, like the one provided in the example document.

Conclusion

Selecting the appropriate method for microservice communication in Java depends on application scale, framework preferences, and specific requirements. While simple approaches suffice for basic needs, more sophisticated techniques offer enhanced performance, maintainability, and resilience as applications grow. By adhering to best practices and avoiding common pitfalls, you can ensure robust and efficient microservice integration in your Java applications.