web-dev-qa-db-fra.com

RestTemplate: exchange () vs postForEntity () vs execute ()

Je travaille sur Rest API en utilisant Spring Boot et je devais accéder au point de terminaison d'une application. J'ai utilisé RestTemplate pour cela. J'ai été capable de le faire en utilisant 2 méthodes,

  • postForEntity():

    responseEntity = 
    restTemplate.postForEntity(uri, httpEntity, ResponseClass.class);

  • exchange():

    responseEntity = 
    restTemplate.exchange(uri, HttpMethod.POST, httpEntity, ResponseClass.class);

J'aimerais connaître l'usage et les différences de ces deux méthodes.

Je vois aussi une autre méthode execute(). S'il vous plaît faire la lumière sur elle. Comment et quand l'utiliser.

javaspring-bootresttemplate
8
Praveen Kumar

Le RestTemplate est un objet très polyvalent.

Commençons par execute, puisqu'il s'agit de la méthode la plus générique:

execute(String url, HttpMethod method, @Nullable RequestCallback requestCallback,
        @Nullable ResponseExtractor<T> responseExtractor, Object... uriVariables)

Notez que uriVariables peut également être passé en tant que Map.

execute est conçu pour être applicable dans la plus grande variété de scénarios possible:

  • Les premier et deuxième paramètres permettent toute combinaison valide d'URL et de méthode.
  • La demande peut être modifiée de multiples façons en transmettant un RequestCallback personnalisé (un @FunctionalInterface Avec une seule méthode doWithRequest(ClientHttpRequest request)) avant de l'envoyer.
  • La réponse renvoyée par la ressource distante peut être désérialisée de la manière nécessaire en transmettant un ResponseExtractor personnalisé.

Comparez ceci avec exchange:

exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity,
         Class<T> responseType, Object... uriVariables)

Il y a deux différences majeures ici:

  • Vous pouvez maintenant passer un HttpEntity directement, alors qu'avant, il devait être défini manuellement à l'aide de RequestCallback.
  • Les mécanismes de désérialisation sont fournis immédiatement en passant le type de réponse souhaité Class.

Comme vous pouvez le constater, cela est beaucoup plus pratique pour une utilisation quotidienne.

Des méthodes telles que getForEntity et postForEntity sont encore plus courtes et plus faciles à comprendre:

getForEntity(String url, Class<T> responseType, Object... uriVariables)

postForEntity(String url, @Nullable Object request, Class<T> responseType,
              Object... uriVariables)

Avis postForEntity vous permet maintenant de POST toute Object directement sans encapsuleur. Il n'y a aucun avantage en termes de performances ni aucun inconvénient à les utiliser au lieu de execute, comme ils s'appellent execute eux-mêmes sous le capot - c'est simplement une question de commodité.

16
Paul Benn

RestTemplate est un client synchrone pour exécuter des requêtes HTTP. Il propose des modèles pour des scénarios courants pour chaque méthode HTTP, en plus des méthodes généralisées exchange(...) et execute(...) qui prennent en charge les cas moins fréquents.

La documentation d'intégration Spring résume l'utilisation de chaque méthode:

postForEntity

Créez une nouvelle ressource via POST et renvoyez la représentation à partir de la réponse.

exchange

Version plus généralisée et moins éclairée des méthodes ci-dessus, offrant une flexibilité supplémentaire en cas de besoin. Il accepte RequestEntity, y compris la méthode HTTP, l'URL, les en-têtes et le corps, et renvoie un ResponseEntity.

Ces méthodes permettent d'utiliser ParameterizedTypeReference à la place de Class pour spécifier un type de réponse avec des génériques.

execute

La manière la plus générale de traiter une requête, avec un contrôle total sur la préparation de la requête et l'extraction de la réponse via des interfaces de rappel.

Finalement, les deux méthodes postForEntity(...), exchange(...) et execute(...) invoqueront la méthode protégée doExecute(...) , qui effectuera la requête HTTP réelle. Vous pouvez vérifier le code source pour plus de détails

5
cassiomolin

Si vous regardez l’implémentation de postForEntity et de la méthode d’échange, vous verrez qu’elles utilisent toutes deux les méthodes execute à l’arrière. L'utilisation de la méthode d'échange vous donnera plus de liberté pour appeler différentes méthodes http.

0
ksadjad