Java Spring - Le socle technique des applications Java 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 [...]
[lire le résumé du livre]
Auteur : Hervé LE MORVAN
Editeur : Eni
Collection : Epsilon
Date parution : 08/2022 4e éditionCB Google/Apple Pay, Chèque, Virement
Quel est le sujet du livre "Java Spring - Le socle technique des applications Java 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 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 !Téléchargements
Hervé LE MORVAN est aujourd'hui consultant DevOps pour de grands comptes de la Banque, de l'Assurance et des Telecoms. Durant ses vingt années d'expérience, il est principalement intervenu en tant que référent technique et formateur dans des équipes de Recherches et Développement ou d'Architectes et en tant que support au développement d’applications sur des missions de migration ou de modernisation de Systèmes d'Informations. À ce titre, il est intervenu dans de nombreux projets de migrations utilisant le socle Spring et connaît parfaitement les attentes des équipes dans ce domaine. C’est toute cette expérience qu’il partage volontiers tout au long des pages de ce livre.
En suivant ce lien, retrouvez tous les livres dans la spécialité Java.
Sommaire et contenu du livre "Java Spring - Le socle technique des applications Java EE"
Avant-propos
- 1. Préambule
- 2. Introduction
- 3. Organisation du livre
- 4. Public visé
- 5. Pourquoi Spring
- 6. Prérequis pour aborder Spring et Jakarta EE
- 7. Objectifs du livre
Éléments constitutifs du framework
- 1. Introduction
- 2. Historique
- 3. Utilité de Spring dans un projet
- 4. Vue d'ensemble et sujets abordés dans l'ouvrage
- 4.1 Les modules Spring
- 4.2 Sujets abordés
- 4.3 Version des briques Spring utilisées dans l'ouvrage
- 4.4 Version des ressources externes
- 4.5 Gestion des dépendances Maven
- 4.6 Utilisation d'un BOM (Bill Of Materials) Maven
- 5. Compléments
- 6. Points clés
Spring et les design patterns
- 1. Introduction
- 2. Le singleton en Java
- 2.1 Préoccupation
- 2.2 Solution Spring
- 2.3 Exemple
- 3. L'inversion de contrôle
- 4. Façade
- 5. Fabrique
- 6. Décorateur
- 7. Proxy
- 8. Modèle Vue Contrôleur (MVC)
- 9. Les templates
- 10. Stratégie
- 11. Points clés
Rappels sur les éléments externes à Spring
- 1. Codage equals et hashCode
- 1.1 Description de la problématique
- 1.2 Mise en œuvre
- 2. Projet Lombok
- 3. Les systèmes de log
- 4. Bases de données H2
- 4.1 Description de la problématique
- 4.2 Mise en œuvre
- 4.2.1 Installation
- 4.2.2 Configuration du POM
- 4.2.3 Connexion à la base de données en utilisant JDBC
- 4.2.4 Utiliser un listener de servlet pour démarrer et arrêter la base
- 5.1 Description de la problématique
- 5.2 Mise en œuvre
- 5.3 Installation de Maven sous Windows
- 5.4 Utilisation d'un archétype Maven
- 5.5 Contenu du fichier pom.xml dans les cas simples utilisés dans ce livre
Le conteneur Spring
- 1. Introduction
- 2. Les origines
- 3. Les modules fondamentaux
- 3.1 Composition d’un bean
- 3.2 Le singleton et le prototype
- 3.3 Les objets fondamentaux du package core
- 3.3.1 Le PropertyEditor
- 3.4 Les PropertyValues
- 3.5 Le BranWrapper
- 3.6 La BeanFactory
- 3.7 L’interface BeanDefinition
- 3.8 Le PropertyPlaceholderConfigurer
- 3.9 Les objets fondamentaux du package context
- 3.10 Relations entre le bean, sa BeanFactory ou son contexte
- 4.1 Configuration par un fichier XML
- 4.2 Configuration avec des annotations
- 4.3 Configurer les beans applicatifs implicitement
- 4.4 Configuration par lambdas
- 5.1 Mapping via le constructeur en XML
- 5.2 Comparaison des méthodes d'instanciation
- 5.3 Autres annotations de configuration
- 5.3.1 L’annotation @Primary
- 5.3.2 Les annotations @Profile et @Conditional
- 7.1 Le projet Maven
- 7.2 Fichier de configuration de Spring
- 7.3 Dépendance Spring Core et système de log
- 7.4 Dépendance vers les librairies de tests unitaires
- 7.5 Exemple illustrant l'utilisation des logs
- 7.6 Fichier de configuration spécifique pour les tests
- 8.1 Utilisation de l’ExpressionParser
- 8.2 L’EvaluationContext
- 8.3 Utilisation avec @Value
- 9.1 Généralités
- 9.2 Web services
- 9.2.1 Via une servlet
- 9.2.2 Serveur intégré
- 9.3.1 Fonctionnement
- 9.3.2 Création de l'EJB distant
- 9.3.3 Configuration de Maven côté client
- 9.3.4 Création du client
- 9.3.5 Intégration plus poussée
- 9.3.6 Le design pattern Business Delegate
Configuration avancée
- 1. Introduction
- 2. Les fichiers de ressources
- 2.1 Les fichiers de ressources standards
- 2.2 Les fichiers de ressources chargés via le contexte Spring
- 2.3 Les fichiers de ressources chargés via un service ResourceLoaderAware
- 2.3.1 Le programme principal
- 2.3.2 Le service ResourceLoaderAware
- 3.1 Built-in converters
- 3.1.1 Pour les types standards
- 3.1.2 Pour les tableaux et les listes
- 3.1.3 Pour les énumérations
- 3.1.4 Pour les objets en général
- 3.3.1 Classe StringToUtilisateurConverterFactory
- 3.3.2 Classe UtilisateurToStringConverterFactory
- 3.3.3 Classe LesConversionsAvecFactories
- 3.4.1 Classe LesConversionsFormateurs
- 3.5.1 Classe CarteDeCredit
- 3.5.2 Classe CarteDeCreditParser
- 3.5.3 Classe CarteDeCreditPrinter
- 3.5.4 Classe CarteDeCreditFormatter
- 3.5.5 Classe LesConversionsFormateursEx2
- 4.1 Classe LesBeanWrappers
- 4.2 Classe UtilisateurValidator
Programmation orientée aspect avec Spring
- 1. Introduction
- 2. Pourquoi l’AOP
- 3. Les concepts d’AOP
- 4. Limites de Spring AOP et utilisation d’AspectJ
- 5. Le support @AspectJ dans Spring
- 5.1 Activation du support
- 5.2 Activation de @AspectJ avec configuration XML
- 5.3 Activation de @AspectJ avec configuration Java
- 5.4 Déclaration d'un aspect
- 5.5 Déclaration d'un pointcut
- 5.6 Déclaration des greffons simples
- 5.7 Les types génériques
- 5.8 Détermination de noms d'arguments
- 5.9 Ordre d’appel des greffons interceptant le point de jonction
- 5.10 Injection
- 5.11 Le mécanisme des proxy
- 5.12 La face cachée des proxy en AOP
- 6. Les API bas niveau pour Spring AOP
- 6.1 L’interface PointCut
- 6.2 L’interface ClassFilter
- 6.3 L’interface MethodMatcher
- 7. Points clés
Les tests et Spring
- 1. Introduction
- 2. Les mock objects
- 2.1 Mocks spécialisés pour "environnement"
- 2.2 Support
- 2.2.1 Utilités générales
- 2.2.2 Spring MVC
- 2.3 Tests d'intégration
- 2.3.1 Vue d'ensemble
- 2.3.2 Mise en cache du contexte de test
- 2.3.3 Tests back et front
- 2.4 Annotations
- 2.4.1 @ContextConfiguration
- 2.4.2 @WebAppConfiguration
- 2.4.3 @ContextHierarchy
- 2.4.4 @ActiveProfiles
- 2.4.5 @TestPropertySource
- 2.4.6 @DirtiesContext
- 2.4.7 Interface TestExecutionListener
- 2.4.8 @TransactionConfiguration
- 2.4.9 @Transactional
- 2.4.10 @Rollback
- 2.4.11 @BeforeTransaction
- 2.4.12 @AfterTransaction
- 2.4.13 @Sql, @SqlConfig et @SqlGroup
- 2.5 Annotations standards
- 3.1 Utilisation avec JUnit 4
- 3.1.1 Spring JUnit Runner
- 3.1.2 @IfProfileValue
- 3.1.3 @ProfileValueSourceConfiguration
- 3.1.4 @Timed
- 3.1.5 @Repeat
- 3.1.6 Méta-annotations de support pour les tests
- 3.2.1 Classes et interfaces du framework de tests
- 3.2.2 Configuration du TestExecutionListener par les annotations
- 3.2.3 Les TestExecutionListeners
- 3.2.4 Mélange XML et classes annotées
- 3.3.1 Configuration de contexte avec des initialiseurs de contexte
- 3.3.2 L’héritage dans la configuration des contextes
- 3.3.3 Prise en compte des profils d'environnement
- 3.3.4 Configuration de contexte avec des fichiers de propriétés de test
- 3.3.5 Déclarer un fichier de propriétés pour les tests
- 3.3.6 Détection du fichier de propriétés par défaut
- 3.4.1 Héritage et surcharge des propriétés de test
- 3.4.2 Chargement d'un WebApplicationContext
- 3.4.3 Conventions
- 3.4.4 La sémantique de ressources explicites
- 3.4.5 Injecter des objets mockés
- 3.4.6 Cachabilité du contexte de test
- 3.4.7 Les hiérarchies des contextes
- 3.4.8 L'injection de dépendance dans les tests
- 3.5.1 Le scope session lors d’un test de requête
- 3.5.2 Test de beans de scope request
- 3.5.3 Configuration d’un bean de scope session
- 3.6.1 La gestion des transactions
- 3.6.2 Les transactions managées par le test
- 3.6.3 Activation et désactivation des transactions
- 3.6.4 Comportement du commit et du rollback d’une transaction
- 3.6.5 Exécution de code en dehors d'une transaction
- 3.6.6 Configuration d'un gestionnaire de transactions
- 3.6.7 Démonstration de toutes les annotations liées à la transaction
- 3.7.1 Exécuter des scripts SQL
- 3.7.2 La sémantique du path des ressources
- 3.7.3 La détection de script par défaut
- 3.7.4 Déclaration de plusieurs @Sql
- 3.7.5 Phases d'exécution pour les scripts
- 3.7.6 Script de configuration avec SqlConfig
- 3.7.7 La gestion des transactions pour @Sql
- 3.8.1 Classes de support de JUnit
- 3.8.2 Spring JUnit Runner
- 3.9.1 Projet autonome
- 3.9.2 Tests côté serveur
- 3.9.3 Définir les attendus
- 3.9.4 Ajouts de filtres
- 3.9.5 Tests REST côté client
Partie back de l’application
- 1. Description de la problématique
- 2. Mise en œuvre
- 2.1 Configuration d’une entité de la couche domaine
- 2.2 Accès à l'objet du domaine
- 2.3 Suppression en cascade
- 2.4 Requêtes typées
- 2.5 Cache de niveaux 1 et 2
- 2.6 Bean Validation (JSR-303)
- 2.7 L'API Criteria
- 2.8 Accès à la base de données
- 2.9 Le fichier persistence.xml
- 2.10 Tests JPA
- 3. Pour aller plus loin
- 3.1 Librairie Java jcabi-aspects
- 3.2 Métriques AspectJ
- 4. Utilisation de MapStruct
- 4.1 Approche API-First
- 5. Les outils
- 5.1 Swagger
- 5.2 OpenAPITools
- 5.3 Autres
- 6. Les générateurs de code
- 7. Utilisation du plugin
- 7.1 Pour le générateur Swagger
- 7.2 Pour le générateur OpenAPITools
- 8. Personnalisation
- 8.1 Swagger
- 8.2 OpenAPITools
- 9. Conception d’une description API
- 10. Outillage pour le design de l’API
- 11. Spring Actuator
- 12. Points clés
Spring dans un contexte web JSP
- 1. Spring MVC
- 1.1 Fonctionnement global
- 1.1.1 Configuration simple XML
- 1.1.2 Configuration par annotation
- 1.1 Fonctionnement global
- 1.2 Éléments complexes du contrôleur
- 1.2.1 Fonctionnement global du contrôleur
- 1.2.2 Exemple de la classe Simple
- 1.2.3 Simple revisité
- 1.2.4 Par le path
- 1.2.5 Par un motif sur le path
- 1.2.6 Par le path et une méthode
- 1.2.7 Mappé par path + méthode + présence de paramètres de query
- 1.2.8 Mappé par path + méthode + présence d’un header
- 1.2.9 Par l'absence d'un header
- 1.2.10 Par consommation
- 1.2.11 Par production via Accept=application/json
- 1.2.12 Par production via Accept=application/xml
- 1.2.13 Paramètres de query
- 1.2.14 Groupes de paramètres de query
- 1.2.15 Variable du path
- 1.2.16 Corps de la requête
- 1.2.17 En-tête et corps de la requête
- 1.2.18 Arguments dans la requête
- 1.2.19 Arguments de la réponse
- 1.2.20 Session
- 1.2.21 Handler personnalisé
- 1.2.22 Lire les données encodées dans l’URL
- 1.2.23 Lire une structure XML
- 1.2.24 Écrire dans une structure XML via Accept=application/xml
- 1.2.25 Lire une structure JSON
- 1.2.26 Écrire dans une structure JSON via Accept=application/json
- 1.2.27 HTML généré par un template JSP
- 1.2.28 Mapping à partir d’un modèle
- 1.2.29 Utiliser des variables dans un template de vue
- 1.2.30 Data binding avec des variables d'URI
- 1.2.31 Types primitifs
- 1.2.32 Date
- 1.2.33 Conversion des collections
- 1.2.34 Utiliser des collections formatées
- 1.2.35 Utiliser des objets personnalisés
- 1.2.36 Utiliser un convertisseur personnalisé
- 1.2.37 Validation
- 1.2.38 @ExceptionHandler dans un contrôleur
- 1.2.39 @ExceptionHandler global
- 1.2.40 Templates de String pour les URI
- 1.2.41 UriComponentsBuilder
- 2.1 Utilisation du RestTemplate
- 2.2 Le bean de domaine avec l'annotation REST pour les champs manquants
- 3.1 Introduction à Spring Security
- 3.2 Spring Security dans un environnement web
- 3.2.1 Authentification par Spring
- 3.2.2 Authentification par page de login personnalisée
- 3.2.3 Authentification par base de données
Intégration JSF2
- 1. Introduction
- 2. Mojarra
- 3. Architecture
- 4. Cycle de vie
- 4.1 Requête
- 4.2 Restore View ou Reconstruct Component Tree
- 4.3 Apply Request Value
- 4.4 Perform Validation
- 4.5 Synchronize Model ou Update Model Values
- 4.6 Invoke Application Logic
- 4.7 Render Response
- 4.8 Réponse
- 4.9 Fichier web.xml
- 4.10 Dépendances
- 4.11 Fichier faces-config.xml
- 4.12 Bean managé sans Spring
- 4.13 Exemple de vue JSF
- 4.14 Aperçu d’un composant JSF
- 5. Intégration Spring
- 5.1 Architecture
- 5.2 Dépendances
- 5.3 Fichier web.xml
- 5.4 Fichier faces-config.xml
- 5.5 Couches basses (back)
- 6. Points clés
Application Spring Angular
- 1. Introduction
- 2. La partie backend
- 2.1 Génération d’un backend
- 3. La partie frontend
- 3.1 Angular CLI
- 3.2 Création du projet initial
- 3.3 Démarrage de l’application
- 3.4 Créer un service Compte
- 4. Points clés
Spring-HATEOAS
- 1. Introduction
- 1.1 Exemple de liens hypermédias codés manuellement
- 1.2 Aller plus loin avec l’hypermédia
- 1.3 Autoconfiguration par annotation
- 1.4 Fournisseurs de relations
- 1.5 Fournisseur d’URI compacte
- 1.6 Support du côté client
- 1.7 Découverte de liens coté client
- 1.8 Utilisation du @RepositoryRestResource
- 2. Points clés
Documentation Spring REST Docs
- 1. Introduction
- 1.1 Dépendance sur la bibliothèque de tests
- 1.2 Dépendance sur les plugins Maven
- 1.3 Les extraits (snippets)
- 2. Exemple JUnit 5 (Jupiter)
- 3. Requête et réponse
- 4. Réponse avec un JSON imbriqué
- 4.1 Les paramètres de requête
- 4.2 Les paramètres inclus dans le path
- 4.3 Les Request parts
- 4.4 Les Request parts payloads
- 4.5 Les champs
- 4.6 Liens hypermédias dans la réponse
- 4.7 Les en-têtes
- 5. Personnalisation de la documentation
- 6. Couplage Swagger 2
- 6.1 Utilisation Springfox
- 6.2 En dehors de Spring Boot
- 7. Utilisation avec Spring Data Rest
- 8. Récapitulatif sur la documentation générée
- 9. Points clés
Spring Boot
- 1. Introduction
- 2. Configuration des exemples
- 2.1 Configuration Maven pour la version 1.5 de Spring Boot
- 2.2 Configuration Maven pour la version 2 de Spring Boot
- 2.3 Utilisation du hot swapping
- 2.4 Packaging et lancement de l’application
- 2.5 Application Spring MVC minimum
- 3. L’auto-configuration Spring Boot
- 4. Les starters
- 4.1 Les starters courants
- 4.2 Les starters orientés messages
- 4.3 Les bases de données
- 4.4 Les web services
- 4.5 Les moteurs de rendus
- 4.6 Les starters moins courants
- 5. Spring MVC
- 6. Personnalisation de la bannière
- 7. Événements d’applications
- 8. La récupération des arguments de la ligne de commande
- 8.1 CommandLineRunner
- 8.2 ApplicationRunner
- 8.3 La configuration yaml et profiles
- 9. L‘annotation EnableConfigurationProperties
- 10. La configuration des logs
- 10.1 Les logs en couleur
- 10.2 Choix du type de logs
- 11. L’auto-configuration pour Spring MVC
- 12. La gestion des sessions
- 13. Le guide de migration de la version 1.5 à la version 2.x
- 13.1 Fichiers de configuration
- 13.2 Comportements différents
- 13.3 Démarrage
- 13.4 Utilisation de ApplicationRunner ou CommandLineRunner
- 13.5 Configuration externalisée
- 13.6 Développement d’applications web
- 13.7 Sécurité
- 14. Description avancée de Spring Boot
- 15. Le chargement du BootstrapContext
- 16. Mise en place des listeners
- 16.1 Le starting : ApplicationStartingEvent
- 16.2 L’environnement : l’ApplicationEnvironmentPreparedEvent
- 16.3 L’EnvironmentPostProcessorApplicationListener
- 17. La configuration des logs
- 18. Création de l’ApplicationContext
- 19. Préparation et rafraîchissement du contexte
- 20. L’EnableAutoConfigurtation
- 21. Lancement des runners
- 22. Points clés
Spring et le NoSQL
- 1. Introduction
- 2. Les modèles de données
- 2.1 Modèle Clé-valeur
- 2.2 Modèle Documents
- 2.3 Modèle Orienté colonnes
- 2.4 Les bases orientées Graph
- 3. Principes des bases de données
- 4. Pourquoi et quand utiliser une base NoSQL
- 5. Problèmes liés à l’utilisation des bases NoSQL
- 6. Limitations des bases de données NoSQL
- 7. Spring et le NoSQL
- 8. Cache de données
- 8.1 Cache simple
- 9. Cacher des données avec GemFire
- 10. GemFire en tant que base de données NoSQL
- 11. Redis en autonome
- 11.1 Utilisation de Redis pour le cache de données
- 11.2 Utilisation de Redis pour gérer des messages
- 12. MongoDB
- 12.1 MongoDB avec Spring Boot
- 12.2 MongoDB avec une API REST
- 13. Points clés
Spring Batch
- 1. Introduction
- 2. Architecture d’un batch
- 3. Exemple Spring Batch version 4
- 4. Chargeur H2 depuis un CSV
- 5. Dépendances Spring Batch 3 et 4
- 6. Autres nouveautés de la version 4
- 7. Évolutions des batchs
- 8. Points clés
Les intergiciels à messages (MOM)
- 1. Introduction
- 2. Implémentations open source
- 3. Implémentations propriétaires
- 4. Les cas d’utilisation
- 5. JMS et ActiveMQ
- 6. RabbitMQ
- 6.1 Spring AMQP et RabbitMQ
- 6.2 Exemple RabbitMQ
- 7. Points clés
Spring et Kotlin
- 1. Introduction
- 2. Caractéristiques principales du langage Kotlin
- 2.1 Les méthodes et les fonctions
- 2.2 L’immutabilité des objets
- 2.3 Les types
- 2.4 La gestion des valeurs nulles
- 2.5 Les appels chaînés sécurisés
- 2.6 Les lambdas
- 3. Contrôleur Spring MVC, Spring Boot en Kotlin
- 3.1 Fonction principale
- 3.2 Test associé à la fonction principale
- 4. Les plugins
- 5. Points clés
Introduction à Spring Reactor et Spring Webflux
- 1. Introduction
- 2. Spring Reactor
- 2.1 Présentation
- 2.2 Utilisation de Reactor Core
- 2.2.1 Les threads
- 2.2.2 Les FutureTask
- 2.2.3 Le CompletableFuture
- 2.2.4 Flux et Mono
- 2.3 Les tests
- 2.3.1 Vérifications avec StepVerifier
- 2.3.2 Emissions manuelles avec TestPublisher
- 3.1 Définition du terme réactif
- 3.2 Les couches réactives
- 3.2.1 la couche contrôleur
- 3.2.2 La couche des services
- 3.2.3 La couche repository
- 3.2.4 Repository reactif R2DBC
- 5.1 Tests unitaires
- 5.1.1 Tests unitaires avec des applications réactives
- 5.1.2 Utilisation de MockWebServer
Spring et JHipster
- 1. Introduction
- 2. Généralités
- 2.1 JHipster web
- 2.2 Personnalisation de l’outil JHispter
- 2.3 Niveaux de personnalisations
- 3. Créer un blueprint
- 3.1 Blueprint pour utiliser lombok dans le domain
- 3.2 Exécution du blueprint local
- 4. JHipster comme outil multi-technologies
- 4.1 Côté client
- 4.2 Côté serveur
- 4.3 Côté déploiement
- 4.4 Côté Spring
- 5. Structure du projet
- 5.1 La partie front
- 5.2 Les grandes lignes de la partie back
- 5.2.1 Spring Boot
- 5.2.2 La classe serveur HTTP/servlet
- 6.1 Configuration DatabaseConfiguration
- 6.2 Configuration DateTimeFormatConfiguration
- 6.3 Configuration LocaleConfiguration
- 6.4 Configuration ReactorConfiguration
- 6.5 Configuration SecurityConfiguration
- 6.6 Configuration WebConfigurer
- 6.7 Les tests
Utilisation de GraphQL
- 1. Introduction
- 2. Le schéma
- 2.1 La section Query
- 2.2 La section Mutation
- 3. Intégration de GraphQL dans Spring
- 4. L’extension Spring Data Querydsl
- 5. Les contrôleurs GraphQL
- 6. Autoconfiguration
- 6.1 Version HTTP
- 6.2 Le Service GraphQlService
- 6.3 Le RuntimeWiringConfigurer
- 6.4 Gestion des erreurs
- 7. Conclusion
- 8. Points clés
Nouveautés de Spring
- 1. Le futur de Spring
- 2. Prise en charge des modules Java
- 3. Spring Native
- 4. Project Leyden
- 5. Spring Observability
- 6. Obsolescence programmée
- Index