Dieses Mal teilen wir Inhalte über die Registrierung und Entdeckung von Frühlingscloud -Dienstleistungen, die durch Gebäudetechnik, Serviceregistrierung bzw. Service Discovery erläutert werden. Jetzt haben sich viele Startups in Peking auf Springcloud verlassen. Dies kann an den reichen Dokumenten und Komponenten zurückzuführen sein. Immerhin ist es derzeit eine relativ vollständige Microservice -Architektur. Ich hoffe, dass dieses Teilen allen eine gute Hilfe bringen kann.
Eureka Service Center
Soweit ich kenne und verwende, gehören viele Registrierungszentren Zookeeper und Eureka. Mein vorheriger Artikel hat Dubbo+Zookeeper geteilt, um Dienste zu erstellen. Dieses Mal benutze ich Eureka. Das SpringCloud -Framework empfiehlt es auch als Registrierungszentrum. Natürlich kann es in andere Dienstleistungszentren integriert werden. Immerhin ist SpringCloud auf Springboot angewiesen, um Projekte zu erstellen. Daher ist es sehr schnell, andere Komponenten zu integrieren. Erstellen Sie zunächst das Registrierungszentrum -Projekt eureka_server und führen Sie Abhängigkeiten in Folgendes ein:
<Depopenty> <gruppe> org.springFramework.cloud </Groupid> <artifactid> Spring-Cloud-Starter-Eureka-server </artifactid> </abhängig>
Fügen Sie dann Konfigurationselemente zur Datei application.yml hinzu:
Server: Port: 2001Spring: Anwendung: Name: eureka-serveureka: Client: Register-with-Eureka: Falsch #forbid selbst, um sich als Dienstfetch-Registrierung zu registrieren: false #mask Registrierungsinformationsinstanz: bevorzugs-ip-address: true Instance-ID: $ {Spring.Application.name}: $ {Server {Server {Server {Server {Server {Server {Server}Nach Abschluss der Konfiguration müssen Sie die Klasse starten und Annotation @EnableEureKaserver hinzufügen. Die Einstellungen werden im Grunde abgeschlossen und ausgeführt. Besuchen Sie http: // localhost: 2001/ um die folgende Schnittstelle zu erhalten:
Anbieterregistrierungsdienst
Mit dem Service Registration Center müssen wir auch einige Dienste anbieten und diese Dienste beim Service Center registrieren. Um dies zu erleichtern, erstellen wir zunächst ein Interface -Modul -Projekt eureka_api, das von Dienstanbietern und Verbrauchern verwendet wird, und erstellen die folgende Schnittstelle und Request -Return Parameter Entity -Klasse:
public interface userInterface {@postmapping ("/user") morp <list <Mouser >> GetUsers (MORQ RQ); @GetMapping ("/msg") String getmsg ();}Mouser -Entität:
public class Mouser {private long id; privater String -Benutzername; private String userPWD; public long getid () {return id; } public void setId (Long id) {this.id = id; } public String getUnername () {return userername; } public void setUnername (String -Benutzername) {this.username = userername; } public String getUserPWD () {return userPWD; } public void setUserpwd (String userPWD) {this.userpwd = userpwd; }}Erstellen Sie dann das Modul Eureka_Provider auf unserer Seite "Dienstanbieter" und führen Sie auch Eureka -Abhängigkeiten ein. Es gibt jedoch einen kleinen Unterschied zwischen IT und Server -Seite:
<Depopenty> <gruppe> org.springFramework.cloud </Groupid> <artifactid> Spring-Cloud-Starter-Eureka </artifactid> </abhängig>
Erstellen Sie dann den Service Usercontroller, der vom Dienstanbieter bereitgestellt werden soll, und implementieren Sie die Benutzerinterface -Schnittstelle in unserem Eureka_API -Modul. Der Code ist wie folgt:
@RestControllerPublic Class UserController implementiert UserInterface {@autowired private httpServletRequest -Anforderung; @Override public morp <list <Mouser >> GetUsers (Morq rq) {Morp <list <Mouser >> rp = new morp <> (); Liste <Mouser> list = new ArrayList <> (); für (int i = 0; i <5; i ++) {Mouser Mouser = new Mouser (); Mouser.Setid (i); Mouser.Setusername ("Shenniu" + i); list.add (Mouser); } rp.sett (Liste); rp.setStatus (list.size ()> = 1? 1: 0); rp.setMessage (list.size ()> = 1? "": "No Data noch"); RP RP zurückgeben; } @Override public String getmsg () {return "hier ist ein Anbieter, Port:"+ request.getServerport (); }}Es ist hier zu beachten, dass die beiden Service -Schnittstellen des Controllers kein Postmapping oder Getmaping hinzugefügt werden, da dies durch die implementierte Schnittstelle deklariert wird. Nachdem wir die Benutzer- und MSG -Dienste definiert haben, müssen wir auch in der Lage sein, sie in das Service Registration Center zu injizieren, sodass die folgende Konfiguration von application.yml erforderlich ist:
Frühling: Anwendung: Name: Eureka-Provider #Service Name Eureka: Client: Service-URL: DefaultZone: http: // localhost: 2001/eureka/#Service Center-Adressinstanz: bevorzugt-ip-adDress: True Instanz-ID: {Spring.Application.Wir müssen auch das folgende Tag @EnableeureKaclient zur Start -up -Klasse hinzufügen, was bedeutet, dass der Eureka -Client starten kann, da der Dienstanbieter im Vergleich zum Service Center zum Kunden gehört. Beim Ausführen des Projekts Eureka_Provider können wir die folgenden Informationen im Registrierungszentrum sehen:
Um sicherzustellen, dass die Benutzeroberfläche der Dienstleister in Ordnung ist, können wir direkt auf Eureka-Provider: 2004 klicken und dann den Pfad zur Verwendung der Schnittstelle erhöhen. Hier ist: http://192.168.153.148:2004/msg, und wir können die folgenden Informationen erhalten, die von der normalen Zugriffsschnittstelle zurückgegeben werden:
Consumer Discovery Service
Mit Interface-Diensten müssen wir auch Dienste konsumieren, damit wir das Modulprojekt eureka_consumer erstellen, da die Feigin Pseudo-Client-Methode verwendet wird, um auf unseren Dienstanbieter zuzugreifen, und wir müssen auch die Abhängigkeiten von Eureka vorstellen:
<Depopentcy> <gruppe> org.springframework.cloud </Groupid> <artifactId> Spring-Cloud-Starter-Eureka </artifactId> </abhängig> <Depopentcy> <gruppe.
Definieren Sie dann den UserService -Dienst in der Serviceschicht und implementieren Sie die Schnittstelle im öffentlichen Schnittstellenmodul eureka_api. Der Code lautet wie folgt:
@FeignClient (value = "eureka-provider") öffentliche Schnittstelle UserService erweitert UserInterface {}Geben Sie über FeignClient den aufgerufenen Serveranwendungsnamen Eureka-Provider an. Dieser Name entspricht dem im Service Center registrierten Anwendungsverzeichnis. Erstellen Sie einen Antwortausgang Usercontroller an der Controller -Ebene und geben Sie zwei angezeigte Schnittstellen an, Codes wie:
@RestControllerPublic Class UserController {@autowired Private UserService UserService; @Getmapping ("/user") public morp <list <Mouser >> GetUsers (Morq RQ) {return userService.getUsers (RQ); } @Getmapping ("/msg") public string getmsg () {return userService.getMsg (); }}In ähnlicher Weise muss die Verbraucherseite auch einige Informationen in application.yml konfigurieren:
spring: application: name: eureka-consumereureka: client: service-url: defaultZone: http://localhost:2001/eureka/ #Register center address instance: prefer-ip-address: true instance-id: ${spring.application.name}:${server.port}server: port: 2005Die Konfiguration ähnelt der des Anbieters. Schließlich müssen Sie die folgenden Anmerkungen in der Startkurs deklarieren:
@SpringBootApplication@enablediscoveryClient // Consumer Client@enableFeignClients // Client öffentliche Klasse EurekonsumerApplication {public static void main (String [] args) {SpringApplication.run (eurekaconsumerApplication.class, args); }}Nach dem Start des Eureka_Consumer -Projekts können wir die Informationen sehen, die sie im Registrierungszentrum registriert haben:
Durch den Zugriff auf die Verbraucherschnittstelle eureka_consumer testen Sie dann die Schnittstellendaten des Eureka_Provider -Dienstanbieters, um festzustellen, ob er normal reagieren kann. Die Schnittstellenadresse lautet http: // 192.168.153.148:2005/msg:
Das Ergebnis des Anbieters wird durch den Zugriff auf den Verbraucher erhalten, bei dem es sich um den grundlegenden Testprozess für die Registrierung und Entdeckung von Dienstleistungen handelt. Wie der Verbraucher die Anbieterschnittstelle anfordert, können wir sie durch das folgende manuelle Diagramm lösen:
Eureka Service Center ist hoch verfügbar
Nach der obigen manuellen Zeichnung spielt das Service Center eine sehr wichtige Rolle. Normalerweise baut diese Art von Servicecenter nicht nur eine auf, weshalb es erforderlich ist, eine Reihe hochverhältnismäßiger Servicehentren zu erstellen. Tatsächlich ist es sehr einfach, dass die Konfiguration von Anbieter und Verbraucher nicht durchgeführt werden muss. Wir müssen es nur in der Anwendung konfigurieren.
server: port: 2001spring: application: name: eureka-serveureureka: client: register-with-eureka: true # When configuring high availability, you need to open and register yourself fetch-registry: true service-url: defaultZone: http://localhost:2002/eureka/ #Register in eureka on port 2002# defaultZone: http: // localhost: 2001/eureka/Instanz: Prefer-ip-address: TRUE ID: $ {Spring.Application.Name}: $ {Server.port} Server: Eviction-Interval-Timer-in-MS: 2000 #Exclude fehlgeschlagene Dienstintervalle-DienstintervalleDie folgenden Punkte sollten in hoch verfügbaren Konfigurationen geachtet werden:
Hier habe ich zwei Registrierungsadressen erstellt: http: // localhost: 2001/und http: // localhost: 2002/; Da die von Anbieter und Verbraucher konfigurierten Registrierungsadressen beide Port 2001 sind, müssen wir die Auswirkungen wie folgt auf das Portregistrierungszentrum von 2002 zugreifen, um eine hohe Verfügbarkeit zu überprüfen:
Sie können sehen, dass der Port 2002 die gleichen Registrierungsinformationen wie 2001 -Port enthält. Wenn ich die Anwendung des Ports 2001 schließe, kann ich 2002 weiterhin die Informationen von Anbieter und Verbraucher finden. Für eine detailliertere Konfiguration finden Sie in der offiziellen Website -Beschreibung.
GIT -Adresse: https://github.com/shenniubuxing3
Nuget Release -Paket: https://www.nuget.org/profiles/shenniubuxing3
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.