Le guide de RestTemplate

1. Vue d'ensemble

Dans ce didacticiel, nous allons illustrer le large éventail d'opérations où le client Spring REST - RestTemplate - peut être utilisé et bien utilisé.

Pour le côté API de tous les exemples, nous exécuterons le service RESTful à partir d'ici.

2. Avis de dépréciation

À partir de Spring Framework 5, parallèlement à la pile WebFlux, Spring a introduit un nouveau client HTTP appelé WebClient .

WebClient est un client HTTP moderne et alternatif à RestTemplate . Non seulement il fournit une API synchrone traditionnelle, mais il prend également en charge une approche non bloquante et asynchrone efficace.

Cela dit, si nous développons de nouvelles applications ou migrons une ancienne, c'est une bonne idée d'utiliser WebClient . À l'avenir, RestTemplate sera obsolète dans les versions futures.

3. Utilisez GET pour récupérer des ressources

3.1. Obtenez du JSON simple

Commençons simplement et parlons des requêtes GET, avec un exemple rapide utilisant l' API getForEntity () :

RestTemplate restTemplate = new RestTemplate(); String fooResourceUrl = "//localhost:8080/spring-rest/foos"; ResponseEntity response = restTemplate.getForEntity(fooResourceUrl + "/1", String.class); assertThat(response.getStatusCode(), equalTo(HttpStatus.OK));

Notez que nous avons un accès complet à la réponse HTTP , nous pouvons donc faire des choses comme vérifier le code d'état pour nous assurer que l'opération a réussi ou travailler avec le corps réel de la réponse:

ObjectMapper mapper = new ObjectMapper(); JsonNode root = mapper.readTree(response.getBody()); JsonNode name = root.path("name"); assertThat(name.asText(), notNullValue());

Nous travaillons ici avec le corps de la réponse en tant que chaîne standard et en utilisant Jackson (et la structure de nœud JSON fournie par Jackson) pour vérifier certains détails.

3.2. Récupération de POJO au lieu de JSON

Nous pouvons également mapper la réponse directement à un DTO de ressources:

public class Foo implements Serializable { private long id; private String name; // standard getters and setters }

Maintenant, nous pouvons simplement utiliser l' API getForObject dans le modèle:

Foo foo = restTemplate .getForObject(fooResourceUrl + "/1", Foo.class); assertThat(foo.getName(), notNullValue()); assertThat(foo.getId(), is(1L));

4. Utilisez HEAD pour récupérer les en-têtes

Jetons maintenant un coup d'œil à l'utilisation de HEAD avant de passer aux méthodes les plus courantes.

Nous allons utiliser l' API headForHeaders () ici:

HttpHeaders httpHeaders = restTemplate.headForHeaders(fooResourceUrl); assertTrue(httpHeaders.getContentType().includes(MediaType.APPLICATION_JSON));

5. Utilisez POST pour créer une ressource

Afin de créer une nouvelle ressource dans l'API, nous pouvons faire bon usage des API postForLocation () , postForObject () ou postForEntity () .

Le premier renvoie l'URI de la ressource nouvellement créée, tandis que le second renvoie la ressource elle-même.

5.1. L' API postForObject ()

RestTemplate restTemplate = new RestTemplate(); HttpEntity request = new HttpEntity(new Foo("bar")); Foo foo = restTemplate.postForObject(fooResourceUrl, request, Foo.class); assertThat(foo, notNullValue()); assertThat(foo.getName(), is("bar"));

5.2. L' API postForLocation ()

De même, examinons l'opération qui, au lieu de renvoyer la ressource complète, renvoie simplement l' emplacement de cette ressource nouvellement créée:

HttpEntity request = new HttpEntity(new Foo("bar")); URI location = restTemplate .postForLocation(fooResourceUrl, request); assertThat(location, notNullValue());

5.3. L' API exchange ()

Voyons comment faire un POST avec l' API d' échange plus générique :

RestTemplate restTemplate = new RestTemplate(); HttpEntity request = new HttpEntity(new Foo("bar")); ResponseEntity response = restTemplate .exchange(fooResourceUrl, HttpMethod.POST, request, Foo.class); assertThat(response.getStatusCode(), is(HttpStatus.CREATED)); Foo foo = response.getBody(); assertThat(foo, notNullValue()); assertThat(foo.getName(), is("bar")); 

5.4. Soumettre les données du formulaire

Voyons ensuite comment soumettre un formulaire à l'aide de la méthode POST.

Tout d'abord, nous devons définir l'en - tête Content-Type sur application / x-www-form-urlencoded.

Cela garantit qu'une grande chaîne de requête peut être envoyée au serveur, contenant des paires nom / valeur séparées par & :

HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);

Nous pouvons envelopper les variables de formulaire dans un LinkedMultiValueMap :

MultiValueMap map= new LinkedMultiValueMap(); map.add("id", "1");

Ensuite, nous construisons la requête en utilisant une instance HttpEntity :

HttpEntity
    
      request = new HttpEntity(map, headers);
    

Enfin, nous pouvons nous connecter au service REST en appelant restTemplate.postForEntity () sur le point de terminaison: / foos / form

ResponseEntity response = restTemplate.postForEntity( fooResourceUrl+"/form", request , String.class); assertThat(response.getStatusCode(), is(HttpStatus.CREATED));

6. Utilisez OPTIONS pour obtenir les opérations autorisées

Ensuite, nous allons jeter un coup d'œil sur l'utilisation d'une requête OPTIONS et explorer les opérations autorisées sur un URI spécifique en utilisant ce type de requête; l'API est optionsForAllow :

Set optionsForAllow = restTemplate.optionsForAllow(fooResourceUrl); HttpMethod[] supportedMethods = {HttpMethod.GET, HttpMethod.POST, HttpMethod.PUT, HttpMethod.DELETE}; assertTrue(optionsForAllow.containsAll(Arrays.asList(supportedMethods)));

7. Utilisez PUT pour mettre à jour une ressource

Next, we'll start looking at PUT and more specifically the exchange() API for this operation, since the template.put API is pretty straightforward.

7.1. Simple PUT With exchange()

We'll start with a simple PUT operation against the API — and keep in mind that the operation isn't returning a body back to the client:

Foo updatedInstance = new Foo("newName"); updatedInstance.setId(createResponse.getBody().getId()); String resourceUrl = fooResourceUrl + '/' + createResponse.getBody().getId(); HttpEntity requestUpdate = new HttpEntity(updatedInstance, headers); template.exchange(resourceUrl, HttpMethod.PUT, requestUpdate, Void.class);

7.2. PUT With exchange() and a Request Callback

Next, we're going to be using a request callback to issue a PUT.

Let's make sure we prepare the callback, where we can set all the headers we need as well as a request body:

RequestCallback requestCallback(final Foo updatedInstance) { return clientHttpRequest -> { ObjectMapper mapper = new ObjectMapper(); mapper.writeValue(clientHttpRequest.getBody(), updatedInstance); clientHttpRequest.getHeaders().add( HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE); clientHttpRequest.getHeaders().add( HttpHeaders.AUTHORIZATION, "Basic " + getBase64EncodedLogPass()); }; }

Next, we create the Resource with a POST request:

ResponseEntity response = restTemplate .exchange(fooResourceUrl, HttpMethod.POST, request, Foo.class); assertThat(response.getStatusCode(), is(HttpStatus.CREATED));

And then we update the Resource:

Foo updatedInstance = new Foo("newName"); updatedInstance.setId(response.getBody().getId()); String resourceUrl =fooResourceUrl + '/' + response.getBody().getId(); restTemplate.execute( resourceUrl, HttpMethod.PUT, requestCallback(updatedInstance), clientHttpResponse -> null);

8. Use DELETE to Remove a Resource

Pour supprimer une ressource existante, nous utiliserons rapidement l' API delete () :

String entityUrl = fooResourceUrl + "/" + existingResource.getId(); restTemplate.delete(entityUrl); 

9. Configurer le délai d'expiration

Nous pouvons configurer RestTemplate pour qu'il expire en utilisant simplement ClientHttpRequestFactory :

RestTemplate restTemplate = new RestTemplate(getClientHttpRequestFactory()); private ClientHttpRequestFactory getClientHttpRequestFactory() { int timeout = 5000; HttpComponentsClientHttpRequestFactory clientHttpRequestFactory = new HttpComponentsClientHttpRequestFactory(); clientHttpRequestFactory.setConnectTimeout(timeout); return clientHttpRequestFactory; }

Et nous pouvons utiliser HttpClient pour d'autres options de configuration:

private ClientHttpRequestFactory getClientHttpRequestFactory() { int timeout = 5000; RequestConfig config = RequestConfig.custom() .setConnectTimeout(timeout) .setConnectionRequestTimeout(timeout) .setSocketTimeout(timeout) .build(); CloseableHttpClient client = HttpClientBuilder .create() .setDefaultRequestConfig(config) .build(); return new HttpComponentsClientHttpRequestFactory(client); }

10. Conclusion

Dans cet article, nous avons passé en revue les principaux verbes HTTP, en utilisant RestTemplate pour orchestrer les requêtes en utilisant tous ces éléments.

Si vous souhaitez découvrir comment faire l'authentification avec le modèle, consultez notre article sur l'authentification de base avec RestTemplate.

L'implémentation de tous ces exemples et extraits de code peut être trouvée sur GitHub.