Formations — 1 037 leçons en français

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

Chargement paresseux parcouru en boucle : 1 + N requêtes findAll() 20 commandes select … from commande 1 requête c.getLignes() dans la boucle, pour chaque commande select … where cmd_id=? × 20 21 allers-retours chacun paie la latence réseau invisible en test sur 2 lignes, fatal sur 2 000 JOIN FETCH ou @EntityGraph : 1 requête trouverAvecLignes() 20 commandes + lignes select … join ligne 1 requête 1 aller-retour une jointure côté base Comment le détecter : activez spring.jpa.show-sql et comptez les lignes. Un nombre de requêtes qui croît avec le nombre de résultats est la signature du N+1 — pas besoin d'outil de profilage.
Le piège n'est pas le chargement paresseux lui-même : c'est de le parcourir dans une boucle. Chaque accès déclenche sa propre requête.

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, true par 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.

Lire l'explication détaillée et faire le quiz →

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.