Mapping avec JPA

De UML à SQL : Relation OneToMany

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 OneToMany unidirectionnelle, p1
Relation OneToMany bidirectionnelle, p2
Conclusion, p2

1 2

Relation OneToMany bidirectionnelle

Dans le cas précédent nous ne pouvions pas aller directement de G vers F.
Nous allons maintenant définir deux classes H et J avec une relation OneToMany bidirectionnelle.

Diagramme de classes

Code java

La classe H

@Entity
@Table( name = "T_TABLE_H" )
public class ClasseH implements Serializable
{
@Id
@GeneratedValue( strategy = GenerationType.IDENTITY )
@Column( name = "H_ID" )
private Long id;
@Column( name = "H_REMARQUE" )
private String remarque;
@OneToMany( mappedBy = "classeH" )
private List< ClasseI > listeI;
...

Télécharger

Par rapport à l’exemple précédent, nous spécifions que la relation va être mappée sur classeH, attribut qui va être ajouté dans la classe I et qui nous permettra d’aller de I vers H.

La classe I

@Entity
@Table( name = "T_TABLE_I" )
public class ClasseI implements Serializable
{
@Id
@GeneratedValue( strategy = GenerationType.IDENTITY )
@Column( name = "I_ID" )
private Long id;
@Column( name = "I_REMARQUE" )
private String remarque;
@ManyToOne
@JoinColumn( name = "H_ID_FK" )
private ClasseH classeH;
...

Télécharger

Nous avons défini un nouvel attribut que nous avons annoté @ManyToOne et nous spécifions le nom du champ clé étrangère dans la table correspondante.

Tables correspondantes

Table H :

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

Table I :

mysql> describe T_TABLE_I;
+------------+--------------+------+-----+---------+----------------+
| Field      | Type         | Null | Key | Default | Extra          |
+------------+--------------+------+-----+---------+----------------+
| I_ID       | bigint(20)   | NO   | PRI | NULL    | auto_increment |
| I_REMARQUE | varchar(255) | YES  |     | NULL    |                |
| H_ID_FK    | bigint(20)   | YES  | MUL | NULL    |                |
+------------+--------------+------+-----+---------+----------------+

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

Script de la table H :

CREATE TABLE `T_TABLE_H` (
`H_ID` BIGINT(20) NOT NULL AUTO_INCREMENT,
`H_REMARQUE` VARCHAR(255) DEFAULT NULL,
PRIMARY KEY (`H_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1

Télécharger

Script de la table I :

CREATE TABLE `T_TABLE_I` (
`I_ID` BIGINT(20) NOT NULL AUTO_INCREMENT,
`I_REMARQUE` VARCHAR(255) DEFAULT NULL,
`H_ID_FK` BIGINT(20) DEFAULT NULL,
PRIMARY KEY (`I_ID`),
KEY `FK_T_TABLE_I_H_ID_FK` (`H_ID_FK`),
CONSTRAINT `FK_T_TABLE_I_H_ID_FK` FOREIGN KEY (`H_ID_FK`) REFERENCES `T_TABLE_H` (`H_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1

Télécharger

Nous pouvons remarquer, comme pour les relations OneToOne, que le fait qu’une relation entre 2 classes soit uni ou bidirectionnelle, cela n’a pas d’incidence sur la structure de la base de données.

Conclusion

Nous venons de voir quelles annotations utiliser pour définir une relation OneToMany. Attention : selon le choix de vos annotations, JPA peut vous générer une table de relation supplémentaire ajoutant une jointure alors que c’est inutile dans les relations de 1 à n en bases de données.

Vous trouverez un exemple concret d’une relation OneToMany dans l’article Relation1,* avec JPA : Exemple d’une commande et ces lignes de commandes

1 2

Développement

Article n° 48

Crée par: chris

Créé le: 19 septembre 2015

Modifié le: 19 septembre 2015

Nombre de visites: 3271

Popularité: 13 %

Popularité absolue: 2

Mapping objet/relationnel avec JPA

Mots clés de cet article

Java39