TOC

Obtenir et publier des listes d’objets avec RestTemplate

Obtenir et publier des listes d'objets avec RestTemplate

1. introduction

La classeRestTemplate est l'outil central pour effectuer des opérations HTTP côté client dans Spring. Il fournit plusieurs méthodes utilitaires pour créer des requêtes HTTP et gérer les réponses.

Et, commeRestTemplate s'intègre bien avecJackson,, il peut sérialiser / désérialiser la plupart des objets vers et depuis JSON sans trop d'effort. Cependant,working with collections of objects is not so straightforward.

Dans ce didacticiel, nous allons voir comment utiliserRestTemplate à la fois pourGET etPOST une liste d'objets.

Lectures complémentaires:

Traitement des erreurs Spring RestTemplate

Apprenez à gérer les erreurs avec le RestTemplate de Spring

Read more →

RestTemplate Post Request avec JSON

Découvrez comment utiliser RestTemplate de Spring pour envoyer des demandes avec du contenu JSON.

Read more →

2. Exemple de service

Nous utiliserons une API d'employé dotée de deux points de terminaison HTTP: obtenez tout et créez:

  • GET / employés

  • POST / employés

Pour la communication entre le client et le serveur, nous utiliserons un DTO simple pour encapsuler les données de base des employés: 

public class Employee {
    public long id;
    public String title;

    // standard constructor and setters/getters
}

Nous sommes maintenant prêts à écrire du code qui utiliseRestTemplate pour obtenir et créer des listes d’objetsEmployee.

3. Obtenir une liste d'objets avecRestTemplate

Normalement, lors de l'appel de GET, vous pouvez utiliser l'une des méthodes simplifiées deRestTemplate, comme:

getForObject (url URI, classe responseType)

Cela envoie une demande à l'URI spécifié à l'aide du verbe GET et convertit le corps de la réponse en type Java demandé. Cela fonctionne très bien pour la plupart des classes, mais il a une limitation:we cannot send lists of objects.

Le problème est dû à l’effacement des types avec les génériques Java. Lorsque l'application est en cours d'exécution, elle ne sait pas quel type d'objet se trouve dans la liste. This means the data in the list cannot be deserialized into the appropriate type.

Heureusement, nous avons deux options pour contourner ce problème.

3.1. Utiliser des tableaux

Tout d'abord, nous pouvons utiliserRestTemplate.getForObject() pour GET un tableau d'objets via le paramètreresponseType. Quel que soit leclass que nous spécifions, il correspondra au type de paramètre deResponseEntity: 

ResponseEntity response =
  restTemplate.getForEntity(
  "http://localhost:8080/employees/",
  Employee[].class);
Employee[] employees = response.getBody();

De plus, nous aurions pu utiliserRestTemplate.exchange pour obtenir le même résultat.

Notez que le collaborateur qui fait le gros du travail ici estResponseExtractor,  donc si nous avons besoin d'une personnalisation supplémentaire, nous pouvons appelerexecute et fournir notre propre instance.

3.2. Utiliser une classe wrapper

Certaines API renverront un objet de niveau supérieur contenant la liste des employés au lieu de la renvoyer directement. Pour gérer cette situation, nous pouvons utiliser une classe wrapper contenant la liste des employés. 

public class EmployeeList {
    private List employees;

    public EmployeeList() {
        employees = new ArrayList<>();
    }

    // standard constructor and getter/setter
}

Nous pouvons maintenant utiliser la méthode plus simplegetForObject() pour obtenir la liste des employés: 

EmployeeList response = restTemplate.getForObject(
  "http://localhost:8080/employees",
  EmployeeList.class);
List employees = response.getEmployees();

Ce code est beaucoup plus simple mais nécessite un objet wrapper supplémentaire.

4. Publier une liste d'objets avecRestTemplate

Voyons maintenant comment envoyer une liste d'objets de notre client au serveur. Tout comme ci-dessus,RestTemplate fournit une méthode simplifiée pour appeler POST:

postForObject (URL URI, demande d'objet, classe responseType)

Cela envoie un HTTP POST à ​​l'URI donné, avec le corps de requête facultatif, et convertit la réponse dans le type spécifié. Contrairement au scénario GET ci-dessus,we don’t have to worry about type erasure.

En effet, nous passons maintenant des objets Java à JSON. La liste des objets et leur type sont connus de la machine virtuelle Java et sont donc correctement sérialisés: 

List newEmployees = new ArrayList<>();
newEmployees.add(new Employee(3, "Intern"));
newEmployees.add(new Employee(4, "CEO"));

restTemplate.postForObject(
  "http://localhost:8080/employees/",
  newEmployees,
  ResponseEntity.class);

4.1. Utiliser une classe wrapper

Si nous devons utiliser une classe wrapper pour être cohérent avec le scénario GET ci-dessus, c'est aussi simple. Nous pouvons envoyer une nouvelle liste en utilisantRestTemplate: 

List newEmployees = new ArrayList<>();
newEmployees.add(new Employee(3, "Intern"));
newEmployees.add(new Employee(4, "CEO"));

restTemplate.postForObject(
  "http://localhost:8080/employees",
  new EmployeeList(newEmployees),
  ResponseEntity.class);

5. Conclusion

Utiliser RestTemplate est un moyen simple de créer des clients HTTP pour communiquer avec vos services.

Il fournit un certain nombre de méthodes pour travailler avec chaque méthode HTTP et des objets simples. Avec un peu de code supplémentaire, nous pouvons facilement l'utiliser pour travailler avec des listes d'objets.

Comme d'habitude, le code complet est disponible dans lesGithub project.

Related