Relation plusieurs-à-plusieurs dans JPA

1. Introduction

Dans ce didacticiel, nous verrons plusieurs façons de gérer les relations plusieurs-à-plusieurs à l'aide de JPA .

Pour présenter les idées, nous utiliserons un modèle d'étudiants, de cours et de diverses relations entre eux.

Par souci de simplicité, dans les exemples de code, nous montrerons uniquement les attributs et la configuration JPA liés aux relations plusieurs-à-plusieurs.

2. Plusieurs-à-plusieurs de base

2.1. Modélisation d'une relation plusieurs-à-plusieurs

Une relation est une connexion entre deux types d'entités. Dans le cas d'une relation plusieurs-à-plusieurs, les deux côtés peuvent être liés à plusieurs instances de l'autre côté.

Notez qu'il est possible que les types d'entités soient en relation avec eux-mêmes. Par exemple, lorsque nous modélisons des arbres généalogiques: chaque nœud est une personne, donc si nous parlons de la relation parent-enfant, les deux participants seront une personne.

Cependant, cela ne fait pas une telle différence que nous parlions d'une relation entre un ou plusieurs types d'entités. Puisqu'il est plus facile de penser aux relations entre deux types d'entités différents, nous allons l'utiliser pour illustrer nos cas.

Par exemple, lorsque les étudiants notent les cours qu'ils aiment: un étudiant peut aimer de nombreux cours, et de nombreux étudiants peuvent aimer le même cours:

Comme nous le savons, dans les SGBDR, nous pouvons créer des relations avec des clés étrangères. Puisque les deux côtés doivent pouvoir référencer l'autre, nous devons créer une table séparée pour contenir les clés étrangères :

Une telle table est appelée une table de jointure . Notez que dans une table de jointure, la combinaison des clés étrangères sera sa clé primaire composite.

2.2. Implémentation dans JPA

Modéliser une relation plusieurs-à-plusieurs avec les POJO est facile. Nous devrions inclure une Collection dans les deux classes , qui contient les éléments des autres.

Après cela, nous devons marquer la classe avec @Entity et la clé primaire avec @Id pour en faire des entités JPA appropriées.

Nous devons également configurer le type de relation. C'est pourquoi nous marquons les collections avec des annotations @ManyToMany :

@Entity class Student { @Id Long id; @ManyToMany Set likedCourses; // additional properties // standard constructors, getters, and setters } @Entity class Course { @Id Long id; @ManyToMany Set likes; // additional properties // standard constructors, getters, and setters }

De plus, nous devons configurer comment modéliser la relation dans le SGBDR.

Le côté propriétaire est l'endroit où nous configurons la relation, qui pour cet exemple, nous choisirons la classe Student .

Nous pouvons le faire avec l' annotation @JoinTable dans la classe Student . Nous fournissons le nom de la table de jointure ( course_like ) et les clés étrangères avec les annotations @JoinColumn . L' attribut joinColumn se connectera au côté propriétaire de la relation et l' inverseJoinColumn de l'autre côté:

@ManyToMany @JoinTable( name = "course_like", joinColumns = @JoinColumn(name = "student_id"), inverseJoinColumns = @JoinColumn(name = "course_id")) Set likedCourses;

Notez que l'utilisation de @JoinTable , ou même de @JoinColumn n'est pas requise: JPA générera les noms de table et de colonne pour nous. Cependant, la stratégie utilisée par JPA ne correspond pas toujours aux conventions de dénomination que nous utilisons. D'où la possibilité de configurer les noms de table et de colonne.

Du côté cible, il suffit de fournir le nom du champ, qui mappe la relation . Par conséquent, nous définissons l' attribut mappedBy de l' annotation @ManyToMany dans la classe Course :

@ManyToMany(mappedBy = "likedCourses") Set likes;

Notez qu'étant donné qu'une relation plusieurs-à-plusieurs n'a pas de côté propriétaire dans la base de données , nous pouvons configurer la table de jointure dans la classe Course et la référencer à partir de la classe Student .

3. Plusieurs à plusieurs à l'aide d'une clé composite

3.1. Modélisation des attributs de relation

Disons que nous voulons laisser les étudiants évaluer les cours. Un étudiant peut noter n'importe quel nombre de cours, et n'importe quel nombre d'étudiants peut évaluer le même cours. Par conséquent, c'est aussi une relation plusieurs-à-plusieurs. Ce qui rend les choses un peu plus compliquées, c'est qu'il y a plus dans la relation de notation que le fait qu'elle existe. Nous devons stocker la note attribuée par l'étudiant au cours.

Où pouvons-nous stocker ces informations? Nous ne pouvons pas le mettre dans l' entité Etudiant car un étudiant peut attribuer différentes notes à différents cours. De même, le stocker dans l' entité Course ne serait pas non plus une bonne solution.

Il s'agit d'une situation où la relation elle-même a un attribut .

En utilisant cet exemple, l'attachement d'un attribut à une relation ressemble à ceci dans un diagramme ER:

Nous pouvons le modéliser presque de la même manière que nous l'avons fait avec la simple relation plusieurs-à-plusieurs. La seule différence est que nous attachons un nouvel attribut à la table de jointure:

3.2. Création d'une clé composite dans JPA

La mise en œuvre d'une simple relation plusieurs-à-plusieurs était plutôt simple. Le seul problème est que nous ne pouvons pas ajouter une propriété à une relation de cette façon, car nous avons connecté les entités directement. Par conséquent, nous n'avions aucun moyen d'ajouter une propriété à la relation elle-même .

Puisque nous mappons les attributs de base de données aux champs de classe dans JPA, nous devons créer une nouvelle classe d'entité pour la relation.

Of course, every JPA entity needs a primary key. Because our primary key is a composite key, we have to create a new class, which will hold the different parts of the key:

@Embeddable class CourseRatingKey implements Serializable { @Column(name = "student_id") Long studentId; @Column(name = "course_id") Long courseId; // standard constructors, getters, and setters // hashcode and equals implementation }

Note, that there're some key requirements, which a composite key class has to fulfill:

  • We have to mark it with @Embeddable
  • It has to implement java.io.Serializable
  • We need to provide an implementation of the hashcode() and equals() methods
  • None of the fields can be an entity themselves

3.3. Using a Composite Key in JPA

Using this composite key class, we can create the entity class, which models the join table:

@Entity class CourseRating { @EmbeddedId CourseRatingKey id; @ManyToOne @MapsId("studentId") @JoinColumn(name = "student_id") Student student; @ManyToOne @MapsId("courseId") @JoinColumn(name = "course_id") Course course; int rating; // standard constructors, getters, and setters }

This code is very similar to a regular entity implementation. However, we have some key differences:

  • we used @EmbeddedId, to mark the primary key, which is an instance of the CourseRatingKey class
  • we marked the student and course fields with @MapsId

@MapsId means that we tie those fields to a part of the key, and they're the foreign keys of a many-to-one relationship. We need it, because as we mentioned above, in the composite key we can't have entities.

After this, we can configure the inverse references in the Student and Course entities like before:

class Student { // ... @OneToMany(mappedBy = "student") Set ratings; // ... } class Course { // ... @OneToMany(mappedBy = "course") Set ratings; // ... }

Note, that there's an alternative way to use composite keys: the @IdClass annotation.

3.4. Further Characteristics

We configured the relationships to the Student and Course classes as @ManyToOne. We could do this because with the new entity we structurally decomposed the many-to-many relationship to two many-to-one relationships.

Why were we able to do this? If we inspect the tables closely in the previous case, we can see, that it contained two many-to-one relationships. In other words, there isn't any many-to-many relationship in an RDBMS. We call the structures we create with join tables many-to-many relationships because that's what we model.

Besides, it's more clear if we talk about many-to-many relationships, because that's our intention. Meanwhile, a join table is just an implementation detail; we don't really care about it.

Moreover, this solution has an additional feature we didn't mention yet. The simple many-to-many solution creates a relationship between two entities. Therefore, we cannot expand the relationship to more entities. However, in this solution we don't have this limit: we can model relationships between any number of entity types.

For example, when multiple teachers can teach a course, students can rate how a specific teacher teaches a specific course. That way, a rating would be a relationship between three entities: a student, a course, and a teacher.

4. Many-to-Many With a New Entity

4.1. Modeling Relationship Attributes

Let's say we want to let students register to courses. Also, we need to store the point when a student registered for a specific course. On top of that, we also want to store what grade she received in the course.

In an ideal world, we could solve this with the previous solution, when we had an entity with a composite key. However, our world is far from ideal and students don't always accomplish a course on the first try.

In this case, there're multiple connections between the same student-course pairs, or multiple rows, with the same student_id-course_id pairs. We can't model it using any of the previous solutions because all primary keys must be unique. Therefore, we need to use a separate primary key.

Therefore, we can introduce an entity, which will hold the attributes of the registration:

In this case, the Registration entity represents the relationship between the other two entities.

Since it's an entity, it'll have its own primary key.

Note, that in the previous solution we had a composite primary key, which we created from the two foreign keys. Now, the two foreign keys won't be the part of the primary key:

4.2. Implementation in JPA

Since the coure_registration became a regular table, we can create a plain old JPA entity modeling it:

@Entity class CourseRegistration { @Id Long id; @ManyToOne @JoinColumn(name = "student_id") Student student; @ManyToOne @JoinColumn(name = "course_id") Course course; LocalDateTime registeredAt; int grade; // additional properties // standard constructors, getters, and setters }

Also, we need to configure the relationships in the Student and Course classes:

class Student { // ... @OneToMany(mappedBy = "student") Set registrations; // ... } class Course { // ... @OneToMany(mappedBy = "courses") Set registrations; // ... }

Again, we configured the relationship before. Hence, we only need to tell JPA, where can it find that configuration.

Note, that we could use this solution to address the previous problem: students rating courses. However, it feels weird to create a dedicated primary key unless we have to. Moreover, from an RDBMS perspective, it doesn't make much sense, since combining the two foreign keys made a perfect composite key. Besides, that composite key had a clear meaning: which entities we connect in the relationship.

Otherwise, the choice between these two implementations is often simply personal preference.

5. Conclusion

In this tutorial, we saw what a many-to-many relationship is and how can we model it in an RDBMS using JPA.

Nous avons vu trois façons de le modéliser dans JPA. Tous les trois ont des avantages et des inconvénients différents en ce qui concerne:

  • clarté du code
  • Clarté DB
  • possibilité d'attribuer des attributs à la relation
  • combien d'entités pouvons-nous lier à la relation, et
  • prise en charge de plusieurs connexions entre les mêmes entités

Comme d'habitude, les exemples sont disponibles à l'adresse over sur GitHub.