JPA : Exemple de Mapping

Relation 1,1 avec JPA : exemple du client et son adresse

2 classes, 2 tables ou 2 classes dans une table ?

Cet article décrit comment définir une relation de type 1,1 entre 2 classes puis, montre comment mapper ces 2 classes dans une table unique de la base de données.

Une relation de type 1,1 entre 2 classes est sans doute le type de relation le plus simple à définir mais il peut être utile de connaître les différentes possibilités que propose JPA pour créer une base de données le plus efficacement possible.

Sommaire

Présentation, p1
Solution 1 : Mapping dans 2 tables, p1
Solution 2 : 2 classes dans une (...), p2
Conclusion, p2

1 2

Présentation

L’exemple que nous allons utiliser va être le cas d’une relation entre un client et son adresse que l’on pourrait représenter à l’aide du diagramme suivant :

Ce diagramme de classes modélise le fait qu’un client est domicilié à une adresse et une seule.

Solution 1 : Mapping dans 2 tables

Nous allons maintenant traduire nos 2 classes en langage Java mais comme nous désirons qu’elles soient persistantes, JPA nous impose qu’elles aient un identifiant et la classe Adresse n’en possède pas. On va donc ajouter un attribut numérique nommé id qui servira d’identifiant à notre adresse.

Créons maintenant nos classes Java correspondant à ce diagramme de classes.

La classe Adresse pourrait correspondre code suivant (extrait) :

@Entity
@Table( name = "T_ADRESSE_ADR")
public class Adresse implements Serializable
{
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue
private Long id;
@Column( name = "ADR_LIG1" )
private String ligne1;
@Column( name = "ADR_LIG2" )
private String ligne2;
@Column( name = "ADR_LIG3" )
private String ligne3;
@Column( name = "ADR_LIG4" )
private String ligne4;
@Column( name = "ADR_CP" )
private String codePostal;
@Column( name = "ADR_COMMUNE" )
private String commune;
@Column( name = "ADR_PAYS" )
private String pays;
geter/seter etc...

Télécharger

Rappel : Seules les annotations @Identity et @id sont obligatoires. @GeneratedValue précise que l’identifiant sera crée automatiquement, @Table et @Column permettent de définir un formalisme différent entre le nommage Java et SQL .

La classe Client pourra être défini par le code suivant :

@Entity
@Table( name = "T_CLIENT_CLI")
public class Client implements Serializable
{
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue
@Column( name = "CLI_ID" )
private Long id;
@Column( name = "CLI_NOM" )
private String nom;
@Column( name = "CLI_PRENOM" )
private String prenom;
@OneToOne
private Adresse adresse;
geter/seter etc...

Télécharger

Si l’on demande la génération de la base, nous obtenons les tables suivantes :

mysql> describe T_ADRESSE_ADR;
+-------------+--------------+------+-----+---------+-------+
| Field       | Type         | Null | Key | Default | Extra |
+-------------+--------------+------+-----+---------+-------+
| ID          | bigint(20)   | NO   | PRI | NULL    |       |
| ADR_CP      | varchar(255) | YES  |     | NULL    |       |
| ADR_COMMUNE | varchar(255) | YES  |     | NULL    |       |
| ADR_LIG1    | varchar(255) | YES  |     | NULL    |       |
| ADR_LIG2    | varchar(255) | YES  |     | NULL    |       |
| ADR_LIG3    | varchar(255) | YES  |     | NULL    |       |
| ADR_LIG4    | varchar(255) | YES  |     | NULL    |       |
| ADR_PAYS    | varchar(255) | YES  |     | NULL    |       |
+-------------+--------------+------+-----+---------+-------+

mysql> describe T_CLIENT_CLI;
+------------+--------------+------+-----+---------+-------+
| Field      | Type         | Null | Key | Default | Extra |
+------------+--------------+------+-----+---------+-------+
| CLI_ID     | bigint(20)   | NO   | PRI | NULL    |       |
| CLI_NOM    | varchar(255) | YES  |     | NULL    |       |
| CLI_PRENOM | varchar(255) | YES  |     | NULL    |       |
| ADRESSE_ID | bigint(20)   | YES  | MUL | NULL    |       |
+------------+--------------+------+-----+---------+-------+

Nous obtenons dans la table des clients, un champ ADRESSE_ID qui correspond à l’identifiant de l’adresse du client se trouvant dans la table T_ADRESSE_ADR. Il s’agit d’une clé étrangère.

On peut ajouter quelques annotations sur l’attribut Adresse. On peut préciser que les opérations de suppression etc... sur la table des clients se répercutent en cascade sur la tables des adresses. Avec l’annotation @JoinColumn on va pouvoir préciser le nom du champ et imposer qu’il ne soit pas nul pour qu’un client ait obligatoirement une adresse.

@OneToOne( cascade = CascadeType.ALL )
@JoinColumn( name = "CLI_ADRESSE_FK", nullable = false )
private Adresse adresse;

Télécharger

Si on relance la génération de la base, on vois par exemple que le nom du champ a changé et que Null est passé à NO.

mysql> describe T_CLIENT_CLI;
+----------------+--------------+------+-----+---------+-------+
| Field          | Type         | Null | Key | Default | Extra |
+----------------+--------------+------+-----+---------+-------+
| CLI_ID         | bigint(20)   | NO   | PRI | NULL    |       |
| CLI_NOM        | varchar(255) | YES  |     | NULL    |       |
| CLI_PRENOM     | varchar(255) | YES  |     | NULL    |       |
| CLI_ADRESSE_FK | bigint(20)   | NO   | MUL | NULL    |       |
+----------------+--------------+------+-----+---------+-------+

1 2

Développement

Article n° 24

Crée par: chris

Créé le: 27 mai 2015

Modifié le: 18 septembre 2015

Nombre de visites: 1185

Popularité: 3 %

Popularité absolue: 1

Mapping objet/relationnel avec JPA

Mots clés de cet article

Java39