Mapping avec JPA

De UML à SQL : Relation OneToOne

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 OneToOne unidirectionnelle

Nous allons voir maintenant une relation OneToOne unidirectionnelle entre une classe B et une classe C. Le lien se fera de B vers C.

Diagramme de classe

Code Java

Code de la classe B :

@Entity
@Table( name = "T_TABLE_B" )
public class ClasseB implements Serializable
{
@Id
@GeneratedValue( strategy = GenerationType.IDENTITY )
@Column( name = "B_ID" )
private Long id;
@Column( name = "B_REMARQUE" )
private String remarque;
@OneToOne
@JoinColumn( name = "C_ID_FK" )
private ClasseC attributC;
...

Télécharger

Nous avons un attribut de type ClasseC nous permettant d’accéder à un objet C depuis un objet B.

Le code la classe C :

@Entity
@Table( name = "T_TABLE_C" )
public class ClasseC implements Serializable
{
@Id
@GeneratedValue( strategy = GenerationType.IDENTITY )
@Column( name = "C_ID" )
private Long id;
@Column( name = "C_REMARQUE" )
private String remarque;
...

Télécharger

Comme la relation est unidirectionnelle, nous n’avons pas d’attribut de type ClasseB dans C.

Les tables correspondantes

La table correspondant à la classe B :

mysql> describe T_TABLE_B;
+------------+--------------+------+-----+---------+----------------+
| Field      | Type         | Null | Key | Default | Extra          |
+------------+--------------+------+-----+---------+----------------+
| B_ID       | bigint(20)   | NO   | PRI | NULL    | auto_increment |
| B_REMARQUE | varchar(255) | YES  |     | NULL    |                |
| C_ID_FK    | bigint(20)   | YES  | MUL | NULL    |                |
+------------+--------------+------+-----+---------+----------------+

La table correspondant à la classe C :

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

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

Script de la table B :

CREATE TABLE `T_TABLE_B` (
`B_ID` BIGINT(20) NOT NULL AUTO_INCREMENT,
`B_REMARQUE` VARCHAR(255) DEFAULT NULL,
`C_ID_FK` BIGINT(20) DEFAULT NULL,
PRIMARY KEY (`B_ID`),
KEY `FK_T_TABLE_B_C_ID_FK` (`C_ID_FK`),
CONSTRAINT `FK_T_TABLE_B_C_ID_FK` FOREIGN KEY (`C_ID_FK`) REFERENCES `T_TABLE_C` (`C_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1

Télécharger

Script de la table C :

CREATE TABLE `T_TABLE_C` (
`C_ID` BIGINT(20) NOT NULL AUTO_INCREMENT,
`C_REMARQUE` VARCHAR(255) DEFAULT NULL,
PRIMARY KEY (`C_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1

Télécharger

Cas d’une relation 1 —> 1

Dans le diagramme de classes précédent, nous avions une cardinalité de 1 —> 0,1 entre B et C, ce qui veut dire que l’on n’est pas obligé d’avoir un objet C pour chaque objet B créé. D’autre part, nous avons bien le champ C_ID_FK qui est défini avec la valeur NULL autorisée. Maintenant si nous désirons que pour tout B nous ayons un C correspondant, nous devrons interdire NULL sur la clé étrangère.

Pour cela, il suffit de modifier la classe B en précisant l’annotation suivante :

@OneToOne
@JoinColumn( name = "C_ID_FK",nullable = false )
private ClasseC attributC;

Télécharger

ce qui donne maintenant la table :

mysql> describe T_TABLE_B;
+------------+--------------+------+-----+---------+----------------+
| Field      | Type         | Null | Key | Default | Extra          |
+------------+--------------+------+-----+---------+----------------+
| B_ID       | bigint(20)   | NO   | PRI | NULL    | auto_increment |
| B_REMARQUE | varchar(255) | YES  |     | NULL    |                |
| C_ID_FK    | bigint(20)   | NO   | MUL | NULL    |                |
+------------+--------------+------+-----+---------+----------------+

Et le script SQL correspondant :

CREATE TABLE `T_TABLE_B` (
`B_ID` BIGINT(20) NOT NULL AUTO_INCREMENT,
`B_REMARQUE` VARCHAR(255) DEFAULT NULL,
`C_ID_FK` BIGINT(20) NOT NULL,
PRIMARY KEY (`B_ID`),
KEY `FK_T_TABLE_B_C_ID_FK` (`C_ID_FK`),
CONSTRAINT `FK_T_TABLE_B_C_ID_FK` FOREIGN KEY (`C_ID_FK`) REFERENCES `T_TABLE_C` (`C_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1

Télécharger

Nous avons bien maintenant la définition de la clé étrangère qui a l’attribut NOT NULL.

Relation OneToOne bidirectionnelle

Dans le cas précédent nous ne pouvions pas aller d’une instance de C vers B puisque la classe C ne disposait pas d’un attribut de type ClasseB.

Nous allons maintenant définir deux classes D et E de telle manière que nous puissions trouver E quand nous avons D mais aussi l’inverse.

Diagramme de classes

Le code Java

La classe D :

@Entity
@Table( name = "T_TABLE_D" )
public class ClasseD implements Serializable
{
@Id
@GeneratedValue( strategy = GenerationType.IDENTITY )
@Column( name = "D_ID" )
private Long id;
@Column( name = "D_REMARQUE" )
private String remarque;
@OneToOne
@JoinColumn( name = "E_ID_FK" )
private ClasseE attributE;

Télécharger

La classe E :

@Entity
@Table( name = "T_TABLE_E" )
public class ClasseE implements Serializable
{
@Id
@GeneratedValue( strategy = GenerationType.IDENTITY )
@Column( name = "E_ID" )
private Long id;
private String remarque;
@OneToOne( mappedBy = "attributE" )
private ClasseD attributD;

Télécharger

Peu de différence entre le code du lien unidirectionnel si ce n’est l’ajout d’un attribut de type ClasseD dans la définition de la classe E.

Tables correspondantes

Table D :

mysql> describe T_TABLE_D;
+------------+--------------+------+-----+---------+----------------+
| Field      | Type         | Null | Key | Default | Extra          |
+------------+--------------+------+-----+---------+----------------+
| D_ID       | bigint(20)   | NO   | PRI | NULL    | auto_increment |
| D_REMARQUE | varchar(255) | YES  |     | NULL    |                |
| E_ID_FK    | bigint(20)   | YES  | MUL | NULL    |                |
+------------+--------------+------+-----+---------+----------------+

La table E :

mysql> describe T_TABLE_E;
+----------+--------------+------+-----+---------+----------------+
| Field    | Type         | Null | Key | Default | Extra          |
+----------+--------------+------+-----+---------+----------------+
| E_ID     | bigint(20)   | NO   | PRI | NULL    | auto_increment |
| REMARQUE | varchar(255) | YES  |     | NULL    |                |
+----------+--------------+------+-----+---------+----------------+
2 rows in set (0.00 sec)

Nous pouvons voir que la structure des tables ne change pas dans ce cas là puisqu’en SQL nous ne précisons pas de sens lorsque nous définissons une relation entre 2 tables contrairement à UML.

Conclusion

Nous venons de voir comment définir une relation OneToOne entre 2 classes persistantes mais dans beaucoup de cas, il pourra être plus judicieux d’embarquer les 2 classes dans une seule table pour des raisons de performances. Vous trouverez dans l’article Deux classes dans une table un exemple concret vous montrant comment utiliser une classe embarquée dans la table de celle à laquelle elle est liée.

Développement

Article n° 47

Crée par: chris

Créé le: 19 septembre 2015

Modifié le: 19 septembre 2015

Nombre de visites: 2084

Popularité: 31 %

Popularité absolue: 3

Mapping objet/relationnel avec JPA

Mots clés de cet article

Java39