TOC

Spring Cloud - Bootstrapping

1. Überblick

Spring Cloud ist ein Framework zum Erstellen robuster Cloud-Anwendungen. Das Framework erleichtert die Entwicklung von Anwendungen, indem Lösungen für viele der häufigsten Probleme bereitgestellt werden, die beim Wechsel in eine verteilte Umgebung auftreten.

Anwendungen, die mit der Microservices-Architektur ausgeführt werden, zielen darauf ab, Entwicklung, Bereitstellung und Wartung zu vereinfachen. Aufgrund der Zerlegung der Anwendung können sich die Entwickler auf jeweils ein Problem konzentrieren.

Verbesserungen können eingeführt werden, ohne andere Teile eines Systems zu beeinträchtigen.

Auf der anderen Seite ergeben sich andere Herausforderungen, wenn wir einen Microservice-Ansatz verfolgen:

  • Die Externalisierung der Konfiguration ist flexibel und erfordert keine

Umbau des Dienstes bei Änderung ** Service Discovery

  • Verbergen der Komplexität von Diensten, die auf verschiedenen Hosts bereitgestellt werden

In diesem Artikel erstellen wir fünf Mikrodienste: einen Konfigurationsserver, einen Discoveryserver, einen Gatewayserver, einen Buchdienst und schließlich einen Bewertungsdienst. Diese fünf Microservices bilden eine solide Basisanwendung, um mit der Cloud-Entwicklung zu beginnen und die oben genannten Herausforderungen zu meistern.

2. Config Server

Bei der Entwicklung einer Cloud-Anwendung besteht ein Problem darin, die Konfiguration für unsere Dienste bereitzustellen und zu verteilen. Wir möchten nicht unbedingt Zeit für die Konfiguration der einzelnen Umgebungen aufwenden, bevor wir unseren Service horizontal skalieren oder Sicherheitsverletzungen riskieren, indem wir unsere Konfiguration in unsere Anwendung integrieren.

Um dies zu lösen, konsolidieren wir unsere gesamte Konfiguration in einem einzigen Git-Repository und verbinden diese mit einer Anwendung, die eine Konfiguration für alle unsere Anwendungen verwaltet. Wir werden eine sehr einfache Implementierung einrichten.

Um mehr Details zu erfahren und ein komplexeres Beispiel zu sehen, werfen Sie einen Blick auf den Link:/spring-cloud-configuration[Spring Cloud Configuration].

2.1. Konfiguration

Navigieren Sie zu start.spring.io und wählen Sie Maven and Spring Boot 1.4.x aus.

Setzen Sie das Artefakt auf " config" . Suchen Sie im Abschnitt "Abhängigkeiten" nach " config-Server" und fügen Sie dieses Modul hinzu. Drücken Sie dann die Taste generate , und Sie können eine ZIP-Datei mit einem vorkonfigurierten Projekt herunterladen und bereit.

Alternativ können Sie ein Spring Boot -Projekt erstellen und der POM-Datei manuell einige Abhängigkeiten hinzufügen.

Diese Abhängigkeiten werden von allen Projekten gemeinsam genutzt: 

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.4.0.RELEASE</version>
    <relativePath/>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Brixton.SR5</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

Fügen wir eine Abhängigkeit für den Konfigurationsserver hinzu: 

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-config-server</artifactId>
</dependency>

Als Referenz: Sie finden die neueste Version auf Maven Central ( https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.cloud%22%20A%3A% 22spring-cloud-Abhängigkeiten% 22[spring-cloud-Abhängigkeiten], https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.boot%22%20AND%20a% 3A% 22spring-boot-starter-test% 22[test], https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.cloud%22%20AND%20a% 3A% 22spring-cloud-config-server% 22[config-server]).

2.2. Spring Config

Um den Konfigurationsserver zu aktivieren, müssen wir der Hauptanwendungsklasse einige Anmerkungen hinzufügen: 

@SpringBootApplication
@EnableConfigServer
public class ConfigApplication {...}

@ EnableConfigServer verwandelt unsere Anwendung in einen Konfigurationsserver.

2.3. Eigenschaften

Fügen wir die application.properties in src/main/resources hinzu: 

server.port=8081
spring.application.name=config

spring.cloud.config.server.git.uri=file://${user.home}/application-config

Die wichtigste Einstellung für den Konfigurationsserver ist der Parameter git.uri . Dies ist derzeit auf einen relativen Dateipfad festgelegt, der im Allgemeinen in c: \ Users \\ {Benutzername} \ unter Windows oder /Users/\ {Benutzername}/ on ** nix aufgelöst wird. Diese Eigenschaft verweist auf ein Git-Repository, in dem die Eigenschaftendateien für alle anderen Anwendungen gespeichert werden. Sie kann bei Bedarf auf einen absoluten Dateipfad gesetzt werden.

  • Tipp : Auf einem Windows-Computer geben Sie den Wert mit "file:///" ein; on nix verwenden Sie dann "file://".

2.4. Git Repository

Navigieren Sie zu dem Ordner, der durch spring.cloud.config.server.git.uri definiert ist, und fügen Sie den Ordner 'application-config' hinzu. CD in diesen Ordner und geben Sie git init ein. Dadurch wird ein Git-Repository initialisiert, in dem wir Dateien speichern und deren Änderungen verfolgen können.

2.5. Lauf

Lassen Sie uns den Konfigurationsserver ausführen und sicherstellen, dass er funktioniert. Geben Sie in der Befehlszeile mvn spring-boot: run ein. Dadurch wird der Server gestartet. Diese Ausgabe sollte anzeigen, dass der Server ausgeführt wird: 

Tomcat started on port(s): 8081 (http)

3. Entdeckung

Nun, da wir uns um die Konfiguration gekümmert haben, brauchen wir einen Weg, auf dem alle unsere Server einander finden können. Wir lösen dieses Problem, indem Sie den Discovery-Server Eureka einrichten. Da unsere Anwendungen auf einer beliebigen IP/Port-Kombination ausgeführt werden können, benötigen wir eine zentrale Adressregistrierungsdatenbank, die als Anwendungsadresssuche dienen kann.

Wenn ein neuer Server bereitgestellt wird, kommuniziert er mit dem Discovery-Server und registriert seine Adresse, damit andere mit ihm kommunizieren können.

Auf diese Weise können andere Anwendungen diese Informationen verwenden, wenn sie Anforderungen stellen.

Weitere Informationen und eine komplexere Implementierung von Discovery finden Sie unter Spring Cloud Eureka-Artikel .

3.1. Konfiguration

Wieder navigieren wir zu start.spring.io . Setzen Sie das Artefakt auf "Discovery". Suchen Sie nach " eureka server " und fügen Sie diese Abhängigkeit hinzu. Suchen Sie nach " config client " und fügen Sie diese Abhängigkeit hinzu.

Generieren Sie das Projekt.

Alternativ können wir ein Spring Boot -Projekt erstellen, den Inhalt des POM vom Konfigurationsserver kopieren und in diesen Abhängigkeiten austauschen: 

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-eureka-server</artifactId>
</dependency>

Zur Information: Sie finden die Pakete unter Maven Central ( https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.cloud%22%20A%3A%22spring -cloud-starter-config% 22[config-client], https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.cloud%22%20AND%20a%3A % 22spring-cloud-starter-eureka-server% 22[eureka-server]).

3.2. Spring Config

Fügen wir der Hauptklasse Java-Konfig hinzu: 

@SpringBootApplication
@EnableEurekaServer
public class DiscoveryApplication {...}

@ EnableEurekaServer konfiguriert diesen Server mithilfe von Netflix Eureka als Erkennungsserver. Spring Boot erkennt automatisch die Konfigurationsabhängigkeit des Klassenpfads und sucht die Konfiguration vom Konfigurationsserver aus.

3.3. Eigenschaften

Jetzt fügen wir zwei Eigenschaftsdateien hinzu:

bootstrap.properties in src/main/resources 

spring.cloud.config.name=discovery
spring.cloud.config.uri=http://localhost:8081

Mit diesen Eigenschaften kann der Discoveryserver den Konfigurationsserver beim Start abfragen.

discovery.properties in unserem Git-Repository 

spring.application.name=discovery
server.port=8082

eureka.instance.hostname=localhost

eureka.client.serviceUrl.defaultZone=http://localhost:8082/eureka/eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

Der Dateiname muss mit der Eigenschaft spring.application.name übereinstimmen.

Außerdem teilen wir diesem Server mit, dass er in der Standardzone betrieben wird. Dies entspricht der Regionseinstellung des Konfigurations-Clients. Wir weisen den Server außerdem an, sich nicht bei einer anderen Discovery-Instanz zu registrieren.

In der Produktion hätten Sie mehr als eine davon, um im Fehlerfall Redundanz bereitzustellen, und diese Einstellung wäre wahr.

Übertragen Sie die Datei in das Git-Repository. Andernfalls wird die Datei nicht erkannt.

3.4. Abhängigkeit zum Config Server hinzufügen

Fügen Sie diese Abhängigkeit zur POM-Datei des Konfigurationsservers hinzu: 

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

Als Referenz : finden Sie das Paket unter Maven Central ( https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.cloud%22%20AND%20a % 3A% 22spring-cloud-starter-eureka% 22[eureka-client]).

Fügen Sie diese Eigenschaften zur Datei application.properties in src/main/resources des Konfigurationsservers hinzu: 

eureka.client.region = default
eureka.client.registryFetchIntervalSeconds = 5
eureka.client.serviceUrl.defaultZone=http://localhost:8082/eureka/----

====  **  3.5. Lauf**

Starten Sie den Discovery-Server mit demselben Befehl, __mvn spring-boot: run__. Die Ausgabe von der Befehlszeile sollte Folgendes enthalten:

[source,text,gutter:,true]

Fetching config from server at: http://localhost:8081 …​ Tomcat started on port(s): 8082 (http) 

Stoppen Sie den Konfigurationsdienst und führen Sie ihn erneut aus. Wenn alles gut ist, sollte die Ausgabe so aussehen:

[source,text,gutter:,true]

DiscoveryClient CONFIG/10.1.10.235:config:8081: registering service…​ Tomcat started on port(s): 8081 (http) DiscoveryClient CONFIG/10.1.10.235:config:8081 - registration status: 204 

===  **  4. Tor**

Jetzt, da unsere Konfigurations- und Erkennungsprobleme behoben sind, haben wir immer noch ein Problem mit Clients, die auf alle unsere Anwendungen zugreifen.

Wenn wir alles in einem verteilten System belassen, müssen wir komplexe CORS-Header verwalten, um Ursprungsanforderungen an Clients zu ermöglichen.

Wir können dies beheben, indem Sie einen __Gateway__-Server erstellen. Dies dient als Reverse-Proxy, der Anforderungen von Clients an unsere Back-End-Server übermittelt.

Ein Gateway-Server ist eine hervorragende Anwendung in der Microservice-Architektur, da alle Antworten von einem einzigen Host stammen können.

Dies macht CORS überflüssig und gibt uns einen bequemen Ort, um häufige Probleme wie die Authentifizierung zu lösen.

====  **  4.1. Konfiguration**

Inzwischen kennen wir den Bohrer. Navigieren Sie zu http://start.spring.io/[start.spring.io]. Setzen Sie das Artefakt auf "__gateway__". Suchen Sie nach "zuul" und fügen Sie diese Abhängigkeit hinzu. Suchen Sie nach "__config client" __ und fügen Sie diese Abhängigkeit hinzu. Suchen Sie nach „__eureka discovery“ __ und fügen Sie diese Abhängigkeit hinzu. Generieren Sie dieses Projekt.

Alternativ können wir eine __Spring Boot__-App mit diesen Abhängigkeiten erstellen:

[source,xml,gutter:,true]

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

Zur Information: Sie finden das Paket unter __Maven Central__ (https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.cloud%22%20A%3A%22spring -cloud-starter-config% 22[config-client], https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.cloud%22%20AND%20a%3A % 22spring-cloud-starter-eureka% 22[eureka-client], https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.cloud%22%20AND%20a % 3A% 22spring-cloud-starter-zuul% 22[zuul]).

====  **  4.2. Spring Config **

Fügen wir die Konfiguration der Hauptklasse hinzu:

[source,java,gutter:,true]

@SpringBootApplication @EnableZuulProxy @EnableEurekaClient public class GatewayApplication {…​} 

====  **  4.3. Eigenschaften**

Jetzt fügen wir zwei Eigenschaftsdateien hinzu:

__bootstrap.properties__ in src/main/resources

[source,text,gutter:,true]

spring.cloud.config.name=gateway spring.cloud.config.discovery.service-id=config spring.cloud.config.discovery.enabled=true

eureka.client.serviceUrl.defaultZone=http://localhost:8082/eureka/----

gateway.properties in unserem Git-Repository 

spring.application.name=gateway
server.port=8080

eureka.client.region = default
eureka.client.registryFetchIntervalSeconds = 5

zuul.routes.book-service.path=/book-service/** **
zuul.routes.book-service.sensitive-headers=Set-Cookie,Authorization
hystrix.command.book-service.execution.isolation.thread.timeoutInMilliseconds=600000

zuul.routes.rating-service.path=/rating-service/** **
zuul.routes.rating-service.sensitive-headers=Set-Cookie,Authorization
hystrix.command.rating-service.execution.isolation.thread.timeoutInMilliseconds=600000

zuul.routes.discovery.path=/discovery/** **
zuul.routes.discovery.sensitive-headers=Set-Cookie,Authorization
zuul.routes.discovery.url=http://localhost:8082
hystrix.command.discovery.execution.isolation.thread.timeoutInMilliseconds=600000

Mit der zuul.routes -Eigenschaft können wir eine Anwendung definieren, die bestimmte Anforderungen basierend auf einem ant-URL-Matcher weiterleitet. Unsere Eigenschaft teilt Zuul mit, dass alle Anfragen, die unter "/book-service/ " eingehen, an eine Anwendung mit dem spring.application.name von "book-service" weitergeleitet werden. Zuul sucht dann den Host vom Discovery-Server anhand des Anwendungsnamens und leitet die Anfrage an diesen Server weiter.

Denken Sie daran, die Änderungen im Repository festzuschreiben!

4.4. Lauf

Führen Sie die Konfigurations- und Erkennungsanwendungen aus und warten Sie, bis sich die Konfigurationsanwendung beim Erkennungsserver registriert hat. Wenn sie bereits laufen, müssen Sie sie nicht neu starten. Sobald dies abgeschlossen ist, führen Sie den Gateway-Server aus. Der Gateway-Server sollte an Port 8080 starten und sich beim Discovery-Server registrieren. Die Ausgabe von der Konsole sollte enthalten: 

Fetching config from server at: http://10.1.10.235:8081/...
DiscoveryClient__GATEWAY/10.1.10.235:gateway:8080: registering service...
DiscoveryClient__GATEWAY/10.1.10.235:gateway:8080 - registration status: 204
Tomcat started on port(s): 8080 (http)

Ein Fehler, der leicht zu begehen ist, ist, den Server zu starten, bevor sich der Konfigurationsserver bei Eureka registriert hat. In diesem Fall wird ein Protokoll mit dieser Ausgabe angezeigt: 

Fetching config from server at: http://localhost:8888

Dies ist die Standard-URL und der Standardport für einen Konfigurationsserver. Dies zeigt an, dass der Discovery-Dienst bei der Konfigurationsanfrage keine Adresse hatte. Warten Sie einfach ein paar Sekunden und versuchen Sie es erneut. Sobald sich der Konfigurationsserver bei Eureka registriert hat, wird das Problem behoben.

5. Buchservice

In der Microservice-Architektur können wir beliebig viele Anwendungen erstellen, um ein Geschäftsziel zu erreichen. Oft teilen die Ingenieure ihre Dienste nach Domänen auf. Wir folgen diesem Muster und erstellen einen Buchservice, der alle Vorgänge für Bücher in unserer Anwendung abwickelt.

5.1. Konfiguration

Ein Mal noch. Navigieren Sie zu start.spring.io . Setzen Sie das Artefakt auf "Buchservice". Suchen Sie nach " web " und fügen Sie diese Abhängigkeit hinzu. Suchen Sie nach " config client " und fügen Sie diese Abhängigkeit hinzu. Suchen Sie nach „Eureka-Entdeckung“ und fügen Sie diese Abhängigkeit hinzu. Generieren Sie dieses Projekt.

Alternativ können Sie diese Abhängigkeiten zu einem Projekt hinzufügen: 

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Zur Information: Sie finden das Paket unter Maven Central ( https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.cloud%22%20A%3A%22spring -cloud-starter-config% 22[config-client], https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.cloud%22%20AND%20a%3A % 22spring-cloud-starter-eureka% 22[eureka-client], https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.boot%22%20AND%20a % 3A% 22spring-boot-starter-web% 22[web]).

5.2. Spring Config

Lassen Sie uns unsere Hauptklasse ändern: 

@SpringBootApplication
@EnableEurekaClient
@RestController
@RequestMapping("/books")
public class BookServiceApplication {
    public static void main(String[]args) {
        SpringApplication.run(BookServiceApplication.class, args);
    }

    private List<Book> bookList = Arrays.asList(
        new Book(1L, "Baeldung goes to the market", "Tim Schimandle"),
        new Book(2L, "Baeldung goes to the park", "Slavisa")
    );

    @GetMapping("")
    public List<Book> findAllBooks() {
        return bookList;
    }

    @GetMapping("/{bookId}")
    public Book findBook(@PathVariable Long bookId) {
        return bookList.stream().filter(b -> b.getId().equals(bookId)).findFirst().orElse(null);
    }
}

Wir haben auch einen REST-Controller und ein Feld hinzugefügt, das in unserer Eigenschaftendatei festgelegt wurde, um einen Wert zurückzugeben, den wir während der Konfiguration festlegen.

Fügen wir nun das Buch POJO hinzu: 

public class Book {
    private Long id;
    private String author;
    private String title;

   //standard getters and setters
}

5.3. Eigenschaften

Jetzt müssen wir nur noch unsere beiden Eigenschaftsdateien hinzufügen:

bootstrap.properties in src/main/resources: 

spring.cloud.config.name=book-service
spring.cloud.config.discovery.service-id=config
spring.cloud.config.discovery.enabled=true

eureka.client.serviceUrl.defaultZone=http://localhost:8082/eureka/----

__book-service.properties__ in unserem Git-Repository:

[source,text,gutter:,true]

spring.application.name=book-service server.port=8083

eureka.client.region = default eureka.client.registryFetchIntervalSeconds = 5 eureka.client.serviceUrl.defaultZone=http://localhost:8082/eureka/----

Übernehmen Sie die Änderungen am Repository.

5.4. Lauf

Sobald alle anderen Anwendungen gestartet sind, können wir den Buchservice starten. Die Konsolenausgabe sollte folgendermaßen aussehen: 

DiscoveryClient__BOOK-SERVICE/10.1.10.235:book-service:8083: registering service...
DiscoveryClient__BOOK-SERVICE/10.1.10.235:book-service:8083 - registration status: 204
Tomcat started on port(s): 8083 (http)

Sobald dies der Fall ist, können wir unseren Browser verwenden, um auf den gerade erstellten Endpunkt zuzugreifen. Navigieren Sie zu http://localhost : 8080/book-service/books und wir erhalten ein JSON-Objekt mit zwei Büchern zurück, die wir in unseren Controller hinzugefügt haben. Beachten Sie, dass wir nicht direkt über den Port 8083 auf den Buchdienst zugreifen, sondern den Gatewayserver.

6. Bewertungsservice

Wie unser Buchservice wird auch unser Bewertungsdienst ein domänengesteuerter Dienst sein, der Vorgänge im Zusammenhang mit Bewertungen abwickelt.

6.1. Konfiguration

Ein Mal noch. Navigieren Sie zu start.spring.io . Setzen Sie das Artefakt auf "Rating-Service". Suchen Sie nach " web " und fügen Sie diese Abhängigkeit hinzu. Suchen Sie nach " config client " und fügen Sie diese Abhängigkeit hinzu. Suchen Sie nach „Eureka-Entdeckung“ und fügen Sie diese Abhängigkeit hinzu. Generieren Sie dieses Projekt.

Alternativ können Sie diese Abhängigkeiten zu einem Projekt hinzufügen: 

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Zur Information: Sie finden das Paket unter Maven Central ( https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.cloud%22%20A%3A%22spring -cloud-starter-config% 22[config-client], https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.cloud%22%20AND%20a%3A % 22spring-cloud-starter-eureka% 22[eureka-client], https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.boot%22%20AND%20a % 3A% 22spring-boot-starter-web% 22[web]).

6.2. Spring Config

Lassen Sie uns unsere Hauptklasse ändern: 

@SpringBootApplication
@EnableEurekaClient
@RestController
@RequestMapping("/ratings")
public class RatingServiceApplication {
    public static void main(String[]args) {
        SpringApplication.run(RatingServiceApplication.class, args);
    }

    private List<Rating> ratingList = Arrays.asList(
        new Rating(1L, 1L, 2),
        new Rating(2L, 1L, 3),
        new Rating(3L, 2L, 4),
        new Rating(4L, 2L, 5)
    );

    @GetMapping("")
    public List<Rating> findRatingsByBookId(@RequestParam Long bookId) {
        return bookId == null || bookId.equals(0L) ? Collections.EMPTY__LIST : ratingList.stream().filter(r -> r.getBookId().equals(bookId)).collect(Collectors.toList());
    }

    @GetMapping("/all")
    public List<Rating> findAllRatings() {
        return ratingList;
    }
}

Wir haben auch einen REST-Controller und ein Feld hinzugefügt, das in unserer Eigenschaftendatei festgelegt wurde, um einen Wert zurückzugeben, den wir während der Konfiguration festlegen.

Fügen wir die Bewertung POJO hinzu: 

public class Rating {
    private Long id;
    private Long bookId;
    private int stars;

   //standard getters and setters
}

6.3. Eigenschaften

Jetzt müssen wir nur noch unsere beiden Eigenschaftsdateien hinzufügen:

bootstrap.properties in src/main/resources: 

spring.cloud.config.name=rating-service
spring.cloud.config.discovery.service-id=config
spring.cloud.config.discovery.enabled=true

eureka.client.serviceUrl.defaultZone=http://localhost:8082/eureka/----

__rating-service.properties__ in unserem Git-Repository:

[source,text,gutter:,true]

spring.application.name=rating-service server.port=8084

eureka.client.region = default eureka.client.registryFetchIntervalSeconds = 5 eureka.client.serviceUrl.defaultZone=http://localhost:8082/eureka/----

Übernehmen Sie die Änderungen am Repository.

6.4. Lauf

Sobald alle anderen Anwendungen gestartet sind, können wir den Bewertungsservice starten. Die Konsolenausgabe sollte folgendermaßen aussehen: 

DiscoveryClient__RATING-SERVICE/10.1.10.235:rating-service:8083: registering service...
DiscoveryClient__RATING-SERVICE/10.1.10.235:rating-service:8083 - registration status: 204
Tomcat started on port(s): 8084 (http)

Sobald dies der Fall ist, können wir unseren Browser verwenden, um auf den gerade erstellten Endpunkt zuzugreifen. Navigieren Sie zu http://localhost : 8080/rating-service/ratings/all und wir erhalten JSON zurück, das alle unsere Bewertungen enthält. Beachten Sie, dass wir nicht direkt über den Port 8084 auf den Bewertungsdienst zugreifen, sondern den Gatewayserver.

7. Fazit

Jetzt können wir die verschiedenen Teile der Spring Cloud zu einer funktionierenden Microservice-Anwendung verbinden. Auf dieser Basis können wir komplexere Anwendungen erstellen.

Diesen Quellcode finden Sie wie immer unter Github .

Related