Contactez-nous

Spring Boot : Le guide de référence complet

Maîtrisez Spring Boot avec ce guide complet pour développeurs Java. Des bases à WebFlux/Microservices : config, API REST, Data JPA, Sécurité, tests, déploiement Docker. La référence ultime pour vos applications.

Table des matières

  1. Introduction et fondamentaux de Spring Boot
    1. Introduction à l'écosystème Spring et Spring Boot
      1. Historique et évolution du framework Spring
      2. Problématiques résolues par Spring (inversion de contrôle, injection de dépendances)
      3. Présentation de Spring Boot : objectifs et philosophie
      4. Avantages de Spring Boot (auto-configuration, starters, opinionated defaults)
      5. Positionnement de Spring Boot dans l'écosystème Java EE / Jakarta EE
      6. Aperçu des modules principaux de l'écosystème Spring (Core, MVC, Data, Security, etc.)
    2. Mise en place de l'environnement et première application
      1. Prérequis : Installation de Java (JDK) et d'un outil de build (Maven/Gradle)
      2. Choix et configuration d'un IDE (IntelliJ IDEA, VS Code, Eclipse)
      3. Utilisation de Spring Initializr (web ou via IDE) pour générer un projet
      4. Structure d'un projet Spring Boot typique
      5. Anatomie de la classe principale `@SpringBootApplication`
      6. Création d'un premier contrôleur REST simple (`@RestController`, `@GetMapping`)
      7. Lancement de l'application (via IDE, Maven/Gradle)
      8. Accéder à l'application via un navigateur ou un outil comme curl/Postman
    3. Les concepts clés de Spring Boot
      1. Les starters Spring Boot (`spring-boot-starter-*`)
      2. Le mécanisme d'auto-configuration (`@EnableAutoConfiguration`)
      3. Comprendre les configurations conditionnelles (`@ConditionalOn...`)
      4. Le conteneur IoC de Spring et la gestion des beans (`@Component`, `@Service`, `@Repository`, `@Configuration`)
      5. L'injection de dépendances (`@Autowired`, injection par constructeur, setter, champ)
      6. Le cycle de vie des beans Spring
      7. Spring Boot et les serveurs embarqués (Tomcat, Jetty, Undertow)
    4. Configuration et gestion des propriétés
      1. Le fichier `application.properties` ou `application.yml`
      2. Syntaxe YAML vs Properties
      3. Accéder aux propriétés via `@Value`
      4. Liaison de type sécurisé avec `@ConfigurationProperties`
      5. Gestion des profils (`spring.profiles.active`, `@Profile`)
      6. Fichiers de configuration spécifiques aux profils (application-{profile}.properties)
      7. Priorité des sources de configuration (variables d'environnement, arguments de ligne de commande, etc.)
      8. Configuration externalisée avancée (Spring Cloud Config - introduction)
  2. Développement d'applications web avec Spring Boot
    1. Création d'API RESTful avec Spring Web MVC
      1. Principes fondamentaux de REST (ressources, verbes HTTP, statelessness)
      2. Utilisation de `@RestController` et des annotations de mapping (`@RequestMapping`, `@GetMapping`, `@PostMapping`, `@PutMapping`, `@DeleteMapping`, `@PatchMapping`)
      3. Gestion des paramètres de requête (`@RequestParam`, `@PathVariable`, `@RequestHeader`)
      4. Gestion du corps de la requête (`@RequestBody`)
      5. Gestion des réponses (`ResponseEntity`, codes de statut HTTP)
      6. Sérialisation et désérialisation JSON/XML (Jackson/JAXB)
      7. Utilisation des DTO (Data Transfer Objects)
      8. Gestion des versions d'API
      9. Documentation d'API avec OpenAPI/Swagger (`springdoc-openapi-ui`)
    2. Développement web traditionnel avec Spring MVC
      1. Introduction au modèle MVC (Modèle-Vue-Contrôleur)
      2. Utilisation de `@Controller` (différence avec `@RestController`)
      3. Transmission de données à la vue (`Model`, `ModelAndView`)
      4. Gestion des formulaires (`@ModelAttribute`)
      5. Redirections et forwards
      6. Gestion des sessions et des cookies
      7. Internationalisation (i18n) et localisation (L10n)
    3. Gestion des vues et moteurs de templates
      1. Introduction aux moteurs de templates côté serveur
      2. Intégration de Thymeleaf (`spring-boot-starter-thymeleaf`)
      3. Syntaxe de base de Thymeleaf (expressions, itérations, conditions)
      4. Layouts et fragments avec Thymeleaf Layout Dialect
      5. Intégration avec d'autres moteurs (Freemarker, Mustache - aperçu)
      6. Servir du contenu statique (CSS, JavaScript, images)
      7. Intégration avec WebJars pour les dépendances frontend
    4. Validation et gestion des erreurs
      1. Validation des données d'entrée avec Bean Validation (JSR 380)
      2. Annotations de validation (`@NotNull`, `@Size`, `@Pattern`, etc.)
      3. Validation dans les contrôleurs (`@Valid`, `BindingResult`)
      4. Création de contraintes de validation personnalisées
      5. Gestion globale des exceptions avec `@ControllerAdvice` et `@ExceptionHandler`
      6. Personnalisation des réponses d'erreur
      7. Gestion des erreurs spécifiques à Spring Boot (page d'erreur Whitelabel)
  3. Accès et persistance des données
    1. Introduction à Spring Data
      1. Philosophie et objectifs de Spring Data
      2. Le concept de Repository
      3. Architecture modulaire de Spring Data (JPA, JDBC, MongoDB, Redis, etc.)
      4. Avantages de l'abstraction fournie par Spring Data
    2. Utilisation de Spring Data JPA avec des bases relationnelles
      1. Configuration de la source de données (`DataSource`)
      2. Intégration avec Hibernate (implémentation JPA par défaut)
      3. Définition des entités JPA (`@Entity`, `@Id`, `@GeneratedValue`, etc.)
      4. Mapping des relations (`@OneToOne`, `@OneToMany`, `@ManyToOne`, `@ManyToMany`)
      5. Création d'interfaces Repository (`JpaRepository`, `CrudRepository`)
      6. Méthodes de requête dérivées (Query Methods)
      7. Requêtes personnalisées avec `@Query` (JPQL et SQL natif)
      8. Pagination et tri (`Pageable`, `Sort`)
      9. Projections Spring Data
      10. Audit JPA (`@CreatedDate`, `@LastModifiedDate`, etc.)
    3. Utilisation de Spring Data JDBC
      1. Quand utiliser Spring Data JDBC vs JPA ?
      2. Configuration et dépendances (`spring-boot-starter-data-jdbc`)
      3. Mapping d'entités simplifié avec Spring Data JDBC
      4. Création de repositories JDBC
      5. Gestion des requêtes et des relations
      6. Comparaison des approches (performance, complexité)
    4. Intégration avec des bases de données NoSQL
      1. Introduction aux bases NoSQL (Document, Clé-Valeur, Colonne, Graphe)
      2. Spring Data MongoDB : configuration et utilisation
      3. Mapping de documents (`@Document`, `@Id`)
      4. Utilisation de `MongoRepository` et `MongoTemplate`
      5. Spring Data Redis : configuration et cas d'usage (cache, sessions)
      6. Utilisation de `RedisRepository` et `RedisTemplate`
      7. Aperçu d'autres intégrations (Cassandra, Neo4j, Elasticsearch)
    5. Transactions et gestion de la concurrence
      1. Concepts ACID et gestion transactionnelle
      2. Gestion déclarative des transactions avec `@Transactional`
      3. Propagation des transactions (`Propagation`)
      4. Niveaux d'isolation (`Isolation`)
      5. Gestion programmatique des transactions (`TransactionTemplate`, `PlatformTransactionManager`)
      6. Verrouillage optimiste et pessimiste avec JPA (`@Version`)
      7. Gestion des transactions distribuées (JTA - aperçu)
    6. Migration de base de données avec Flyway ou Liquibase
      1. Importance de la gestion des schémas de base de données
      2. Intégration de Flyway avec Spring Boot
      3. Structure des scripts de migration SQL (convention de nommage)
      4. Intégration de Liquibase avec Spring Boot
      5. Format des 'changelogs' Liquibase (XML, YAML, JSON, SQL)
      6. Exécution automatique des migrations au démarrage
      7. Bonnes pratiques pour les migrations de base de données
  4. Sécurisation des applications Spring Boot
    1. Introduction à Spring Security
      1. Principes fondamentaux de la sécurité (authentification, autorisation, protection CSRF, etc.)
      2. Architecture de Spring Security (filtres, contexte de sécurité)
      3. Intégration de `spring-boot-starter-security`
      4. Configuration de base par défaut (formulaire de login, utilisateur en mémoire)
      5. Personnalisation de la configuration de sécurité (`WebSecurityConfigurerAdapter` ou `SecurityFilterChain` bean)
    2. Mécanismes d'authentification
      1. Authentification basée sur un formulaire (Form Login)
      2. Authentification HTTP Basic
      3. Authentification basée sur une base de données (JDBC/JPA)
      4. Implémentation de `UserDetailsService`
      5. Gestion des mots de passe (encodage avec `PasswordEncoder` - bcrypt)
      6. Authentification via LDAP
      7. Authentification via OAuth2 / OpenID Connect (connexion via Google, Facebook, etc.)
      8. Authentification multi-facteurs (MFA - concepts et intégration)
    3. Gestion des autorisations
      1. Autorisation basée sur les rôles (`hasRole`, `hasAnyRole`)
      2. Autorisation basée sur les permissions/autorités (`hasAuthority`)
      3. Configuration des règles d'accès via `HttpSecurity` (antMatchers, mvcMatchers)
      4. Sécurité au niveau des méthodes avec `@PreAuthorize`, `@PostAuthorize`, `@Secured`, `@RolesAllowed`
      5. Utilisation des expressions SpEL (Spring Expression Language) pour des règles complexes
      6. Gestion des permissions fines (Access Control Lists - ACL)
    4. Sécurité des API REST
      1. Désactivation de la protection CSRF pour les API stateless
      2. Sécurisation avec JWT (JSON Web Tokens)
      3. Génération et validation des tokens JWT
      4. Intégration de JWT avec Spring Security (filtres d'authentification)
      5. Gestion du rafraîchissement des tokens (refresh tokens)
      6. Sécurisation avec OAuth2 (Resource Server)
      7. Validation des tokens OAuth2 (introspection, JWK)
      8. Utilisation de API Keys
    5. Bonnes pratiques de sécurité et sujets avancés
      1. Protection contre les attaques courantes (XSS, CSRF, Injection SQL)
      2. Configuration de HTTPS/SSL
      3. Gestion des en-têtes de sécurité (Content Security Policy, HSTS, X-Frame-Options)
      4. Sécurité des mots de passe (stockage, politiques)
      5. Gestion des secrets et clés (Vault, AWS Secrets Manager - introduction)
      6. Audit de sécurité et logging
      7. Tests de sécurité avec Spring Security Test
  5. Préparation à la production et exploitation
    1. Tests dans Spring Boot
      1. Importance et types de tests (unitaires, intégration, end-to-end)
      2. Utilisation de `spring-boot-starter-test` (JUnit 5, Mockito, AssertJ, Spring Test)
      3. Tests unitaires de composants Spring (services, repositories)
      4. Utilisation de Mockito pour mocker les dépendances (`@MockBean`)
      5. Tests d'intégration avec `@SpringBootTest`
      6. Tests des contrôleurs web avec `MockMvc`
      7. Tests des clients REST avec `RestTemplate` ou `WebClient` (`@RestClientTest`)
      8. Tests de la couche persistance (`@DataJpaTest`, `@DataJdbcTest`, `@DataMongoTest`)
      9. Utilisation de bases de données en mémoire (H2) ou Testcontainers pour les tests d'intégration
      10. Tests de configuration avec `@TestPropertySource`
      11. Tests des slices (couches spécifiques) de l'application
    2. Spring Boot Actuator : surveillance et métriques
      1. Introduction à Spring Boot Actuator (`spring-boot-starter-actuator`)
      2. Configuration des endpoints Actuator (exposition, sécurité)
      3. Endpoints courants (`health`, `info`, `metrics`, `env`, `loggers`, `beans`, `mappings`)
      4. Personnalisation de l'endpoint `/info`
      5. Vérifications de santé (`HealthIndicator` personnalisés)
      6. Collecte et exposition de métriques (Micrometer)
      7. Intégration avec des systèmes de monitoring (Prometheus, Grafana, Datadog)
      8. Suivi distribué (Distributed Tracing) avec Spring Cloud Sleuth / Micrometer Tracing (introduction)
      9. Accès aux endpoints via HTTP ou JMX
    3. Packaging et déploiement d'applications
      1. Création de JAR exécutables (fat JARs)
      2. Création de WAR traditionnels pour déploiement sur serveur d'applications externe
      3. Optimisation de la taille et du démarrage (layers Maven/Gradle, AOT, GraalVM Native Image - introduction)
      4. Déploiement simple sur une machine virtuelle
      5. Gestion des processus (systemd, supervisor)
      6. Déploiement sur des plateformes Cloud (PaaS comme Heroku, Cloud Foundry)
      7. Déploiement sur AWS, GCP, Azure (concepts généraux)
    4. Intégration avec Docker et conteneurisation
      1. Introduction aux conteneurs et à Docker
      2. Ecriture d'un `Dockerfile` pour une application Spring Boot
      3. Bonnes pratiques pour la création d'images Docker Java (multi-stage builds, JRE vs JDK)
      4. Utilisation des plugins Maven/Gradle pour construire des images Docker (Jib, Spring Boot Build Plugin)
      5. Gestion de la configuration dans les conteneurs (variables d'environnement, volumes)
      6. Orchestration de conteneurs avec Docker Compose (pour le développement et les tests)
      7. Introduction à Kubernetes pour le déploiement en production (concepts)
    5. Logging et gestion des logs
      1. Frameworks de logging supportés (Logback, Log4j2, JUL)
      2. Configuration du logging via `application.properties`/`yml`
      3. Configuration avancée via fichiers dédiés (logback-spring.xml, log4j2-spring.xml)
      4. Niveaux de log et gestion dynamique via Actuator
      5. Formatage des logs (patterns, JSON)
      6. Appenders (Console, File, RollingFile)
      7. Logging structuré pour l'agrégation centralisée (ELK stack, Splunk)
      8. Utilisation de MDC (Mapped Diagnostic Context) pour le suivi des requêtes
  6. Sujets avancés et écosystème Spring
    1. Programmation asynchrone et réactive avec Spring WebFlux
      1. Introduction à la programmation réactive (manifeste réactif)
      2. Project Reactor : `Mono` et `Flux`
      3. Spring WebFlux : alternative réactive à Spring MVC
      4. Création de contrôleurs réactifs (annotation-based et functional endpoints)
      5. Utilisation de `WebClient` pour les appels HTTP réactifs
      6. Accès aux données réactif (Spring Data R2DBC, MongoDB Reactive, Redis Reactive)
      7. Server-Sent Events (SSE)
      8. WebSockets avec Spring
      9. Quand choisir WebFlux vs Web MVC ?
      10. Méthodes asynchrones avec `@Async` et `CompletableFuture` (alternative non-réactive)
    2. Intégration de systèmes de messagerie (Messaging)
      1. Concepts de messagerie (point-à-point, publish-subscribe)
      2. Spring JMS (`spring-boot-starter-activemq`, `spring-boot-starter-artemis`)
      3. Envoi et réception de messages avec `JmsTemplate` et `@JmsListener`
      4. Spring AMQP (`spring-boot-starter-amqp` pour RabbitMQ)
      5. Envoi et réception de messages avec `RabbitTemplate` et `@RabbitListener`
      6. Spring for Apache Kafka (`spring-kafka`)
      7. Production et consommation de messages Kafka (`KafkaTemplate`, `@KafkaListener`)
      8. Spring Cloud Stream (abstraction pour les systèmes de messagerie - introduction)
    3. Développement de microservices avec Spring Cloud (Introduction)
      1. Principes de l'architecture microservices
      2. Rôle de Spring Cloud dans l'écosystème microservices
      3. Configuration centralisée avec Spring Cloud Config Server
      4. Découverte de services (Service Discovery) avec Eureka ou Consul
      5. Appels inter-services avec des clients REST déclaratifs (OpenFeign)
      6. Tolérance aux pannes avec Resilience4j (Circuit Breaker)
      7. Passerelle d'API (API Gateway) avec Spring Cloud Gateway
      8. Suivi distribué avec Micrometer Tracing (anciennement Spring Cloud Sleuth) et Zipkin/Jaeger
    4. Mise en cache (Caching)
      1. Principes et avantages de la mise en cache
      2. Abstraction de cache de Spring (`@EnableCaching`)
      3. Annotations de cache (`@Cacheable`, `@CachePut`, `@CacheEvict`, `@Caching`)
      4. Fournisseurs de cache supportés (EhCache, Caffeine, Redis, Hazelcast)
      5. Configuration d'un gestionnaire de cache (`CacheManager`)
      6. Stratégies de cache et invalidation
      7. Mise en cache conditionnelle
    5. Tâches planifiées et traitement par lots
      1. Planification de tâches avec `@Scheduled` (`@EnableScheduling`)
      2. Configuration des pools de threads pour les tâches planifiées
      3. Introduction à Spring Batch (`spring-boot-starter-batch`)
      4. Concepts clés de Spring Batch (Job, Step, ItemReader, ItemProcessor, ItemWriter)
      5. Configuration et lancement de jobs Batch
      6. Gestion de l'état et redémarrage des jobs (JobRepository)
      7. Cas d'usage typiques du traitement par lots
    6. Extensibilité et personnalisation avancée
      1. Création de ses propres starters Spring Boot
      2. Création de ses propres auto-configurations
      3. Personnalisation du contexte d'application Spring (`ApplicationContextInitializer`, `EnvironmentPostProcessor`)
      4. Utilisation des événements Spring (`ApplicationEvent`, `@EventListener`)
      5. Programmation orientée aspect (AOP) avec Spring AOP
      6. Intégration avec d'autres bibliothèques et frameworks Java
    7. Migration et perspectives
      1. Migration d'une application Spring Framework classique vers Spring Boot
      2. Tendances actuelles (GraalVM Native Image, Serverless, Kotlin)
      3. Ressources pour aller plus loin (documentation officielle, communauté, blogs)
      4. Conclusion et résumé des acquis