Une application Spring Boot avec Spring Data JPA tourne sans erreur en développement, avec un jeu de données de vingt lignes et une base H2 en mémoire. En production, avec de vraies volumétries, les mêmes endpoints se mettent à répondre en trois secondes, et les logs Hibernate débordent de requêtes SQL identiques répétées des dizaines de fois. C'est le symptôme le plus courant du lazy loading mal maîtrisé : le N+1 select.
Le mécanisme : pourquoi le lazy loading génère du N+1
Par défaut, Hibernate charge les relations @OneToMany et @ManyToMany en FetchType.LAZY, et les relations @ManyToOne et @OneToOne en FetchType.EAGER. Ce choix par défaut est une source fréquente de confusion : beaucoup de développeurs pensent que tout est lazy par défaut, alors que seules les collections le sont.
@Entity
public class Order {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@ManyToOne(fetch = FetchType.EAGER) // par défaut
private Customer customer;
@OneToMany(mappedBy = "order", fetch = FetchType.LAZY) // par défaut
private List<OrderLine> lines;
}
Une relation lazy n'est pas chargée au moment de la requête initiale. Hibernate remplace l'attribut par un proxy, et ce proxy exécute une requête SQL séparée au premier accès. Le problème arrive dès qu'on itère sur une liste d'entités et qu'on accède à une relation lazy de chacune :
List<Order> orders = orderRepository.findAll(); // 1 requête
for (Order order : orders) {
System.out.println(order.getLines().size()); // 1 requête par order
}
Avec cent commandes, ce code exécute 1 requête pour récupérer les commandes, puis 100 requêtes supplémentaires, une par commande, pour charger ses lignes. C'est le N+1 : N requêtes supplémentaires pour N résultats initiaux, là où une seule requête bien construite suffirait.
Le piège inverse : LazyInitializationException
Le symptôme opposé survient quand on essaye d'accéder à une relation lazy après la fermeture de la session Hibernate, typiquement en dehors de la transaction, par exemple dans un @RestController qui sérialise l'entité en JSON :
@GetMapping("/orders/{id}")
public Order getOrder(@PathVariable Long id) {
return orderRepository.findById(id).orElseThrow();
}
Si Order.customer ou Order.lines sont lazy et que la session s'est fermée à la sortie de la méthode de repository (comportement par défaut sans @Transactional englobant), Jackson déclenche une LazyInitializationException au moment de sérialiser la réponse, parce qu'il essaye d'accéder à un proxy dont la session propriétaire n'existe plus.
Diagnostiquer : activer les logs SQL et compter les requêtes
Avant de corriger, il faut confirmer le nombre réel de requêtes. Deux leviers simples en développement :
# application.properties
spring.jpa.show-sql=true
logging.level.org.hibernate.SQL=DEBUG
logging.level.org.hibernate.orm.jdbc.bind=TRACE
Pour une mesure fiable en test d'intégration, la bibliothèque datasource-proxy ou l'assertion SessionFactory.getStatistics() d'Hibernate permettent de compter précisément les requêtes exécutées pendant un scénario, et d'écrire un test qui échoue si ce nombre dépasse un seuil :
Statistics stats = entityManagerFactory.unwrap(SessionFactoryImpl.class).getStatistics();
stats.setStatisticsEnabled(true);
long before = stats.getQueryExecutionCount();
orderService.listOrdersWithLines();
long queryCount = stats.getQueryExecutionCount() - before;
assertThat(queryCount).isLessThanOrEqualTo(2);
Ce genre de test de régression de performance est sous-utilisé, alors qu'il détecte un N+1 introduit par un changement de code bien avant que la volumétrie de production ne le révèle.
Les correctifs, avec leurs compromis
JOIN FETCH dans une requête JPQL explicite
@Query("SELECT o FROM Order o JOIN FETCH o.lines WHERE o.status = :status")
List<Order> findWithLinesByStatus(@Param("status") OrderStatus status);
C'est le correctif le plus prévisible : une seule requête SQL avec un JOIN, aucune surprise. La limite apparaît avec plusieurs collections à précharger simultanément : un JOIN FETCH sur deux collections @OneToMany différentes produit un produit cartésien (le nombre de lignes explose par multiplication des deux collections), ce qui peut devenir plus coûteux que le N+1 qu'on voulait éviter.
@EntityGraph pour piloter le préchargement sans dupliquer les requêtes
@EntityGraph(attributePaths = {"lines", "customer"})
@Query("SELECT o FROM Order o WHERE o.status = :status")
List<Order> findWithGraphByStatus(@Param("status") OrderStatus status);
@EntityGraph évite de dupliquer la requête JPQL pour chaque combinaison de relations à charger, et Hibernate choisit la stratégie de jointure la plus adaptée. C'est l'approche à privilégier quand le même repository doit parfois charger les relations, parfois non, selon le contexte d'appel.
FetchType.LAZY partout, JOIN FETCH au cas par cas
Changer une relation en FetchType.EAGER au niveau de l'entité pour corriger un N+1 ponctuel est une erreur fréquente : ça résout le cas observé, mais ça charge systématiquement cette relation sur tous les usages de l'entité, y compris ceux qui n'en ont pas besoin, ce qui déplace le problème de performance plutôt que de le résoudre. La bonne pratique reste de garder toutes les relations en lazy par défaut, et de précharger explicitement au cas par cas dans la requête qui en a besoin.
Le piège du @Transactional(readOnly = true) mal placé
Encapsuler la méthode de service dans une transaction permet d'accéder aux relations lazy sans LazyInitializationException, mais si la méthode retourne directement l'entité à un contrôleur REST qui sérialise après la fin de la transaction, le problème réapparaît. La solution durable est de ne jamais exposer une entité JPA directement en réponse HTTP, mais de la convertir en DTO à l'intérieur de la couche transactionnelle, pendant que la session est encore active.
@Transactional(readOnly = true)
public OrderDto getOrderDto(Long id) {
Order order = orderRepository.findById(id).orElseThrow();
return new OrderDto(order.getId(), order.getCustomer().getName(),
order.getLines().stream().map(OrderLineDto::from).toList());
}
Cette conversion force l'accès aux relations lazy pendant que la session Hibernate est encore ouverte, et élimine à la fois le risque de LazyInitializationException et le risque de sérialiser accidentellement des champs internes de l'entité (mot de passe, champs d'audit).
Le faux ami de l'Open Session in View
Spring Boot active par défaut le pattern Open Session in View (spring.jpa.open-in-view=true), qui maintient la session Hibernate ouverte pendant tout le cycle de la requête HTTP, y compris pendant la sérialisation de la réponse. C'est précisément ce qui permet au code vu plus haut (return orderRepository.findById(id) sans @Transactional explicite) de fonctionner sans lever de LazyInitializationException : la session reste ouverte assez longtemps pour que Jackson accède aux relations lazy pendant la sérialisation.
Le problème est que ce confort cache le N+1 plutôt que de le résoudre. Les requêtes supplémentaires déclenchées par l'accès aux relations lazy pendant la sérialisation s'exécutent bien, mais en dehors de toute transaction explicite et souvent sans que l'équipe en ait conscience, parce que rien ne lève d'erreur. C'est pour cette raison que beaucoup d'équipes expérimentées désactivent open-in-view en production :
spring.jpa.open-in-view=false
Avec ce réglage désactivé, chaque accès à une relation lazy hors transaction lève immédiatement une LazyInitializationException, ce qui force à traiter le préchargement explicitement dans la couche service, comme montré plus haut avec la conversion en DTO. Le correctif demande plus de rigueur au moment d'écrire le code, mais rend les coûts de requête visibles au lieu de les laisser masqués par un confort par défaut.
@BatchSize comme compromis intermédiaire
Entre le N+1 complet et un JOIN FETCH qui risque le produit cartésien, Hibernate propose @BatchSize, qui regroupe les chargements lazy de plusieurs entités en un nombre réduit de requêtes IN (...) plutôt qu'une requête par entité :
@Entity
public class Order {
@OneToMany(mappedBy = "order", fetch = FetchType.LAZY)
@BatchSize(size = 20)
private List<OrderLine> lines;
}
Avec cette annotation, accéder aux lignes de cent commandes ne génère plus cent requêtes mais cinq (cent divisé par la taille de lot de vingt), chaque requête chargeant les lignes de vingt commandes à la fois via une clause WHERE order_id IN (...). Ce n'est pas aussi efficace qu'un JOIN FETCH unique, mais c'est un filet de sécurité simple à poser globalement sur une relation à risque, sans devoir réécrire chaque requête qui y accède.
Quand ça ne suffit plus
Pour des listes paginées avec des collections à précharger, JOIN FETCH combiné à Pageable lève une exception Hibernate (firstResult/maxResults specified with collection fetch) parce que la pagination sur un résultat avec jointure de collection n'a pas de sens au niveau SQL. Dans ce cas, la solution courante est de paginer d'abord sur les identifiants, puis de précharger les collections dans une seconde requête WHERE id IN (...). Pour des graphes de relations vraiment complexes avec des besoins de lecture très différents selon l'écran, une couche de projection dédiée (DTO projections via @Query avec constructeur, ou une requête native) devient souvent plus simple à maintenir qu'un entity graph de plus en plus large.
À retenir
Seules les collections (@OneToMany, @ManyToMany) sont lazy par défaut en JPA, pas les relations @ManyToOne/@OneToOne. Le N+1 se diagnostique en comptant les requêtes SQL, pas en devinant, et se corrige avec JOIN FETCH ou @EntityGraph ciblés plutôt qu'en passant une relation en EAGER globalement. Convertir les entités en DTO à l'intérieur de la transaction reste la façon la plus sûre d'éviter à la fois le LazyInitializationException et la sursérialisation.
