Accueil › SQL & bases de données › Le problème N+1 et comment le tuer
Le problème N+1 et comment le tuer
SQL vu depuis Java et JPAavance
Le N+1 est le problème de performance le plus fréquent dans une application Java qui parle à une base.
List<Commande> commandes = repo.findAll(); // 1 requête
for (Commande c : commandes) {
c.getLignes().size(); // 1 requête par commande
}
// 100 commandes → 101 requêtes
Chaque requête est rapide ; c'est leur nombre qui tue. Avec 5 ms de latence réseau, 500 commandes coûtent deux secondes et demie d'attente pure.
Trois remèdes, par ordre de préférence :
// 1. JOIN FETCH — explicite, dans la requête
@Query("SELECT DISTINCT c FROM Commande c JOIN FETCH c.lignes WHERE c.creeeLe >= :depuis")
List<Commande> findAvecLignes(@Param("depuis") LocalDate depuis);
// 2. @EntityGraph — déclaratif, lisible
@EntityGraph(attributePaths = {"lignes", "client"})
List<Commande> findByStatut(String statut);
// 3. @BatchSize — atténue quand on ne peut pas éviter le lazy
@OneToMany(mappedBy = "commande") @BatchSize(size = 20)
private List<LigneCommande> lignes;
Ce qu'il ne faut pas faire : passer l'association en EAGER. Le chargement devient systématique, y compris pour les écrans qui n'en ont pas besoin, et le N+1 réapparaît ailleurs sous une forme moins visible.
La détection est simple : activez le compteur de requêtes en test, ou lisez pg_stat_statements — une requête unitaire appelée des dizaines de milliers de fois est un N+1.
pg_stat_statements : une requête, exécutée des milliers de fois, avec un temps unitaire minuscule et un temps total énorme.Les termes à connaître
- Problème N+1
Une requête pour récupérer N entités, puis une requête par entité pour charger une association : N+1 allers-retours là où un seul suffirait.
- Chargement paresseux (*lazy*)
Le comportement par défaut de JPA pour
@OneToManyet@ManyToMany: l'association n'est chargée qu'au premier accès. C'est ce qui produit le N+1 quand on itère.- JOIN FETCH
Demande explicitement à JPQL de charger l'association dans la même requête :
SELECT c FROM Commande c JOIN FETCH c.lignes. Le remède le plus direct.- @EntityGraph
Déclare, au niveau du repository, quelles associations charger :
@EntityGraph(attributePaths = {"lignes", "client"}). Plus lisible qu'un JPQL pour les cas simples.- MultipleBagFetchException
Erreur levée quand on fait un
JOIN FETCHsur deux collections de typeList: le produit cartésien rend le résultat ambigu. Contournement :Set, ou deux requêtes.- @BatchSize
Charge les associations par lots de N au lieu d'une par une : 100 requêtes deviennent 10 avec
@BatchSize(size = 10). Ne supprime pas le N+1, mais le divise.
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.