Formations — 1 037 leçons en français

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.

CE QUE LA BASE REÇOIT N+1 — 21 requêtes select * from commande select * from ligne where cmd_id=1 select * from ligne where cmd_id=2 … 18 autres, identiques même requête, paramètre différent Avec jointure — 1 requête select c.*, l.* from commande c join ligne l on l.cmd_id = c.id un seul aller-retour, une seule analyse JOIN FETCH explicite, par requête @EntityGraph déclaratif, sans JPQL batch_fetch_size 21 requêtes → 2 ou 3 Ce qu'il ne faut pas faire : passer l'association en EAGER Le chargement devient systématique, même pour les écrans qui n'en ont pas besoin.
La signature est reconnaissable dans 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 @OneToMany et @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 FETCH sur deux collections de type List : 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.

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.