Formations — 1 037 leçons en français

Accueil › Spring Boot › Appeler une API avec RestClient

Appeler une API avec RestClient

Appeler et documenter des APIintermediaire

RestClient est le client HTTP synchrone de Spring, introduit en Spring Framework 6.1 (Spring Boot 3.2). Il reprend l'API fluide de WebClient mais reste bloquant : pas de dépendance à spring-webflux. C'est le choix par défaut pour appeler une API depuis une application Spring MVC classique.

Spring Boot auto-configure un bean RestClient.Builder : il suffit de l'injecter.

@Service
public class ProduitApiClient {
    private final RestClient restClient;

    public ProduitApiClient(RestClient.Builder builder) {
        this.restClient = builder.baseUrl("https://api.exemple.com").build();
    }

    public Produit trouver(Long id) {
        return restClient.get()
                .uri("/produits/{id}", id)
                .retrieve()
                .body(Produit.class);
    }
}

retrieve() déclenche l'appel. .body(Produit.class) désérialise directement le JSON. Pour une liste, la simple Class ne suffit pas (effacement de type) : on utilise ParameterizedTypeReference<List<Produit>>.

Pour un POST avec un corps JSON :

Produit cree = restClient.post()
        .uri("/produits")
        .contentType(MediaType.APPLICATION_JSON)
        .body(nouveauProduit)
        .retrieve()
        .body(Produit.class);

Par défaut, une réponse 4xx ou 5xx lève une exception (HttpClientErrorException / HttpServerErrorException) : pas besoin de vérifier le statut à la main.

Les termes à connaître

RestClient

Client HTTP synchrone introduit dans Spring Framework 6.1 (Spring Boot 3.2). Il propose une API fluide inspirée de WebClient, mais bloquante : pas besoin de Project Reactor ni de spring-webflux.

RestClient.Builder

Bean auto-configuré par Spring Boot (depuis 3.2) : il suffit de l'injecter et d'appeler .build() pour obtenir un RestClient déjà relié aux convertisseurs JSON de l'application. Il est fourni en scope prototype : chaque injection reçoit une nouvelle instance de builder, pour éviter qu'une personnalisation (URL de base, en-têtes) faite à un endroit ne se propage ailleurs.

retrieve()

Déclenche l'appel HTTP et donne accès à la réponse : .body(Class) pour récupérer directement le corps désérialisé, ou .toEntity(Class) pour obtenir un ResponseEntity complet (statut, en-têtes, corps).

ParameterizedTypeReference

Permet de décrire un type générique (ex. List<Produit>) là où une simple Class ne le peut pas, à cause de l'effacement de type (type erasure) en Java : new ParameterizedTypeReference<List<Produit>>() {}.

HttpClientErrorException / HttpServerErrorException

Exceptions levées par défaut par retrieve() quand la réponse a un code 4xx ou 5xx : HttpClientErrorException pour les erreurs client, HttpServerErrorException pour les erreurs serveur. Toutes deux héritent de RestClientResponseException, qui donne accès au statut et au corps de la réponse d'erreur.

onStatus

Méthode de retrieve() pour personnaliser la réaction à un statut donné, par exemple transformer une erreur 404 en exception métier plutôt que de laisser passer l'exception par défaut.

@HttpExchange

Annotation qui permet de décrire un client HTTP comme une simple interface (@GetExchange, @PostExchange…), sans écrire l'appel à la main. Spring génère l'implémentation via un HttpServiceProxyFactory adossé à un RestClient (ou un WebClient).

RestTemplate / WebClient

RestTemplate est l'ancien client HTTP synchrone de Spring, en mode maintenance depuis Spring 5 : il continue de fonctionner mais ne reçoit plus de nouvelles fonctionnalités. WebClient est le client réactif (non bloquant, basé sur Project Reactor), utile dans une chaîne d'appels réactive ou à haute concurrence.

Lire l'explication détaillée et faire le quiz →

Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.