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

Téléchargements

• Des fichiers complémentaires (249 Ko)

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

É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
   1. 1. Modules Spring
   2. 2. Sujets abordés
   3. 3. Gestion des dépendances Maven
5. Compléments
6. Points clés

Spring et les design patterns

1. Introduction
2. Singleton en Java
   1. 1. Préoccupation
   2. 2. Solution Spring
   3. 3. Exemple
3. Inversion de contrôle
4. Façade
5. Fabrique
6. Décorateur
7. Proxy
8. Modèle Vue Contrôleur (MVC)
9. 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
   2. 2. Mise en œuvre
2. Log4j, SLF4J et Logback
3. Bases de données H2 et HSQLDB
   1. 1. Description de la problématique
   2. 2. Mise en œuvre
      1. a. Installation
      2. b. Configuration du POM
      3. c. Connexion à la base de données enutilisant JDBC
      4. d. Utiliser un listener de servlet pour démarreret arrêter la base
4. Fin de vie des versions de Spring
5. Points clés

Le conteneur Spring

1. Introduction
2. Origines
3. Modules fondamentaux
   1. 1. Singleton et prototype
   2. 2. Objets fondamentaux du package core
   3. 3. PropertyValue(s)
   4. 4. BranWrapper
   5. 5. BeanFactory et ApplicationContext
   6. 6. Interface BeanDefinition
   7. 7. PropertySourcesPlaceholderConfigurer
   8. 8. ApplicationContext
   9. 9. Relations entre le bean et sa BeanFactory ou son contexte
4. Configuration des beans
   1. 1. Configuration par un fichier XML
   2. 2. Mapping via le constructeur en XML
   3. 3. Configuration par annotations
   4. 4. Injecter les beans configurés
   5. 5. Configuration par lambdas
   6. 6. Comparaison des méthodes d’instanciation
   7. 7. Autres annotations de configuration
      1. a. Annotation @Primary
      2. b. Annotations @Profile et @Conditional
5. Contrôle du cycle de vie : construction et destruction
6. Spring Expression Language
   1. 1. Utilisation de l’ExpressionParser
   2. 2. L’EvaluationContext
   3. 3. Utilisation avec @Value
   4. 4. Web services
      1. a. Via une servlet
      2. b. Serveur intégré
7. Points clés

Configuration avancée Java Spring

1. Introduction
2. Fichiers de ressources
   1. 1. Fichiers de ressources standards
   2. 2. Fichiers de ressources chargés via le contexteSpring
   3. 3. Fichiers de ressources chargés via un serviceResourceLoaderAware
      1. a. Programme principal
      2. b. Service ResourceLoaderAware
3. Convertisseurs et formateurs
   1. 1. Built-in converters
      1. a. Pour les types standards
      2. b. Pour les tableaux et les listes
      3. c. Pour les énumérations
      4. d. Pour les objets en général
   2. 2. Convertir un Array en Collection et en String
   3. 3. Converter Factory
      1. a. Classe StringToUtilisateurConverterFactory
      2. b. Classe UtilisateurToStringConverterFactory
      3. c. Classe LesConversionsAvecFactories
   4. 4. Formateurs par défaut
   5. 5. Formateurs personnalisés
      1. a. Classe CarteDeCredit
      2. b. Classe CarteDeCreditParser
      3. c. Classe CarteDeCreditPrinter
      4. d. Classe CarteDeCreditFormatter
      5. e. Classe LesConversionsFormateursEx2
4. BeanWrapper, binding et validateurs
   1. 1. Classe LesBeanWrappers
   2. 2. Classe UtilisateurValidator
5. Points clés

Programmation orientée aspect avec Spring

1. Introduction
2. Pourquoi l’AOP ?
3. Concepts d’AOP
4. Limites de Spring AOP et utilisation d’AspectJ
   1. 1. Activation du support
   2. 2. Activation de @AspectJ avec configurationXML
   3. 3. Activation de @AspectJ avec configurationJava
   4. 4. Déclaration d’un aspect
   5. 5. Déclaration d’un pointcut
   6. 6. Déclaration des greffons simples
   7. 7. Types génériques
   8. 8. Détermination de noms d’arguments
   9. 9. Ordre d’appel des greffons interceptant lepoint de jonction
   10. 10. Injection
   11. 11. Mécanisme des proxies
   12. 12. Face cachée des proxies en AOP
5. API bas niveau pour Spring AOP
   1. 1. Interface PointCut
   2. 2. Interface ClassFilter
   3. 3. Interface MethodMatcher
6. Pour aller plus loin
   1. 1. Librairie Java jcabi-aspects
   2. 2. Métriques AspectJ
7. Points clés

Partie back de l’application

1. Introduction
2. Éléments fondamentaux
   1. 1. Stratégies d’héritage
      1. a. Objet par table
      2. b. Table par hiérarchie de classe
      3. c. Table par sous-classe
      4. d. Table par classe concrète
      5. e. Bilan de ces stratégies
   2. 2. Type des relations entre les classes
3. Mise en œuvre
   1. 1. Modèle en couche
   2. 2. Configuration d’une entité de lacouche domaine
      1. a. Mapping many-to-one et one-to-many
      2. b. Types de données
   3. 3. Accès à l’objet du domaine
      1. a. DAO (Data Access Object)
      2. b. Repository
      3. c. Autres considérations
      4. d. Exemple de Repository
      5. e. EntityManager
   4. 4. Suppression en cascade
   5. 5. Requêtes typées
   6. 6. Caches de niveaux 1 et 2
   7. 7. Bean Validation (JSR-303)
   8. 8. Query(s)
   9. 9. API Criteria
   10. 10. API Specification
   11. 11. Requête par l’exemple
       1. a. Utilisation
       2. b. Exemple Matchers
       3. c. API Fluente
   12. 12. Annotation @Query
       1. a. Requêtes JPQL personnalisées
       2. b. Requêtes SQL natives et paramètresnommés
       3. c. Requêtes de mise à jour
       4. d. Autres considérations
   13. 13. Accès à la base de données
   14. 14. Fichier persistence.xml
   15. 15. Tests JPA
4. Pour aller plus loin
5. Points clés

Spring et le NoSQL

1. Introduction
2. Modèles de données
   1. 1. Bases de données clé/valeur
   2. 2. Bases de données document
   3. 3. Bases de données de graphes
   4. 4. Bases de données de colonnes larges
   5. 5. Bases de données orientées objets
3. Principes des bases de données
4. Pourquoi et quand utiliser une base NoSQL ?
5. Spring et le NoSQL
6. Cache de données
7. Cache simple
8. Cacher des données avec Geode
9. Geode en tant que base de données NoSQL
10. Redis en mode autonome
11. MongoDB
    1. 1. MongoDB avec Spring Boot
    2. 2. MongoDB avec une API REST
12. Points clés

Les intergiciels à messages (MOM)

1. Introduction
   1. 1. Fonctionnalités de base
   2. 2. Exemples de middlewares de messagerie
   3. 3. Avantages des MOM
   4. 4. Modèle de file d’attente (queue)
   5. 5. Modèle de publication-abonnement (Pub/Sub)
2. Implémentations open source
3. Implémentations propriétaires
4. Cas d’utilisation
5. JMS et ActiveMQ
6. RabbitMQ
   1. 1. Spring AMQP et RabbitMQ
   2. 2. Exemple RabbitMQ
7. Points clés

Spring dans un contexte web

1. Introduction
2. Serveurs de pages
3. Contrôleur
   1. 1. Fonctionnement du contrôleur
   2. 2. Gestion des requêtes HTTP
      1. a. @RequestMapping
      2. b. @GetMapping
      3. c. @PostMapping
      4. d. @PutMapping, @DeleteMapping et @PatchMapping
      5. e. Redirections
      6. f. Gestion des modèles
   3. 3. Interprétation des données de requête
      1. a. Paramètres d’URL (@PathVariable)
      2. b. Paramètres de requête (@RequestParam)
      3. c. Corps de requête (@RequestBody)
      4. d. En-tête de requête (@RequestHeader)
      5. e. Cookies (@CookieValue)
      6. f. Objets de formulaire (@ModelAttribute)
      7. g. Paramètres de session et de modèle
   4. 4. Traitement de la logique métier
      1. a. Appel de services métier
      2. b. Récupération et persistance desdonnées
      3. c. Gestion des transactions
      4. d. Validation des données
      5. e. Traitement asynchrone et opérations longues
      6. f. Gestion des erreurs et exceptions
   5. 5. Préparation de la réponse
      1. a. Sélection d’une vue
      2. b. Renvoi de données JSON/XML
      3. c. Utilisation de ResponseEntity
   6. 6. Renvoi de la réponse au client
      1. a. Vue Rendue
      2. b. Redirection
      3. c. Données JSON/XML (API REST)
4. Gestion des exceptions et des erreurs
   1. 1. Gestion des exceptions
      1. a. @ExceptionHandler et @ControllerAdvice
      2. b. Personnalisation des réponses d’erreur
      3. c. Exemple d’utilisation d’@ExceptionHandler
   2. 2. Gestion des erreurs
5. @RestController
   1. 1. Annotation @ResponseBody par défaut
   2. 2. Pas de vues ou de rendu de page
   3. 3. XML ou JSON dans la réponse
      1. a. Définir le type de média dans lesannotations de mapping
      2. b. Utiliser la négociation de contenu
      3. c. Configurer les convertisseurs de message HTTP
      4. d. Exemple de négociation de contenu
6. Classes UriComponentsBuilder
7. Client REST
   1. 1. RestTemplate
   2. 2. WebClient
      1. a. Feign Client
      2. b. Apache HttpClient
8. Spring Security
   1. 1. Authentification
      1. a. Authentification basée sur un formulaire
      2. b. Authentification via des jetons (comme JWT)
   2. 2. Autorisation
      1. a. Autorisations au niveau des méthodes
      2. b. Autorisations au niveau des requêtes
      3. c. AuthorizationFilter
      4. d. Définir l’autorisation d’un point d’accès
      5. e. Autorisations au niveau des objets métier
   3. 3. Protection contre les attaques
   4. 4. Gestion des sessions
9. Spring et HATEOAS
   1. 1. Simplification de la création de liens hypertexte
   2. 2. Création de réponses REST conformes
10. Utilisation de MapStruct
11. Approche API-First
    1. 1. Outils
       1. a. Swagger
       2. b. OpenAPITools
       3. c. Pour le générateur Swagger
       4. d. Pour le générateur OpenAPITools
       5. e. Personnalisation des générateurs
    2. 2. Conception d’une description API
    3. 3. Outillage pour le design de l’API
12. Spring Actuator
13. Points clés

Les tests et Spring

1. Introduction
2. Objets mock(és)
   1. 1. Mocks spécialisés pour les classesd’environnement
   2. 2. Classes de support
      1. a. Utilités générales
      2. b. Spring MVC
   3. 3. Tests d’intégration
      1. a. Vue d’ensemble
      2. b. Mise en cache du contexte de test
      3. c. Tests back et front
      4. d. Tests des parties back
      5. e. Bases de données
   4. 4. Librairies de tests Spring
   5. 5. Annotations
      1. a. @TestPropertySource
      2. b. Interface TestExecutionListener
      3. c. Tests Beans Spring avec JUnit
   6. 6. Utilisation avec JUnit 5
      1. a. Utiliser @ExtendWith
      2. b. Utilisation de @EnabledIf et @DisabledIf
      3. c. Annotation @Timeout
      4. d. Annotation @RepeatedTest
      5. e. Autres considérations
3. Configuration des contextes de tests
   1. 1. @ContextConfiguration
   2. 2. @DirtiesContext
   3. 3. @WebAppConfiguration
   4. 4. Héritage dans la configuration des contextes
   5. 5. Prise en compte des profils d’environnement
   6. 6. Hiérarchie des contextes de tests
   7. 7. Scope session lors d’un test de requête
   8. 8. Transactions
      1. a. Configuration d’un gestionnaire de transactions
      2. b. Démonstration de toutes les annotations liées à latransaction
   9. 9. Scripts SQL
      1. a. Exemple avec @Sql
      2. b. @Sql, @SqlConfig et @SqlGroup
   10. 10. Test de contrôleurs REST
   11. 11. Autres ressources
4. Points clés

Spring Batch

1. Introduction
2. Architecture d’un batch
3. Description des éléments Spring Batch
   1. 1. Versions
   2. 2. Nouveautés de la version 5.1.0
   3. 3. Migrer depuis Spring Batch 4
4. Exemple Spring Batch version 5
   1. 1. Dépendance Maven
   2. 2. Lanceur du batch
   3. 3. Configuration du batch
   4. 4. Classe Departement
   5. 5. ItemProcessor
5. Données traitées
6. Batchs fictifs
7. Évolutions des batchs
8. Points clés

Spring Boot

1. Introduction
2. Avantages de Spring Boot
   1. 1. Configuration automatisée
   2. 2. Démarrage rapide
   3. 3. Moins de code de configuration
   4. 4. Support intégré pour microservices
   5. 5. Facilité de déploiement
   6. 6. Pourquoi choisir un serveur embarqué ?
   7. 7. Gestion facile des dépendances
   8. 8. Principaux starters
3. Facilitations des développements
4. Détails sur l’autoconfiguration Spring Boot
5. Personnalisation de la bannière
6. Événements d’applications
   1. 1. ApplicationStartingEvent
   2. 2. ApplicationContextInitializedEvent
   3. 3. ApplicationEnvironmentPreparedEvent
   4. 4. ApplicationPreparedEvent
   5. 5. ApplicationStartedEvent
   6. 6. ApplicationReadyEvent
   7. 7. ApplicationFailedEvent
   8. 8. Interception des événements
7. Récupération des arguments de la ligne de commande
   1. 1. CommandLineRunner
   2. 2. ApplicationRunner
   3. 3. Configuration de l’application et des profils
      1. a. application.properties
      2. b. application.yml
      3. c. Choix de la structure du fichier
8. Annotation
9. Configuration des logs
   1. 1. Logs en couleur
   2. 2. Choix du type de logs
   3. 3. Événements
10. Autoconfiguration pour Spring MVC
11. Gestion des sessions
12. Description avancée de Spring Boot
    1. 1. Séquence de lancement
    2. 2. Chargement du BootstrapContext
    3. 3. Mise en place des listeners
       1. a. Starting : ApplicationStartingEvent
       2. b. ApplicationEnvironmentPreparedEvent
       3. c. EnvironmentPostProcessorApplicationListener
    4. 4. Création de l’ApplicationContext
    5. 5. Préparation et rafraîchissementdu contexte
    6. 6. Détails sur EnableAutoConfiguration
    7. 7. Lancement des runners
13. Spring Boot Admin
14. Points clés

Introduction à Spring Reactor et Spring Webflux

1. Introduction
2. Spring Reactor
   1. 1. Présentation
   2. 2. RxJava 3
   3. 3. Utilisation de Reactor Core
      1. a. Les threads
      2. b. Les FutureTask
      3. c. Le CompletableFuture
      4. d. Les threads virtuels
      5. e. Flux et Mono
      6. f. Opérateurs de collecte
      7. g. Ajout de délais
   4. 4. Tests
      1. a. Vérifications avec StepVerifier
      2. b. Émissions manuelles avec TestPublisher
3. WebFlux
   1. 1. Définition du terme réactif
   2. 2. Couches réactives
      1. a. La couche contrôleur
      2. b. La couche des services
      3. c. La couche repository
      4. d. Repository reactif R2DBC
      5. e. Seul pour H2
      6. f. Avec Spring Data et H2
      7. g. Programmation fonctionnelle
      8. h. Repository Spring Data
4. Client réactif
5. Tests avec WebFlux
   1. 1. Tests unitaires
      1. a. Tests unitaires avec des applications réactives
      2. b. Utilisation de MockWebServer
   2. 2. Tests d’intégration
6. Server Site Event avec Spring
7. Pour aller plus loin
8. Points clés

Spring et Kotlin

1. Introduction
2. Framework Spring
   1. 1. Sécurité avec la nullabilité
   2. 2. Classes et Interfaces
   3. 3. Annotations
   4. 4. DSL de définition de Beans
   5. 5. Web
      1. a. DSL Web Router
      2. b. DSL MockMvc
   6. 6. Coroutines Kotlin
      1. a. Dépendances
      2. b. Framework réactif et Coroutines
      3. c. Contrôleurs
      4. d. WebFlux.fn
      5. e. Transactions
3. Spécificités des projets Spring en Kotlin
   1. 1. Utilisation d’instances de classes immuables pourla persistance
   2. 2. Détails sur les tests
   3. 3. Spécificités Spring boot
      1. a. Support Kotlin
      2. b. Le runApplication
4. Points clés

Utilisation de GraphQL

1. Introduction
2. Schémas GraphQL
   1. 1. Types d’objets et champs
   2. 2. Arguments
   3. 3. Types scalaires
   4. 4. Types énumérés
3. Queries et mutations
   1. 1. Requête (query)
   2. 2. Mutations
4. Utilisation de Spring Boot
   1. 1. Création du schéma
   2. 2. Création du modèle et du repository
5. Query, mutation et mapping
   1. 1. @SchemaMapping
   2. 2. @QueryMapping
   3. 3. @MutationMapping
6. Tests de l’API
   1. 1. Utilisation de Querydsl
   2. 2. Gestion des erreurs
   3. 3. Mise en cache des requêtes
7. Utilisation de GraphiQL
8. Points clés

Application Spring Angular

1. Introduction
2. La partie backend
   1. 1. Classes de domaine
   2. 2. Repositories
   3. 3. Contrôleurs
   4. 4. Lanceur
3. La partie frontend
   1. 1. Angular CLI
   2. 2. Création du projet initial
   3. 3. Démarrage de l’application
   4. 4. Créer un service compte
4. Facilitations
5. Points clés

Spring et JHipster

1. Introduction
   1. 1. JHipster web
   2. 2. Personnalisation de l’outil JHispter
   3. 3. Niveaux de personnalisations
2. Créer un blueprint
   1. 1. Blueprint pour utiliser lombok dans le domain
   2. 2. Exécution du blueprint local
3. JHipster comme outil multi-technologies
   1. 1. Côté client
   2. 2. Côté serveur
   3. 3. Côté déploiement
   4. 4. Côté Spring
4. Structure du projet
   1. 1. La partie front
   2. 2. Les grandes lignes de la partie back
5. Applications générées
   1. 1. Spring Boot
      1. a. Système de gestion des dépendances
      2. b. Utilisation de Spring Security
      3. c. Spring MVC REST + Jackson
      4. d. Support optionnel de WebSocket avec Spring WebSocket
      5. e. Spring Data JPA + Bean Validation
      6. f. Évolution des bases de données avecLiquibase
      7. g. Support Elasticsearch
      8. h. Bases SQL et NoSQL
      9. i. Packaging multiplateforme
      10. j. Monitoring et métriques
      11. k. Autres avantages non abordés
      12. l. Avantages de Spring Boot
6. Étude des sources générées
   1. 1. Dépendances Maven
   2. 2. Configuration de l’application
   3. 3. La classe Application qui contient le main
   4. 4. La classe WebConfigurer
   5. 5. La classe SecurityConfiguration
   6. 6. La classe SecurityUtils
   7. 7. Classe AuthoritiesConstants
   8. 8. Spring Data JPA et Bean Validation
   9. 9. Spring MVC REST + Jackson
   10. 10. Les classes de la couche Repository
   11. 11. La couche Service
   12. 12. La couche Resource
7. JHipster et WebFlux
   1. 1. Configuration DatabaseConfiguration
   2. 2. Configuration LocaleConfiguration
   3. 3. Configuration ReactorConfiguration
   4. 4. Configuration SecurityConfiguration
   5. 5. Configuration WebConfigurer
   6. 6. Les tests
8. Points clés

Les images natives de GraalVM

1. Introduction
2. Images natives de GraalVM
3. Ahead Of Time (AOT)
   1. 1. Génération de fichiers d’indices
   2. 2. Génération de classes proxy
   3. 3. Traitement Spring AOT et GraalVM
4. Application optimisée pour le mode natif
   1. 1. Éviter la réflexion excessive
   2. 2. Utilisez des proxies statiques
   3. 3. Configurez correctement Spring Native
   4. 4. Autres conseils
      1. a. Minimisez l’utilisation de bibliothèquesdynamiques
      2. b. Utilisez des bibliothèques natives si possible
      3. c. Testez régulièrement avec GraalVM
      4. d. Évitez la surspécification des dépendances
      5. e. Soyez conscient des performances au moment du démarrage
      6. f. Suivez les mises à jour de GraalVM et SpringNative
      7. g. Consultez la documentation
5. Exemple d'application
6. Conteneurisation de l'exemple
7. Support natif et tests
   1. 1. Tests avec la JVM
   2. 2. Tests avec les outils de build natifs GraalVM
8. Notions avancées
9. Pour aller plus loin
10. Alternatives
    1. 1. Quarkus
    2. 2. Micronaut
       1. a. Points clés de la compatibilité
       2. b. Objectif de la compatibilité
       3. c. Considérations
    3. 3. Helidon
       1. a. Interopérabilité avec l’écosystèmeSpring
       2. b. Points à considérer
11. Points clés

Les microservices

1. Introduction
   1. 1. Découverte de service avec Spring Cloud NetflixEureka
      1. a. Usage
      2. b. Fonctionnement
      3. c. Utilité
   2. 2. Communication interservices via Spring Cloud OpenFeign
      1. a. Qu’est-ce que Spring Cloud OpenFeign ?
      2. b. Fonctionnement
      3. c. Avantages
   3. 3. Configuration distribuée avec Spring CloudConfig
      1. a. Fonctionnalités
      2. b. Fonctionnement
      3. c. Avantages
   4. 4. API Gateway et documentation Springdoc
      1. a. Porte d’entrée pour les microservices
      2. b. Documentation OpenAPI avec Springdoc
      3. c. Avantages de l’intégration
   5. 5. Collecte de traces
      1. a. Micrometer et OpenTelemetry
      2. b. Visualisation et analyse des traces
      3. c. Avantages de l’intégration
2. Exemple d'utilisation
   1. 1. Fichiers de configuration
   2. 2. Serveur de découverte (Discovery)
   3. 3. Les applications
   4. 4. API Gateway avec Spring Cloud Gateway
   5. 5. Exécution des microservices
3. Conclusion
4. Points clés

Nouveautés de Spring 6

1. Introduction
2. Passage à Java 17
   1. 1. Les record(s)
   2. 2. Blocs de texte
   3. 3. Expressions switch
   4. 4. Correspondance de motifs
   5. 5. Classes et interfaces scellées
3. Jakarta EE 9
4. Dépendances supplémentaires
5. Points d'intérêts
6. Petites modifications dans Spring Web MVC
7. Migration du code vers la version 6 de Spring-core
   1. 1. Mise à niveau vers la version 6.0
      1. a. Conteneur de base
      2. b. Le cache
      3. c. Accès aux données et transactions
      4. d. Applications web
   2. 2. Migration vers Spring 6.1
      1. a. API retirées
      2. b. Rétention des noms de paramètres
      3. c. Le conteneur de base
      4. d. Mise en cache
      5. e. Accès aux données et transactions
      6. f. Applications web
      7. g. Applications de messages
8. Migration vers Spring Boot 3
   1. 1. Phases préparatoires
      1. a. Examen des dépendances
      2. b. Mise à niveau vers Spring Security 6.0
      3. c. Types de dispatch
      4. d. Examen des exigences système
      5. e. Examen des obsolescences de Spring Boot 2.x
   2. 2. Mise à niveau vers Spring Boot 3
      1. a. Migration des propriétés de configuration
      2. b. Spring Framework 6.0
      3. c. Jakarta EE
   3. 3. Changements fondamentaux
      1. a. Support des bannières d’images
      2. b. Format de date des journaux
      3. c. Modification @ConstructorBinding
      4. d. Suppression de YamlJsonParser
      5. e. Fichiers d’autoconfiguration
   4. 4. Changements dans les applications web
      1. a. URL de Spring MVC et WebFlux
      2. b. Le server.max-http-header-size
      3. c. Apache HttpClient dans RestTemplate
   5. 5. Changements dans Actuator
      1. a. Exposition de l’endpoint JMX
      2. b. Renommage de l’Endpoint httptrace en httpexchanges
      3. c. Réponses JSON d’Actuator
      4. d. Sanitisation des endpoints d’Actuator
      5. e. Changements dans Micrometer et les métriques
      6. f. Dépréciation de l’instrumentationSpring Boot 2.x
      7. g. Migration des fournisseurs et contributeurs de balises
      8. h. Configuration automatique des JvmInfoMetrics de Micrometer
      9. i. Propriétés d’export des métriquesd’Actuator
      10. j. Vérification de l’état de MongoDB
   6. 6. Changements d’accès aux données
      1. a. Changements dans les propriétésde données
      2. b. Propriétés Cassandra
      3. c. Propriétés Redis
      4. d. Flyway
      5. e. Liquibase
      6. f. Hibernate 6.1
   7. 7. Changements dans les propriétésde données
      1. a. MongoDB embarqué
      2. b. R2DBC 1.0
      3. c. Clients et modèles Elasticsearch
      4. d. ReactiveElasticsearchRestClientAutoConfiguration
      5. e. Pilote JDBC MySQL
   8. 8. Changements de Spring Security
      1. a. ReactiveUserDetailsService
      2. b. Configuration du fournisseur de confiance SAML2
   9. 9. Changements de Spring Batch
      1. a. @EnableBatchProcessing est maintenant déconseillé
      2. b. Jobs Batch multiples
   10. 10. Changements de Spring Session
       1. a. Type de stockage de Spring Session
   11. 11. Changements de Gradle
       1. a. Résolution simplifiée du nom dela classe principale
       2. b. Configuration des tâches Gradle
       3. c. Fichier build-info.properties
   12. 12. Modifications dans Maven
       1. a. Exécution de notre application dans le processusMaven
       2. b. Git Commit ID Maven Plugin
       3. c. Modifications de la gestion des dépendances
   13. 13. Autres suppressions
9. Conclusion
10. Points clés

Conclusion

1. Récapitulatif
2. Le mot de la fin