Persistance Java avec JPA, Hibernate et Spring Data
Persistance avec JPA et Hibernate est un cours de niveau avancé de 5 leçons (environ 2 h 46), avec 15 exercices et 15 questions de quiz. Prérequis : Spring Boot : API REST, Modélisation de bases de données. Le cours demande un environnement de projet complet, prévu dans une phase ultérieure de la plateforme.
- Java
- Avancé
- 5 leçons
- 2 h 46
- 15 exercices
- Environnement de projet complet (phase 2)
Le cours en bref
Ce cours connecte votre API Spring Boot à une base relationnelle avec JPA et Hibernate. Vous écrirez des entités et leurs relations, des repositories Spring Data avec requêtes dérivées, JPQL et pagination, puis maîtriserez les transactions, le contexte de persistance et le problème N+1. Vous terminerez par les migrations Flyway, le verrouillage optimiste et les tests @DataJpaTest. Les exercices exécutés reproduisent les mécanismes de l'ORM en Java standard, les tâches se réalisent dans votre environnement de développement.
Ce que tu sauras faire
- Mapper des classes Java sur des tables avec les annotations JPA et contrôler le schéma généré
- Créer des repositories Spring Data JPA avec requêtes dérivées, JPQL, projections et pagination
- Modéliser des relations @ManyToOne, @OneToMany et @ManyToMany cohérentes, avec cascade adaptée
- Délimiter les transactions et exploiter le contexte de persistance (dirty checking, cache de premier niveau)
- Détecter et corriger le problème N+1 et la LazyInitializationException
- Versionner le schéma avec Flyway, gérer la concurrence avec @Version et tester avec @DataJpaTest
Programme des 5 leçons
- Expliquer le rôle d'un ORM, de JPA et d'Hibernate
- Écrire une entité JPA avec @Entity, @Id, @GeneratedValue, @Column et @Enumerated
- Configurer la source de données et comprendre la génération du schéma (ddl-auto)
- 02
Repositories Spring Data JPA et requêtes
- Créer un repository en étendant JpaRepository
- Écrire des requêtes dérivées du nom des méthodes et des requêtes JPQL avec @Query
- Paginer et trier des résultats avec Pageable et Page
- 03
Relations entre entités
- Mapper des relations @ManyToOne, @OneToMany et @ManyToMany
- Identifier le côté propriétaire d'une relation et l'attribut mappedBy
- Maintenir la cohérence d'une relation bidirectionnelle avec des méthodes utilitaires, cascade et orphanRemoval
Relations JPACôté propriétaire et mappedByCascade et orphanRemoval
- 04
Transactions, contexte de persistance et problème N+1
- Délimiter les transactions avec @Transactional dans la couche service
- Comprendre le contexte de persistance : cache de premier niveau, états des entités et dirty checking
- Diagnostiquer et corriger le problème N+1 et la LazyInitializationException
@TransactionalContexte de persistanceChargement paresseuxProblème N+1
- 05
Migrations Flyway, verrouillage optimiste et tests JPA
- Versionner le schéma de base avec des migrations Flyway
- Protéger les mises à jour concurrentes avec @Version (verrouillage optimiste)
- Tester les repositories avec @DataJpaTest
Projet final
Persistance complète d'une API de boutique
Reprenez l'API REST du cours Spring Boot (ou celle de bibliothèque) et remplacez le repository en mémoire par JPA sur PostgreSQL (ou H2 en développement). Modélisez Client, Produit, Commande et LigneCommande avec leurs relations, gérez le schéma avec Flyway, ajoutez la recherche paginée des produits, l'historique des commandes d'un client sans N+1, le passage de commande transactionnel (décrément du stock) et le verrouillage optimiste sur le produit.
Livrables
- Le projet Maven avec entités, repositories, services transactionnels et DTO
- Les scripts de migration Flyway (au moins trois versions)
- Des tests @DataJpaTest pour les requêtes personnalisées et un test de conflit de version
- Une capture ou un extrait des journaux SQL montrant que l'historique des commandes s'exécute en une ou deux requêtes
Critères d'évaluation
- Les relations sont correctement mappées (côté propriétaire, LAZY, cascade limitée à la composition)
- Aucune entité n'est exposée en JSON ; les DTO sont construits dans les transactions
- Le passage de commande est atomique : en cas de stock insuffisant, rien n'est enregistré
- Le schéma est entièrement géré par Flyway avec ddl-auto=validate
- Le problème N+1 est absent des endpoints de liste et les tests passent
Questions fréquentes
Quelle différence entre JPA, Hibernate et Spring Data JPA ?
JPA est la spécification standard (annotations et interfaces jakarta.persistence), Hibernate en est l'implémentation la plus utilisée, et Spring Data JPA génère les repositories et les requêtes au-dessus de JPA.
Faut-il connaître SQL pour suivre ce cours ?
Oui, des bases en modélisation relationnelle et en SQL (tables, clés étrangères, jointures) sont nécessaires : elles permettent de comprendre ce que génère Hibernate et d'éviter les requêtes inefficaces.
Quelle base de données est utilisée ?
Les exemples ciblent PostgreSQL en production et H2 en mémoire pour expérimenter. Le code JPA est le même : seule la configuration de la source de données change.
Qu'est-ce que le problème N+1 ?
C'est le fait d'exécuter une requête pour charger une liste, puis une requête supplémentaire pour chaque élément afin de charger une relation. Le cours montre comment le détecter et le corriger avec join fetch, @EntityGraph ou des projections.
Ce cours, raconté pour ton métier
Dis ce que tu veux savoir faire : « Persistance avec JPA et Hibernate » prend sa place dans ton parcours, avec des exemples de ton secteur. Les notions restent celles du cours.