Mapping avec JPA

De UML à SQL : Relation ManyToMany avec attributs

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

Présentation

Voyons d’abord comment représenter une relation ManyToMay possédant des attributs en UML. Nous prendrons comme exemple les classes L et M avec comme attribut d’association une donnée nommée options de type String.

En UML nous sommes obligé de passer par une classe d’association, nommée ClasseLM dans cet exemple.

Pour pouvoir traduire notre exemple en Java avec JPA , nous allons être obligé de modifier notre diagramme de classes pour traduire notre classe d’association en classe standard. Ce qui donne :

Ce qui nous donne 2 jointures de type OneToMany sur la classe LM qui correspondra à une table de jointure dans la base de données. Il reste maintenant à définir l’identifiant de cette classe qui sera composé des 2 clés des classes L et M.

Code Java

Comme la classe LM servant de jointure possède une clé composée, nous somme obligé de créer d’abord une classe pour la clé :

Code de la classe clé composite :

public class ClasseLM_pk implements Serializable
{
private Long idL;
private Long idM;
@Override
public int hashCode()
{
...
}
@Override
public boolean equals( Object obj )
{
...
}

Télécharger

Cette classe n’est pas une entity mais doit être Sérializable et doit avoir ces méthodes hashCode() et equals() de redéfinies pour pouvoir être utilisée comme clé composite.

Pour les 3 classes suivantes, nous nous retrouverons avec des relations OnToMany bidirectionnelles.

Voici le code de la classe L.

@Entity
@Table( name = "T_TABLE_L")
public class ClasseL implements Serializable
{
@Id
@GeneratedValue( strategy = GenerationType.IDENTITY )
@Column( name = "L_ID" )
private Long id;
@Column( name = "L_REMARQUE" )
private String remarque;
@OneToMany( mappedBy = "classeL", cascade = CascadeType.PERSIST )
private List< ClasseLM > listeM;
...

Télécharger

Le code de la classe M ;

@Entity
@Table( name = "T_TABLE_M" )
public class ClasseM implements Serializable
{
@Id
@GeneratedValue( strategy = GenerationType.IDENTITY )
@Column( name = "M_ID" )
private Long id;
@Column( name = "M_REMARQUE" )
private String remarque;
@OneToMany( mappedBy = "classeM", cascade = CascadeType.PERSIST )
private List< ClasseLM > listeL;
...

Télécharger

Le code de la classe intermédiaire LM.

@Entity
@Table( name = "T_TABLE_LM" )
@IdClass( ClasseLM_pk.class )
public class ClasseLM implements Serializable
{
@Id
@Column( name = "LM_ID_L_FK", nullable = false )
private Long idL;
@Id
@Column( name = "LM_ID_M_FK", nullable = false )
private Long idM;
@Column( name = "LM_OPTIONS" )
private String options;
@ManyToOne( cascade = CascadeType.PERSIST )
@JoinColumn( name = "LM_ID_L_FK", insertable = false, updatable = false )
private ClasseL classeL;
@ManyToOne( cascade = CascadeType.PERSIST )
@JoinColumn( name = "LM_ID_M_FK", insertable = false, updatable = false )
private ClasseM classeM;
...

Télécharger

Les tables correspondantes

Structure de la table L :

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

Structure de la table M :

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

Structure de la table LM ;

mysql> describe T_TABLE_LM;
+------------+--------------+------+-----+---------+-------+
| Field      | Type         | Null | Key | Default | Extra |
+------------+--------------+------+-----+---------+-------+
| LM_ID_L_FK | bigint(20)   | NO   | PRI | NULL    |       |
| LM_ID_M_FK | bigint(20)   | NO   | PRI | NULL    |       |
| LM_OPTIONS | varchar(255) | YES  |     | NULL    |       |
+------------+--------------+------+-----+---------+-------+

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

Je ne vous retranscrit pas ici les scripts des tables L et M qui n’on rien de particulier mais uniquement celui de la table de jointure.

Script de la table T_TABLE_LM :

CREATE TABLE `T_TABLE_LM` (
`LM_ID_L_FK` BIGINT(20) NOT NULL,
`LM_ID_M_FK` BIGINT(20) NOT NULL,
`LM_OPTIONS` VARCHAR(255) DEFAULT NULL,
PRIMARY KEY (`LM_ID_L_FK`,`LM_ID_M_FK`),
KEY `FK_T_TABLE_LM_LM_ID_M_FK` (`LM_ID_M_FK`),
CONSTRAINT `FK_T_TABLE_LM_LM_ID_M_FK` FOREIGN KEY (`LM_ID_M_FK`) REFERENCES `T_TABLE_M` (`M_ID`),
CONSTRAINT `FK_T_TABLE_LM_LM_ID_L_FK` FOREIGN KEY (`LM_ID_L_FK`) REFERENCES `T_TABLE_L` (`L_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1

Télécharger

On peut remarquer que cette table dispose bien d’une clé primaire composite mais que nous avons également chaque champs de cette clé comme clé étrangère vers les 2 autres tables.

Conclusion

Nous avons vu que pour traduire le concept UML de classe d’association, nous devons passer par une modification du modèle pour transformer une relation ManyToMany en 2 relations OneToMany.

Développement

Article n° 51

Crée par: chris

Créé le: 3 octobre 2015

Modifié le: 3 octobre 2015

Nombre de visites: 6086

Popularité: 46 %

Popularité absolue: 2

Mapping objet/relationnel avec JPA

Mots clés de cet article

Java39