Authentification de base avec RestTemplate

Table des matières

Présentation de1.
2. Configuration desRestTemplate au printemps
3. Gestion manuelle de l'en-tête HTTP d'autorisation
4. Gestion automatique de l'en-tête HTTP Authorization
Dépendances Maven5.
Conclusion de6.

1. Vue d'ensemble

Cet article explique comment utiliser les ressortsRestTemplate àconsume a RESTful Service secured with Basic Authentication.

Une fois l'authentification de base configurée pour le modèle, chaque demande sera envoyéepreemptively containing the full credentials nécessaire pour effectuer le processus d'authentification. Les informations d'identification seront codées et utiliseront l'en-tête HTTPAuthorization, conformément aux spécifications du schéma d'authentification de base. Un exemple ressemblerait à ceci:

Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==

Lectures complémentaires:

Traitement des erreurs Spring RestTemplate

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

Utilisation de l'intercepteur Spring RestTemplate

En savoir plus sur l'utilisation d'intercepteurs dans votre application Spring avec RestTemplate.

Explorer le Spring TestRestTemplate

Apprenez à utiliser le nouveau TestRestTemplate dans Spring Boot pour tester une API simple.

2. Configuration desRestTemplate

L'amorçage desRestTemplate dans le contexte Spring peut être fait en déclarant simplement un bean pour celui-ci; cependant, configurer lesRestTemplate avecBasic Authentication nécessitera une intervention manuelle, donc au lieu de déclarer directement le bean, un SpringFactoryBean sera utilisé pour plus de flexibilité. Cette fabrique créera et configurera le modèle à l’initialisation:

@Component
public class RestTemplateFactory
  implements FactoryBean, InitializingBean {

    private RestTemplate restTemplate;

    public RestTemplate getObject() {
        return restTemplate;
    }
    public Class getObjectType() {
        return RestTemplate.class;
    }
    public boolean isSingleton() {
        return true;
    }

    public void afterPropertiesSet() {
        HttpHost host = new HttpHost("localhost", 8082, "http");
        restTemplate = new RestTemplate(
          new HttpComponentsClientHttpRequestFactoryBasicAuth(host));
    }
}

Les valeurshost etport doivent dépendre de l'environnement, ce qui permet au client de définir un ensemble de valeurs pour les tests d'intégration et un autre pour une utilisation en production. Les valeurs peuvent être gérées par lesfirst class Spring support for properties files.

3. Gestion manuelle de l'en-tête HTTP d'autorisation

Le processus de création de l'en-têteAuthorization est relativement simple pour l'authentification de base, il peut donc être fait à peu près manuellement avec quelques lignes de code:

HttpHeaders createHeaders(String username, String password){
   return new HttpHeaders() {{
         String auth = username + ":" + password;
         byte[] encodedAuth = Base64.encodeBase64(
            auth.getBytes(Charset.forName("US-ASCII")) );
         String authHeader = "Basic " + new String( encodedAuth );
         set( "Authorization", authHeader );
      }};
}

Ensuite, envoyer une demande devient aussi simple:

restTemplate.exchange
 (uri, HttpMethod.POST, new HttpEntity(createHeaders(username, password)), clazz);

4. Gestion automatique de l'en-tête HTTP d'autorisation

Spring 3.0, 3.1 et maintenant 4.x supportent très bien les bibliothèques HTTP Apache:

Spring 3.0, leCommonsClientHttpRequestFactory intégré au maintenantend-of-life’dHttpClient 3.x
Spring 3.1 a introduit la prise en charge desHttpClient 4.x actuels viaHttpComponentsClientHttpRequestFactory (prise en charge ajoutée dans lesSPR-6180 JIRA)
Spring 4.0 a introduit le support async via lesHttpComponentsAsyncClientHttpRequestFactory

Commençons par configurer les choses avec HttpClient 4 et Spring 4.

LesRestTemplate nécessiteront une fabrique de requêtes HTTP - une usine qui prend en charge l'authentification de base - jusqu'à présent, tout va bien. Cependant, utiliser directement lesHttpComponentsClientHttpRequestFactory existants s'avérera difficile, car l'architecture deRestTemplate a été conçuewithout good support pourHttpContext - une pièce instrumentale du puzzle. Nous devrons donc sous-classerHttpComponentsClientHttpRequestFactory et remplacer la méthodecreateHttpContext:

public class HttpComponentsClientHttpRequestFactoryBasicAuth
  extends HttpComponentsClientHttpRequestFactory {

    HttpHost host;

    public HttpComponentsClientHttpRequestFactoryBasicAuth(HttpHost host) {
        super();
        this.host = host;
    }

    protected HttpContext createHttpContext(HttpMethod httpMethod, URI uri) {
        return createHttpContext();
    }

    private HttpContext createHttpContext() {
        AuthCache authCache = new BasicAuthCache();

        BasicScheme basicAuth = new BasicScheme();
        authCache.put(host, basicAuth);

        BasicHttpContext localcontext = new BasicHttpContext();
        localcontext.setAttribute(HttpClientContext.AUTH_CACHE, authCache);
        return localcontext;
    }
}

C'est ici - lors de la création desHttpContext - que le support d'authentification de base est intégré. Comme vous pouvez le voir, faire une authentification de base préemptive avec HttpClient 4.x esta bit of a burden: les informations d'authentification sont mises en cache et le processus de configuration de ce cache d'authentification est très manuel et peu intuitif.

Et avec cela, tout est en place - lesRestTemplate pourront désormais prendre en charge le schéma d'authentification de base simplement en ajoutant unBasicAuthorizationInterceptor;

restTemplate.getInterceptors().add(
  new BasicAuthorizationInterceptor("username", "password"));

Et la demande:

restTemplate.exchange(
  "http://localhost:8082/spring-security-rest-basic-auth/api/foos/1",
  HttpMethod.GET, null, Foo.class);

Pour une discussion approfondie sur la façon de sécuriser le service REST lui-même,check out this article.

5. Dépendances Maven

Les dépendances Maven suivantes sont requises pour leRestTemplate lui-même et pour la bibliothèque HttpClient:


   org.springframework
   spring-webmvc
   5.0.6.RELEASE



   org.apache.httpcomponents
   httpclient
   4.5.3

Facultativement, si l'en-tête HTTPAuthorization est construit manuellement, une bibliothèque supplémentaire est requise pour la prise en charge du codage:


   commons-codec
   commons-codec
   1.10

Vous trouverez les dernières versions dans lesMaven repository.

6. Conclusion

Bien que la branche de développement 3.x pour Apache HttpClient soit arrivée en fin de vie depuis un certain temps maintenant, et que la prise en charge de Spring pour cette version soit totalement obsolète, une grande partie des informations qui peuvent être trouvées surRestTemplate et la sécurité ne tient toujours pas compte des versions dethe current HttpClient 4.x. Cet article tente de changer cela grâce à une discussion détaillée, étape par étape, sur la configuration de l'authentification de base avec lesRestTemplate et sur son utilisation pour utiliser une API REST sécurisée.

Pour aller au-delà des exemples de code de l'article avec une implémentation à la fois du côté consommateur, examiné ici, mais aussi du service RESTful réel, jetez un œil au projetover on Github.

Ceci est un projet basé sur Maven, il devrait donc être facile à importer et à exécuter tel quel.

TOC

Authentification de base avec RestTemplate