Como aceder a outro serviço a partir de uma aplicação…

Para chamar outro serviço a partir de uma aplicação Spring, pode usar as seguintes abordagens:

HttpClient (Biblioteca padrão do Java): Método básico para enviar pedidos HTTP. Requer manipulação manual de conexões e análise de respostas.

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.io.IOException;

public class HttpClientExample {
    public static void main(String[] args) throws IOException, InterruptedException {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("http://other-service/api/data"))
                .GET() // Ou .POST(HttpRequest.BodyPublishers.ofString("...")) para POST
                .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.statusCode());
        System.out.println(response.body());
    }
}

RestTemplate (Spring Framework): Facilita a execução de pedidos HTTP, suporta a conversão de objetos para JSON/XML e vice-versa. É considerado obsoleto em favor do WebClient.

import org.springframework.web.client.RestTemplate;

public class RestTemplateExample {
    public static void main(String[] args) {
        RestTemplate restTemplate = new RestTemplate();
        String result = restTemplate.getForObject("http://other-service/api/data", String.class);
        System.out.println(result);
    }
}

WebClient (Spring WebFlux): Cliente HTTP não bloqueante (reativo), preferido em aplicações Spring modernas. Oferece melhor escalabilidade.

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

public class WebClientExample {
    public static void main(String[] args) {
        WebClient webClient = WebClient.create("http://other-service");

        webClient.get()
                .uri("/api/data")
                .retrieve()
                .bodyToMono(String.class)
                .subscribe(System.out::println); // Chamada não bloqueante
    }
}

Feign Client (Spring Cloud OpenFeign): Cliente REST declarativo. Permite definir uma interface, e o Feign gera a sua implementação para realizar pedidos HTTP. Usado em arquiteturas de microserviços com Service Discovery.

Dependência:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

Anotação @EnableFeignClients na classe principal da aplicação.

Interface do cliente:

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;

@FeignClient(name = "other-service") // Nome do serviço no Service Discovery
public interface OtherServiceClient {

    @GetMapping("/api/data")
    String getData();
}

Uso pelo cliente:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class MyService {

    @Autowired
    private OtherServiceClient otherServiceClient;

    public String callOtherService() {
        return otherServiceClient.getData();
    }
}

A escolha da abordagem depende das necessidades da aplicação:

HttpClient: para integrações simples e básicas.
RestTemplate: para aplicações Spring MVC mais simples, onde é necessário uma chamada síncrona.
WebClient: para aplicações reactivas, onde o desempenho e a não bloqueabilidade são importantes.
Feign Client: para arquiteturas de microserviços com Service Discovery, onde é necessária uma abordagem declarativa e abstração de chamadas HTTP.

Como aceder a outro serviço a partir de uma aplicação Spring?