Mapping avec JPA

De UML à SQL : Relation ManyToMany

Article faisant partie d’une série présentant les différentes annotations permettant de traduire des relations entre classes persistantes en bases de données relationnelles.

Sommaire

Relation ManyToMany

Une relation ManyToMany est généralement utilisée dans les 2 sens ; nous allons donc voir ce type de relation entre 2 classes J et K.

Diagramme de classes

Dans ce cas, nous devrons obligatoirement nous retrouver avec trois tables dont une de jointure.

Code Java

Code de la classe J

@Entity
@Table( name = "T_TABLE_J" )
public class ClasseJ implements Serializable
{
@Id
@GeneratedValue( strategy = GenerationType.IDENTITY )
@Column( name = "J_ID" )
private Long id;
@Column( name = "J_REMARQUE" )
private String remarque;
@ManyToMany( mappedBy = "listeJ" )
private List< ClasseK > listeK;
...

Télécharger

Nous avons défini un attribut liste d’objets K et nous précision dans l’annotation que le lien est mappé avec l’attribut listeJ qui sera définie dans la classe K.

Code de la classe K

@Entity
@Table( name = "T_TABLE_K" )
public class ClasseK implements Serializable
{
@Id
@GeneratedValue( strategy = GenerationType.IDENTITY )
@Column( name = "K_ID" )
private Long id;
@Column( name = "K_REMARQUE" )
private String remarque;
@ManyToMany
@JoinTable( name = "TJ_JK",
joinColumns = @JoinColumn( name = "K_ID_FK" ),
inverseJoinColumns = @JoinColumn( name = "J_ID_FK" )
)
private List< ClasseJ > listeJ;
...

Télécharger

Dans cette classe, nous utilisons l’annotation JoinTable pour définir le nom de la table de jointure et de ces champs qui devront correspondre aux deux clés étrangères correspondant aux clés primaires des 2 tables.

Les tables correspondantes

Structure de la table J :

mysql> describe T_TABLE_J;
+------------+--------------+------+-----+---------+----------------+
| Field      | Type         | Null | Key | Default | Extra          |
+------------+--------------+------+-----+---------+----------------+
| J_ID       | bigint(20)   | NO   | PRI | NULL    | auto_increment |
| J_REMARQUE | varchar(255) | YES  |     | NULL    |                |
+------------+--------------+------+-----+---------+----------------+

Structure de la table K :

mysql> describe T_TABLE_K;
+------------+--------------+------+-----+---------+----------------+
| Field      | Type         | Null | Key | Default | Extra          |
+------------+--------------+------+-----+---------+----------------+
| K_ID       | bigint(20)   | NO   | PRI | NULL    | auto_increment |
| K_REMARQUE | varchar(255) | YES  |     | NULL    |                |
+------------+--------------+------+-----+---------+----------------+

Structure de la table de jointure :

mysql> describe TJ_JK;
+---------+------------+------+-----+---------+-------+
| Field   | Type       | Null | Key | Default | Extra |
+---------+------------+------+-----+---------+-------+
| J_ID_FK | bigint(20) | NO   | PRI | NULL    |       |
| K_ID_FK | bigint(20) | NO   | PRI | NULL    |       |
+---------+------------+------+-----+---------+-------+

Et voici le script SQL permettant de générer les tables :

Script de la table T_TABLE_J :

CREATE TABLE `T_TABLE_J` (
`J_ID` BIGINT(20) NOT NULL AUTO_INCREMENT,
`J_REMARQUE` VARCHAR(255) DEFAULT NULL,
PRIMARY KEY (`J_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1

Télécharger

Script de la table T_TABLE_K :

CREATE TABLE `T_TABLE_K` (
`K_ID` BIGINT(20) NOT NULL AUTO_INCREMENT,
`K_REMARQUE` VARCHAR(255) DEFAULT NULL,
PRIMARY KEY (`K_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1

Télécharger

Script de la table de jointure :

CREATE TABLE `TJ_JK` (
`J_ID_FK` BIGINT(20) NOT NULL,
`K_ID_FK` BIGINT(20) NOT NULL,
PRIMARY KEY (`J_ID_FK`,`K_ID_FK`),
KEY `FK_TJ_JK_K_ID_FK` (`K_ID_FK`),
CONSTRAINT `FK_TJ_JK_K_ID_FK` FOREIGN KEY (`K_ID_FK`) REFERENCES `T_TABLE_K` (`K_ID`),
CONSTRAINT `FK_TJ_JK_J_ID_FK` FOREIGN KEY (`J_ID_FK`) REFERENCES `T_TABLE_J` (`J_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1

Télécharger

Nous pouvons vérifier que la clé primaire est composée des deux champs de la table et que chacun est également clé étrangère pour faire le lien entre les 2 autres tables.

Conclusion

Nous venons de voir les différentes annotations qui permettent de définir tous les éléments des tables entrant en jeux pour gérer une relation ManyToMany. En matière de bases de données relationnelle, il existe des relations N,N avec des attributs qui dépendent des 2 entités. Ce cas est un peu plus complexe et sera traité dans un autre article.

Développement

Article n° 50

Crée par: chris

Créé le: 19 septembre 2015

Modifié le: 19 septembre 2015

Nombre de visites: 1238

Popularité: 20 %

Popularité absolue: 2

Mapping objet/relationnel avec JPA

Mots clés de cet article

Java39