Heim >Java >javaLernprogramm >Implementierung der Verwendung des Spring Cloud Netflix Zuul-Proxy-Gateways für den Zugriff auf Backend-REST-Dienste (Code)
Implementierung der Verwendung des Spring Cloud Netflix Zuul-Proxy-Gateways für den Zugriff auf Backend-REST-Dienste (Code)
- 不言Original
- 2018-09-11 14:12:252339Durchsuche
Der Inhalt dieses Artikels befasst sich mit der Implementierung (Code) der Verwendung des Spring Cloud Netflix Zuul-Proxy-Gateways für den Zugriff auf den Backend-REST-Dienst. Ich hoffe, dass er hilfreich ist Dir zu helfen.
1. Übersicht
In diesem Artikel untersuchen wir, wie zwischen einer Front-End-Anwendung und einem Back-End-REST-API-Dienst kommuniziert wird, die getrennt voneinander bereitgestellt werden. Der Zweck besteht darin, die domänenübergreifenden Ressourcenzugriffs- und Same-Origin-Richtlinieneinschränkungen des Browsers zu lösen, sodass die Seiten-Benutzeroberfläche die Hintergrund-API aufrufen kann, auch wenn sie sich nicht auf demselben Server befinden.
Wir haben hier zwei separate Anwendungen erstellt – eine UI-Anwendung und eine einfache REST-API. Wir werden den Zuul-Proxy in der UI-Anwendung verwenden, um die Aufrufe an die REST-API weiterzuleiten. Zuul ist der JVM-basierte Router und serverseitige Load Balancer von Netflix. Spring Cloud bietet eine hervorragende Integration mit dem eingebetteten Zuul-Proxy.
2.REST-Anwendung
Unsere REST-API-Anwendung ist eine einfache Spring Boot-Anwendung. In diesem Artikel wird die auf dem Server bereitgestellte API auf Port 8081 ausgeführt.
Konfigurationsdatei
server.contextPath=/spring-zuul-foos-resourceserver.port=80 81
Beginnen wir mit der Definition eines grundlegenden DTO für die Ressource, die wir verwenden werden:
public class Foo {
private long id;
private String name;
// standard getters and setters
}Definieren Sie einen einfachen Controller:
@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 . Front-End-Anwendung
Unsere UI-Anwendung ist auch eine einfache Spring Boot-Anwendung. In diesem Artikel wird die Anwendung auf Port 8080 ausgeführt.
Zuerst müssen wir der pom.xml unserer UI-Anwendung eine Abhängigkeit für Zuul-Unterstützung über Spring Cloud hinzufügen:
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-zuul</artifactId></dependency>Als nächstes müssen wir Zuul konfigurieren, da wir Spring Boot verwenden, also werden wir es tun Tun Sie dies in application.yml:
zuul:
routes:
foos:
path: /foos/**
url: http://localhost:8081/spring-zuul-foos-resource/foosHinweis:
Wir stellen einen Proxy für unseren Ressourcenserver Foos dar.
Alle Anfragen, die mit „/foos/“ von der Benutzeroberfläche beginnen, werden an unseren Foos-Ressourcenserver unter http://loclahost:8081/spring-zuul-foos-resource/ weitergeleitet. foos/
Dann schreiben Sie unsere Hauptseite index.html – mit etwas AngularJS hier:
<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('myApp', ["ngResource"]);
app.controller('mainCtrl', function($scope,$resource,$http) {
$scope.foo = {id:0 , name:"sample foo"};
$scope.foos = $resource("/foos/:fooId",{fooId:'@id'});
$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>Der wichtigste Aspekt hier ist, wie wir die relative URL-Zugriffs-API verwenden!
Beachten Sie, dass die API-Anwendung nicht auf demselben Server wie die UI-Anwendung bereitgestellt wird, sodass relative URLs nicht funktionieren und ohne einen Proxy nicht funktionieren.
Allerdings greifen wir über den Proxy auf die Foo-Ressourcen über den Zuul-Proxy zu, der so konfiguriert ist, dass er diese Anfragen dorthin weiterleitet, wo die API tatsächlich bereitgestellt wird.
Schließlich die Boot-fähige Anwendung:
@EnableZuulProxy@SpringBootApplicationpublic class UiApplication extends SpringBootServletInitializer {
public static void main(String[] args) {
SpringApplication.run(UiApplication.class, args);
}
}Diese verwendet die Annotation @EnableZuulProxy, um den Zuul-Proxy zu starten, was sehr sauber und prägnant ist.
4. Führen Sie den Test aus
Starten Sie jeweils 2 Anwendungssysteme, geben Sie http://localhost:8080/index in den Browser ein
Besuchen Sie jedes Mal, wenn Sie auf die Schaltfläche „Neues Foo“ klicken Backend-REST-API einmalig. 
5. Benutzerdefinierter Zuul-Filter
Es stehen mehrere Zuul-Filter zur Verfügung. Wir können auch unseren eigenen benutzerdefinierten Filter erstellen:
@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;
} // ...}Dieser ist einfach Der Filter fügt lediglich ein Attribut namens „Test“ zum Anforderungsheader hinzu. Natürlich können wir unserer Anforderung bei Bedarf weitere hinzufügen.
6. Testen Sie den benutzerdefinierten Zuul-Filter
Zum Schluss testen wir ihn und stellen sicher, dass unser benutzerdefinierter Filter funktioniert. Zuerst ändern wir unseren FooController auf dem Foos-Ressourcenserver:
@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));
}
}Jetzt testen wir es:
@Testpublic void whenSendRequest_thenHeaderAdded() {
Response response = RestAssured.get("http://localhost:8080/foos/1");
assertEquals(200, response.getStatusCode());
assertEquals("TestSample", response.getHeader("Test"));
}7. Fazit
In diesem Beitrag haben wir uns auf die Weiterleitung von Anfragen von der UI-Anwendung an REST mithilfe der Zuul-API konzentriert. Wir haben die CORS- und Same-Origin-Richtlinie erfolgreich gelöst und es ist uns auch gelungen, die HTTP-Anfragen während der Übertragung anzupassen und zu erweitern.
Verwandte Empfehlungen:
Feign von Spring Cloud verwendet HTTP, um Remote-Dienste anzufordern
Spring-Cloud-Sleuth+Zipkin-Tracking Service-Implementierung (2)
Das obige ist der detaillierte Inhalt vonImplementierung der Verwendung des Spring Cloud Netflix Zuul-Proxy-Gateways für den Zugriff auf Backend-REST-Dienste (Code). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!