Tutorial: Reaktiver Spring Boot

Im vergangenen Monat präsentierte Trisha Gee (JetBrains) auf der SpringOne eine Demo zur Erstellung einer Echtzeit-Aktienkurs-App mit Spring Boot, Kotlin und JavaFX. Die Live-Demo wurde aufgezeichnet und ist als 70-minütiges Video verfügbar.

Am 18. Dezember hat Trisha die Veröffentlichung des reaktiven Spring Boot-Tutorials auf dzone.com abgeschlossen, das auf diesem Video basiert. Es besteht aus einer Reihe kürzerer Videos mit einem begleitenden Blogbeitrag, in dem die einzelnen Schritte langsamer und ausführlicher erläutert werden.

Ich hatte die Idee, dieses Tutorial ins Russische zu übersetzen. Trisha antwortete jedoch höflich mit meiner Anfrage dazu:

"Lassen Sie mich mit meiner Organisation sprechen. Ich würde es gerne übersetzen lassen, aber wir könnten einen bevorzugten Weg finden, um die Dinge zu übersetzen. “

Deshalb habe ich mich auf einen Überblick über dieses Tutorial beschränkt, das die folgenden Lektionen enthält:

1. Aufbau eines Kotlin REST Service
2. Ein REST-Client für reaktive Streams
3. Eine JavaFX Spring Boot-Anwendung
4. Ein JavaFX-Liniendiagramm
5. Automatische Konfiguration für gemeinsam genutzte Beans
6. Reaktive Daten anzeigen
7. Mehrere Abonnenten abonnieren
8. Kotlin RSocket Server
9. Java RSocket Client
10. Spring-Profile zum Wechseln von Clients

Das Tutorial besteht aus einer Reihe von Lektionen, in denen eine vollständige Spring Boot-Anwendung mit der internen Kotlin-Oberfläche, dem Java-Client und der JavaFX-Benutzeroberfläche erstellt wird.

Teil 1. Einen REST-Service auf Kotlin erstellen

Im ersten Teil des Tutorials wird beschrieben, wie Sie eine Spring Boot-Anwendung auf Kotlin erstellen, die als Serverseite der Anwendung dient. Es wird ein reaktiver REST-Service erstellt, zu dem Sie in den folgenden Teilen des Handbuchs eine Verbindung herstellen können.

Dieser Blogeintrag enthält ein Video, das den schrittweisen Ablauf zeigt, und eine Textanleitung (angepasst aus dem Transkript des Videos) für diejenigen, die ein schriftliches Format bevorzugen.

Dieser Teil des Tutorials enthält die folgenden Schritte:

• Erstellen eines Spring Boot Service-Projekts
• Struktur des Spring Boot-Projekts
• Erstellen eines REST-Controllers
• Erstellen einer Datenklasse für Aktienkurse
• Preisgenerierung und Rendite
• Anwendungsstart

Nachdem Sie diese Schritte in Teil 1 des Tutorials ausgeführt haben, wird eine einfache Kotlin Spring Boot-Anwendung erstellt, die mithilfe von Reactive Streams einmal pro Sekunde einen zufällig generierten Aktienkurs ausgibt.

Der vollständige Code für Teil 1 des Tutorials ist auf GitHub verfügbar .

Teil 2. REST-Client für reaktive Flows

Teil 2 des Tutorials zeigt, wie Sie in Spring einen reaktiven Java-Client erstellen, der eine Verbindung zu einem REST-Service herstellt, der einmal pro Sekunde Aktienkurse überträgt. Dieser Client wird in den folgenden Abschnitten des Handbuchs verwendet. Während der Entwicklung wird ein TDD-basierter Prozess verwendet, um den Client zu erstellen und zu testen.

Dieser Blogeintrag enthält ein Video, das den schrittweisen Ablauf zeigt, und eine Textanleitung (angepasst aus dem Transkript des Videos) für diejenigen, die ein schriftliches Format bevorzugen.

Dieser Teil des Tutorials enthält die folgenden Schritte:

• Ein Projekt für einen Kunden erstellen
• Kundenklasse anlegen
• Kundentest erstellen
• Erstellen einer Kundenbasispreismethode
• Erstellen Sie eine Klasse, um die Aktienkurse zu halten
• Assertions zum Test hinzufügen
• Verbinden Sie den Client mit dem REST-Service
• Führen Sie den Integrationstest aus
• Genauere Aussagen im Integrationstest

Reaktive Anwendungen zu testen ist keine leichte Aufgabe, und es gibt sicherlich viel bessere Möglichkeiten, dies zu tun als in diesem einfachen Beispiel. Ein Integrationstest wurde jedoch erfolgreich verwendet, um die API- und Client-Funktionalität für Aktienkurse zu bestimmen.

Dieser Client stellt eine Verbindung zum Endpunkt her, der vom Server gesendete Ereignisse generiert und einen Stream von StockPrice-Objekten zurückgibt, die von einem anderen Service verwendet werden können. Wie das geht, zeigen die nächsten Videos dieser Reihe.

Der vollständige 2-Teile-Code ist auf GitHub verfügbar .

Teil 3. JavaFX Spring Boot-Anwendung

Die dritte Demonstration zeigt, wie eine JavaFX-Anwendung erstellt wird, die über Spring Boot gestartet und verwaltet wird, um Spring-Funktionen wie Inversion of Control und Dependency Injection in unserer JavaFX-Anwendung zu verwenden.

Dieser Blogeintrag enthält auch ein Video, das den schrittweisen Ablauf zeigt, und eine Textanleitung (angepasst aus dem Transkript des Videos) für diejenigen, die ein schriftliches Format bevorzugen.

Dieser Teil des Tutorials enthält die folgenden Schritte:

• Moduleinrichtung
• Ändern der Spring Boot-Anwendungsklasse
• Bearbeiten der Spring Boot-Einstellungen
• JavaFX-Anwendungsklasse erstellen
• Einrichten der Spring Boot Application-Klasse
• Veröffentlichen von Ereignissen über den Anwendungskontext
• Anwendungskontext erstellen
• Anwendungskontext schließen
• App-Events abhören

Nach Abschluss der Schritte 3 des Lernprogramms wird das Hauptfenster der JavaFX-Anwendung erstellt (Phase - siehe Teil 2 des JavaFX-Lernprogramms ), in dem Sie die Benutzeroberfläche konfigurieren können. Als Nächstes können Sie unsere StockUIA-Anwendung ausführen und feststellen, dass sie erfolgreich als Spring Boot-Anwendung gestartet wird. Außerdem wird ein Java-Prozess gestartet, der die Benutzeroberfläche anzeigt, wenn wir sie erstellt haben. Momentan wurde eine JavaFX-Anwendung erfolgreich erstellt, die mit Spring gestartet und verwaltet wird und es Ihnen ermöglicht, die praktischen Funktionen jeder Spring-Anwendung zu nutzen.

Der vollständige 3-teilige Tutorial-Code ist auf GitHub verfügbar.

Teil 4. JavaFX-Liniendiagramm

In diesem Schritt des Tutorials erfahren Sie, wie Sie eine JavaFX-Anwendung erstellen, die ein Liniendiagramm zeigt. Diese Anwendung verwendet Spring für wichtige Funktionen wie die Umkehrung der Steuerung.

Dieser Blogeintrag enthält ein Video, das den schrittweisen Ablauf zeigt, und eine Textanleitung (angepasst aus dem Transkript des Videos) für diejenigen, die ein schriftliches Format bevorzugen.

Dieser Teil des Tutorials enthält die folgenden Schritte:

• Erstellen einer Szene (Szene - siehe Teil 2 des JavaFX-Tutorials )
• FXML verwenden
• Erstellen einer FXML-Datei
• Anwendungsheader festlegen
• Festlegen des Anwendungsheaders aus application.properties
• JavaFX-Controller von Spring beziehen
• Erstellen Sie ein Liniendiagramm

Nachdem Sie die obigen Schritte ausgeführt haben, wird in Teil 4 des Tutorials eine JavaFX-Anwendung erstellt. Nach dem Start der Anwendung sollte der Umriss des Liniendiagramms in unserem Fenster mit Zahlen für den Preis entlang der Y-Achse und die Zeit entlang der X-Achse angezeigt werden.



Es wurde eine in Spring Boot integrierte JavaFX-Anwendung erstellt, die mithilfe von FXML deklariert, was in der Ansicht angezeigt werden soll.

Der vollständige Code für diesen Teil des Tutorials ist auf GitHub verfügbar.

Teil 5. Automatische Konfiguration für gemeinsam genutzte Beans

In Lektion 5 wird gezeigt, wie Spring Beans von einem Modul in einem anderen Modul mithilfe der automatischen Konfiguration verwendet werden.

Dieser Blogeintrag enthält auch ein Video, das den schrittweisen Ablauf zeigt, und eine Textanleitung (angepasst aus dem Transkript des Videos) für diejenigen, die ein schriftliches Format bevorzugen.

In der letzten Lektion wurde eine JavaFX Spring Boot-Anwendung erstellt, in der ein leeres Liniendiagramm angezeigt wurde. In diesem Video wird gezeigt, wie die automatische Konfiguration für Spring Beans konfiguriert wird, damit die im Modul stock-client im Modul stock-ui definierten Bean-Komponenten verwendet werden können.

Dieser Teil des Tutorials enthält die folgenden Schritte:

• Hinzufügen einer Abhängigkeit von einem anderen Modul
• Erstellen eines WebClientStockClient-Beans
• Aktivieren Sie die automatische Konfiguration

Dies ist ein ziemlich kleiner Teil des Tutorials, aber es ermöglicht uns, Module zu erstellen, die von verschiedenen Spring Boot-Anwendungen wiederverwendet werden können. Jetzt können wir den Client in ChartController verwenden, um eine Verbindung zum Kursdienst herzustellen und die Kurse in Echtzeit auf einem Liniendiagramm anzuzeigen.

Der vollständige Code für diesen Teil ist auf GitHub verfügbar.

Teil 6. Reaktive Datenanzeige

In dieser Lektion wird erläutert, wie Sie JavaFX-Diagramme mit unserem Kotlin Spring Boot-Service verbinden, um die Preise in Echtzeit anzuzeigen. Dieser Blogeintrag enthält ein Video, das den schrittweisen Ablauf zeigt, und eine Textanleitung (angepasst aus dem Transkript des Videos) für diejenigen, die ein schriftliches Format bevorzugen.

Im vierten Teil wurde die JavaFX Spring Boot-Anwendung erstellt, die ein leeres Liniendiagramm zeigt. Die neueste Version ( fünfter Teil ) verwendete WebClientStockClient, um eine Verbindung zum Preisservice herzustellen. In diesem Teil wurde ein Liniendiagramm erstellt, in dem die Preise unseres Kotlin Spring Boot-Service in Echtzeit angezeigt werden.

Dieser Teil des Tutorials enthält die folgenden Schritte:

• Diagrammdaten konfigurieren
• Preisdaten abonnieren
• Preisdatenanzeige
• Anwendungsstart
• Zeichennamenanzeige
• Code-Reinigung

Mit einigen Codezeilen in diesem Teil des Lernprogramms wurde eine JavaFX-Anwendung erstellt, die SpringClient zum Herstellen einer Verbindung mit dem Spring Boot-Dienst verwendet, einen reaktiven Preisstrom abonniert und die Preise in einem Liniendiagramm in Echtzeit zeichnet.

Der vollständige Code für diesen Teil ist auf GitHub verfügbar.

Teil 7. Mehrere Abonnenten abonnieren

Im vorherigen Teil haben wir ein JavaFX-Liniendiagramm für die Preise von unserem Reactive Spring Boot-Service abonniert und diese in Echtzeit angezeigt.

In dieser Lektion wird ein Zeitplan für die Echtzeitaktualisierung fertiggestellt, in dem die Preise für mehr als eine Aktie angezeigt werden, sodass mehr als ein Verbraucher unseren reaktiven Preisstrom abonnieren muss.

Auf dem Blog finden Sie ein Video, das den Schritt-für-Schritt-Prozess zeigt, und eine Textbeschreibung (angepasst aus dem Transkript des Videos) für diejenigen, die ein schriftliches Format bevorzugen.

Dieser Teil des Tutorials enthält die folgenden Schritte:

• Wir realisieren die Abonnentenpreise
• Übertragen von Aufgaben an einen Preisabonnenten
• Hinzufügen eines zweiten Abonnenten
• Code-Reinigung
• Bonus Refactoring (nicht im Video!)

Am Ende dieses Teils des Tutorials erstellen Sie eine JavaFX-Anwendung, die mehr als einen Preis von unserem Spring Boot-Service abonniert und jeden Satz von Echtzeit-Preisdaten in mehreren Serien in einem Liniendiagramm anzeigt.

Der vollständige Code für diesen Teil ist auf GitHub verfügbar.

Teil 8. Kotlin RSocket Server

In dieser Lektion wird Kotlin um einen neuen internen Service erweitert, der Preise über RSocket, ein Protokoll für reaktive Flows, sendet. Dieser Blogeintrag enthält ein Video, das den schrittweisen Ablauf zeigt, und eine Textanleitung (angepasst aus dem Transkript des Videos) für diejenigen, die ein schriftliches Format bevorzugen.

In dieser Phase der Lernprogrammreihe wurde erfolgreich eine umfassende Anwendung erstellt, die die Preise aus dem Kotlin Spring Boot-Service veröffentlicht und in einem JavaFX-Liniendiagramm anzeigt. Es verwendet das HTTP-Protokoll, um Ereignisse an den Server zu senden. Da es sich jedoch um eine reaktive Anwendung handelt, können wir das Protokoll auswählen, das für das Streaming von Daten am besten geeignet ist.

In diesem Teil des Tutorials wird ein Service erstellt, der mithilfe des RSocket-Protokolls Preisdaten erzeugt.

Dieser Teil des Tutorials enthält die folgenden Schritte:

• Erstellen eines RSocket-Controllers
• Wir realisieren preis service
• Portierung von allgemeinem Code nach PriceService
• Reduzieren Sie die Code-Duplikation
• Refactoring zur Reduzierung der Boilerplate
• Einstellungen für die Nachrichtenanzeige
• RSocket-Serverkonfiguration

Am Ende dieses Teils des Tutorials startet Port 7000 einen Preisservice, mit dem ein Client verbunden werden kann, um Aktienkurse über RSocket zu erhalten.

Der vollständige Quellcode für diesen Teil ist auf GitHub verfügbar.

Teil 9. Java RSocket Client

In dieser Lektion fügen wir einen RSocket-Client hinzu, der mit dem in der letzten Lektion erstellten RSocket- Server kommunizieren kann.

Dieser Blogeintrag enthält ein Video, das den schrittweisen Ablauf zeigt, und eine Textanleitung (angepasst aus dem Transkript des Videos) für diejenigen, die ein schriftliches Format bevorzugen.

Derzeit haben wir eine Anwendung, die mit Spring's WebClient von Anfang bis Ende funktioniert . In der letzten Lektion haben wir den neuen RSocket-Server vorgestellt, der derzeit funktioniert. In dieser Lektion erfahren Sie, wie Sie einen Client erstellen, um eine Verbindung zu ihm herzustellen.

Dieser Teil des Tutorials enthält die folgenden Schritte:

• Erstellen Sie einen Integrationstest
• RSocket Stock Client erstellen
• Einführung in die StockClient-Oberfläche
• Implementierung der RSocket-Verbindung
• RSocketRequester erstellen
• Integrationstest bestanden
• Testen mit StepVerifier
• Hinzufügen von Rollback- und Fehlerbehandlungsstrategien

Am Ende dieses Teils des Tutorials werden wir einen RSocket-Server haben, der Aktienkurse generiert, und einen RSocket-Client, der eine Verbindung dazu herstellen und diese Kurse anzeigen kann. In der nächsten Lektion erfahren Sie, wie Sie von WebClientStockClient zu unserem neuen RSocketStockClient wechseln.

Der vollständige Quellcode für diesen Teil ist auf GitHub verfügbar.

Teil 10. Federprofile zum Mandantenwechsel

Im letzten Teil des Lernprogramms wird die Einstellung "Spring-Profile" verwendet, damit die Anwendung bestimmen kann, auf welchem ​​unserer beiden Clients (Ereignisse, die vom Server über WebClient oder RSocket gesendet werden) eine Verbindung zu unserem Kotlin Spring Boot-Preisdienst hergestellt werden soll.

Wie üblich enthält dieser Blog-Beitrag ein Video, das den schrittweisen Ablauf zeigt, und eine Textanleitung (angepasst an das Transkript des Videos) für diejenigen, die ein schriftliches Format bevorzugen.

In dieser Phase der Tutorial-Reihe haben wir einen RSocket-Client, mit dem wir eine Verbindung zu unserem RSocket-Server herstellen können. Wir möchten diese Funktionen aus unserer JavaFX-Anwendung heraus nutzen.

Dieser Teil des Tutorials enthält die folgenden Schritte:

• Erstellen eines RSocketStockClient-Beans
• Bean zur Verwendung auswählen
• Aktive Profilauswahl
• Protokollierung zum Debuggen
• Preise über RSocket erhalten

Am Ende dieses Teils des Tutorials finden Sie eine umfassende JavaFX-Liniendiagramm-Anwendung, die den reaktiven Preisstrom der Kotlin Spring Boot-Anwendung abonniert. Darüber hinaus kann die Anwendung so konfiguriert werden, dass diese Preise entweder über vom Server gesendete Ereignisse oder über das neue RSocket-Protokoll empfangen werden.

Vollständiger Code ist auf GitHub verfügbar:

Kundenprojekt (Stock-Client und Stock-UI-Module).
Serverprojekt (Kotlin Spring Boot-Anwendung)

Zusätzliche Lektüre

Voll reaktiv: Spring, Kotlin und JavaFX spielen zusammen [Links]
Kotlin Microservice mit Spring Boot Tutorial
Spring Reactive Programming in Java