Java Spring : construisez vos applications réactives avec une architecture micro-services en environnement Jakarta EE

Auteur(s) :

Le Morvan, Hervé Découvrir l'auteur

Résumé

Présentation des différentes technologies utilisées dans les projets basés sur Spring. La configuration, les contextes et les librairies tiers sont détaillés dans un premier temps, suivis d'explications sur des aspects plus complexes. La partie Spring d'un projet généré à partir d'un JHipster est également abordée. Des éléments complémentaires sont en téléchargement sur le site de l'éditeur.

Éditeur(s)
- Editions ENI
Date
- 2024
Notes
- EE = Enterprise edition
Langues
- Français
Description matérielle
- 1 vol. (562 p.) : ill. ; 22 cm
Collections
- Epsilon
Sujet(s)
- J2EE (plate-forme informatique)
- Spring (environnement de développement d'applications)
ISBN
- 978-2-409-04362-8
Indice
- 681.225 Java
Quatrième de couverture
- Java Spring
  Construisez vos applications réactives avec une architecture micro-services en environnement Jakarta EE
  Ce livre sur le développement d'applications réactives et de streaming s'adresse à toute personne (programmeur, 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 profiter 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
Tables des matières
- - Java Spring
  - Construisez vos applications réactives avec une architecture micro-services en environnement Jakarta EE
  - 2e édition
  - Éditions ENI
  - Avant-propos
  - 1. Préambule13
  - 2. Contexte des applications14
  - 3. Aperçu de Spring15
  - 4. Principes des applications réactives17
  - 5. Objectifs du livre18
  - 6. Organisation du livre18
  - 7. Public visé19
  - 8. Prérequis pour aborder la programmation réactive avec Spring19
  - 9. Ressources complémentaires20
  - 10. Remerciements20
  - Chapitre 1
  - La programmation fonctionnelle
  - 1. Introduction21
  - 2. Expressions lambda21
  - 3. Interfaces fonctionnelles22
  - 4. Méthodes de référence23
  - 5. Opérations sur les flux23
  - 6. Immutabilité24
  - 7. Haut ordre de fonction25
  - 8. Réduction de boucle25
  - 9. Conclusion26
  - Chapitre 2
  - Programmation réactive
  - 1. Introduction27
  - 2. Concepts clés de la programmation réactive28
  - 3. Reactive Streams30
  - 3.1 Origines30
  - 3.2 Initiative Reactive Streams31
  - 3.3 Adoption31
  - 4. Applications reactives sans Reactor32
  - 4.1 Akka33
  - 4.2 Vert.x35
  - 5. Fonctionnement de Reactor36
  - 5.1 En interne36
  - 5.2 API Rx-ified37
  - Chapitre 3
  - Reactor Core
  - 1. Introduction41
  - 2. Reactor Core43
  - 3. Méthode subscribe()49
  - 3.1 Surcharge49
  - 3.2 Gestion des erreurs50
  - 3.3 Valeur de retour51
  - 4. Utilisation du BaseSubscriber54
  - 5. Générer une séquence manuellement58
  - 5.1 Modèle synchrone58
  - 5.2 Modèle asynchrone60
  - 5.3 Modèle hybride push/pull62
  - 6. Méthode handle()64
  - 7. Scheduler66
  - 8. Traiter correctement les cas d'erreurs69
  - 8.1 Opérateur onErrorResume69
  - 8.2 Opérateur onErrorReturn70
  - 8.3 Opérateur onErrorMap70
  - 8.4 Opérateur doOnError71
  - 8.5 Opérateur onErrorStop71
  - 8.6 Opérateur onErrorContinue72
  - 9. Capture et renvoi d'exceptions72
  - 9.1 Gestion des exceptions72
  - 9.2 doFinally74
  - 9.3 retry76
  - 10. Sinks78
  - 11. Transformations personnalisées sur le flux81
  - 11.1 Créer des flux83
  - 11.1.1 Opérateurs just() et defer()83
  - 11.1.2 Opérateurs share() et replay(...)84
  - 11.1.3 ConnectableFlux85
  - 11.2 Regroupements de flux88
  - 11.2.1 ParallelFlux89
  - 11.2.2 Flux<GroupedFlux<T, K>>91
  - 11.2.3 Modifier les planificateurs par défaut92
  - 11.2.4 Gestionnaire d'erreur global92
  - 12. Global hooks94
  - 12.1 Hooks de suppression94
  - 12.2 Hook onOperatorError96
  - 12.3 Hooks d'assemblage98
  - 12.4 Hooks préconfigurés99
  - 13. API Context101
  - 13.1 Structure du Context102
  - 13.2 Opérateur contextWrite105
  - 14. Tests107
  - 14.1 Tester avec StepVerifier108
  - 14.1.1 Interface Step<T>111
  - 14.1.2 StepVerifierOptions114
  - 14.1.3 Couverture de test116
  - 14.2 Tests de programmes basés sur l'horloge système116
  - 14.2.1 Méthode withVirtualTime117
  - 14.2.2 VirtualTimeScheduler118
  - 14.2.3 expectNoEvent(Duration)118
  - 14.3 Utilisation du verifyThenAssertThat()119
  - 14.4 Tester avec le contexte associé à une séquence réactive120
  - 14.5 TestPublisher122
  - 14.6 createNonCompliant()124
  - 14.7 PublisherProbe127
  - 15. Réacteur de débogage129
  - 15.1 Hooks.onOperatorDebug()131
  - 15.2 Méthode checkpoint()132
  - 16. Conclusion134
  - Chapitre 4
  - Stack web reactive Spring
  - 1. Introduction à la stack web réactive135
  - 2. Noyau réactif136
  - 3. HttpHandler137
  - 3.1 Généralités137
  - 3.2 Pour Reactor Netty138
  - 4. API WebHandler140
  - 5. WebHttpHandlerBuilder143
  - 6. ServerWebExchange144
  - 7. Spring WebFlux144
  - 7.1 Aspects principaux pour démarrer144
  - 7.1.1 Sécurité minimale145
  - 7.1.2 Routage et manipulation fonctionnelle145
  - 7.1.3 Composants réactifs basés sur des annotations148
  - 7.2 Utilisation des composants149
  - 7.2.1 Utilisation de ServerWebExchange150
  - 7.2.2 WebFilter156
  - 7.3 CORS160
  - 7.4 WebExceptionHandler162
  - 7.5 Utilisation du ProblemDetail165
  - 7.6 Encodeurs et décodeurs168
  - 7.7 FormHttpMessageReader et FormHttpMessageWriter171
  - 7.8 MultipartHttpMessageReader et MultipartHttpMessageWriter174
  - 7.9 maxInMemorySize177
  - 7.10 Faire du streaming177
  - 7.11 Journalisation180
  - 7.12 DispatcherHandler182
  - 7.13 WebFluxConfigurer186
  - 7.13.1 Configuration globale186
  - 7.13.2 Configurer des intercepteurs de requêtes188
  - 7.13.3 Configurer les gestionnaires de ressources189
  - 7.13.4 Configurer les paramètres de sécurité189
  - 7.14 HandlerAdapter et HandlerResult191
  - 7.15 DispatchExceptionHandler191
  - 7.16 Résolution des vues194
  - 7.17 Redirections195
  - 7.18 Négociation de contenu196
  - 7.19 Aspect-Oriented Programming198
  - 7.20 Validation de beans200
  - 7.21 Utilisation de Springdoc203
  - 7.22 Gestion de l'internationalisation205
  - 7.22.1 Configuration205
  - 7.22.2 Messages d'erreur207
  - 7.23 Configuration WebFlux209
  - 8. WebSocket(s) réactive(s)211
  - 9. WebClient219
  - 9.1 MaxInMemorySize222
  - 9.2 Filtres223
  - 9.3 Utilisation du contexte226
  - 9.4 Utilisation synchrone228
  - 9.5 WebClientResponseException229
  - 9.6 Tests231
  - 9.7 Test avec WebTestClient235
  - 10. RSocket236
  - 10.1 RSocketRequester239
  - 10.2 Exemple pratique247
  - 10.2.1 Client247
  - 10.2.2 Serveur250
  - 11. Conclusion253
  - Chapitre 5
  - Bases de données réactives
  - 1. Accès aux données en mode réactif255
  - 2. Bases NoSQL utilisables257
  - 3. Exemple avec MongoDB258
  - 4. R2DBC260
  - Chapitre 6
  - Les différents reactors étendus
  - 1. Introduction265
  - 2. Reactor Netty266
  - 3. Programmation Netty avec Spring267
  - 4. Protocole TCP269
  - 4.1 Serveur simple272
  - 4.1.1 Annotations et variables d'instance273
  - 4.1.2 Méthode start()273
  - 4.1.3 Méthode stop()274
  - 4.2 Client simple274
  - 4.2.1 Annotations et déclaration de classe276
  - 4.2.2 Configuration via propriétés276
  - 4.2.3 Logique du client TCP277
  - 4.2.4 Consommer des données278
  - 4.2.5 Configurations au niveau TCP281
  - 4.2.6 Configuration des options de canal282
  - 4.2.7 Journalisation des connexions287
  - 4.2.8 Groupe de boucles d'événements288
  - 4.2.9 Sécurisation des échanges via SSL et TLS291
  - 4.2.10 Indication du nom du serveur292
  - 4.2.11 Métrique294
  - 4.2.12 Sockets de domaine Unix295
  - 4.3 Détails côté client296
  - 4.3.1 Journalisation des connexions298
  - 4.3.2 « Formateurs Wire Logger »299
  - 4.3.3 Groupe de boucles d'événements300
  - 4.3.4 Groupe de connexion300
  - 4.3.5 Métrique303
  - 4.3.6 Indication du nom du serveur303
  - 4.3.7 Prise en charge des proxys304
  - 4.3.8 Sockets de domaine Unix305
  - 4.3.9 Résolution du nom d'hôte306
  - 5. Serveur HTTP310
  - 6. Serveur UDP312
  - 7. Conclusion sur Reactor Netty314
  - 8. Reactor Rabbit MQ315
  - 8.1 Utilisation de la partie serveur de RabbitMQ316
  - 8.1.1 Mise en place du serveur316
  - 8.1.2 Gestion via l'inferface web317
  - 8.1.3 Gestion en ligne de commande318
  - 8.2 Programmation avec RabbitMQ319
  - 8.2.1 Programmation AMQP simple319
  - 8.2.2 Première intégration avec Spring AMQP322
  - 8.3 Développement avec Reactor-rabbit-mq325
  - 8.3.1 Contre-pression326
  - 8.3.2 Recevoir des messages340
  - 8.3.3 Le modèle de threading342
  - 8.4 Gestion via le RPC347
  - 8.5 Demandes/réponses réactives347
  - 8.5.1 Client RPC.348
  - 8.5.2 Serveur RPC349
  - 8.6 Reactive RabbitMQ Receiver.354
  - 8.7 Utilisations avancées358
  - 8.7.1 Personnalisation de la création de connexion358
  - 8.7.2 Créer une connexion avec un Mono personnalisé361
  - 8.8 Conclusion sur Reactor RabbitMQ362
  - 9. Reactor Kafka363
  - 9.1 Introduction363
  - 9.2 API réactive pour Kafka364
  - 9.3 Motivations365
  - 9.4 Dépendances367
  - 9.5 Utilisation du produit Kafka367
  - 9.5.1 Configuration de docker-compose.yml368
  - 9.5.2 Démarrage du serveur Kafka369
  - 9.5.3 Connexion à l'aide de Kafka Tool369
  - 9.5.4 Surveillance des logs370
  - 9.6 Exemple d'utilisation de Reactor Kafka370
  - 9.7 API de Reactor Kafka374
  - 9.7.1 Publier des messages375
  - 9.7.2 Publier une séquence de messages398
  - 9.7.3 Gestion des erreurs401
  - 9.7.4 Modèle de threading405
  - 9.7.5 Accès au KafkaProducer sous-jacent407
  - 9.7.6 Recevoir des messages409
  - 9.7.7 Envoi d'enregistrements à Kafka443
  - 9.7.8 Livraison au plus une fois449
  - 9.7.9 Sortie avec plusieurs flux450
  - 9.7.10 Traitement simultané avec classement basé sur les partitions452
  - 9.7.11 Exactement une seule livraison456
  - 9.8 Conclusion pour l'utilisation de Reactor Kafka457
  - Chapitre 7
  - Support Kotlin
  - 1. Utilisation de Kotlin459
  - 1.1 Avantages460
  - 1.1.1 Concision du code460
  - 1.1.2 Valeurs nulles460
  - 1.1.3 Extensions de fonction461
  - 1.1.4 Smart cast462
  - 1.1.5 Coroutines462
  - 1.1.6 Interopérabilité avec Java463
  - 1.1.7 Lisibilité463
  - 1.2 Exclusivités avec Kotlin464
  - 1.2.1 Fonctions inline464
  - 1.2.2 Inférence de type464
  - 1.2.3 Interpolation de chaînes465
  - 1.2.4 Exceptions checked465
  - 1.2.5 Expression when465
  - 2. Utiliser Kotlin avec Reactor466
  - 2.1 Null safety étendue466
  - 2.2 Types réifiés467
  - 2.3 Exemple468
  - 3. CRUD pour un utilisateur469
  - 3.1 CRUD simple469
  - 3.2 CRUD avec des coroutines471
  - 4. Conclusion474
  - Chapitre 8
  - Micro-services et applications dans le cloud
  - 1. Problématiques475
  - 1.1 Douze facteurs DevOps475
  - 1.2 Problématiques cloud478
  - 1.3 Répartition des états sur plusieurs noeuds479
  - 2. Conclusion483
  - Chapitre 9
  - Utilisations avancées
  - 1. Introduction485
  - 2. Domain-Driven Design486
  - 2.1 Modélisation événementielle et event sourcing487
  - 2.2 Event store489
  - 2.3 Event storming490
  - 3. Architecture hexagonale et clean architecture491
  - 4. CQRS493
  - 5. Sagas494
  - 6. Évolution des architectures496
  - 7. Éléments de mise en oeuvre498
  - 7.1 Spring Cloud Stream500
  - 7.2 Spring Cloud Function502
  - 7.3 Spring Cloud Gateway504
  - 7.4 Spring Integration506
  - 7.5 Spring State Machine508
  - 8. Conclusion511
  - Chapitre 10
  - Exemple utilisant le générateur JHipster
  - 1. Introduction513
  - 2. Installation via Docker514
  - 3. Génération du code518
  - 4. Étude du code généré518
  - 4.1 Configuration524
  - 4.1.1 Logs524
  - 4.1.2 Configuration des dates et heures529
  - 4.1.3 Sécurité530
  - 4.1.4 Configuration WebFluxConfigurer534
  - 4.2 Couches537
  - 4.2.1 Domain537
  - 4.2.2 Repository538
  - 4.2.3 Service539
  - 4.2.4 Contrôleurs540
  - 5. Conclusion542
  - Conclusion543
  - Index545
Origine de la notice:
- BPI