Différence entre @JoinColumn et mappedBy

1. Introduction

Les relations JPA peuvent être unidirectionnelles ou bidirectionnelles. Cela signifie simplement que nous pouvons les modéliser comme un attribut sur exactement l'une des entités associées ou les deux.

La définition de la direction de la relation entre les entités n'a aucun impact sur le mappage de la base de données. Il définit uniquement les directions dans lesquelles nous utilisons cette relation dans notre modèle de domaine.

Pour une relation bidirectionnelle, nous définissons généralement:

  • le côté propriétaire
  • inverse ou côté référencement

L' annotation @JoinColumn nous aide à spécifier la colonne que nous utiliserons pour joindre une association d'entités ou une collection d'éléments. D'autre part, l' attribut mappedBy est utilisé pour définir le côté de référence (côté non propriétaire) de la relation.

Dans ce rapide tutoriel, nous examinerons la différence entre @JoinColumn et mappedBy dans JPA. Nous présenterons également comment les utiliser dans une association un-à-plusieurs.

2. Configuration initiale

Pour suivre ce tutoriel, disons que nous avons deux entités: Employee et Email.

De toute évidence, un employé peut avoir plusieurs adresses e-mail. Cependant, une adresse e-mail donnée peut appartenir exactement à un seul employé.

Cela signifie qu'ils partagent une association un-à-plusieurs:

Également dans notre modèle SGBDR, nous aurons une clé étrangère employee_id dans notre entité Email faisant référence à l' attribut id d'un employé .

3. Annotation @JoinColumn

Dans une relation un-à-plusieurs / plusieurs-à-un, le côté propriétaire est généralement défini du côté « plusieurs» de la relation. C'est généralement le côté qui possède la clé étrangère.

L' annotation @JoinColumn définit ce mappage physique réel du côté propriétaire:

@Entity public class Email { @Id @GeneratedValue(strategy = GenerationType.AUTO) private Long id; @ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name = "employee_id") private Employee employee; // ... }

Cela signifie simplement que notre entité Email aura une colonne de clé étrangère nommée employee_id faisant référence à l' ID d' attribut principal de notre entité Employee .

4. attribut mappedBy

Une fois que nous avons défini le côté propriétaire de la relation, Hibernate dispose déjà de toutes les informations nécessaires pour cartographier cette relation dans notre base de données. Pour rendre cette association bidirectionnelle, il suffit de définir le côté de référencement. L'inverse ou le côté de référence correspond simplement au côté propriétaire.

On peut facilement utiliser l' mappedBy attribut de @OneToMany annotation pour le faire. Alors, définissons notre entité Employé :

@Entity public class Employee { @Id @GeneratedValue(strategy = GenerationType.AUTO) private Long id; @OneToMany(fetch = FetchType.LAZY, mappedBy = "employee") private List emails; // ... }

Ici, la valeur de mappedBy est le nom de l'attribut de mappage d'association du côté propriétaire. Avec cela, nous avons maintenant établi une association bidirectionnelle entre nos entités Employé et Email .

5. Conclusion

Dans ce didacticiel, nous avons examiné la différence entre @JoinColumn et mappedBy et comment les utiliser dans une relation bidirectionnelle un-à-plusieurs.

L' annotation @JoinColumn définit le mappage physique réel du côté propriétaire. D'autre part, le côté de référencement est défini à l'aide de l' attribut mappedBy de l' annotation @OneToMany .

Comme d'habitude, le code source est disponible sur sur Github.