Comment utiliser RestTemplate pour appeler l'API RESTful

Comment utiliser RestTemplate pour appeler l'API RESTful ?

L'appel d'API RESTful est une tâche courante lors du développement d'applications Web. Pour appeler l'API RESTful, nous devons utiliser le protocole HTTP pour envoyer une requête à l'API et analyser la réponse renvoyée par l'API. Pour simplifier ce processus, vous pouvez utiliser la classe RestTemplate fournie par Spring Framework. Cet article explique comment utiliser RestTemplate pour appeler l'API RESTful et fournit un exemple de code.

Qu'est-ce que RestTemplate ?

RestTemplate est un outil fourni par Spring Framework pour appeler l'API RESTful. RestTemplate encapsule l'accès au protocole HTTP, peut envoyer des requêtes HTTP et analyser les réponses HTTP. RestTemplate prend en charge une variété de méthodes HTTP (telles que GET, POST, PUT, DELETE, etc.) et fournit une variété d'options (telles que des en-têtes de requête, des paramètres de requête, etc.) pour répondre à différents besoins. RestTemplate simplifie le processus d'appel des API RESTful, en évitant la complexité de la gestion manuelle du protocole HTTP.

Comment utiliser RestTemplate ?

Les étapes pour appeler l'API RESTful à l'aide de RestTemplate sont les suivantes :

1. Créer une instance RestTemplate

Tout d'abord, une instance RestTemplate doit être créée. Les instances RestTemplate peuvent être créées à l'aide de la configuration automatique de Spring Boot ou manuellement. Par exemple, voici un exemple de code qui crée manuellement une instance RestTemplate :

RestTemplate restTemplate = new RestTemplate();

Dans l'exemple de code ci-dessus, nous avons utilisé le constructeur par défaut pour créer l'instance RestTemplate. D'autres constructeurs peuvent également être utilisés pour configurer l'instance RestTemplate, comme la spécification de HttpClient, HttpMessageConverter, etc.

2. envoyer une requête HTTP

Utilisez RestTemplate pour envoyer des requêtes HTTP, vous pouvez appeler les méthodes de RestTemplate pour envoyer différents types de requêtes HTTP, telles que GET, POST, PUT, DELETE, etc. Par exemple, voici un exemple de code qui utilise RestTemplate pour envoyer une requête GET :

String url = "https://api.example.com/users/{id}";
Map<String, String> params = new HashMap<>();
params.put("id", "123");
User user = restTemplate.getForObject(url, User.class, params);

Dans l'exemple de code ci-dessus, nous utilisons la getForObjectméthode pour envoyer une requête GET et analyser la réponse dans un objet User. getForObjectLe premier paramètre de la méthode est l'URL demandée, qui peut contenir des espaces réservés (par exemple {id}), dont les valeurs peuvent être spécifiées dans le troisième paramètre. getForObjectLe deuxième paramètre de la méthode est le type de la réponse, qui peut être n'importe quel type Java, tel que String, Integer, List, Map, etc.

Vous pouvez utiliser d'autres méthodes de RestTemplate pour envoyer POST, PUT, DELETE et d'autres types de requêtes HTTP, par exemple :

• postForObject: envoie une requête POST et renvoie un objet de réponse.
• put: envoie une requête PUT et renvoie l'objet de réponse.
• delete: envoie une requête DELETE et renvoie l'objet de réponse.
• exchange: envoie tout type de requête HTTP et renvoie un objet de réponse.

Par exemple, voici un exemple de code qui utilise RestTemplate pour envoyer une requête POST :

String url = "https://api.example.com/users";
User user = new User("张三", 18);
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);
HttpEntity<User> requestEntity = new HttpEntity<>(user, headers);
User createdUser = restTemplate.postForObject(url, requestEntity, User.class);

Dans l'exemple de code ci-dessus, nous utilisons postForObjectla méthode pour envoyer la requête POST et définir le corps de la requête en tant qu'objet utilisateur. Afin de définir le type de corps de requête, nous devons créer un objet HttpEntity et définir l'objet User et l'en-tête de requête comme propriétés de HttpEntity.

3. Gérer les réponses HTTP

Après avoir envoyé une requête HTTP à l'aide de RestTemplate, vous pouvez utiliser les méthodes de RestTemplate pour traiter la réponse HTTP. Par exemple, vous pouvez utiliser getForObjectla méthode pour analyser la réponse dans un objet ou exchangela méthode pour obtenir la réponse HTTP complète. Par exemple, voici un exemple de code qui utilise un RestTemplate pour gérer une réponse à une requête GET :

String url = "https://api.example.com/users/{id}";
Map<String, String> params = new HashMap<>();
params.put("id", "123");
ResponseEntity<User> responseEntity = restTemplate.getForEntity(url, User.class, params);
HttpStatus statusCode = responseEntity.getStatusCode();
User user =responseEntity.getBody();

Dans l'exemple de code ci-dessus, nous utilisons getForEntityla méthode pour envoyer une requête GET et obtenir la réponse HTTP complète. getForEntityLa valeur de retour de la méthode est un ResponseEntityobjet , qui contient le code d'état, l'en-tête de réponse et le corps de la réponse HTTP. Nous pouvons utiliser getStatusCodela méthode pour obtenir le code d'état de la réponse HTTP, utiliser getBodyla méthode pour obtenir le corps de la réponse et l'analyser dans un objet User.

En plus de getForEntityla méthode , des méthodes telles que postForEntity, put, delete, exchangeetc. peuvent également être utilisées pour traiter les réponses HTTP.

4. la gestion des erreurs

Lors de l'utilisation de RestTemplate pour appeler l'API RESTful, certaines erreurs peuvent se produire, telles qu'une erreur réseau, une erreur HTTP, etc. Pour gérer ces erreurs, vous pouvez utiliser des blocs try-catch ou utiliser le mécanisme de gestion des exceptions fourni par Spring Framework. Par exemple, voici un exemple de code qui utilise un bloc try-catch pour gérer les erreurs HTTP :

String url = "https://api.example.com/users/{id}";
Map<String, String> params = new HashMap<>();
params.put("id", "123");
try {
    
    
    User user = restTemplate.getForObject(url, User.class, params);
} catch (HttpClientErrorException e) {
    
    
    HttpStatus statusCode = e.getStatusCode();
    String responseBody = e.getResponseBodyAsString();
    // 处理 HTTP 错误
} catch (RestClientException e) {
    
    
    // 处理其它错误
}

Dans l'exemple de code ci-dessus, nous avons utilisé un bloc try-catch pour gérer les erreurs HTTP. Si une erreur HTTP se produit, HttpClientErrorExceptionune exception getStatusCodeet les getResponseBodyAsStringméthodes peuvent être utilisées pour obtenir le code d'état et le corps de la réponse HTTP.

exemple de code

Voici un exemple de code complet qui montre comment utiliser RestTemplate pour appeler l'API RESTful :

import org.springframework.http.*;
import org.springframework.web.client.RestTemplate;

import java.util.HashMap;
import java.util.Map;

public class RestTemplateDemo {
    
    
    public static void main(String[] args) {
    
    
        RestTemplate restTemplate = new RestTemplate();

        // 发送 GET 请求
        String url = "https://api.example.com/users/{id}";
        Map<String, String> params = new HashMap<>();
        params.put("id", "123");
        User user = restTemplate.getForObject(url, User.class, params);
        System.out.println(user);

        // 发送 POST 请求
        url = "https://api.example.com/users";
        User newUser = new User("张三", 18);
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        HttpEntity<User> requestEntity = new HttpEntity<>(newUser, headers);
        User createdUser = restTemplate.postForObject(url, requestEntity, User.class);
        System.out.println(createdUser);

        // 处理 HTTP 响应
        url = "https://api.example.com/users/{id}";
        params = new HashMap<>();
        params.put("id", "123");
        ResponseEntity<User> responseEntity = restTemplate.getForEntity(url, User.class, params);
        HttpStatus statusCode = responseEntity.getStatusCode();
        User retrievedUser = responseEntity.getBody();
        System.out.println(statusCode);
        System.out.println(retrievedUser);

        // 错误处理
        url = "https://api.example.com/nonexistent";
        try {
    
    
            String result = restTemplate.getForObject(url, String.class);
            System.out.println(result);
        } catch (HttpClientErrorException e) {
    
    
            HttpStatus errorStatus = e.getStatusCode();
            String errorBody = e.getResponseBodyAsString();
            System.out.println(errorStatus);
            System.out.println(errorBody);
        } catch (RestClientException e) {
    
    
            e.printStackTrace();
        }
    }

    static class User {
    
    
        private String name;
        private int age;

        public User(String name, int age) {
    
    
            this.name = name;
            this.age = age;
        }

        public String getName() {
    
    
            return name;
        }

        public void setName(String name) {
    
    
            this.name = name;
        }

        public int getAge() {
    
    
            return age;
        }

        public void setAge(int age) {
    
    
            this.age = age;
        }

        @Override
        public String toString() {
    
    
            return "User{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
}

Dans l'exemple de code ci-dessus, nous avons d'abord créé une instance RestTemplate, puis montré comment utiliser RestTemplate pour envoyer des requêtes GET, des requêtes POST et gérer les réponses et les erreurs HTTP.

## Configuration de RestTemplate

Lorsque vous utilisez RestTemplate pour appeler l'API RESTful, vous pouvez configurer l'instance RestTemplate pour répondre à différentes exigences. Par exemple, les fabriques de requêtes, les intercepteurs, les convertisseurs de messages, etc. de RestTemplate peuvent être configurés. Ce qui suit présente plusieurs méthodes de configuration RestTemplate couramment utilisées.

configurer la fabrique de requêtes

RestTemplate utilise l'interface ClientHttpRequestFactory pour créer des requêtes HTTP. Par défaut, RestTemplate utilise l'implémentation de SimpleClientHttpRequestFactory pour créer des requêtes HTTP, et vous pouvez contrôler le comportement des requêtes HTTP en définissant des paramètres tels que le délai de connexion et le délai de lecture. Si vous avez besoin de fonctionnalités plus avancées, telles que le regroupement de connexions, la prise en charge SSL, etc., vous pouvez utiliser d'autres classes d'implémentation pour remplacer l'implémentation SimpleClientHttpRequestFactory.

Voici un exemple de code qui montre comment remplacer l'implémentation par défaut de SimpleClientHttpRequestFactory par HttpComponentsClientHttpRequestFactory :

CloseableHttpClient httpClient = HttpClients.custom()
        .setDefaultRequestConfig(RequestConfig.custom()
                .setConnectTimeout(5000)
                .setSocketTimeout(5000)
                .build())
        .build();
HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(httpClient);
RestTemplate restTemplate = new RestTemplate(requestFactory);

Dans l'exemple de code ci-dessus, nous créons d'abord une fabrique de requêtes à l'aide de la classe HttpComponentsClientHttpRequestFactory, puis nous la transmettons au constructeur RestTemplate. La classe HttpComponentsClientHttpRequestFactory est implémentée à l'aide de la bibliothèque Apache HttpComponents et prend en charge des fonctionnalités avancées telles que le regroupement de connexions et la prise en charge SSL.

Configurer les intercepteurs

RestTemplate prend en charge l'ajout d'intercepteurs pour gérer les requêtes HTTP. Les intercepteurs peuvent traiter avant d'envoyer des requêtes HTTP et après avoir reçu des réponses HTTP, telles que l'ajout d'en-têtes de requête, l'enregistrement de journaux de requêtes, etc.

Voici un exemple de code qui montre comment ajouter un intercepteur de requête à l'aide de l'interface ClientHttpRequestInterceptor :

RestTemplate restTemplate = new RestTemplate();
restTemplate.setInterceptors(Collections.singletonList((request, body, execution) -> {
    
    
    request.getHeaders().add("Authorization", "Bearer token");
    return execution.execute(request, body);
}));

Dans l'exemple de code ci-dessus, nous avons ajouté un intercepteur de requête, qui ajoutera un en-tête de requête d'autorisation avant d'envoyer la requête HTTP, la valeur est Bearer token.

Configurer le convertisseur de message

RestTemplate utilise l'interface HttpMessageConverter pour gérer les messages de requête et de réponse HTTP. Par défaut, RestTemplate fournit plusieurs convertisseurs de messages intégrés, tels que StringHttpMessageConverter, MappingJackson2HttpMessageConverter, etc. Si vous devez prendre en charge d'autres types de messages, tels que XML, Protobuf, etc., vous pouvez ajouter des convertisseurs de messages personnalisés.

Voici un exemple de code qui montre comment ajouter un convertisseur de message personnalisé :

RestTemplate restTemplate = new RestTemplate();
restTemplate.setMessageConverters(Collections.singletonList(new MyHttpMessageConverter()));

Dans l'exemple de code ci-dessus, nous avons ajouté un convertisseur de message personnalisé MyHttpMessageConverter, qui implémente l'interface HttpMessageConverter, qui peut convertir des types de message personnalisés en messages de requête et de réponse HTTP.

Résumer

L'utilisation de RestTemplate pour appeler une API RESTful est une tâche courante, et la classe RestTemplate fournie par Spring Framework peut être utilisée pour simplifier ce processus. RestTemplate encapsule l'accès au protocole HTTP, peut envoyer des requêtes HTTP et analyser les réponses HTTP, et prend en charge plusieurs méthodes et options HTTP. Les étapes d'utilisation de RestTemplate incluent la création d'une instance RestTemplate, l'envoi de requêtes HTTP, le traitement des réponses HTTP et la gestion des erreurs. RestTemplate prend également en charge diverses options de configuration, telles que la configuration des fabriques de requêtes, des intercepteurs et des convertisseurs de messages, etc. L'utilisation de RestTemplate peut simplifier le processus d'appel de l'API RESTful et améliorer l'efficacité du développement.