Comment accéder à un autre service depuis une…

Pour appeler un autre service depuis une application Spring, vous pouvez utiliser les approches suivantes :

HttpClient (Bibliothèque standard de Java) : Méthode de base pour envoyer des requêtes HTTP. Nécessite une gestion manuelle des connexions et de l'analyse des réponses.

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("...")) pour POST
                .build();

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

RestTemplate (Spring Framework) : Facilite l'exécution de requêtes HTTP, supporte la conversion d'objets en JSON/XML et inversement. Est considéré comme obsolète au profit de 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) : Client HTTP non bloquant (réactif), préféré dans les applications Spring modernes. Offre une meilleure évolutivité.

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); // Appel non bloquant
    }
}

Feign Client (Spring Cloud OpenFeign) : Client REST déclaratif. Permet de définir une interface, et Feign générera son implémentation pour effectuer des requêtes HTTP. Utilisé dans une architecture microservices avec Service Discovery.

Dépendance :

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

Annotation @EnableFeignClients sur la classe principale de l'application.

Interface du client :

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

@FeignClient(name = "other-service") // Nom du service dans Service Discovery
public interface OtherServiceClient {

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

Utilisation par le client :

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

Le choix de l'approche dépend des besoins de l'application :

HttpClient : pour des intégrations simples et basiques.
RestTemplate : pour des applications Spring MVC plus simples nécessitant un appel synchrone.
WebClient : pour des applications réactives où la performance et la non-blocabilité sont importantes.
Feign Client : pour des architectures microservices avec Service Discovery, où une approche déclarative et une abstraction des appels HTTP sont nécessaires.

Comment accéder à un autre service depuis une application Spring?