Obtenir et publier des listes d'objets avec RestTemplate

1. Introduction

La classe RestTemplate 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, comme RestTemplate s'intègre bien à Jackson, il peut sérialiser / désérialiser la plupart des objets vers et depuis JSON sans trop d'effort. Cependant, travailler avec des collections d'objets n'est pas si simple .

Dans ce didacticiel, nous verrons comment utiliser RestTemplate pour GET et POST une liste d'objets.

2. Exemple de service

Nous utiliserons une API pour les employés qui a deux points de terminaison HTTP - obtenir tout et créer:

  • 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 utilise RestTemplate pour obtenir et créer des listes d' objets Employee .

3. Obtenez une liste d'objets avec RestTemplate

Normalement, lors de l'appel de GET, vous pouvez utiliser l'une des méthodes simplifiées de RestTemplate , telles que :

getForObject (URL URI, classe responseType)

Cela envoie une requête à l'URI spécifié à l'aide du verbe GET et convertit le corps de la réponse dans le type Java demandé. Cela fonctionne très bien pour la plupart des classes, mais cela a une limitation: nous ne pouvons pas envoyer de listes d'objets.

Le problème est dû à l'effacement de type 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. Cela signifie que les données de la liste ne peuvent pas être désérialisées dans le type approprié.

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

3.1. Utilisation de tableaux

Tout d'abord, nous pouvons utiliser RestTemplate. getForEntity () pour OBTENIR un tableau d'objets via le paramètre responseType . Quelle que soit la classe que nous spécifions, il correspondra au type de paramètre de ResponseEntity :

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

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

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

3.2. Utilisation d'une classe wrapper

Certaines API renverront un objet de niveau supérieur contenant la liste des employés au lieu de renvoyer directement la liste. Pour gérer cette situation, nous pouvons utiliser une classe wrapper qui contient 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 simple getForObject () pour obtenir la liste des employés:

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

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

4. Publiez une liste d'objets avec RestTemplate

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, nous n'avons pas à nous soucier de l'effacement des types .

C'est parce que nous passons maintenant des objets Java à JSON. La liste des objets et leur type sont connus de la JVM, et donc correctement sérialisés:

List newEmployees = new ArrayList(); newEmployees.add(new Employee(3, "Intern")); newEmployees.add(new Employee(4, "CEO")); restTemplate.postForObject( "//localhost:8080/employees/", newEmployees, ResponseEntity.class);

4.1. Utilisation d'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 utilisant RestTemplate :

List newEmployees = new ArrayList(); newEmployees.add(new Employee(3, "Intern")); newEmployees.add(new Employee(4, "CEO")); restTemplate.postForObject( "//localhost:8080/employees", new EmployeeList(newEmployees), ResponseEntity.class);

5. Conclusion

L'utilisation de 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 le projet Github.