Java Spring : le socle technique des applications 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, et complétés d'explications sur des aspects plus complexes. La partie Spring d'un projet généré à partir de JHipster est également abordée. Des éléments complémentaires sont accessibles sur le site de l'éditeur. ©Electre 2022

Éditeur(s)
- Éditions ENI
Date
- C 2022
Notes
- La couv. porte en plus : "En téléchargement : exemples" ; "+ quiz" ; "Version en ligne offerte ! pendant 1 an." ; "Informatique technique"
- La 4e de couv. indique : "Sur www.editions-eni.fr : une qurantaine d'exemples indépendants et de différents niveaux de complexité"
- Contient un "flashcode" permettant d'accéder à un contenu via Internet
- EE = Enterprise Edition
Langues
- Français
Description matérielle
- 1 vol. (656 p.) : ill. ; 22 cm
Collections
- Epsilon
Sujet(s)
ISBN
- 978-2-409-03655-2
Indice
- 681.225 Java
Quatrième de couverture
- Java Spring
  Le socle technique des applications Jakarta EE
  Ce livre apporte les éléments clés pour se repérer dans les différentes technologies utilisées dans les projets basés sur Spring. Il prend en compte les différences de configuration liées aux versions de Spring (en version 4.3 et 5.3 au moment de l'écriture) et se base sur des exemples concrets d'utilisation. Il permet au lecteur d'être très rapidement autonome sur un projet d'entreprise qui utilise Spring, que ce soit au début d'un nouveau projet ou pour maintenir un projet existant : compréhension du noyau, accès aux données, maîtrise de la couche web. Des connaissances sur le développement Java et notamment le développement d'applications web sont un prérequis indispensable pour tirer le meilleur parti possible du livre.
  L'auteur présente tout d'abord les éléments simples et courants de Spring (la configuration, les contextes, les librairies tiers) et explique ensuite certains aspects plus complexes que l'on rencontre souvent dans les projets (Ressources, Bindeurs, Validateurs, Convertisseurs et Tests). La programmation par aspects est expérimentée, les applications web Spring MVC et les Web Services sont détaillés avec les tests unitaires associés. L'auteur présente les nouveautés Spring Boot, Kotlin avec Angular, les applications orientées messages et Spring Batch, une introduction à Reactor et Web-Flux et une description de la partie Spring d'un projet généré à partir de JHipster afin d'illustrer une mise en œuvre très actuelle ainsi qu'une présentation de l'utilisation de GraphQL avec Spring.
  Tout au long des chapitres, l'auteur s'appuie sur des exemples fonctionnels afin de permettre l'expérimentation au plus tôt par le lecteur. Dans ce but, des éléments sont en téléchargement sur le site www.editions-eni.fr.
Tables des matières
- - Java Spring
  - Le socle technique des applications Jakarta EE
  - 4e édition
  - Éditions ENI
  - Avant-propos
  - 1. Préambule23
  - 2. Introduction26
  - 3. Organisation du livre28
  - 4. Public visé28
  - 5. Pourquoi Spring29
  - 6. Prérequis pour aborder Spring et Jakarta EE29
  - 7. Objectifs du livre31
  - Chapitre 1
  - Éléments constitutifs du framework
  - 1. Introduction33
  - 2. Historique33
  - 3. Utilité de Spring dans un projet37
  - 4. Vue d'ensemble et sujets abordés dans l'ouvrage42
  - 4.1 Les modules Spring42
  - 4.2 Sujets abordés44
  - 4.3 Version des briques Spring utilisées dans l'ouvrage44
  - 4.4 Version des ressources externes45
  - 4.5 Gestion des dépendances Maven45
  - 4.6 Utilisation d'un BOM (Bill Of Materials) Maven47
  - 5. Compléments50
  - 6. Points clés51
  - Chapitre 2
  - Spring et les design patterns
  - 1. Introduction53
  - 2. Le singleton en Java54
  - 2.1 Préoccupation55
  - 2.2 Solution Spring57
  - 2.3 Exemple57
  - 3. L'inversion de contrôle61
  - 4. Façade62
  - 5. Fabrique63
  - 6. Décorateur64
  - 7. Proxy65
  - 8. Modèle Vue Contrôleur (MVC)66
  - 9. Les templates68
  - 10. Stratégie69
  - 11. Points clés70
  - Chapitre 3
  - Rappels sur les éléments externes à Spring
  - 1. Codage equals et hashCode71
  - 1.1 Description de la problématique74
  - 1.2 Mise en ouvre75
  - 2. Projet Lombok77
  - 3. Les systèmes de log79
  - 4. Bases de données H281
  - 4.1 Description de la problématique81
  - 4.2 Mise en ouvre82
  - 4.2.1 Installation82
  - 4.2.2 Configuration du POM82
  - 4.2.3 Connexion à la base de données en utilisant JDBC83
  - 4.2.4 Utiliser un listener de servlet pour démarrer et arrêter la base84
  - 5. Projets Maven85
  - 5.1 Description de la problématique85
  - 5.2 Mise en ouvre85
  - 5.3 Installation de Maven sous Windows86
  - 5.4 Utilisation d'un archétype Maven87
  - 5.5 Contenu du fichier pom.xml dans les cas simples utilisés dans ce livre88
  - 6. Spring et les versions de Java90
  - 7. Points clés94
  - Chapitre 4
  - Le conteneur Spring
  - 1. Introduction95
  - 2. Les origines95
  - 3. Les modules fondamentaux97
  - 3.1 Composition d'un bean97
  - 3.2 Le singleton et le prototype98
  - 3.3 Les objets fondamentaux du package core98
  - 3.3.1 Le PropertyEditor99
  - 3.4 Les PropertyValues101
  - 3.5 Le BranWrapper102
  - 3.6 La BeanFactory102
  - 3.7 L'interface BeanDefinition103
  - 3.8 Le PropertyPlaceholderConfigurer103
  - 3.9 Les objets fondamentaux du package context106
  - 3.10 Relations entre le bean, sa BeanFactory ou son contexte107
  - 4. Configuration des beans108
  - 4.1 Configuration par un fichier XML110
  - 4.2 Configuration avec des annotations111
  - 4.3 Configurer les beans applicatifs implicitement113
  - 4.4 Configuration par lambdas114
  - 5. Utilisation des beans : injection par setters et constructeurs114
  - 5.1 Mapping via le constructeur en XML115
  - 5.2 Comparaison des méthodes d'instanciation117
  - 5.3 Autres annotations de configuration117
  - 5.3.1 L'annotation @Primary117
  - 5.3.2 Les annotations @Profile et @Conditional119
  - 6. Contrôle du cycle de vie : construction et destruction129
  - 7. Exemple illustrant les mappings standards130
  - 7.1 Le projet Maven130
  - 7.2 Fichier de configuration de Spring131
  - 7.3 Dépendance Spring Core et système de log131
  - 7.4 Dépendance vers les librairies de tests unitaires132
  - 7.5 Exemple illustrant l'utilisation des logs133
  - 7.6 Fichier de configuration spécifique pour les tests134
  - 8. Le Spring Expression Language135
  - 8.1 Utilisation de l'ExpressionParser135
  - 8.2 L'EvaluationContext136
  - 8.3 Utilisation avec @Value138
  - 9. Serveurs J2EE, Java EE et Jakarta EE139
  - 9.1 Généralités139
  - 9.2 Web services145
  - 9.2.1 Via une servlet145
  - 9.2.2 Serveur intégré145
  - 9.3 Les EJB148
  - 9.3.1 Fonctionnement148
  - 9.3.2 Création de l'EJB distant151
  - 9.3.3 Configuration de Maven côté client152
  - 9.3.4 Création du client153
  - 9.3.5 Intégration plus poussée154
  - 9.3.6 Le design pattern Business Delegate156
  - 10. Points clés160
  - Chapitre 5
  - Configuration avancée
  - 1. Introduction161
  - 2. Les fichiers de ressources161
  - 2.1 Les fichiers de ressources standards162
  - 2.2 Les fichiers de ressources chargés via le contexte Spring163
  - 2.3 Les fichiers de ressources chargés via un service ResourceLoaderAware164
  - 2.3.1 Le programme principal164
  - 2.3.2 Le service ResourceLoaderAware165
  - 3. Convertisseurs et formateurs166
  - 3.1 Built-in converters166
  - 3.1.1 Pour les types standards166
  - 3.1.2 Pour les tableaux et les listes167
  - 3.1.3 Pour les énumérations168
  - 3.1.4 Pour les objets en général168
  - 3.2 Convertir un Array en Collection et String170
  - 3.3 Converter Factory171
  - 3.3.1 Classe StringToUtilisateurConverterFactory171
  - 3.3.2 Classe UtilisateurToStringConverterFactory171
  - 3.3.3 Classe LesConversionsAvecFactories172
  - 3.4 Les formateurs par défaut172
  - 3.4.1 Classe LesConversionsFormateurs172
  - 3.5 Les formateurs personnalisés173
  - 3.5.1 Classe CarteDeCredit -173
  - 3.5.2 Classe CarteDeCreditParser174
  - 3.5.3 Classe CarteDeCreditPrinter174
  - 3.5.4 Classe CarteDeCreditFormatter175
  - 3.5.5 Classe LesConversionsFormateursEx2175
  - 4. Les BeanWrappers, le binding et les validateurs176
  - 4.1 Classe LesBeanWrappers176
  - 4.2 Classe UtilisateurValidator177
  - 5. Points clés178
  - Chapitre 6
  - Programmation orientée aspect avec Spring
  - 1. Introduction :179
  - 2. Pourquoi l'AOP185
  - 3. Les concepts d'AOP186
  - 4. Limites de Spring AOP et utilisation d'AspectJ188
  - 5. Le support @Aspect J dans Spring188
  - 5.1 Activation du support189
  - 5.2 Activation de @Aspect J avec configuration XML189
  - 5.3 Activation de @AspectJ avec configuration Java190
  - 5.4 Déclaration d'un aspect190
  - 5.5 Déclaration d'un pointcut191
  - 5.6 Déclaration des greffons simples193
  - 5.7 Les types génériques195
  - 5.8 Détermination de noms d'arguments196
  - 5.9 Ordre d'appel des greffons interceptant le point de jonction.196
  - 5.10 Injection197
  - 5.11 Le mécanisme des proxy197
  - 5.12 La face cachée des proxy en AOP198
  - 6. Les API bas niveau pour Spring AOP201
  - 6.1 L'interface PointCut201
  - 6.2 L'interface ClassFilter201
  - 6.3 L'interface MethodMatcher202
  - 7. Points clés202
  - Chapitre 7
  - Les tests et Spring
  - 1. Introduction203
  - 2. Les mock objects204
  - 2.1 Mocks spécialisés pour « environnement »205
  - 2.2 Support205
  - 2.2.1 Utilités générales205
  - 2.2.2 Spring MVC207
  - 2.3 Tests d'intégration207
  - 2.3.1 Vue d'ensemble207
  - 2.3.2 Mise en cache du contexte de test208
  - 2.3.3 Tests back et front208
  - 2.4 Annotations209
  - 2.4.1 @ContextConfiguration209
  - 2.4.2 @WebAppConfiguration210
  - 2.4.3 @ContextHierarchy210
  - 2.4.4 @ActiveProfiles211
  - 2.4.5 @TestPropertySource212
  - 2.4.6 @DirtiesContext212
  - 2.4.7 Interface TestExecutionListener213
  - 2.4.8 @TransactionConfiguration214
  - 2.4.9 @Transactional214
  - 2.4.10 @Rollback215
  - 2.4.11 @BeforeTransaction215
  - 2.4.12 @AfterTransaction215
  - 2.4.13 @Sql @SqlConfig et @SqlGroup215
  - 2.5 Annotations standards216
  - 3. Les frameworks de test JUnit et TestNG217
  - 3.1 Utilisation avec JUnit 4217
  - 3.1.1 Spring JUnit Runner217
  - 3.1.2 @IfProfileValue218
  - 3.1.3 @ProfileValueSourceConfiguration218
  - 3.1.4 @Timed218
  - 3.1.5 @Repeat219
  - 3.1.6 Méta-annotations de support pour les tests219
  - 3.2 Les arcanes du framework Spring TestContext223
  - 3.2.1 Classes et interfaces du framework de tests223
  - 3.2.2 Configuration du TestExecutionListener par les annotations225
  - 3.2.3 Les TestExecutionListeners226
  - 3.2.4 Mélange XML et classes annotées230
  - 3.3 Configuration des contextes de tests231
  - 3.3.1 Configuration de contexte avec des initialiseurs de contexte231
  - 3.3.2 L'héritage dans la configuration des contextes231
  - 3.3.3 Prise en compte des profils d'environnement232
  - 3.3.4 Configuration de contexte avec des fichiers de propriétés de test237
  - 3.3.5 Déclarer un fichier de propriétés pour les tests238
  - 3.3.6 Détection du fichier de propriétés par défaut239
  - 3.4 Hiérarchie des contextes de tests239
  - 3.4.1 Héritage et surcharge des propriétés de test239
  - 3.4.2 Chargement d'un WebApplicationContext240
  - 3.4.3 Conventions241
  - 3.4.4 La sémantique de ressources explicites241
  - 3.4.5 Injecter des objets piockés242
  - 3.4.6 Cachabilité du contexte de test243
  - 3.4.7 Les hiérarchies des contextes244
  - 3.4.8 L'injection de dépendance dans les tests247
  - 3.5 Le scope session lors d'un test de requête249
  - 3.5.1 Le scope session lors d'un test de requête249
  - 3.5.2 Test de beans de scope request250
  - 3.5.3 Configuration d'un bean de scope session251
  - 3.6 Les transactions252
  - 3.6.1 La gestion des transactions252
  - 3.6.2 Les transactions managées par le test252
  - 3.6.3 Activation et désactivation des transactions253
  - 3.6.4 Comportement du commit et du rollback d'une transaction254
  - 3.6.5 Exécution de code en dehors d'une transaction255
  - 3.6.6 Configuration d'un gestionnaire de transactions256
  - 3.6.7 Démonstration de toutes les annotations liées à la transaction256
  - 3.7 Les scripts SQL257
  - 3.7.1 Exécuter des scripts SQL258
  - 3.7.2 La sémantique du path des ressources260
  - 3.7.3 La détection de script par défaut261
  - 3.7.4 Déclaration de plusieurs @Sql261
  - 3.7.5 Phases d'exécution pour les scripts262
  - 3.7.6 Script de configuration avec SqlConfig262
  - 3.7.7 La gestion des transactions pour @Sql263
  - 3.8 Classes de support TestContext265
  - 3.8.1 Classes de support de JUnit265
  - 3.8.2 Spring JUnit Runner266
  - 3.9 Framework Spring MVC Test267
  - 3.9.1 Projet autonome267
  - 3.9.2 Tests côté serveur268
  - 3.9.3 Définir les attendus273
  - 3.9.4 Ajouts de filtres275
  - 3.9.5 Tests REST côté client276
  - 3.10 Autres ressources276
  - 4. Points clés277
  - Chapitre 8
  - Partie back de l'application
  - 1. Description de la problématique279
  - 2. Mise en oeuvre282
  - 2.1 Configuration d'une entité de la couche domaine282
  - 2.2 Accès à l'objet du domaine284
  - 2.3 Suppression en cascade285
  - 2.4 Requêtes typées285
  - 2.5 Cache de niveaux 1 et 2286
  - 2.6 Bean Validation (JSR-303)286
  - 2.7 L'API Criteria289
  - 2.8 Accès à la base de données289
  - 2.9 Le fichier persistence.xml290
  - 2.10 Tests JPA291
  - 3. Pour aller plus loin293
  - 3.1 Librairie Java jcabi-aspects293
  - 3.2 Métriques AspectJ293
  - 4. Utilisation de MapStruct293
  - 4.1 Approche API-First294
  - 5. Les outils295
  - 5.1 Swagger295
  - 5.2 OpenAPITools295
  - 5.3 Autres296
  - 6. Les générateurs de code296
  - 7. Utilisation du plugin297
  - 7.1 Pour le générateur Swagger297
  - 7.2 Pour le générateur OpenAPITools297
  - 8. Personnalisation298
  - 8.1 Swagger298
  - 8.2 OpenAPITools298
  - 9. Conception d'une description API299
  - 10. Outillage pour le design de TAPI299
  - 11. Spring Actuator300
  - 12. Points clés302
  - Chapitre 9
  - Spring dans un contexte web JSP
  - 1. Spring MVC303
  - 1.1 Fonctionnement global305
  - 1.1.1 Configuration simple XML305
  - 1.1.2 Configuration par annotation308
  - 1.2 Éléments complexes du contrôleur309
  - 1.2.1 Fonctionnement global du contrôleur309
  - 1.2.2 Exemple de la classe Simple311
  - 1.2.3 Simple revisité311
  - 1.2.4 Par le path312
  - 1.2.5 Par un motif sur le path313
  - 1.2.6 Par le path et une méthode313
  - 1.2.7 Mappé par path + méthode + présence de paramètres de query314
  - 1.2.8 Mappé par path + méthode + présence d'un header314
  - 1.2.9 Par l'absence d'un header315
  - 1.2.10 Par consommation316
  - 1.2.11 Par production via Accept=application/json316
  - 1.2.12 Par production via Accept=application/xml317
  - 1.2.13 Paramètres de query318
  - 1.2.14 Groupes de paramètres de query319
  - 1.2.15 Variable du path319
  - 1.2.16 Corps de la requête320
  - 1.2.17 En-tête et corps de la requête321
  - 1.2.18 Arguments dans la requête321
  - 1.2.19 Arguments de la réponse322
  - 1.2.20 Session323
  - 1.2.21 Handler personnalisé323
  - 1.2.22 Lire les données encodées dans l'URL324
  - 1.2.23 Lire une structure XML325
  - 1.2.24 Écrire dans une structure XML via Accept=application/xml325
  - 1.2.25 Lire une structure JSON326
  - 1.2.26 Écrire dans une structure JSON via Accept=application/json327
  - 1.2.27 HTML généré par un template JSP328
  - 1.2.28 Mapping à partir d'un modèle328
  - 1.2.29 Utiliser des variables dans un template de vue329
  - 1.2.30 Data binding avec des variables d'URI329
  - 1.2.31 Types primitifs330
  - 1.2.32 Date333
  - 1.2.33 Conversion des collections333
  - 1.2.34 Utiliser des collections formatées334
  - 1.2.35 Utiliser des objets personnalisés334
  - 1.2.36 Utiliser un convertisseur personnalisé335
  - 1.2.37 Validation339
  - 1.2.38 @ExceptionHandler dans un contrôleur340
  - 1.2.39 @ExceptionHandler global340
  - 1.2.40 Templates de String pour les URI340
  - 1.2.41 UriComponentsBuilder341
  - 2. Client REST342
  - 2.1 Utilisation du RestTemplate342
  - 2.2 Le bean de domaine avec l'annotation REST pour les champs manquants343
  - 3. Spring Security343
  - 3.1 Introduction à Spring Security343
  - 3.2 Spring Security dans un environnement web346
  - 3.2.1 Authentification par Spring346
  - 3.2.2 Authentification par page de login personnalisée347
  - 3.2.3 Authentification par base de données347
  - 4. Points clés349
  - Chapitre 10
  - Intégration JSF2
  - 1. Introduction351
  - 2. Mojarra353
  - 3. Architecture354
  - 4. Cycle de vie356
  - 4.1 Requête356
  - 4.2 Restore View ou Reconstruct Component Tree356
  - 4.3 Apply Request Value357
  - 4.4 Perform Validation357
  - 4.5 Synchronize Model ou Update Model Values357
  - 4.6 Invoke Application Logic358
  - 4.7 Render Response358
  - 4.8 Réponse358
  - 4.9 Fichier web.xml358
  - 4.10 Dépendances359
  - 4.11 Fichier faces-config.xml359
  - 4.12 Bean managé sans Spring361
  - 4.13 Exemple de vue JSF361
  - 4.14 Aperçu d'un composant JSF362
  - 5. Intégration Spring363
  - 5.1 Architecture364
  - 5.2 Dépendances364
  - 5.3 Fichier web.xml364
  - 5.4 Fichier faces-config.xml365
  - 5.5 Couches basses (back)366
  - 6. Points clés366
  - Chapitre 11
  - Application Spring Angular
  - 1. Introduction367
  - 2. La partie backend368
  - 2.1 Génération d'un backend368
  - 3. La partie frontend371
  - 3.1 Angular CLI372
  - 3.2 Création du projet initial372
  - 3.3 Démarrage de l'application372
  - 3.4 Créer un service Compte373
  - 4. Points clés375
  - Chapitre 12
  - Spring-HATEOAS
  - 1. Introduction377
  - 1.1 Exemple de liens hypermédias codés manuellement380
  - 1.2 Aller plus loin avec l'hypermédia382
  - 1.3 Autoconfiguration par annotation383
  - 1.4 Fournisseurs de relations383
  - 1.5 Fournisseur d'URI compacte384
  - 1.6 Support du côté client385
  - 1.7 Découverte de liens coté client386
  - 1.8 Utilisation du @RepositoryRestResource386
  - 2. Points clés394
  - Chapitre 13
  - Documentation Spring REST Docs
  - 1. Introduction395
  - 1.1 Dépendance sur la bibliothèque de tests398
  - 1.2 Dépendance sur les plugins Maven398
  - 1.3 Les extraits (snippets)400
  - 2. Exemple JUnit 5 (Jupiter)401
  - 3. Requête et réponse402
  - 4. Réponse avec un JSON imbriqué403
  - 4.1 Les paramètres de requête404
  - 4.2 Les paramètres inclus dans le path404
  - 4.3 Les Request parts405
  - 4.4 Les Request parts payloads405
  - 4.5 Les champs405
  - 4.6 Liens hypermédias dans la réponse406
  - 4.7 Les en-têtes407
  - 5. Personnalisation de la documentation407
  - 6. Couplage Swagger 2408
  - 6.1 Utilisation Springfox408
  - 6.2 En dehors de Spring Boot409
  - 7. Utilisation avec Spring Data Rest411
  - 8. Récapitulatif sur la documentation générée411
  - 9. Points clés412
  - Chapitre 14
  - Spring Boot
  - 1. Introduction413
  - 2. Configuration des exemples415
  - 2.1 Configuration Maven pour la version 1.5 de Spring Boot415
  - 2.2 Configuration Maven pour la version 2 de Spring Boot415
  - 2.3 Utilisation du hot swapping416
  - 2.4 Packaging et lancement de l'application416
  - 2.5 Application Spring MVC minimum417
  - 3. L'auto-configuration Spring Boot418
  - 4. Les starters420
  - 4.1 Les starters courants420
  - 4.2 Les starters orientés messages423
  - 4.3 Les bases de données423
  - 4.4 Les web services424
  - 4.5 Les moteurs de rendus424
  - 4.6 Les starters moins courants425
  - 5. SpringMVC426
  - 6. Personnalisation de la bannière426
  - 7. Evénements d'applications427
  - 8. La récupération des arguments de la ligne de commande428
  - 8.1 CommandLineRunner :428
  - 8.2 ApplicationRunner429
  - 8.3 La configuration yaml et profiles429
  - 9. L'annotation EnableConfigurationProperties431
  - 10. La configuration des logs431
  - 10.1 Les logs en couleur431
  - 10.2 Choix du type de logs436
  - 11. L'auto-configuration pour Spring MVC436
  - 12. La gestion des sessions437
  - 13. Le guide de migration de la version 1.5 à la version 2.x439
  - 13.1 Fichiers de configuration439
  - 13.2 Comportements différents439
  - 13.3 Démarrage440
  - 13.4 Utilisation de ApplicationRunner ou CommandLineRunner440
  - 13.5 Configuration externalisée440
  - 13.6 Développement d'applications web441
  - 13.7 Sécurité442
  - 14. Description avancée de Spring Boot443
  - 15. Le chargement du BootstrapContext444
  - 16. Mise en place des listeners445
  - 16.1 Le starting : ApplicationStartingEvent445
  - 16.2 L'environnement : l'ApplicationEnvironmentPreparedEvent446
  - 16.3 L'EnvironmentPostProcessorApplicationListener448
  - 17. La configuration des logs448
  - 18. Création de l'ApplicationContext449
  - 19. Préparation et rafraîchissement .du contexte449
  - 20. L'EnableAutoConfigurtation450
  - 21. Lancement des runners451
  - 22. Points clés451
  - Chapitre 15
  - Spring et le NoSQL
  - 1. Introduction453
  - 2. Les modèles de données455
  - 2.1 Modèle Clé-valeur455
  - 2.2 Modèle Documents455
  - 2.3 Modèle Orienté colonnes456
  - 2.4 Les bases orientées Graph457
  - 3. Principes des bases de données457
  - 4. Pourquoi et quand utiliser une base NoSQL460
  - 5. Problèmes liés à l'utilisation des bases NoSQL462
  - 6. Limitations des bases de données NoSQL463
  - 7. Spring et le NoSQL464
  - 8. Cache de données465
  - 8.1 Cache simple465
  - 9. Cacher des données avec GemFire468
  - 10. GemFire en tant que base de données NoSQL469
  - 11. Redis en autonome471
  - 11.1 Utilisation de Redis pour le cache de données471
  - 11.2 Utilisation de Redis pour gérer des messages474
  - 12. MongoDB476
  - 12.1 MongoDB avec Spring Boot477
  - 12.2 MongoDB avec une API REST479
  - 13. Points clés483
  - Chapitre 16
  - Spring Batch
  - 1. Introduction485
  - 2. Architecture d'un batch489
  - 3. Exemple Spring Batch version 4490
  - 4. Chargeur H2 depuis un CSV492
  - 5. Dépendances Spring Batch 3 et 4496
  - 6. Autres nouveautés de la version 4496
  - 7. Évolutions des batchs498
  - 8. Points clés499
  - Chapitre 17
  - Les intergiciels à messages (MOM)
  - 1. Introduction501
  - 2. Implémentations open source503
  - 3. Implémentations propriétaires504
  - 4. Les cas d'utilisation504
  - 5. JMS et ActiveMQ507
  - 6. RabbitMQ512
  - 6.1 Spring AMQP et RabbitMQ512
  - 6.2 Exemple RabbitMQ513
  - 7. Points clés516
  - Chapitre 18
  - Spring et Kotlin
  - 1. Introduction517
  - 2. Caractéristiques principales du langage Kotlin519
  - 2.1 Les méthodes et les fonctions519
  - 2.2 L'immutabilité des objets519
  - 2.3 Les types520
  - 2.4 La gestion des valeurs nulles524
  - 2.5 Les appels chaînés sécurisés524
  - 2.6 Les lambdas525
  - 3. Contrôleur Spring MVC, Spring Boot en Kotlin526
  - 3.1 Fonction principale527
  - 3.2 Test associé à la fonction principale527
  - 4. Les plugins530
  - 5. Points clés532
  - Chapitre 19
  - Introduction à Spring Reactor et Spring Webflux
  - 1. Introduction533
  - 2. Spring Reactor534
  - 2.1 Présentation534
  - 2.2 Utilisation de Reactor Core538
  - 2.2.1 Les threads538
  - 2.2.2 Les FutureTask538
  - 2.2.3 Le CompletableFuture539
  - 2.2.4 Flux et Mono540
  - 2.3 Les tests544
  - 2.3.1 Vérifications avec StepVerifier544
  - 2.3.2 Emissions manuelles avec TestPublisher547
  - 3. WebFlux549
  - 3.1 Définition du terme réactif550
  - 3.2 Les couches réactives551
  - 3.2.1 la couche contrôleur551
  - 3.2.2 La couche des services555
  - 3.2.3 La couche repository556
  - 3.2.4 Repository reactif R2DBC556
  - 4. Client réactif561
  - 5. Les tests avec WebFlux562
  - 5.1 Tests unitaires562
  - 5.1.1 Tests unitaires avec des applications réactives562
  - 5.1.2 Utilisation de MockWebServer563
  - 5.2 Tests d'intégration565
  - 6. Server Site Event avec Spring568
  - 7. Pour aller plus loin570
  - 8. Points clés570
  - Chapitre 20
  - Spring et J Hipster
  - 1. Introduction571
  - 2. Généralités572
  - 2.1 JHipsterweb573
  - 2.2 Personnalisation de l'outil JHispter578
  - 2.3 Niveaux de personnalisations579
  - 3. Créer un blueprint584
  - 3.1 Blueprint pour utiliser lombok dans le domain586
  - 3.2 Exécution du blueprint local589
  - 4. JHipster comme outil multi-technologies590
  - 4.1 Côté client590
  - 4.2 Côté serveur592
  - 4.3 Côté déploiement594
  - 4.4 Côté Spring595
  - 5. Structure du projet596
  - 5.1 La partie front596
  - 5.2 Les grandes lignes de la partie back596
  - 5.2.1 Spring Boot597
  - 5.2.2 La classe serveur HTTP/servlet603
  - 6. JHipster et WebFlux615
  - 6.1 Configuration DatabaseConfiguration616
  - 6.2 Configuration DateTimeFormatConfiguration618
  - 6.3 Configuration LocaleConfiguration618
  - 6.4 Configuration ReactorConfiguration619
  - 6.5 Configuration SecurityConfiguration619
  - 6.6 Configuration WebConfigurer619
  - 6.7 Les tests619
  - 7. Points clés620
  - Chapitre 21
  - Utilisation de GraphQL
  - 1. Introduction621
  - 2. Le schéma622
  - 2.1 La section Query624
  - 2.2 La section Mutation625
  - 3. Intégration de GraphQL dans Spring626
  - 4. L'extension Spring Data Querydsl627
  - 5. Les contrôleurs GraphQL629
  - 6. Autoconfiguration632
  - 6.1 Version HTTP632
  - 6.2 Le Service GraphQlService632
  - 6.3 Le RuntimeWiringConfigurer633
  - 6.4 Gestion des erreurs634
  - 7. Conclusion634
  - 8. Points clés635
  - Chapitre 22
  - Nouveautés de Spring 6
  - 1. Le futur de Spring637
  - 2. Prise en charge des modules Java638
  - 3. Spring Native638
  - 4. Project Leyden639
  - 5. Spring Observability639
  - 6. Obsolescence programmée639
  - Index641
Origine de la notice:
- Electre