🤰🏽 🤦 👨🏾‍🍳 Tutoriel: Boot de printemps réactif 🎬 👩🏿‍🌾 🤱🏼

Le mois dernier, Trisha Gee (JetBrains) a présenté à SpringOne une démonstration de la création d'une application de cours des actions en temps réel à l'aide de Spring Boot, Kotlin et JavaFX. La démo en direct a été enregistrée et est disponible en vidéo de 70 minutes .

Le 18 décembre, Trisha a terminé la publication sur dzone.com du didacticiel réactif Spring Boot basé sur la vidéo, sous la forme d'une série de vidéos plus courtes accompagnées d'un article de blog expliquant chaque étape plus lentement et plus en détail.

J'ai eu l'idée de traduire ce tutoriel en russe. Cependant, Trisha a répondu poliment avec mon enquête à ce sujet:

"Permettez-moi de vérifier auprès de mon organisation. J'adorerais le faire traduire, mais nous pourrions avoir une façon préférée de faire traduire les choses. »

J'ai donc décidé de me limiter à un aperçu de ce tutoriel, qui comprend la série de leçons suivante:

Le didacticiel est une série de leçons dans lesquelles une application Spring Boot complète sera créée avec l'interface interne Kotlin, le client Java et l'interface utilisateur JavaFX.

Partie 1. Créer un service REST sur Kotlin

La première partie du didacticiel décrit comment créer une application Spring Boot sur Kotlin, qui sert du côté serveur de l'application. Un service REST réactif sera créé, auquel vous pourrez vous connecter dans les parties suivantes du manuel.

Cette entrée de blog contient une vidéo montrant le processus étape par étape et un guide de texte (adapté de la transcription de la vidéo) pour ceux qui préfèrent un format écrit.

Cette partie du didacticiel comprend les étapes suivantes:

Création d'un projet de service Spring Boot
Structure du projet Spring Boot
Création d'un contrôleur REST
Création d'une classe de données pour les cours des actions
Génération et retour des prix
Lancement de l'application

Après avoir terminé ces étapes dans la partie 1 du didacticiel, une application Kotlin Spring Boot simple sera créée qui utilise Reactive Streams pour émettre un prix des actions généré au hasard une fois par seconde.

Le code complet de la partie 1 du tutoriel est disponible sur GitHub .

Partie 2. Client REST pour les flux réactifs

La partie 2 du didacticiel montre comment créer un client Java réactif sur Spring qui se connecte à un service REST qui diffuse les cours des actions une fois par seconde. Ce client sera utilisé dans les sections suivantes du manuel. Pendant le développement, un processus basé sur TDD sera utilisé pour créer le client et le tester.

Cette entrée de blog contient une vidéo montrant le processus étape par étape et un guide de texte (adapté de la transcription de la vidéo) pour ceux qui préfèrent un format écrit.

Cette partie du didacticiel comprend les étapes suivantes:

Création d'un projet pour un client
Création d'une classe de clients
Création d'un test client
Création d'une méthode de prix de base client
Créer une classe pour maintenir les cours des actions
Ajout d'assertions au test
Connectez le client au service REST
Exécuter le test d'intégration
Assertions plus approfondies dans le test d'intégration

Tester des applications réactives n'est pas une compétence facile, et il existe certainement de bien meilleures façons de le faire que dans cet exemple simple. Cependant, un test d'intégration a été utilisé avec succès pour déterminer l'API et la fonctionnalité client pour les cours des actions.

Ce client se connecte au point de terminaison, qui génère des événements envoyés par le serveur et renvoie un flux d'objets StockPrice qui peuvent être utilisés par un autre service. Comment faire cela sera montré dans les prochaines vidéos de cette série.

Le code complet en 2 parties est disponible sur GitHub .

Partie 3. Application JavaFX Spring Boot

La troisième démonstration montre comment créer une application JavaFX qui est lancée et gérée via Spring Boot pour utiliser les fonctionnalités Spring, telles que l'inversion de contrôle et l'injection de dépendances, dans notre application JavaFX.

Cette entrée de blog contient également une vidéo montrant le processus étape par étape et un guide de texte (adapté de la transcription de la vidéo) pour ceux qui préfèrent un format écrit.

Cette partie du didacticiel comprend les étapes suivantes:

Configuration du module
Modification de la classe d'application Spring Boot
Modification des paramètres de démarrage de Spring
Création d'une classe d'application JavaFX
Configuration de la classe d'application Spring Boot
Publication d'événements dans le contexte de l'application
Créer un contexte d'application
Fermeture du contexte d'application
Écoute des événements d'application

Après avoir terminé les étapes 3 du didacticiel, la fenêtre principale de l'application JavaFX sera créée (étape - voir la partie 2 du didacticiel JavaFX ), ce qui vous permet de configurer l'interface utilisateur. Ensuite, vous pouvez exécuter notre application StockUIA et voir qu'elle démarre correctement en tant qu'application Spring Boot. Il lance également un processus Java qui afficherait l'interface utilisateur si nous la créions. À l'heure actuelle, une application JavaFX a été créée avec succès, qui est lancée et gérée à l'aide de Spring et vous permet d'utiliser les fonctions pratiques de n'importe quelle application Spring.

Le code tutoriel complet en 3 parties est disponible sur GitHub.

Partie 4. Graphique linéaire JavaFX

Dans cette étape du didacticiel, nous verrons comment créer une application JavaFX qui affiche un diagramme linéaire. Cette application utilise Spring pour des fonctions importantes telles que l'inversion de contrôle.

Cette entrée de blog contient une vidéo montrant le processus étape par étape et un guide de texte (adapté de la transcription de la vidéo) pour ceux qui préfèrent un format écrit.

Cette partie du didacticiel comprend les étapes suivantes:

Création d'une scène (Scène - voir la partie 2 du tutoriel JavaFX )
Utilisation de FXML
Création d'un fichier FXML
Définir l'en-tête d'application
Définition de l'en-tête d' application à partir de application.properties
Obtenir des contrôleurs JavaFX à partir de Spring
Créer un graphique linéaire

Après avoir effectué les étapes ci-dessus, la partie 4 du didacticiel créera une application JavaFX. Après avoir lancé l'application, nous devrions voir le contour du graphique linéaire affiché dans notre fenêtre, avec des chiffres pour le prix le long de l'axe Y et le temps le long de l'axe X.

Une application JavaFX intégrée à Spring Boot a été créée qui utilise FXML pour déclarer ce qui doit être affiché dans la vue.

Le code complet de cette partie du tutoriel est disponible sur GitHub.

Partie 5. Configuration automatique pour les beans partagés

La leçon 5 montre comment utiliser les beans Spring d'un module dans un autre module à l'aide de la configuration automatique.

Cette entrée de blog contient également une vidéo montrant le processus étape par étape et un guide de texte (adapté de la transcription de la vidéo) pour ceux qui préfèrent un format écrit.

Dans la dernière leçon, une application JavaFX Spring Boot a été créée qui affiche un diagramme linéaire vide. Dans cette vidéo, nous verrons comment configurer l'autoconfiguration pour Spring Beans afin que nous puissions utiliser les composants de bean définis dans le module stock-client dans le module stock-ui.

Cette partie du didacticiel comprend les étapes suivantes:

Ajout d'une dépendance à un autre module
Création d'un bean WebClientStockClient
Activer la configuration automatique

Il s'agit d'une petite partie du didacticiel, mais elle nous permet de créer des modules qui peuvent être réutilisés par diverses applications Spring Boot. Maintenant, nous pouvons utiliser le client dans ChartController pour se connecter au service de prix et commencer à afficher les prix en temps réel sur un graphique linéaire.

Le code complet de cette partie est disponible sur GitHub.

Partie 6. Affichage réactif des données

Cette leçon traite de la connexion des diagrammes JavaFX à notre service Kotlin Spring Boot pour afficher les prix en temps réel. Cette entrée de blog contient une vidéo montrant le processus étape par étape et un guide de texte (adapté de la transcription de la vidéo) pour ceux qui préfèrent un format écrit.

Dans la quatrième partie , l'application JavaFX Spring Boot a été créée, qui montre un diagramme linéaire vide. La dernière version ( cinquième partie ) utilisait WebClientStockClient pour se connecter au service de prix. Dans cette partie, un graphique linéaire montrant les prix provenant de notre service Kotlin Spring Boot en temps réel a été obtenu.

Cette partie du didacticiel comprend les étapes suivantes:

Configuration des données de graphique
Abonnez-vous aux données de tarification
Affichage des données de prix
Lancement de l'application
Affichage du nom du personnage
Nettoyage de code

Quelques lignes de code dans cette partie du didacticiel ont créé une application JavaFX qui utilise SpringClient pour se connecter au service Spring Boot, s'abonne à un flux de prix réactif et dessine les prix sur un graphique linéaire en temps réel.

Le code complet de cette partie est disponible sur GitHub.

Partie 7. Abonnement à plusieurs abonnés

Dans la partie précédente , nous nous sommes abonnés à un graphique en ligne JavaFX pour les prix de notre service Reactive Spring Boot et les avons affichés en temps réel.

Dans cette leçon, un calendrier de mise à jour en temps réel sera finalisé pour afficher les prix de plusieurs actions, ce qui nécessite plus d'un consommateur de s'abonner à notre flux de prix réactif.

Sur le blog, vous trouverez une vidéo montrant le processus étape par étape et une description textuelle (adaptée de la transcription de la vidéo) pour ceux qui préfèrent un format écrit.

Cette partie du didacticiel comprend les étapes suivantes:

Nous réalisons les prix des abonnés
Transfert de droits à un abonné au prix
Ajout d'un deuxième abonné
Nettoyage de code
Refactoring bonus (pas dans la vidéo!)

À la fin de cette partie du didacticiel, vous allez créer une application JavaFX qui souscrit à plus d'un prix à partir de notre service Spring Boot et affiche chaque ensemble de données de prix en temps réel en plusieurs séries sur un graphique linéaire.

Le code complet de cette partie est disponible sur GitHub.

Partie 8. Serveur Kotlin RSocket

Dans cette leçon , un nouveau service interne sera ajouté à Kotlin, qui envoie les prix via RSocket, un protocole pour les flux réactifs. Cette entrée de blog contient une vidéo montrant le processus étape par étape et un guide de texte (adapté de la transcription de la vidéo) pour ceux qui préfèrent un format écrit.

À ce stade de la série de didacticiels, une application complète a été créée avec succès qui publie les prix du service Kotlin Spring Boot et les affiche sur un graphique en ligne JavaFX. Il utilise le protocole HTTP pour envoyer des événements au serveur. Cependant, comme il s'agit d'une application réactive, nous pouvons choisir le protocole qui convient le mieux pour la diffusion de données en continu.

Dans cette partie du tutoriel, un service sera créé qui produira des données de prix en utilisant le protocole RSocket.

Cette partie du didacticiel comprend les étapes suivantes:

Création d'un contrôleur RSocket
Nous réalisons un service de prix
Portage du code commun vers PriceService
Réduisez la duplication de code
Refactoring pour réduire la chaudière
Paramètres d'affichage des messages
Configuration du serveur RSocket

À la fin de cette partie du didacticiel, le port 7000 lancera un service de tarification, prêt à connecter un client pour recevoir les cours des actions via RSocket.

Le code source complet de cette partie est disponible sur GitHub.

Partie 9. Client Java RSocket

Dans cette leçon, nous allons ajouter un client RSocket qui peut communiquer avec le serveur RSocket que nous avons créé dans la dernière leçon .

Cette entrée de blog contient une vidéo montrant le processus étape par étape et un guide de texte (adapté de la transcription de la vidéo) pour ceux qui préfèrent un format écrit.

Actuellement, nous avons une application qui fonctionne du début à la fin en utilisant WebClient de Spring. Dans la dernière leçon, nous avons présenté le nouveau serveur RSocket, qui fonctionne actuellement, et dans cette leçon, nous verrons comment créer un client pour s'y connecter.

Cette partie du didacticiel comprend les étapes suivantes:

Créer un test d'intégration
Création d'un client RSocket Stock
Présentation de l'interface StockClient
Implémentation de la connexion RSocket
Création de RSocketRequester
Test de réussite d'intégration
Test avec StepVerifier
Ajout de stratégies de restauration et de gestion des erreurs

À la fin de cette partie du tutoriel, nous aurons un serveur RSocket qui génère les cours des actions et un client RSocket qui peut s'y connecter et voir ces prix. Dans la prochaine leçon, nous verrons comment passer de l'utilisation de WebClientStockClient à notre nouveau RSocketStockClient.

Le code source complet de cette partie est disponible sur GitHub.

Partie 10. Profils Spring pour changer de client

La dernière partie du didacticiel utilise le paramètre Spring Profiles afin que l'application puisse déterminer lequel de nos deux clients (événements envoyés par le serveur via WebClient ou RSocket) utiliser pour se connecter à notre service de tarification Kotlin Spring Boot.

Comme d'habitude, ce billet de blog contient une vidéo montrant le processus étape par étape et un guide de texte (adapté de la transcription de la vidéo) pour ceux qui préfèrent un format écrit.

Pour cette étape de la série de tutoriels, nous avons un client RSocket qui nous permet de nous connecter à notre serveur RSocket, nous voulons utiliser ces fonctionnalités de notre application JavaFX.

Cette partie du didacticiel comprend les étapes suivantes:

Création d'un bean RSocketStockClient
Choisir un bean à utiliser
Sélection active de profil
Journalisation pour le débogage
Obtenir des prix via RSocket

À la fin de cette partie du didacticiel, nous aurons une application complète de graphique en ligne JavaFX qui s'abonne au flux de prix réactif de l'application Kotlin Spring Boot. De plus, l'application peut être configurée pour recevoir ces prix soit via des événements envoyés par le serveur, soit via le nouveau protocole RSocket.

Le code complet est disponible sur GitHub:

Projet client (stock-client et stock-ui-modules).
Projet serveur (application Kotlin Spring Boot)

Lecture complémentaire

Entièrement réactif: Spring, Kotlin et JavaFX jouent ensemble [Liens]
Microservice Kotlin avec didacticiel Spring Boot
Programmation réactive Spring en Java

Tutoriel: Boot de printemps réactif