Maison >Java >javaDidacticiel >Implémentation de l'utilisation de la passerelle proxy Spring Cloud Netflix Zuul pour accéder aux services REST backend (code)

Implémentation de l'utilisation de la passerelle proxy Spring Cloud Netflix Zuul pour accéder aux services REST backend (code)

不言original: 2018-09-11 14:12:252337parcourir

Le contenu de cet article concerne l'implémentation (code) de l'utilisation de la passerelle proxy Spring Cloud Netflix Zuul pour accéder au service REST backend. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. à vous.

1. Présentation

Dans cet article, nous explorerons comment communiquer entre une application frontale et un service API REST back-end déployés séparément l'un de l'autre. L'objectif est de résoudre les restrictions d'accès aux ressources inter-domaines du navigateur et de politique de même origine, permettant à l'interface utilisateur de la page d'appeler l'API d'arrière-plan même si elles ne se trouvent pas sur le même serveur.

Nous avons créé ici deux applications distinctes - une application UI et une simple API REST, nous utiliserons le proxy Zuul dans l'application UI pour proxy les appels à l'API REST. Zuul est le routeur basé sur JVM et l'équilibreur de charge côté serveur de Netflix. Spring Cloud a une excellente intégration avec le proxy Zuul intégré.

2.Application REST

Notre application API REST est une simple application Spring Boot. Dans cet article, l'API déployée sur le serveur sera exécutée sur le port 8081.

Fichiers de configuration

server.contextPath=/spring-zuul-foos-resourceserver.port=80
81

Commençons par définir un DTO de base pour les ressources que nous allons utiliser :

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

Définir un contrôleur simple :

@Controllerpublic class FooController {

    @RequestMapping(method = RequestMethod.GET, value = "/foos/{id}")    
    @ResponseBody
    public Foo findById(
      @PathVariable long id, HttpServletRequest req, HttpServletResponse res) {        
      return new Foo(Long.parseLong(randomNumeric(2)), randomAlphabetic(4));
    }
}

3. Application frontale

Notre application d'interface utilisateur est également une simple application Spring Boot. Dans cet article, l'application s'exécute sur le port 8080.

Nous devons d'abord ajouter une dépendance sur le support de Zuul via Spring Cloud au pom.xml de notre application d'interface utilisateur :

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-zuul</artifactId></dependency>

Ensuite - nous devons configurer Zuul comme nous le faisons en utilisant Spring Boot , nous allons donc le faire dans application.yml :

zuul:
  routes:
    foos:
      path: /foos/**
      url: http://localhost:8081/spring-zuul-foos-resource/foos

Remarque :

Nous proxyons notre serveur de ressources Foos.
Toutes les requêtes commençant par "/foos/" provenant de l'interface utilisateur seront acheminées vers notre serveur de ressources Foos à l'adresse : http://loclahost:8081/spring-zuul-foos-resource/ foos/

Ensuite, écrivez notre page principale index.html — en utilisant du AngularJS ici :

<html>
<body ng-app="myApp" ng-controller="mainCtrl">
<script src="angular.min.js"></script>
<script src="angular-resource.min.js"></script>
<script>
var app = angular.module(&#39;myApp&#39;, ["ngResource"]);

app.controller(&#39;mainCtrl&#39;, function($scope,$resource,$http) {
    $scope.foo = {id:0 , name:"sample foo"};
    $scope.foos = $resource("/foos/:fooId",{fooId:&#39;@id&#39;});

    $scope.getFoo = function(){
        $scope.foo = $scope.foos.get({fooId:$scope.foo.id});
    }  
});</script><p>
    <h1>Foo Details</h1>
    <span>{{foo.id}}</span>
    <span>{{foo.name}}</span>
    <a href="#" ng-click="getFoo()">New Foo</a>
    </p>
    </body>
    </html>

L'aspect le plus important ici est la façon dont nous utilisons les URL relatives pour accéder l'API !
Gardez à l'esprit que l'application API n'est pas déployée sur le même serveur que l'application UI, donc les URL relatives ne fonctionneront pas et ne fonctionneront pas sans proxy.
Cependant, via le proxy, nous accédons aux ressources Foo via le proxy Zuul, qui est configuré pour acheminer ces requêtes vers l'endroit où l'API est réellement déployée.

Enfin, l'application compatible Boot :

@EnableZuulProxy@SpringBootApplicationpublic class UiApplication extends SpringBootServletInitializer {

    public static void main(String[] args) {
        SpringApplication.run(UiApplication.class, args);
    }
}

Ici, nous utilisons l'annotation @EnableZuulProxy pour démarrer le proxy Zuul, qui est très propre et concis.

4. Exécutez le test

Démarrez respectivement 2 systèmes d'application, entrez http://localhost:8080/index dans le navigateur
Visitez chaque fois que vous cliquez sur le bouton "New Foo" API REST backend une fois.
Implémentation de lutilisation de la passerelle proxy Spring Cloud Netflix Zuul pour accéder aux services REST backend (code)

5. Filtres Zuul personnalisés

Il existe plusieurs filtres Zuul disponibles, nous pouvons également créer nos propres filtres personnalisés :

@Componentpublic class CustomZuulFilter extends ZuulFilter {

    @Override
    public Object run() {
        RequestContext ctx = RequestContext.getCurrentContext();
        ctx.addZuulRequestHeader("Test", "TestSample");        
        return null;
    }    @Override
    public boolean shouldFilter() {       
    return true;
    }    // ...}

Ce simple filter ajoute simplement un attribut appelé "Test" à l'en-tête de la requête - bien sûr, nous pouvons en ajouter davantage à notre demande si nécessaire.

6. Testez le filtre Zuul personnalisé

Enfin, testons-le et assurons-nous que notre filtre personnalisé fonctionne - nous allons d'abord modifier notre FooController sur le serveur de ressources Foos :

@Controllerpublic class FooController {

    @GetMapping("/foos/{id}")    @ResponseBody
    public Foo findById(
      @PathVariable long id, HttpServletRequest req, HttpServletResponse res) {        
      if (req.getHeader("Test") != null) {
            res.addHeader("Test", req.getHeader("Test"));
        }        return new Foo(Long.parseLong(randomNumeric(2)), randomAlphabetic(4));
    }
}

Maintenant, testons-le :

@Testpublic void whenSendRequest_thenHeaderAdded() {    
Response response = RestAssured.get("http://localhost:8080/foos/1");

    assertEquals(200, response.getStatusCode());
    assertEquals("TestSample", response.getHeader("Test"));
}

7. Conclusion

Dans cet article, nous nous sommes concentrés sur l'utilisation de Zuul pour déplacer les requêtes de l'application d'interface utilisateur. Le programme est routé à l'API REST. Nous avons résolu avec succès le CORS et la politique de même origine, et nous avons également réussi à personnaliser et à augmenter les requêtes HTTP en transit.

Recommandations associées :

Feign de Spring Cloud utilise HTTP pour demander des services à distance

spring-cloud-sleuth+zipkin tracking Mise en œuvre du service (2)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Déclaration：

Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn

Article précédent：Analyse de code pour les problèmes de consommation en JavaArticle suivant：Analyse de code pour les problèmes de consommation en Java

Articles Liés

Voir plus