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
Nach dem Login kopieren
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
}Nach dem Login kopieren
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));
}
}Nach dem Login kopieren
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>Nach dem Login kopieren
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/foosNach dem Login kopieren
Hinweis:
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>Nach dem Login kopieren
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);
}
}Nach dem Login kopieren
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;
} // ...}Nach dem Login kopieren
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));
}
}Nach dem Login kopieren
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"));
}Nach dem Login kopieren
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!
