Java Spring : construisez vos applications réactives avec une architecture micro-services en environnement Java 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. ©Electre 2018

Éditeur(s)
- Éditions ENI
Date
- cop. 2018
Notes
- La couv. porte en plus : "Fichiers complémentaire à téléchargeré ; "Informatique technique" ; "Version numérique offerte ! www.editions-eni.fr"
- La 4ème de couv. porte en plus : "Sur www.editions-eni.fr : le code source des projets"
- Contient un "flashcode" permettant d'accéder à un contenu via Internet
- EE = Enterprise edition
Langues
- Français
Description matérielle
- 1 vol. (302 p.) : ill.; ; 21 cm
Collections
- Epsilon
Sujet(s)
ISBN
- 978-2-409-01449-9
Indice
- 681.225 Java
Quatrième de couverture
- Java Spring
  Construisez vos applications réactives avec une architecture micro-services en environnement Java 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 4.5 et 5.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 Java 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 architectures hexagonales basées sur le DDD (Domain Driven Design) et la gestion des événements d'une application CQRS utilisant l'Event Sourcing.
  Après un rappel sur ZooKeeper et Kafka, le lecteur est amené à étudier la programmation fonctionnelle et les Streams ainsi que la programmation réseau asynchrone avec Netty. La programmation réactive est ensuite traitée à travers l'utilisation de RxJava, Akka et Reactor avant de détailler l'utilisation des bases de données SQL et Kafka avec Reactor.
  L'auteur présente également la programmation des microservices et des applications dans le cloud en se basant sur 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 Java EE
  - Avant-propos
  - 1. Préambule11
  - 2. Introduction15
  - 3. Organisation du livre16
  - 4. Public visé16
  - 5. Pourquoi Spring ?17
  - 6. Prérequis pour aborder Spring et Java EE17
  - Chapitre 1
    Architectures alternatives
  - 1. Évolution des architectures19
  - 2. Domain-Driven Design30
  - 3. Event storming33
  - 4. Architecture hexagonale34
  - 5. Coeur de métier35
  - 5.1 Cas d'utilisation36
  - 5.2 Couche de ports et d'adaptateurs36
  - 5.3 Repository37
  - 5.4 Couche d'anticorruption37
  - 5.5 Sens des dépendances37
  - 6. Découpage de l'hexagone sur deux axes39
  - 6.1 Axe vertical39
  - 6.2 Axe horizontal39
  - 7. Respecter le modèle40
  - 8. Hexagones multiples40
  - 9. Modélisation événementielle et event sourcing42
  - 10. Event store42
  - 11. Reconstitution de l'état42
  - 11.1 Dimension temporelle43
  - 11.2 Problèmes43
  - 11.3 Avantages44
  - 11.4 Rebranchements44
  - 11.5 Agrégats44
  - 12. Points clés45
  - Chapitre 2
    ZooKeeper et Kafka
  - 1. Apache ZooKeeper47
  - 1.1 Installation de ZooKeeper49
  - 1.2 Lancement de ZooKeeper50
  - 1.3 Connexion à ZooKeeper en ligne de commande50
  - 1.4 Mode répliqué53
  - 1.5 Arrêt de ZooKeeper53
  - 1.6 Utilisation de ZooKeeper dans un programme Spring Boot54
  - 1.7 Implémentations types60
  - 2. Librairie Curator61
  - 3. Apache Kafka64
  - 3.1 Système de messagerie65
  - 3.1.1 Système point à point66
  - 3.1.2 Système publication-abonnement66
  - 3.2 Particularités de Kafka67
  - 3.3 Installation de Kafka69
  - 3.4 Test en ligne de commande70
  - 3.5 Fonctionnalités de Kafka71
  - 3.5.1 Dépendances Maven71
  - 3.5.2 Exemple Spring Boot72
  - 3.6 Avro, un système de sérialisation de données75
  - Chapitre 3
    Programmation fonctionnelle et streams
  - 1. Introduction85
  - 2. Streams87
  - 3. Exemple de programmation fonctionnelle en Java90
  - 4. Bibliothèque Vavr90
  - 5. Pour aller plus loins92
  - 6. Points clés93
  - Chapitre 4
    Programmation réseau asynchrone avec Netty
  - 1. Introduction95
  - 2. Éléments de l'architecture de Netty97
  - 2.1 Canal (channel)97
  - 2.2 Interfaces Future et ChannelFuture97
  - 2.3 Événements et handlers98
  - 2.4 Encodeurs et décodeurs99
  - 2.5 Serveur99
  - 3. Exemples100
  - 3.1 Serveurs et clients simples100
  - 3.2 Client Netty106
  - 4. Transferts basés sur des streams108
  - 5. Arrêt de l'application111
  - 6. Pour aller plus loin111
  - 7. Points clés111
  - Chapitre 5
    Programmation réactive
  - 1. Flux réactifs (reactive streams)113
  - 2. Programmation asynchrone historique116
  - 3. API réactives117
  - 3.1 Akka117
  - 3.2 Modèle d'acteur118
  - 3.3 Configurer un projet Akka119
  - 3.4 Créer un acteur120
  - 3.5 Configurer un acteur121
  - 3.6 Interactions et communications entre acteurs121
  - 3.6.1 Envoyer des messages122
  - 3.6.2 Recevoir des messages123
  - 3.7 Tuer un acteur123
  - 3.8 Bonnes pratiques avec Akka124
  - 3.9 Spring et Akka124
  - 3.9.1 Dépendances Maven124
  - 3.9.2 Récupérer des acteurs gérés par Spring128
  - 3.10 Utilisation de Akka Streams129
  - 3.10.1 Dépendances Maven129
  - 3.10.2 Créer un flux Akka130
  - 4. RxJava 1.3.4131
  - 4.1 Observateurs et observables132
  - 4.2 Opérations sur les observables136
  - 4.2.1 Opérateurs de création136
  - 4.2.2 Opérateurs de transformation137
  - 4.2.3 Opérateurs de filtrage138
  - 4.2.4 Combiner des observables139
  - 4.2.5 Opérateurs de gestion d'erreurs140
  - 4.2.6 Opérateurs de services utilitaires140
  - 4.2.7 Opérateurs conditionnels et booléens141
  - 4.2.8 Opérateurs mathématiques et agrégats142
  - 4.2.9 Conversion d'observables143
  - 4.2.10 Opérateurs de connexion143
  - 4.2.11 Opérateurs de contre-pression143
  - 4.2.12 Exemples d'utilisation d'opérateurs144
  - 4.2.13 Chaînage des opérateurs145
  - 4.2.14 Spécificités de l'observable Single145
  - 4.3 Sujets (subject)148
  - 4.3.1 AsyncSubject148
  - 4.3.2 BehaviorSubject149
  - 4.3.3 ReplaySubject149
  - 4.4 Schedulers149
  - 4.4.1 Schedulers avec RxJava 1.x151
  - 5. Implémentation réactive avec Vert.x153
  - 5.1 Vert.x avec RxJava155
  - 5.2 Support des résultats asynchrones157
  - 6. Prise en charge du scheduler160
  - 7. JSON unmarshalling161
  - 8. Déploiement d'un verticale162
  - 9. HttpClient GET sur un abonnement162
  - 10. API Rx-ified163
  - 10.1 Intégration de Rx-ified Vert.x163
  - 11. Exemples d'API163
  - 11.1 Timers164
  - 11.2 Requêtes de client HTTP165
  - 11.3 Requêtes du serveur HTTP166
  - 12. Client WebSocket167
  - 13. Serveur WebSocket168
  - 14. Reactor169
  - 15. Mono et Flux172
  - 15.1 Opérations sur les observables172
  - 15.1.1 Opérateurs de création de Flux173
  - 15.1.2 Opérateurs de transformation des éléments observables174
  - 15.1.3 Opérateurs de filtrage des observables175
  - 15.1.4 Opérateurs de combinaison des observables176
  - 15.1.5 Opérateurs de gestion d'erreurs176
  - 15.1.6 Opérateurs de services utilitaires177
  - 15.1.7 Opérateurs conditionnels178
  - 15.1.8 Opérateurs mathématiques179
  - 15.1.9 Opérateurs de conversion d'observables180
  - 15.1.10 Opérateurs de connexion180
  - 15.1.11 Spécificités de l'observable Mono181
  - 16. Contre-pression183
  - 17. Chaud ou froid183
  - 17.1 Reactor-test184
  - 17.2 Tester un scénario avec StepVerifier185
  - 17.3 Identifier les tests en erreur186
  - 17.4 Manipuler du temps187
  - 17.5 Exécuter les assertions post-exécution avec StepVerifier189
  - 17.6 Tester le Context189
  - 17.7 Émettre manuellement avec TestPublisher190
  - 17.8 Vérifier le chemin d'exécution191
  - 17.9 Réacteur de débogage193
  - 17.10 Conclusion sur Reactor193
  - 18. Conclusion sur la programmation réactive194
  - Chapitre 6
    Exemples d'applications avec une base SQL
  - 1. Introduction195
  - 2. Isoler la partie JDBC196
  - 3. Adapter un pilote JDBC réactif à Reactor197
  - 3.1 Solution avec rxjava2-jdbc198
  - 3.2 Solution avec vertx-jdbc-client198
  - 3.2.1 Créer un client199
  - 3.2.2 Obtenir une connexion200
  - 3.2.3 Configuration201
  - 3.2.4 Types de données203
  - 4. Conclusion sur les pilotes JDBC asynchrones205
  - 5. Pour aller plus loin205
  - 6. Points clés206
  - Chapitre 7
    Librairie Reactor Kafka
  - 1. Introduction207
  - 2. Producteur208
  - 3. Consommateur210
  - 4. Scénarios211
  - 4.1 Flux d'entrée211
  - 4.2 Flux de sortie212
  - 4.3 Transformation internes212
  - 5. Points clés213
  - Chapitre 8
    Applications web avec Spring WebFlux
  - 1. Introduction215
  - 1.1 Types de endpoints218
  - 2. Quand privilégier l'utilisation de Spring WebFlux ?220
  - 3. Serveurs Spring WebFlux221
  - 4. Organisation du framework réactif221
  - 4.1 HttpHandler et adaptateurs de serveur221
  - 4.2 Initialisation d'un HttpHandler223
  - 5. HttpHandler des différentes implémentations224
  - 5.1 Reactor Netty224
  - 5.2 Undertow224
  - 5.3 Jetty225
  - 5.4 Tomcat225
  - 6. Déploiement d'un war226
  - 6.1 API WebHandler228
  - 6.2 Beans Spring spécifiques228
  - 7. DispatcherHandler232
  - 7.1 Beans spéciaux pour le DispatcherHandler233
  - 7.2 Configuration WebFlux234
  - 7.3 Traitement d'un appel234
  - 7.4 Gestion des valeurs de retour234
  - 8. Exemple de service Rest réactif avec WebFlux et la version réactive de MongoDB236
  - 9. Endpoints fonctionnels242
  - 9.1 HandlerFunction242
  - 9.2 RouterFunction245
  - 9.2.1 Exécuter une fonction sur un serveur247
  - 9.2.2 HandlerFilterFunction248
  - 10. Tests spécifiques à WebFlux249
  - 10.1 Spring Security pour les méthodes réactives249
  - 10.2 WebTestClient250
  - 10.3 Tests d'authentification251
  - 11. Tests sans Spring252
  - 12. WebSocket254
  - 12.1 HTTP ou WebSocket255
  - 12.2 Quand utiliser WebSocket avec WebFlux ?256
  - 12.3 API WebSocket257
  - 12.3.1 WebSocketHandler257
  - 12.3.2 WebSocket Handshake258
  - 12.3.3 Configuration du serveur258
  - 12.4 WebSocketClient259
  - Chapitre 9
    Microservices Docker et DevOps
  - 1. Introduction261
  - 2. Docker et machines virtuelles263
  - 3. Spring Boot avec Docker264
  - 3.1 Utilisation de profils de Spring268
  - 3.2 Débogage de l'application dans un conteneur Docker268
  - 4. Conteneurs et écosystème Spring Boot269
  - 5. Limites des conteneurs269
  - 6. Pour aller plus loin270
  - 7. Points clés270
Origine de la notice:
- Electre