Comprendre la persistance
Entités, identifiants, relations, EntityManager et cycle de vie. Expliquer ce qu’est une entité gérée.
RESSOURCE GRATUITE · ENTRETIEN TECHNIQUE
20 questions expliquées, des entités JPA aux problèmes de production.
Prépare ton entretien JPA et Hibernate : contexte de persistance, relations, lazy loading, N+1, transactions et concurrence. Comprends les requêtes SQL et les garanties qui se cachent derrière les annotations.
Diagnostic gratuit en 8 questions · Choisis ton niveau et ton objectif
À TON NIVEAU
À mesure que tu progresses, on attend de toi plus qu’une définition de @Entity : tu dois comprendre ce qui est chargé, écrit, verrouillé et garanti en base de données.
Entités, identifiants, relations, EntityManager et cycle de vie. Expliquer ce qu’est une entité gérée.
Lazy loading, N+1, merge(), dirty checking et propagation des modifications. Éviter les surprises.
Transactions, pagination, batch, contraintes SQL et concurrence. Identifier les limites des garanties.
Verrouillage, contention, chargements optimisés et architecture des accès aux données. Arbitrer selon le risque.
Ces repères sont indicatifs : les attentes varient selon le poste et l’entreprise.
QUESTIONS ET RÉPONSES
Entraîne-toi d’abord à répondre sans regarder l’explication. Les dix premières questions reprennent les bases de ta ressource initiale ; les suivantes montrent ce qui peut vraiment se produire en production.
01 · FONDAMENTAUX
C’est une question très fréquente en entretien Java backend, car beaucoup de candidats utilisent Hibernate sans savoir clairement distinguer JPA et Hibernate.
JPA, pour Java Persistence API, est une spécification. Elle définit un standard pour gérer la persistance des objets Java en base de données.
Hibernate est une implémentation de cette spécification. En pratique, quand on utilise Spring Data JPA, on utilise souvent JPA comme API et Hibernate comme moteur d’implémentation derrière.
@Entity indique qu’une classe Java est une entité persistante, c’est-à-dire qu’elle peut être
associée à une table en base de données.
Une entité possède généralement un identifiant annoté avec @Id. Cet identifiant permet à JPA
de distinguer les instances et de suivre leur état dans le contexte de persistance.
En entretien, il faut expliquer qu’une entité n’est pas seulement une classe classique : elle est gérée par JPA lorsqu’elle est attachée au contexte de persistance.
L’EntityManager est l’interface principale de JPA pour interagir avec le contexte de persistance.
Il permet notamment de persister une entité, la rechercher, la supprimer, la détacher ou exécuter des requêtes.
En entretien, il faut surtout comprendre que l’EntityManager ne fait pas que lancer des requêtes SQL. Il gère aussi l’état des entités dans le contexte de persistance.
Une entité JPA peut passer par plusieurs états pendant son cycle de vie.
Une entité transient est un objet Java classique qui n’est pas encore connu du contexte de persistance.
Une entité managed est suivie par JPA. Toute modification peut être détectée puis synchronisée avec la base de données lors du flush.
Une entité detached a déjà été gérée par JPA, mais elle n’est plus attachée au contexte courant. Une entité removed est marquée pour suppression.
Lazy signifie que la donnée liée n’est chargée que lorsqu’elle est réellement utilisée.
Eager signifie que la donnée liée est chargée immédiatement avec l’entité principale.
Par exemple, une entité User peut avoir une liste de commandes. En lazy loading, les commandes
ne sont pas forcément chargées au moment où l’utilisateur est récupéré.
En entretien, il faut expliquer que le lazy loading peut améliorer les performances, mais qu’il peut aussi provoquer
une LazyInitializationException si la relation est accédée en dehors d’une session ou transaction active.
Le problème N+1 est un piège classique en entretien Hibernate. Il se produit lorsqu’une première requête récupère une liste d’entités, puis qu’une requête supplémentaire est exécutée pour chaque entité afin de charger une relation.
Par exemple, une requête récupère 100 utilisateurs. Puis Hibernate exécute 100 requêtes supplémentaires pour charger leurs commandes. On obtient alors 1 requête initiale + N requêtes supplémentaires.
Ce problème peut fortement dégrader les performances. Pour le corriger, on peut utiliser un JOIN FETCH,
un @EntityGraph, une requête adaptée ou revoir la stratégie de chargement.
persist() sert à rendre persistante une nouvelle entité. Elle est utilisée lorsqu’un objet n’existe
pas encore en base et doit être ajouté au contexte de persistance.
merge() sert à recopier l’état d’une entité détachée dans une entité gérée par le contexte de persistance.
Un piège fréquent est de croire que merge() rattache directement l’objet passé en paramètre.
En réalité, merge() retourne une instance managed, tandis que l’objet original peut rester detached.
Le dirty checking est un mécanisme Hibernate qui détecte automatiquement les modifications faites sur une entité managed.
Si une entité est attachée au contexte de persistance et que ses champs sont modifiés, Hibernate peut détecter
ces changements et générer une requête SQL UPDATE au moment du flush.
C’est une notion importante en entretien, car elle explique pourquoi il n’est pas toujours nécessaire d’appeler explicitement une méthode save sur une entité déjà managed.
PASSER DES DÉFINITIONS AUX SITUATIONS
Avec DevUpNow, passe de la définition de JPA aux situations concrètes d’entreprise. Choisis ton niveau, réponds à 8 questions gratuites et identifie les mécanismes à renforcer en Java & Spring.
02 · HIBERNATE EN PRATIQUE
cascade permet de propager certaines opérations d’une entité parente vers ses entités liées.
Par exemple, si on persiste un parent, on peut aussi persister automatiquement ses enfants.
orphanRemoval sert à supprimer automatiquement une entité enfant lorsqu’elle est retirée de la relation
avec son parent.
En entretien, il faut éviter de confondre les deux. Cascade propage une opération, tandis que orphanRemoval concerne la suppression d’un enfant qui n’est plus rattaché à son parent.
@Version permet de mettre en place le verrouillage optimiste, aussi appelé optimistic locking.
L’idée est d’éviter qu’une mise à jour écrase silencieusement les modifications faites par une autre transaction. JPA vérifie la version de l’entité au moment de la mise à jour.
Si deux transactions modifient la même entité en parallèle, la version permet de détecter un conflit. Une exception peut alors être levée au lieu d’écraser les données sans contrôle.
@ManyToOne peut-elle provoquer du N+1 ?JPA définit EAGER comme valeur par défaut pour @ManyToOne, mais « eager » ne veut pas toujours dire « une seule jointure SQL ». Sur une liste, le fournisseur peut effectuer des requêtes secondaires pour les associations.
Observe les requêtes réellement générées, puis ajuste au cas d’usage : projection DTO, JOIN FETCH adapté, @EntityGraph ou récupération en lots. Passer toutes les relations en EAGER n’est pas une stratégie de performance.
LazyInitializationException après le service ?Ton service retourne une entité dont la collection est encore non initialisée. Une autre couche tente ensuite de lire cette collection, alors que la session Hibernate permettant de la charger est déjà fermée.
Définis les données nécessaires dans la couche de lecture : projection DTO ou chargement ciblé pendant l’unité de travail. Laisser la sérialisation JSON déclencher des requêtes implicites masque les coûts et peut échouer.
Deux transactions peuvent toutes deux constater qu’un e-mail n’existe pas, puis tenter d’insérer chacune un utilisateur. Un existsByEmail() avant save() ne rend pas l’opération atomique.
Une contrainte UNIQUE en base doit protéger l’invariant. Traite ensuite l’échec d’insertion de façon explicite. La transaction JPA et le test préalable ne remplacent pas une garantie SQL.
JOIN FETCH sur un @OneToMany est-il risqué ?Une commande jointe à plusieurs lignes peut produire plusieurs lignes SQL pour la même commande. Avec certaines versions et configurations d’Hibernate, la pagination associée à un collection fetch join conduit à charger trop de lignes puis limiter en mémoire, au lieu de limiter efficacement côté base.
Pour une pagination robuste, pagine d’abord les identifiants des parents, puis charge les associations nécessaires dans une seconde requête ; ou utilise une projection. Vérifie la version d’Hibernate et les SQL émis avant de conclure.
Dans une association bidirectionnelle, un côté est propriétaire de la relation : c’est lui qui détermine l’écriture de la clé étrangère. mappedBy désigne le côté inverse, qui ne pilote pas cette écriture.
Mettre un enfant dans parent.getEnfants() ne suffit pas toujours. Mets également à jour le champ propriétaire, par exemple enfant.setParent(parent), idéalement dans une méthode métier qui maintient les deux côtés cohérents.
03 · RAISONNEMENT AVANCÉ
flush() n’est-il pas équivalent à commit() ?Le flush() synchronise les changements du contexte de persistance avec la base, notamment en envoyant des instructions SQL. Il ne valide pas définitivement la transaction : celle-ci peut encore être annulée.
Un flush peut rendre certaines erreurs SQL visibles avant le commit, mais la durabilité finale dépend toujours de la transaction. N’utilise pas flush() comme preuve qu’une opération métier est définitivement confirmée.
Charger puis modifier des milliers d’entités gérées peut augmenter l’utilisation mémoire et le coût du dirty checking. Sans stratégie adaptée, l’application accumule des objets dans le contexte de persistance.
Selon le besoin, utilise des lots, un flush() et un clear() périodiques, ou une requête bulk appropriée. Vérifie le batching JDBC, la taille des transactions et les effets éventuels sur les événements d’entité.
Deux transactions lisent la même version d’un enregistrement puis essaient de le modifier. Avec @Version, le contrôle optimiste peut détecter qu’une transaction travaille sur un état devenu obsolète.
Traite le conflit avec une décision métier : informer l’utilisateur, recharger les données ou réessayer une opération réellement rejouable. Un retry aveugle peut écraser une intention concurrente.
Avec PESSIMISTIC_WRITE, on demande au fournisseur d’obtenir un verrou en base afin de coordonner les accès concurrents. Cela peut sécuriser une opération courte sur une ressource fortement disputée, mais augmente l’attente et le risque d’interblocage.
Compare la fréquence des conflits, la durée des transactions et la tolérance aux retries. Utilise des transactions courtes et un ordre d’accès stable ; une stratégie de verrouillage ne remplace pas les contraintes d’intégrité.
UPDATE peut-elle laisser des entités obsolètes en mémoire ?Une mise à jour en masse JPQL est exécutée directement en base et ne synchronise pas automatiquement les instances déjà gérées dans le contexte de persistance. Une entité chargée avant la requête peut ainsi contenir un ancien état.
Après une requête bulk, anticipe le besoin de synchroniser ou vider le contexte (clear(), rechargement). Vérifie aussi l’effet sur la gestion des versions et les callbacks : une opération bulk ne suit pas nécessairement le cycle normal des entités.
CONSEIL POUR L’ENTRETIEN
Une réponse convaincante sur Hibernate suit le chemin du code à la base : quel état est suivi, quelles requêtes partent, et quel risque apparaît en concurrence ou sous charge ?
POUR CONTINUER
JPA/Hibernate relie le modèle Java à la base. Les deux autres ressources t’aident à consolider les mécanismes du langage et les frontières Spring qui entourent cette persistance.
FAQ
Le contexte de persistance, les états des entités, persist() et merge(), le lazy loading, le N+1, les associations et les transactions. Pour les postes expérimentés, il faut aussi discuter des performances et des conflits concurrents.
Commence par @Entity, @Id, les relations, le rôle de l’EntityManager et les états managed/detached. Sache expliquer quand une modification se retrouve en base.
Hibernate n’annule ni les jointures ni les contraintes ni les coûts du SQL. Comprendre les requêtes générées permet d’identifier le N+1, les index manquants, la pagination coûteuse et les problèmes de concurrence.
Le rôle de @Version, les limites d’un JOIN FETCH paginé, les compromis entre verrouillages optimiste et pessimiste, et la manière de mesurer puis corriger une requête inefficace.
PROCHAINE ÉTAPE
Choisis ton niveau et ton objectif. Le diagnostic gratuit en 8 questions identifie tes priorités, puis DevUpNow t’aide à progresser en Java & Spring avec des situations concrètes, des explications et des fiches.
Commencer mon diagnostic gratuit