Relations One-to-Many et Many-to-Many
Mappez @OneToMany, @ManyToMany et @JoinTable avec des types de cascade et des stratégies de chargement.
Relations One-to-Many et Many-to-Many est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.
Types de relations en JPA
JPA prend en charge quatre types de relations : @OneToOne, @OneToMany, @ManyToOne, @ManyToMany. Chacun correspond à des contraintes de clés étrangères ou de tables de jointure.
@ManyToOne : le côté propriétaire
Une relation plusieurs-à-un (par exemple, plusieurs commandes appartiennent à un seul utilisateur) est mappée avec @ManyToOne et un @JoinColumn pour la clé étrangère.
@Entity
public class Order {
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "user_id", nullable = false)
private User user;
}@OneToMany : le côté inverse
Le côté inverse (un utilisateur possède plusieurs commandes) utilise @OneToMany(mappedBy = "user"). L’attribut mappedBy pointe vers le champ du côté propriétaire qui contient la clé étrangère.
@Entity
public class User {
@OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
private List<Order> orders = new ArrayList<>();
}Assistant de cohérence bidirectionnelle
Avec les associations bidirectionnelles, maintenez les deux côtés de la relation dans une méthode auxiliaire afin de conserver la cohérence du graphe d’objets avant la synchronisation.
public void addOrder(Order order) {
orders.add(order);
order.setUser(this); // keep both sides in sync
}
public void removeOrder(Order order) {
orders.remove(order);
order.setUser(null);
}Types de cascade
CascadeType.ALL propage toutes les opérations (persist, merge, remove, refresh, detach) du parent vers l’enfant. PERSIST et MERGE sont des choix courants et sûrs. REMOVE supprime les enfants lorsque le parent est supprimé.
@OneToMany(mappedBy = "user",
cascade = {CascadeType.PERSIST, CascadeType.MERGE},
orphanRemoval = true)
private List<Order> orders;orphanRemoval : suppression automatique des enfants
orphanRemoval = true supprime une entité enfant lorsqu’elle est retirée de la collection du parent, même sans appel explicite à entityManager.remove().
user.getOrders().remove(order); // triggers DELETE for the orphaned order on flush@ManyToMany avec @JoinTable
Une relation plusieurs-à-plusieurs (par exemple, entre un étudiant et un cours) utilise une table de jointure. Définissez-la sur le côté propriétaire avec @JoinTable ; le côté inverse utilise mappedBy.
@Entity
public class Student {
@ManyToMany
@JoinTable(
name = "student_course",
joinColumns = @JoinColumn(name = "student_id"),
inverseJoinColumns = @JoinColumn(name = "course_id"))
private Set<Course> courses = new HashSet<>();
}Colonnes supplémentaires dans la table de jointure
Lorsque la table de jointure nécessite des colonnes supplémentaires (par exemple, la date d’inscription), remplacez @ManyToMany par deux relations @OneToMany / @ManyToOne et créez une nouvelle entité représentant la table de jointure.
@Entity
public class Enrollment {
@ManyToOne Student student;
@ManyToOne Course course;
private LocalDate enrolledAt;
}FetchType : LAZY contre EAGER
Chargement par défaut : @ManyToOne et @OneToOne sont EAGER (chargés immédiatement). @OneToMany et @ManyToMany sont LAZY (chargés lors de l’accès). Utilisez toujours LAZY pour les collections afin d’éviter les requêtes N+1.
// Always override to LAZY:
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "category_id")
private Category category;Problème des requêtes N+1
Accéder à une collection LAZY dans une boucle déclenche une requête par entité (N+1). Corrigez ce problème avec JOIN FETCH dans JPQL ou avec @EntityGraph pour charger la collection en une seule requête.
// N+1 problem:
List<User> users = repo.findAll();
users.forEach(u -> u.getOrders().size()); // 1 + N queries!
// Fix:
@Query("SELECT u FROM User u LEFT JOIN FETCH u.orders")
List<User> findAllWithOrders();Set ou List pour les collections
Utilisez Set pour @ManyToMany afin d’éviter les lignes de jointure en double. Utilisez List pour @OneToMany lorsque l’ordre est important. N’utilisez jamais List avec @ManyToMany : Hibernate supprimerait puis réinsérerait toutes les lignes.
Vérification rapide
Qu’indique mappedBy dans une annotation @OneToMany ?
Récapitulatif
Utilisez @ManyToOne+@JoinColumn sur le côté propriétaire (FK). Utilisez @OneToMany(mappedBy=...) sur le côté inverse. Utilisez toujours LAZY pour les collections. Corrigez les requêtes N+1 avec JOIN FETCH. Utilisez une entité de jointure pour les relations plusieurs-à-plusieurs comportant des colonnes supplémentaires.
Questions Fréquemment Posées
La leçon « Relations One-to-Many et Many-to-Many » est-elle gratuite ?
Oui — le texte complet de « Relations One-to-Many et Many-to-Many » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Relations One-to-Many et Many-to-Many » ?
Mappez @OneToMany, @ManyToMany et @JoinTable avec des types de cascade et des stratégies de chargement. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Java Academy ?
Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Relations One-to-Many et Many-to-Many » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?
Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Mappage des entités avec les annotations JPA
- Référentiels Spring Data et méthodes de requête
- Relations One-to-Many et Many-to-Many
- Pagination, tri et projections