TOC

Utilisation de l’intercepteur Spring RestTemplate

Utilisation de l'intercepteur Spring RestTemplate

1. Vue d'ensemble

Dans ce didacticiel, nous allons apprendre à implémenter un lien Spring: / rest-template Interceptor.

Nous allons passer par un exemple dans lequel nous allons créer un intercepteur qui ajoute un en-tête personnalisé à la réponse.

2. Scénarios d'utilisation d'intercepteurs

Outre la modification de l'en-tête, certains des autres cas d'utilisation où un intercepteurRestTemplate est utile sont:

  • Enregistrement des demandes et des réponses

  • Réessayer les demandes avec une stratégie de retrait configurable

  • Demande refusée en fonction de certains paramètres de demande

  • Modification de l'adresse URL de la demande

3. Création de l'intercepteur

Dans la plupart des paradigmes de programmation, le framework Spring deinterceptors are an essential part that enables programmers to control the execution by intercepting it. prend également en charge une variété d'intercepteurs à des fins différentes.

SpringRestTemplate nous permet d'ajouter des intercepteurs qui implémentent l'interfaceClientHttpRequestInterceptor. La méthodeintercept(HttpRequest, byte[], ClientHttpRequestExecution) de cette interface interceptera la requête donnée et retournera la réponse en nous donnant accès aux objetsrequest,body etexecution.

Nous allons utiliser l'argumentClientHttpRequestExecution pour effectuer l'exécution proprement dite et transmettre la requête à la chaîne de processus suivante.

Dans un premier temps, créons une classe d'intercepteur qui implémente l'interfaceClientHttpRequestInterceptor: 

public class RestTemplateHeaderModifierInterceptor
  implements ClientHttpRequestInterceptor {

    @Override
    public ClientHttpResponse intercept(
      HttpRequest request,
      byte[] body,
      ClientHttpRequestExecution execution) throws IOException {

        ClientHttpResponse response = execution.execute(request, body);
        response.getHeaders().add("Foo", "bar");
        return response;
    }
}

Our interceptor will be invoked for every incoming request, et il ajoutera un en-tête personnaliséFoo à chaque réponse, une fois l'exécution terminée et retournée.

Étant donné que la méthodeintercept() incluait lesrequest etbody en tant qu'arguments, il est également possible de faire n'importe quelle modification sur la demande ou même de refuser l'exécution de la demande en fonction de certaines conditions.

4. Configuration desRestTemplate

Maintenant que nous avons créé notre intercepteur, créons le beanRestTemplate et ajoutons-y notre intercepteur: 

@Configuration
public class RestClientConfig {

    @Bean
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate();

        List interceptors
          = restTemplate.getInterceptors();
        if (CollectionUtils.isEmpty(interceptors)) {
            interceptors = new ArrayList<>();
        }
        interceptors.add(new RestTemplateHeaderModifierInterceptor());
        restTemplate.setInterceptors(interceptors);
        return restTemplate;
    }
}

Dans certains cas, il peut y avoir des intercepteurs déjà ajoutés à l'objetRestTemplate. Donc, pour s'assurer que tout fonctionne comme prévu, notre code initialisera la liste des intercepteurs uniquement si elle est vide.

Comme notre code le montre, nous utilisons le constructeur par défaut pour créer l'objetRestTemplate, mais il existe certains scénarios dans lesquels nous devons lire le flux de demande / réponse deux fois.

Par exemple, si nous voulons que notre intercepteur fonctionne comme un enregistreur de requêtes / réponses, nous devons le lire deux fois - la première fois par l'intercepteur et la deuxième fois par le client.

L'implémentation par défaut nous permet de lire le flux de réponses une seule fois. Pour répondre à ces scénarios spécifiques, Spring fournit une classe spéciale appeléeBufferingClientHttpRequestFactory. Comme son nom l'indique, cette classe mettra en mémoire tampon la requête / réponse dans la mémoire JVM pour un usage multiple.

Voici comment l'objetRestTemplate est initialisé à l'aide deBufferingClientHttpRequestFactory pour activer la mise en cache du flux de demande / réponse: 

RestTemplate restTemplate
  = new RestTemplate(
    new BufferingClientHttpRequestFactory(
      new SimpleClientHttpRequestFactory()
    )
  );

5. Tester notre exemple

Voici le cas de test JUnit pour tester notre intercepteurRestTemplate: 

public class RestTemplateItegrationTest {

    @Autowired
    RestTemplate restTemplate;

    @Test
    public void givenRestTemplate_whenRequested_thenLogAndModifyResponse() {
        LoginForm loginForm = new LoginForm("username", "password");
        HttpEntity requestEntity
          = new HttpEntity(loginForm);
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);

        ResponseEntity responseEntity
          = restTemplate.postForEntity(
            "http://httpbin.org/post", requestEntity, String.class
          );

        assertThat(
          responseEntity.getStatusCode(),
          is(equalTo(HttpStatus.OK))
        );
        assertThat(
          responseEntity.getHeaders().get("Foo").get(0),
          is(equalTo("bar"))
        );
    }
}

Ici, nous avons utilisé le service de requête et de réponse HTTP hébergé gratuitementhttps://httpbin.org pour publier nos données. Ce service de test renverra notre corps de demande avec quelques métadonnées.

6. Conclusion

Ce didacticiel explique comment configurer un intercepteur et l'ajouter à l'objetRestTemplate. Ce type d'intercepteur peut également être utilisé pour filtrer, surveiller et contrôler les demandes entrantes.

Un cas d'utilisation courant pour un intercepteurRestTemplate est la modification d'en-tête - que nous avons illustrée en détail dans cet article.

Et, comme toujours, vous pouvez trouver l'exemple de code surGithub project. Ceci est un projet basé sur Maven, il devrait donc être facile à importer et à exécuter tel quel.

Related