Accueil › Spring Boot › Chargement lazy/eager et le problème N+1
Chargement lazy/eager et le problème N+1
JPA avancéintermediaire
Par défaut, JPA charge les relations @OneToMany/@ManyToMany en LAZY (à la demande) et les @ManyToOne/@OneToOne en EAGER (immédiatement). Le chargement LAZY évite de charger des données inutiles, mais expose au problème N+1 : parcourir une liste d'entités en accédant, pour chacune, à une relation LAZY déclenche une requête par entité.
List<Commande> commandes = commandeRepository.findAll(); // 1 requête
for (Commande c : commandes) {
c.getLignes().size(); // 1 requête supplémentaire PAR commande
}
// 1 (commandes) + N (une par commande) requêtes au lieu d'une seule
Trois solutions principales, à choisir selon le cas :
// JOIN FETCH : une seule requête, écrite explicitement
@Query("SELECT c FROM Commande c JOIN FETCH c.lignes")
List<Commande> trouverAvecLignes();
// @EntityGraph : la même idée, sans JPQL à écrire
@EntityGraph(attributePaths = "lignes")
List<Commande> findAll();
Le taux de requêtes peut aussi être réduit sans les supprimer, avec un chargement par lots (spring.jpa.properties.hibernate.default_batch_fetch_size).
Enfin, spring.jpa.open-in-view (true par défaut, avec un avertissement au démarrage tant qu'il n'est pas fixé explicitement) garde la session Hibernate ouverte pendant tout le traitement de la requête HTTP — pratique pour éviter des LazyInitializationException, mais au prix d'un N+1 potentiellement invisible. Le désactiver rend les accès aux relations explicites, dans la couche service.
Les termes à connaître
- Problème N+1
Situation où une requête initiale ramène N résultats, puis chaque résultat déclenche une requête supplémentaire pour charger une relation : 1 + N requêtes au lieu d'une seule bien construite. Le cas le plus fréquent : parcourir une liste d'entités en accédant, pour chacune, à une collection ou une relation en chargement paresseux.
- JOIN FETCH
Clause JPQL qui charge une relation dans la même requête SQL que l'entité principale, via une jointure, au lieu d'une requête séparée par entité. S'écrit dans une méthode annotée
@Query.- @EntityGraph
Annotation Spring Data qui décrit, sans JPQL, les relations à charger en une seule requête pour une méthode de repository donnée :
@EntityGraph(attributePaths = "lignes"). Une alternative déclarative àJOIN FETCH.- Taille de lot (@BatchSize / default_batch_fetch_size)
Au lieu d'une requête séparée par entité pour charger une relation LAZY, Hibernate peut regrouper plusieurs identifiants dans une seule requête
IN (...), par lots. Se règle entité par entité (@BatchSize, annotation Hibernate) ou globalement (spring.jpa.properties.hibernate.default_batch_fetch_size).- spring.jpa.open-in-view
Propriété Spring Boot,
truepar défaut, qui garde la session Hibernate ouverte au-delà de la transaction, jusqu'à la fin du traitement de la requête HTTP. Spring Boot affiche un avertissement au démarrage tant qu'elle n'est pas explicitement définie.- LazyInitializationException
Exception levée quand on accède à une relation LAZY alors que la session Hibernate qui l'a chargée est déjà fermée. Message typique : « failed to lazily initialize a collection of role... could not initialize proxy - no Session ».
- FetchType.LAZY / FetchType.EAGER
LAZY: la relation n'est chargée qu'au premier accès.EAGER: elle est chargée immédiatement, avec l'entité propriétaire. Défauts JPA : LAZY pour@OneToMany/@ManyToMany, EAGER pour@ManyToOne/@OneToOne.
Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.