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 oeuvre 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.


Quizinclus dans
la version en ligne !

• Testez vos connaissances à l'issue de chaque chapitre
• Validez vos acquis

Téléchargements

• Des fichiers complémentaires (474 Ko)

Avant-propos

1. 1. Préambule
2. 2. Introduction
3. 3. Organisation du livre
4. 4. Public visé
5. 5. Pourquoi Spring
6. 6. Prérequis pour aborder Spring et Jakarta EE
7. 7. Objectifs du livre

Éléments constitutifs du framework

1. 1. Introduction
2. 2. Historique
3. 3. Utilité de Spring dans un projet
4. 4. Vue d'ensemble et sujets abordés dans l'ouvrage
   1. 4.1 Les modules Spring
   2. 4.2 Sujets abordés
   3. 4.3 Version des briques Spring utilisées dans l'ouvrage
   4. 4.4 Version des ressources externes
   5. 4.5 Gestion des dépendances Maven
   6. 4.6 Utilisation d'un BOM (Bill Of Materials) Maven
5. 5. Compléments
6. 6. Points clés

Spring et les design patterns

1. 1. Introduction
2. 2. Le singleton en Java
   1. 2.1 Préoccupation
   2. 2.2 Solution Spring
   3. 2.3 Exemple
3. 3. L'inversion de contrôle
4. 4. Façade
5. 5. Fabrique
6. 6. Décorateur
7. 7. Proxy
8. 8. Modèle Vue Contrôleur (MVC)
9. 9. Les templates
10. 10. Stratégie
11. 11. Points clés

Rappels sur les éléments externes à Spring

1. 1. Codage equals et hashCode
   1. 1.1 Description de la problématique
   2. 1.2 Mise en œuvre
2. 2. Projet Lombok
3. 3. Les systèmes de log
4. 4. Bases de données H2
   1. 4.1 Description de la problématique
   2. 4.2 Mise en œuvre
      1. 4.2.1 Installation
      2. 4.2.2 Configuration du POM
      3. 4.2.3 Connexion à la base de données en utilisant JDBC
      4. 4.2.4 Utiliser un listener de servlet pour démarrer et arrêter la base
5. 5. Projets Maven
   1. 5.1 Description de la problématique
   2. 5.2 Mise en œuvre
   3. 5.3 Installation de Maven sous Windows
   4. 5.4 Utilisation d'un archétype Maven
   5. 5.5 Contenu du fichier pom.xml dans les cas simples utilisés dans ce livre
6. 6. Spring et les versions de Java
7. 7. Points clés

Le conteneur Spring

1. 1. Introduction
2. 2. Les origines
3. 3. Les modules fondamentaux
   1. 3.1 Composition d’un bean
   2. 3.2 Le singleton et le prototype
   3. 3.3 Les objets fondamentaux du package core
      1. 3.3.1 Le PropertyEditor
   4. 3.4 Les PropertyValues
   5. 3.5 Le BranWrapper
   6. 3.6 La BeanFactory
   7. 3.7 L’interface BeanDefinition
   8. 3.8 Le PropertyPlaceholderConfigurer
   9. 3.9 Les objets fondamentaux du package context
   10. 3.10 Relations entre le bean, sa BeanFactory ou son contexte
4. 4. Configuration des beans
   1. 4.1 Configuration par un fichier XML
   2. 4.2 Configuration avec des annotations
   3. 4.3 Configurer les beans applicatifs implicitement
   4. 4.4 Configuration par lambdas
5. 5. Utilisation des beans : injection par setters et constructeurs
   1. 5.1 Mapping via le constructeur en XML
   2. 5.2 Comparaison des méthodes d'instanciation
   3. 5.3 Autres annotations de configuration
      1. 5.3.1 L’annotation @Primary
      2. 5.3.2 Les annotations @Profile et @Conditional
6. 6. Contrôle du cycle de vie : construction et destruction
7. 7. Exemple illustrant les mappings standards
   1. 7.1 Le projet Maven
   2. 7.2 Fichier de configuration de Spring
   3. 7.3 Dépendance Spring Core et système de log
   4. 7.4 Dépendance vers les librairies de tests unitaires
   5. 7.5 Exemple illustrant l'utilisation des logs
   6. 7.6 Fichier de configuration spécifique pour les tests
8. 8. Le Spring Expression Language
   1. 8.1 Utilisation de l’ExpressionParser
   2. 8.2 L’EvaluationContext
   3. 8.3 Utilisation avec @Value
9. 9. Serveurs J2EE, Java EE et Jakarta EE
   1. 9.1 Généralités
   2. 9.2 Web services
      1. 9.2.1 Via une servlet
      2. 9.2.2 Serveur intégré
   3. 9.3 Les EJB
      1. 9.3.1 Fonctionnement
      2. 9.3.2 Création de l'EJB distant
      3. 9.3.3 Configuration de Maven côté client
      4. 9.3.4 Création du client
      5. 9.3.5 Intégration plus poussée
      6. 9.3.6 Le design pattern Business Delegate
10. 10. Points clés

Configuration avancée

1. 1. Introduction
2. 2. Les fichiers de ressources
   1. 2.1 Les fichiers de ressources standards
   2. 2.2 Les fichiers de ressources chargés via le contexte Spring
   3. 2.3 Les fichiers de ressources chargés via un service ResourceLoaderAware
      1. 2.3.1 Le programme principal
      2. 2.3.2 Le service ResourceLoaderAware
3. 3. Convertisseurs et formateurs
   1. 3.1 Built-in converters
      1. 3.1.1 Pour les types standards
      2. 3.1.2 Pour les tableaux et les listes
      3. 3.1.3 Pour les énumérations
      4. 3.1.4 Pour les objets en général
   2. 3.2 Convertir un Array en Collection et String
   3. 3.3 Converter Factory
      1. 3.3.1 Classe StringToUtilisateurConverterFactory
      2. 3.3.2 Classe UtilisateurToStringConverterFactory
      3. 3.3.3 Classe LesConversionsAvecFactories
   4. 3.4 Les formateurs par défaut
      1. 3.4.1 Classe LesConversionsFormateurs
   5. 3.5 Les formateurs personnalisés
      1. 3.5.1 Classe CarteDeCredit
      2. 3.5.2 Classe CarteDeCreditParser
      3. 3.5.3 Classe CarteDeCreditPrinter
      4. 3.5.4 Classe CarteDeCreditFormatter
      5. 3.5.5 Classe LesConversionsFormateursEx2
4. 4. Les BeanWrappers, le binding et les validateurs
   1. 4.1 Classe LesBeanWrappers
   2. 4.2 Classe UtilisateurValidator
5. 5. Points clés

Programmation orientée aspect avec Spring

1. 1. Introduction
2. 2. Pourquoi l’AOP
3. 3. Les concepts d’AOP
4. 4. Limites de Spring AOP et utilisation d’AspectJ
5. 5. Le support @AspectJ dans Spring
   1. 5.1 Activation du support
   2. 5.2 Activation de @AspectJ avec configuration XML
   3. 5.3 Activation de @AspectJ avec configuration Java
   4. 5.4 Déclaration d'un aspect
   5. 5.5 Déclaration d'un pointcut
   6. 5.6 Déclaration des greffons simples
   7. 5.7 Les types génériques
   8. 5.8 Détermination de noms d'arguments
   9. 5.9 Ordre d’appel des greffons interceptant le point de jonction
   10. 5.10 Injection
   11. 5.11 Le mécanisme des proxy
   12. 5.12 La face cachée des proxy en AOP
6. 6. Les API bas niveau pour Spring AOP
   1. 6.1 L’interface PointCut
   2. 6.2 L’interface ClassFilter
   3. 6.3 L’interface MethodMatcher
7. 7. Points clés

Les tests et Spring

1. 1. Introduction
2. 2. Les mock objects
   1. 2.1 Mocks spécialisés pour "environnement"
   2. 2.2 Support
      1. 2.2.1 Utilités générales
      2. 2.2.2 Spring MVC
   3. 2.3 Tests d'intégration
      1. 2.3.1 Vue d'ensemble
      2. 2.3.2 Mise en cache du contexte de test
      3. 2.3.3 Tests back et front
   4. 2.4 Annotations
      1. 2.4.1 @ContextConfiguration
      2. 2.4.2 @WebAppConfiguration
      3. 2.4.3 @ContextHierarchy
      4. 2.4.4 @ActiveProfiles
      5. 2.4.5 @TestPropertySource
      6. 2.4.6 @DirtiesContext
      7. 2.4.7 Interface TestExecutionListener
      8. 2.4.8 @TransactionConfiguration
      9. 2.4.9 @Transactional
      10. 2.4.10 @Rollback
      11. 2.4.11 @BeforeTransaction
      12. 2.4.12 @AfterTransaction
      13. 2.4.13 @Sql, @SqlConfig et @SqlGroup
   5. 2.5 Annotations standards
3. 3. Les frameworks de test JUnit et TestNG
   1. 3.1 Utilisation avec JUnit 4
      1. 3.1.1 Spring JUnit Runner
      2. 3.1.2 @IfProfileValue
      3. 3.1.3 @ProfileValueSourceConfiguration
      4. 3.1.4 @Timed
      5. 3.1.5 @Repeat
      6. 3.1.6 Méta-annotations de support pour les tests
   2. 3.2 Les arcanes du framework Spring TestContext
      1. 3.2.1 Classes et interfaces du framework de tests
      2. 3.2.2 Configuration du TestExecutionListener par les annotations
      3. 3.2.3 Les TestExecutionListeners
      4. 3.2.4 Mélange XML et classes annotées
   3. 3.3 Configuration des contextes de tests
      1. 3.3.1 Configuration de contexte avec des initialiseurs de contexte
      2. 3.3.2 L’héritage dans la configuration des contextes
      3. 3.3.3 Prise en compte des profils d'environnement
      4. 3.3.4 Configuration de contexte avec des fichiers de propriétés de test
      5. 3.3.5 Déclarer un fichier de propriétés pour les tests
      6. 3.3.6 Détection du fichier de propriétés par défaut
   4. 3.4 Hiérarchie des contextes de tests
      1. 3.4.1 Héritage et surcharge des propriétés de test
      2. 3.4.2 Chargement d'un WebApplicationContext
      3. 3.4.3 Conventions
      4. 3.4.4 La sémantique de ressources explicites
      5. 3.4.5 Injecter des objets mockés
      6. 3.4.6 Cachabilité du contexte de test
      7. 3.4.7 Les hiérarchies des contextes
      8. 3.4.8 L'injection de dépendance dans les tests
   5. 3.5 Le scope session lors d’un test de requête
      1. 3.5.1 Le scope session lors d’un test de requête
      2. 3.5.2 Test de beans de scope request
      3. 3.5.3 Configuration d’un bean de scope session
   6. 3.6 Les transactions
      1. 3.6.1 La gestion des transactions
      2. 3.6.2 Les transactions managées par le test
      3. 3.6.3 Activation et désactivation des transactions
      4. 3.6.4 Comportement du commit et du rollback d’une transaction
      5. 3.6.5 Exécution de code en dehors d'une transaction
      6. 3.6.6 Configuration d'un gestionnaire de transactions
      7. 3.6.7 Démonstration de toutes les annotations liées à la transaction
   7. 3.7 Les scripts SQL
      1. 3.7.1 Exécuter des scripts SQL
      2. 3.7.2 La sémantique du path des ressources
      3. 3.7.3 La détection de script par défaut
      4. 3.7.4 Déclaration de plusieurs @Sql
      5. 3.7.5 Phases d'exécution pour les scripts
      6. 3.7.6 Script de configuration avec SqlConfig
      7. 3.7.7 La gestion des transactions pour @Sql
   8. 3.8 Classes de support TestContext
      1. 3.8.1 Classes de support de JUnit
      2. 3.8.2 Spring JUnit Runner
   9. 3.9 Framework Spring MVC Test
      1. 3.9.1 Projet autonome
      2. 3.9.2 Tests côté serveur
      3. 3.9.3 Définir les attendus
      4. 3.9.4 Ajouts de filtres
      5. 3.9.5 Tests REST côté client
   10. 3.10 Autres ressources
4. 4. Points clés

Partie back de l’application

1. 1. Description de la problématique
2. 2. Mise en œuvre
   1. 2.1 Configuration d’une entité de la couche domaine
   2. 2.2 Accès à l'objet du domaine
   3. 2.3 Suppression en cascade
   4. 2.4 Requêtes typées
   5. 2.5 Cache de niveaux 1 et 2
   6. 2.6 Bean Validation (JSR-303)
   7. 2.7 L'API Criteria
   8. 2.8 Accès à la base de données
   9. 2.9 Le fichier persistence.xml
   10. 2.10 Tests JPA
3. 3. Pour aller plus loin
   1. 3.1 Librairie Java jcabi-aspects
   2. 3.2 Métriques AspectJ
4. 4. Utilisation de MapStruct
   1. 4.1 Approche API-First
5. 5. Les outils
   1. 5.1 Swagger
   2. 5.2 OpenAPITools
   3. 5.3 Autres
6. 6. Les générateurs de code
7. 7. Utilisation du plugin
   1. 7.1 Pour le générateur Swagger
   2. 7.2 Pour le générateur OpenAPITools
8. 8. Personnalisation
   1. 8.1 Swagger
   2. 8.2 OpenAPITools
9. 9. Conception d’une description API
10. 10. Outillage pour le design de l’API
11. 11. Spring Actuator
12. 12. Points clés

Spring dans un contexte web JSP

1. 1. Spring MVC
   1. 1.1 Fonctionnement global
      1. 1.1.1 Configuration simple XML
      2. 1.1.2 Configuration par annotation
   2. 1.2 Éléments complexes du contrôleur
      1. 1.2.1 Fonctionnement global du contrôleur
      2. 1.2.2 Exemple de la classe Simple
      3. 1.2.3 Simple revisité
      4. 1.2.4 Par le path
      5. 1.2.5 Par un motif sur le path
      6. 1.2.6 Par le path et une méthode
      7. 1.2.7 Mappé par path + méthode + présence de paramètres de query
      8. 1.2.8 Mappé par path + méthode + présence d’un header
      9. 1.2.9 Par l'absence d'un header
      10. 1.2.10 Par consommation
      11. 1.2.11 Par production via Accept=application/json
      12. 1.2.12 Par production via Accept=application/xml
      13. 1.2.13 Paramètres de query
      14. 1.2.14 Groupes de paramètres de query
      15. 1.2.15 Variable du path
      16. 1.2.16 Corps de la requête
      17. 1.2.17 En-tête et corps de la requête
      18. 1.2.18 Arguments dans la requête
      19. 1.2.19 Arguments de la réponse
      20. 1.2.20 Session
      21. 1.2.21 Handler personnalisé
      22. 1.2.22 Lire les données encodées dans l’URL
      23. 1.2.23 Lire une structure XML
      24. 1.2.24 Écrire dans une structure XML via Accept=application/xml
      25. 1.2.25 Lire une structure JSON
      26. 1.2.26 Écrire dans une structure JSON via Accept=application/json
      27. 1.2.27 HTML généré par un template JSP
      28. 1.2.28 Mapping à partir d’un modèle
      29. 1.2.29 Utiliser des variables dans un template de vue
      30. 1.2.30 Data binding avec des variables d'URI
      31. 1.2.31 Types primitifs
      32. 1.2.32 Date
      33. 1.2.33 Conversion des collections
      34. 1.2.34 Utiliser des collections formatées
      35. 1.2.35 Utiliser des objets personnalisés
      36. 1.2.36 Utiliser un convertisseur personnalisé
      37. 1.2.37 Validation
      38. 1.2.38 @ExceptionHandler dans un contrôleur
      39. 1.2.39 @ExceptionHandler global
      40. 1.2.40 Templates de String pour les URI
      41. 1.2.41 UriComponentsBuilder
2. 2. Client REST
   1. 2.1 Utilisation du RestTemplate
   2. 2.2 Le bean de domaine avec l'annotation REST pour les champs manquants
3. 3. Spring Security
   1. 3.1 Introduction à Spring Security
   2. 3.2 Spring Security dans un environnement web
      1. 3.2.1 Authentification par Spring
      2. 3.2.2 Authentification par page de login personnalisée
      3. 3.2.3 Authentification par base de données
4. 4. Points clés

Intégration JSF2

1. 1. Introduction
2. 2. Mojarra
3. 3. Architecture
4. 4. Cycle de vie
   1. 4.1 Requête
   2. 4.2 Restore View ou Reconstruct Component Tree
   3. 4.3 Apply Request Value
   4. 4.4 Perform Validation
   5. 4.5 Synchronize Model ou Update Model Values
   6. 4.6 Invoke Application Logic
   7. 4.7 Render Response
   8. 4.8 Réponse
   9. 4.9 Fichier web.xml
   10. 4.10 Dépendances
   11. 4.11 Fichier faces-config.xml
   12. 4.12 Bean managé sans Spring
   13. 4.13 Exemple de vue JSF
   14. 4.14 Aperçu d’un composant JSF
5. 5. Intégration Spring
   1. 5.1 Architecture
   2. 5.2 Dépendances
   3. 5.3 Fichier web.xml
   4. 5.4 Fichier faces-config.xml
   5. 5.5 Couches basses (back)
6. 6. Points clés

Application Spring Angular

1. 1. Introduction
2. 2. La partie backend
   1. 2.1 Génération d’un backend
3. 3. La partie frontend
   1. 3.1 Angular CLI
   2. 3.2 Création du projet initial
   3. 3.3 Démarrage de l’application
   4. 3.4 Créer un service Compte
4. 4. Points clés

Spring-HATEOAS

1. 1. Introduction
   1. 1.1 Exemple de liens hypermédias codés manuellement
   2. 1.2 Aller plus loin avec l’hypermédia
   3. 1.3 Autoconfiguration par annotation
   4. 1.4 Fournisseurs de relations
   5. 1.5 Fournisseur d’URI compacte
   6. 1.6 Support du côté client
   7. 1.7 Découverte de liens coté client
   8. 1.8 Utilisation du @RepositoryRestResource
2. 2. Points clés

Documentation Spring REST Docs

1. 1. Introduction
   1. 1.1 Dépendance sur la bibliothèque de tests
   2. 1.2 Dépendance sur les plugins Maven
   3. 1.3 Les extraits (snippets)
2. 2. Exemple JUnit 5 (Jupiter)
3. 3. Requête et réponse
4. 4. Réponse avec un JSON imbriqué
   1. 4.1 Les paramètres de requête
   2. 4.2 Les paramètres inclus dans le path
   3. 4.3 Les Request parts
   4. 4.4 Les Request parts payloads
   5. 4.5 Les champs
   6. 4.6 Liens hypermédias dans la réponse
   7. 4.7 Les en-têtes
5. 5. Personnalisation de la documentation
6. 6. Couplage Swagger 2
   1. 6.1 Utilisation Springfox
   2. 6.2 En dehors de Spring Boot
7. 7. Utilisation avec Spring Data Rest
8. 8. Récapitulatif sur la documentation générée
9. 9. Points clés

Spring Boot

1. 1. Introduction
2. 2. Configuration des exemples
   1. 2.1 Configuration Maven pour la version 1.5 de Spring Boot
   2. 2.2 Configuration Maven pour la version 2 de Spring Boot
   3. 2.3 Utilisation du hot swapping
   4. 2.4 Packaging et lancement de l’application
   5. 2.5 Application Spring MVC minimum
3. 3. L’auto-configuration Spring Boot
4. 4. Les starters
   1. 4.1 Les starters courants
   2. 4.2 Les starters orientés messages
   3. 4.3 Les bases de données
   4. 4.4 Les web services
   5. 4.5 Les moteurs de rendus
   6. 4.6 Les starters moins courants
5. 5. Spring MVC
6. 6. Personnalisation de la bannière
7. 7. Événements d’applications
8. 8. La récupération des arguments de la ligne de commande
   1. 8.1 CommandLineRunner
   2. 8.2 ApplicationRunner
   3. 8.3 La configuration yaml et profiles
9. 9. L‘annotation EnableConfigurationProperties
10. 10. La configuration des logs
    1. 10.1 Les logs en couleur
    2. 10.2 Choix du type de logs
11. 11. L’auto-configuration pour Spring MVC
12. 12. La gestion des sessions
13. 13. Le guide de migration de la version 1.5 à la version 2.x
    1. 13.1 Fichiers de configuration
    2. 13.2 Comportements différents
    3. 13.3 Démarrage
    4. 13.4 Utilisation de ApplicationRunner ou CommandLineRunner
    5. 13.5 Configuration externalisée
    6. 13.6 Développement d’applications web
    7. 13.7 Sécurité
14. 14. Description avancée de Spring Boot
15. 15. Le chargement du BootstrapContext
16. 16. Mise en place des listeners
    1. 16.1 Le starting : ApplicationStartingEvent
    2. 16.2 L’environnement : l’ApplicationEnvironmentPreparedEvent
    3. 16.3 L’EnvironmentPostProcessorApplicationListener
17. 17. La configuration des logs
18. 18. Création de l’ApplicationContext
19. 19. Préparation et rafraîchissement du contexte
20. 20. L’EnableAutoConfigurtation
21. 21. Lancement des runners
22. 22. Points clés

Spring et le NoSQL

1. 1. Introduction
2. 2. Les modèles de données
   1. 2.1 Modèle Clé-valeur
   2. 2.2 Modèle Documents
   3. 2.3 Modèle Orienté colonnes
   4. 2.4 Les bases orientées Graph
3. 3. Principes des bases de données
4. 4. Pourquoi et quand utiliser une base NoSQL
5. 5. Problèmes liés à l’utilisation des bases NoSQL
6. 6. Limitations des bases de données NoSQL
7. 7. Spring et le NoSQL
8. 8. Cache de données
   1. 8.1 Cache simple
9. 9. Cacher des données avec GemFire
10. 10. GemFire en tant que base de données NoSQL
11. 11. Redis en autonome
    1. 11.1 Utilisation de Redis pour le cache de données
    2. 11.2 Utilisation de Redis pour gérer des messages
12. 12. MongoDB
    1. 12.1 MongoDB avec Spring Boot
    2. 12.2 MongoDB avec une API REST
13. 13. Points clés

Spring Batch

1. 1. Introduction
2. 2. Architecture d’un batch
3. 3. Exemple Spring Batch version 4
4. 4. Chargeur H2 depuis un CSV
5. 5. Dépendances Spring Batch 3 et 4
6. 6. Autres nouveautés de la version 4
7. 7. Évolutions des batchs
8. 8. Points clés

Les intergiciels à messages (MOM)

1. 1. Introduction
2. 2. Implémentations open source
3. 3. Implémentations propriétaires
4. 4. Les cas d’utilisation
5. 5. JMS et ActiveMQ
6. 6. RabbitMQ
   1. 6.1 Spring AMQP et RabbitMQ
   2. 6.2 Exemple RabbitMQ
7. 7. Points clés

Spring et Kotlin

1. 1. Introduction
2. 2. Caractéristiques principales du langage Kotlin
   1. 2.1 Les méthodes et les fonctions
   2. 2.2 L’immutabilité des objets
   3. 2.3 Les types
   4. 2.4 La gestion des valeurs nulles
   5. 2.5 Les appels chaînés sécurisés
   6. 2.6 Les lambdas
3. 3. Contrôleur Spring MVC, Spring Boot en Kotlin
   1. 3.1 Fonction principale
   2. 3.2 Test associé à la fonction principale
4. 4. Les plugins
5. 5. Points clés

Introduction à Spring Reactor et Spring Webflux

1. 1. Introduction
2. 2. Spring Reactor
   1. 2.1 Présentation
   2. 2.2 Utilisation de Reactor Core
      1. 2.2.1 Les threads
      2. 2.2.2 Les FutureTask
      3. 2.2.3 Le CompletableFuture
      4. 2.2.4 Flux et Mono
   3. 2.3 Les tests
      1. 2.3.1 Vérifications avec StepVerifier
      2. 2.3.2 Emissions manuelles avec TestPublisher
3. 3. WebFlux
   1. 3.1 Définition du terme réactif
   2. 3.2 Les couches réactives
      1. 3.2.1 la couche contrôleur
      2. 3.2.2 La couche des services
      3. 3.2.3 La couche repository
      4. 3.2.4 Repository reactif R2DBC
4. 4. Client réactif
5. 5. Les tests avec WebFlux
   1. 5.1 Tests unitaires
      1. 5.1.1 Tests unitaires avec des applications réactives
      2. 5.1.2 Utilisation de MockWebServer
   2. 5.2 Tests d'intégration
6. 6. Server Site Event avec Spring
7. 7. Pour aller plus loin
8. 8. Points clés

Spring et JHipster

1. 1. Introduction
2. 2. Généralités
   1. 2.1 JHipster web
   2. 2.2 Personnalisation de l’outil JHispter
   3. 2.3 Niveaux de personnalisations
3. 3. Créer un blueprint
   1. 3.1 Blueprint pour utiliser lombok dans le domain
   2. 3.2 Exécution du blueprint local
4. 4. JHipster comme outil multi-technologies
   1. 4.1 Côté client
   2. 4.2 Côté serveur
   3. 4.3 Côté déploiement
   4. 4.4 Côté Spring
5. 5. Structure du projet
   1. 5.1 La partie front
   2. 5.2 Les grandes lignes de la partie back
      1. 5.2.1 Spring Boot
      2. 5.2.2 La classe serveur HTTP/servlet
6. 6. JHipster et WebFlux
   1. 6.1 Configuration DatabaseConfiguration
   2. 6.2 Configuration DateTimeFormatConfiguration
   3. 6.3 Configuration LocaleConfiguration
   4. 6.4 Configuration ReactorConfiguration
   5. 6.5 Configuration SecurityConfiguration
   6. 6.6 Configuration WebConfigurer
   7. 6.7 Les tests
7. 7. Points clés

Utilisation de GraphQL

1. 1. Introduction
2. 2. Le schéma
   1. 2.1 La section Query
   2. 2.2 La section Mutation
3. 3. Intégration de GraphQL dans Spring
4. 4. L’extension Spring Data Querydsl
5. 5. Les contrôleurs GraphQL
6. 6. Autoconfiguration
   1. 6.1 Version HTTP
   2. 6.2 Le Service GraphQlService
   3. 6.3 Le RuntimeWiringConfigurer
   4. 6.4 Gestion des erreurs
7. 7. Conclusion
8. 8. Points clés

Nouveautés de Spring

1. 1. Le futur de Spring
2. 2. Prise en charge des modules Java
3. 3. Spring Native
4. 4. Project Leyden
5. 5. Spring Observability
6. 6. Obsolescence programmée
8. Index