Ce livre sur le développement d’applications réactives et de streaming s’adresse à toute personne (pro­grammeur, tech lead, architecte…) amenée à travailler sur un projet basé sur Java Spring (en version 6.0 au moment de l’écriture). Il a pour objectif de donner les connaissances nécessaires pour appréhender les problématiques liées aux nouvelles architectures réactives avec la programmation asynchrone. Pour pro­fiter pleinement de la lecture de ce livre, il est nécessaire de bien comprendre les mécanismes de Jakarta EE et de la programmation Java en général. Des connaissances de base sur le framework Spring sont également un plus.

L’auteur commence par présenter les éléments fondamentaux pour la programmation réactive. Il présente ensuite les librairies reactor-core, la stack web réactive Spring avec WebFlux et les WebSockets et RSocket. La gestion des bases de données réactives est ensuite étudiée avant d’explorer les reactor(s) spécialisés pour Netty, RabbitMQ et Kafka. Les extensions pour Kotlin sont également détaillées.

La suite du livre aborde la programmation des microservices et des applications dans le cloud ainsi que des éléments comme le DDD, l’event sourcing, l’architecture Hexagonale et le CQRS. L’auteur présente pour conclure une étude des applications générées par JHipster.

Tout au long du livre, l’auteur s’appuie sur des exemples concrets d’utilisation. Les éléments nécessaires à la réalisation de ces exemples sont disponibles en téléchargement sur le site www.editions-eni.fr

Téléchargements

• Des fichiers complémentaires (258 Ko)

Avant-propos

1. Préambule
2. Contexte des applications
3. Aperçu de Spring
4. Principes des applications réactives
5. Objectifs du livre
6. Organisation du livre
7. Public visé
8. Prérequis pour aborder la programmation réactive avec Spring
9. Ressources complémentaires
10. Remerciements

La programmation fonctionnelle

1. Introduction
2. Expressions lambda
3. Interfaces fonctionnelles
4. Méthodes de référence
5. Opérations sur les flux
6. Immutabilité
7. Haut ordre de fonction
8. Réduction de boucle
9. Conclusion

Programmation réactive

1. Introduction
2. Concepts clés de la programmation réactive
3. Reactive Streams
   1. 1. Origines
   2. 2. Initiative Reactive Streams
   3. 3. Adoption
4. Applications réactives sans Reactor
   1. 1. Akka
   2. 2. Vert.x
5. Fonctionnement de Reactor
   1. 1. En interne
   2. 2. API Rx-ified

Reactor Core

1. Introduction
2. Reactor Core
3. Méthode subscribe()
   1. 1. Surcharge
   2. 2. Gestion des erreurs
   3. 3. Valeur de retour
4. Utilisation du BaseSubscriber
5. Générer une séquence manuellement
   1. 1. Modèle synchrone
   2. 2. Modèle asynchrone
   3. 3. Modèle hybride push/pull
6. Méthode handle()
7. Scheduler
8. Traiter correctement les cas d’erreurs
   1. 1. Opérateur onErrorResume
   2. 2. Opérateur onErrorReturn
   3. 3. Opérateur onErrorMap
   4. 4. Opérateur doOnError
   5. 5. Opérateur onErrorStop
   6. 6. Opérateur onErrorContinue
9. Capture et renvoi d'exceptions
   1. 1. Gestion des exceptions
   2. 2. doFinally
   3. 3. retry
10. Sinks
11. Transformations personnalisées sur le flux
    1. 1. Créer des flux
       1. a. Opérateurs just() et defer()
       2. b. Opérateurs share() et replay(...)
       3. c. ConnectableFlux
    2. 2. Regroupements de flux
       1. a. ParallelFlux
       2. b. Flux<><t, k="">></t,>
       3. c. Modifier les planificateurs par défaut
       4. d. Gestionnaire d’erreur global
12. Global hooks
    1. 1. Hooks de suppression
    2. 2. Hook onOperatorError
    3. 3. Hooks d’assemblage
    4. 4. Hooks préconfigurés
13. API Context
    1. 1. Structure du Context
    2. 2. Opérateur contextWrite
14. Tests
    1. 1. Tester avec StepVerifier
       1. a. Interface Step<t></t>
       2. b. StepVerifierOptions
       3. c. Couverture de test
    2. 2. Tests de programmes basés sur l’horlogesystème
       1. a. Méthode withVirtualTime
       2. b. VirtualTimeScheduler
       3. c. expectNoEvent(Duration)
    3. 3. Utilisation du verifyThenAssertThat()
    4. 4. Tester avec le contexte associé à uneséquence réactive
    5. 5. TestPublisher
    6. 6. createNonCompliant()
    7. 7. PublisherProbe
15. Réacteur de débogage
    1. 1. Hooks.onOperatorDebug()
    2. 2. Méthode checkpoint()
16. Conclusion

Stack web reactive Spring

1. Introduction à la stack web réactive
2. Noyau réactif
3. HttpHandler
   1. 1. Généralités
   2. 2. Pour Reactor Netty
4. API WebHandler
5. WebHttpHandlerBuilder
6. ServerWebExchange
7. Spring WebFlux
   1. 1. Aspects principaux pour démarrer
      1. a. Sécurité minimale
      2. b. Routage et manipulation fonctionnelle
      3. c. Composants réactifs basés sur desannotations
   2. 2. Utilisation des composants
      1. a. Utilisation de ServerWebExchange
      2. b. WebFilter
   3. 3. CORS
   4. 4. WebExceptionHandler
   5. 5. Utilisation du ProblemDetail
   6. 6. Encodeurs et décodeurs
   7. 7. FormHttpMessageReader et FormHttpMessageWriter
   8. 8. MultipartHttpMessageReader et MultipartHttpMessageWriter
   9. 9. maxInMemorySize
   10. 10. Faire du streaming
   11. 11. Journalisation
   12. 12. DispatcherHandler
   13. 13. WebFluxConfigurer
       1. a. Configuration globale
       2. b. Configurer des intercepteurs de requêtes
       3. c. Configurer les gestionnaires de ressources
       4. d. Configurer les paramètres de sécurité
   14. 14. HandlerAdapter et HandlerResult
   15. 15. DispatchExceptionHandler
   16. 16. Résolution des vues
   17. 17. Redirections
   18. 18. Négociation de contenu
   19. 19. Aspect-Oriented Programming
   20. 20. Validation de beans
   21. 21. Utilisation de Springdoc
   22. 22. Gestion de l’internationalisation
       1. a. Configuration
       2. b. Messages d’erreur
   23. 23. Configuration WebFlux
8. WebSocket(s) réactive(s)
9. WebClient
   1. 1. MaxInMemorySize
   2. 2. Filtres
   3. 3. Utilisation du contexte
   4. 4. Utilisation synchrone
   5. 5. WebClientResponseException
   6. 6. Tests
   7. 7. Test avec WebTestClient
10. RSocket
    1. 1. RSocketRequester
    2. 2. Exemple pratique
       1. a. Client
       2. b. Serveur
11. Conclusion

Bases de données réactives

1. Accès aux données en mode réactif
2. Bases NoSQL utilisables
3. Exemple avec MongoDB
4. R2DBC

Les différents reactors étendus

1. Introduction
2. Reactor Netty
3. Programmation Netty avec Spring
4. Protocole TCP
   1. 1. Serveur simple
      1. a. Annotations et variables d’instance
      2. b. Méthode start()
      3. c. Méthode stop()
   2. 2. Client simple
      1. a. Annotations et déclaration de classe
      2. b. Configuration via propriétés
      3. c. Logique du client TCP
      4. d. Consommer des données
      5. e. Configurations au niveau TCP
      6. f. Configuration des options de canal
      7. g. Journalisation des connexions
      8. h. Groupe de boucles d’événements
      9. i. Sécurisation des échanges via SSLet TLS
      10. j. Indication du nom du serveur
      11. k. Métrique
      12. l. Sockets de domaine Unix
   3. 3. Détails côté client
      1. a. Journalisation des connexions
      2. b. "Formateurs Wire Logger"
      3. c. Groupe de boucles d’événements
      4. d. Groupe de connexion
      5. e. Métrique
      6. f. Indication du nom du serveur
      7. g. Prise en charge des proxys
      8. h. Sockets de domaine Unix
      9. i. Résolution du nom d’hôte
5. Serveur HTTP
6. Serveur UDP
7. Conclusion sur Reactor Netty
8. Reactor Rabbit MQ
   1. 1. Utilisation de la partie serveur de RabbitMQ
      1. a. Mise en place du serveur
      2. b. Gestion via l’inferface web
      3. c. Gestion en ligne de commande
   2. 2. Programmation avec RabbitMQ
      1. a. Programmation AMQP simple
      2. b. Première intégration avec SpringAMQP
   3. 3. Développement avec Reactor-rabbit-mq
      1. a. Contre-pression
      2. b. Recevoir des messages
      3. c. Le modèle de threading
   4. 4. Gestion via le RPC
   5. 5. Demandes/réponses réactives
      1. a. Client RPC
      2. b. Serveur RPC
   6. 6. Reactive RabbitMQ Receiver
   7. 7. Utilisations avancées
      1. a. Personnalisation de la création de connexion
      2. b. Créer une connexion avec un Mono personnalisé
   8. 8. Conclusion sur Reactor RabbitMQ
9. Reactor Kafka
   1. 1. Introduction
   2. 2. API réactive pour Kafka
   3. 3. Motivations
   4. 4. Dépendances
   5. 5. Utilisation du produit Kafka
      1. a. Configuration de docker-compose.yml
      2. b. Démarrage du serveur Kafka
      3. c. Connexion à l’aide de Kafka Tool
      4. d. Surveillance des logs
   6. 6. Exemple d’utilisation de Reactor Kafka
   7. 7. API de Reactor Kafka
      1. a. Publier des messages
      2. b. Publier une séquence de messages
      3. c. Gestion des erreurs
      4. d. Modèle de threading
      5. e. Accès au KafkaProducer sous-jacent
      6. f. Recevoir des messages
      7. g. Envoi d’enregistrements à Kafka
      8. h. Livraison au plus une fois
      9. i. Sortie avec plusieurs flux
      10. j. Traitement simultané avec classement basé surles partitions
      11. k. Exactement une seule livraison
   8. 8. Conclusion pour l’utilisation de ReactorKafka

Support Kotlin

1. Utilisation de Kotlin
   1. 1. Avantages
      1. a. Concision du code
      2. b. Valeurs nulles
      3. c. Extensions de fonction
      4. d. Smart cast
      5. e. Coroutines
      6. f. Interopérabilité avec Java
      7. g. Lisibilité
   2. 2. Exclusivités avec Kotlin
      1. a. Fonctions inline
      2. b. Inférence de type
      3. c. Interpolation de chaînes
      4. d. Exceptions checked
      5. e. Expression when
2. Utiliser Kotlin avec Reactor
   1. 1. Null safety étendue
   2. 2. Types réifiés
   3. 3. Exemple
3. CRUD pour un utilisateur
   1. 1. CRUD simple
   2. 2. CRUD avec des coroutines
4. Conclusion

Micro-services et applications dans le cloud

1. Problématiques
   1. 1. Douze facteurs DevOps
   2. 2. Problématiques cloud
   3. 3. Répartition des états sur plusieursnœuds
2. Conclusion

Utilisations avancées

1. Introduction
2. Domain-Driven Design
   1. 1. Modélisation événementielleet event sourcing
   2. 2. Event store
   3. 3. Event storming
3. Architecture hexagonale et clean architecture
4. CQRS
5. Sagas
6. Évolution des architectures
7. Éléments de mise en œuvre
   1. 1. Spring Cloud Stream
   2. 2. Spring Cloud Function
   3. 3. Spring Cloud Gateway
   4. 4. Spring Integration
   5. 5. Spring State Machine
8. Conclusion

Exemple utilisant le générateur JHipster

1. Introduction
2. Installation via Docker
3. Génération du code
4. Étude du code généré
   1. 1. Configuration
      1. a. Logs
      2. b. Configuration des dates et heures
      3. c. Sécurité
      4. d. Configuration WebFluxConfigurer
   2. 2. Couches
      1. a. Domain
      2. b. Repository
      3. c. Service
      4. d. Contrôleurs
5. Conclusion

Conclusion

1. Introduction