JPA @Embedded et @Embeddable

1. Vue d'ensemble

Dans ce didacticiel, nous verrons comment nous pouvons mapper une entité contenant des propriétés incorporées à une seule table de base de données.

Donc, à cette fin, nous utiliserons les annotations @Embeddable et @Embedded fournies par l'API Java Persistence (JPA).

2. Contexte du modèle de données

Tout d'abord, définissons une table appelée société .

La table de l' entreprise stockera des informations de base telles que le nom, l'adresse et le téléphone de l'entreprise, ainsi que les informations d'une personne de contact:

public class Company { private Integer id; private String name; private String address; private String phone; private String contactFirstName; private String contactLastName; private String contactPhone; // standard getters, setters }

La personne de contact, cependant, semble devoir être transférée à une classe distincte. Le problème est que nous ne voulons pas créer un tableau séparé pour ces détails. Alors, voyons ce que nous pouvons faire.

3. @Embeddable

JPA fournit l' annotation @Embeddable pour déclarer qu'une classe sera incorporée par d'autres entités.

Définissons une classe pour extraire les détails de la personne de contact:

@Embeddable public class ContactPerson { private String firstName; private String lastName; private String phone; // standard getters, setters }

4. @Embedded

L'annotation JPA @Embedded est utilisée pour incorporer un type dans une autre entité.

Modifions ensuite notre classe Company . Nous ajouterons les annotations JPA et nous changerons également pour utiliser ContactPerson au lieu de champs séparés:

@Entity public class Company { @Id @GeneratedValue private Integer id; private String name; private String address; private String phone; @Embedded private ContactPerson contactPerson; // standard getters, setters }

En conséquence, nous avons notre entité Entreprise , intégrant les détails de la personne de contact et mappant vers une table de base de données unique.

Nous avons encore un problème, cependant, et c'est ainsi que JPA mappera ces champs aux colonnes de la base de données.

5. Remplacement des attributs

Le fait est que nos champs s'appelaient des choses comme contactFirstName dans notre classe Company d' origine et maintenant firstName dans notre classe ContactPerson . Ainsi, JPA voudra les mapper respectivement à contact_first_name et first_name .

En plus d'être loin d'être idéal, cela nous cassera réellement avec notre colonne téléphonique désormais dupliquée .

Ainsi, nous pouvons utiliser @AttributeOverrides et @AttibuteOverride pour remplacer les propriétés de colonne de notre type incorporé.

Ajoutons ceci au champ ContactPerson dans notre entité Entreprise :

@Embedded @AttributeOverrides({ @AttributeOverride( name = "firstName", column = @Column(name = "contact_first_name")), @AttributeOverride( name = "lastName", column = @Column(name = "contact_last_name")), @AttributeOverride( name = "phone", column = @Column(name = "contact_phone")) }) private ContactPerson contactPerson;

Notez que, puisque ces annotations vont sur le terrain, nous pouvons avoir des remplacements différents pour chaque entité englobante.

6. Conclusion

Dans ce didacticiel, nous avons configuré une entité avec certains attributs incorporés et les avons mappés à la même table de base de données que l'entité englobante. Pour cela, nous avons utilisé les annotations @Embedded , @Embeddable , @AttributeOverrides et @AttributeOverride fournies par l'API Java Persistence.

Comme toujours, le code source de l'exemple est disponible à l'adresse over sur GitHub.