RESSOURCE GRATUITE · ENTRETIEN TECHNIQUE

Questions d’entretien JPA & Hibernate.

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

Les mêmes entités. Des enjeux différents selon 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.

Junior

Comprendre la persistance

Entités, identifiants, relations, EntityManager et cycle de vie. Expliquer ce qu’est une entité gérée.

Intermédiaire

Lire les requêtes produites

Lazy loading, N+1, merge(), dirty checking et propagation des modifications. Éviter les surprises.

Senior

Protéger la cohérence

Transactions, pagination, batch, contraintes SQL et concurrence. Identifier les limites des garanties.

Tech Lead

Choisir les compromis

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

20 questions d’entretien JPA et Hibernate avec réponses expliquées.

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

Comprendre le contexte de persistance et les associations.

8 questions

1. Quelle est la différence entre JPA et Hibernate ?

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.

À retenir : JPA est une spécification ; Hibernate est une implémentation très utilisée de JPA.

2. À quoi sert l’annotation @Entity ?

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

À retenir : @Entity marque une classe comme persistante et permet à JPA de la mapper avec une table.

3. Qu’est-ce que l’EntityManager ?

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.

À retenir : EntityManager permet de gérer les entités et leur cycle de vie dans le contexte de persistance.

4. Quels sont les états d’une entité JPA ?

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.

À retenir : les états importants sont transient, managed, detached et removed.

5. Quelle est la différence entre Lazy et Eager ?

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.

À retenir : Lazy charge à la demande ; Eager charge immédiatement. Lazy est souvent préférable, mais il faut comprendre le contexte de persistance.

6. Qu’est-ce que le problème N+1 en Hibernate ?

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.

À retenir : N+1 = une requête principale + une requête par entité pour charger une relation. C’est un piège majeur de performance.

7. Quelle est la différence entre persist() et merge() ?

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.

À retenir : persist() est utilisé pour une nouvelle entité ; merge() copie l’état d’une entité détachée vers une entité gérée.

8. Qu’est-ce que le dirty checking ?

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.

À retenir : dirty checking = Hibernate détecte les changements sur les entités managed et les synchronise avec la base.

PASSER DES DÉFINITIONS AUX SITUATIONS

Une annotation ne garantit pas le résultat métier.

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.

Faire mon diagnostic gratuit Junior · Intermédiaire · Senior · Tech Lead

02 · HIBERNATE EN PRATIQUE

Quand Hibernate rencontre le SQL et les cas limites.

7 questions

9. Quelle est la différence entre cascade et orphanRemoval ?

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.

À retenir : cascade propage les opérations ; orphanRemoval supprime les enfants retirés de la relation.

10. À quoi sert @Version en JPA ?

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

À retenir : @Version permet de détecter les conflits de modification avec le verrouillage optimiste.

11. Pourquoi une relation @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.

À retenir : Le comportement SQL dépend du plan de chargement, pas seulement de l’annotation.

12. Pourquoi une relation déclenche-t-elle une 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.

À retenir : Le chargement paresseux exige un contexte capable de charger la relation.

13. Deux requêtes créent le même compte. Une vérification applicative suffit-elle ?

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.

À retenir : Un invariant concurrent critique doit être garanti par la base, pas uniquement par un contrôle préalable.

14. Pourquoi paginer avec 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.

À retenir : Pagination et chargement d’une collection doivent être conçus ensemble ; leur combinaison naïve peut coûter cher.

15. Pourquoi la clé étrangère n’est-elle pas mise à jour dans une relation bidirectionnelle ?

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.

À retenir : Le côté propriétaire définit la relation persistée ; les deux côtés Java doivent rester cohérents.

03 · RAISONNEMENT AVANCÉ

Performance, concurrence et cohérence en production.

5 questions

16. Pourquoi 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.

À retenir : Flush = synchroniser ; commit = valider la transaction.

17. Comment mettre à jour des milliers d’entités sans saturer le contexte de persistance ?

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

À retenir : Une opération de masse demande une stratégie de mémoire, de SQL et de transaction explicite.

18. Deux requêtes modifient la même entité. Comment éviter une mise à jour silencieusement perdue ?

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.

À retenir : Le verrouillage optimiste détecte un conflit ; l’application décide comment le résoudre.

19. Quand choisir un verrouillage pessimiste plutôt qu’optimiste ?

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

À retenir : Optimiste : détecter les conflits ; pessimiste : coordonner l’accès, avec davantage de contention.

20. Pourquoi une requête JPQL 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.

À retenir : Les requêtes bulk contournent le suivi habituel des entités gérées : maîtrise l’état de ton contexte.

CONSEIL POUR L’ENTRETIEN

Relie chaque annotation à une requête SQL.

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 ?

  1. Pars du contexte. L’entité est-elle managed, detached ou nouvelle ?
  2. Anticipe le SQL. Chargement d’association, N+1, update ou verrou attendu.
  3. Montre le risque. Concurrence, pagination coûteuse, objet obsolète ou violation d’une contrainte.
  4. Propose une vérification. Logs SQL, métriques, test d’intégration ou scénario avec deux transactions.

POUR CONTINUER

Complète ta préparation avec Java et Spring Boot.

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

Préparer son entretien JPA / Hibernate.

Quelles questions reviennent en entretien JPA/Hibernate ?

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.

Que réviser pour un entretien JPA junior ?

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.

Pourquoi connaître SQL même si on utilise Hibernate ?

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.

Que doit savoir expliquer un développeur Senior ou Tech Lead ?

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

Prépare ton prochain entretien JPA / Hibernate à ton niveau.

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
Diagnostic gratuit en 8 questions · Choisis ton niveau