Hibernate One to One Mapping Annotation Example

Si nous travaillons sur n’importe quelle application hibernate ou si nous prévoyons de travailler sur n’importe laquelle dans le futur, alors vous pouvez facilement comprendre les relations one-to-one entre plusieurs entités dans l’application. Dans cet exemple de mapping un à un hibernate, Nous allons discuter de 4 variations différentes.

Table of ContentsVarious supported techniques for one to one mapping1. Using foreign key association2. Using join table3. Using shared primary key4. @MapsId

Pour cet exemple de mapping un à un hibernate, j’étend l’exemple écrit pour l’exemple hibernate hello world. Nous avons deux entités ici : Employee et Account.

Un employé ne peut avoir qu’un seul compte. De même, un compte sera associé à un seul employé. C’est une relation un à un pour cet exemple.

Diverses techniques supportées

Dans hibernate il y a 3 façons de créer des relations un à un entre deux entités. Dans les deux cas, nous devons utiliser l’annotation @OneToOne.

La première technique est la plus utilisée et utilise une colonne de clé étrangère dans l’une des tables.
La deuxième technique utilise une solution plutôt connue qui consiste à avoir une troisième table pour stocker le mapping entre les deux premières tables.
La troisième technique est quelque chose de nouveau qui utilise une valeur de clé primaire commune dans les deux tables.

Mapping one to one d’Hibernate avec association de clé étrangère

Dans ce type d’association, une colonne de clé étrangère est créée dans l’entité propriétaire. Par exemple, si nous rendons EmployeeEntity propriétaire, alors une colonne supplémentaire "ACCOUNT_ID" sera créée dans la table Employee. Cette colonne stockera la clé étrangère pour la table Account.

La structure de la table sera comme ceci:

Pour faire une telle association, référez l’entité Account dans la classe EmployeeEntity comme suit:

@OneToOne@JoinColumn(name="ACCOUNT_ID")private AccountEntity account;

La colonne de jointure est déclarée avec l’annotation @JoinColumn qui ressemble à l’annotation @Column. Elle possède un paramètre supplémentaire nommé referencedColumnName. Ce paramètre déclare la colonne dans l’entité ciblée qui sera utilisée pour la jointure.

Si aucun @JoinColumn n’est déclaré du côté du propriétaire, les valeurs par défaut s’appliquent. Une ou plusieurs colonnes de jointure seront créées dans la table propriétaire et son nom sera la concaténation du nom de la relation du côté propriétaire, _ (trait de soulignement), et du nom de la ou des colonnes de clé primaire du côté propriétaire.

Dans une relation bidirectionnelle, un des côtés (et un seul) doit être le propriétaire. Le propriétaire est responsable de la mise à jour de la ou des colonnes d’association. Pour déclarer un côté comme non responsable de la relation, on utilise l’attribut mappedBy. ‘mappedBy’ se réfère au nom de propriété de l’association du côté propriétaire.

@OneToOne(mappedBy="account")private EmployeeEntity employee;

L’attribut « above "mappedBy » déclare qu’il dépend de l’entité propriétaire pour le mappage.

Testons les mappages ci-dessus dans le code d’exécution:

L’exécution du code ci-dessus crée le schéma désiré dans la base de données et exécute ces requêtes SQL.

Vous pouvez vérifier les données et les mappings dans les deux tables lorsque vous exécutez le programme ci-dessus.

Hibernate one to one mapping with common join table

Cette approche n’est pas nouvelle pour nous tous. Commençons par la structure de la BD ciblée dans cette technique.

Dans cette technique, l’annotation principale à utiliser est @JoinTable. Cette annotation est utilisée pour définir le nouveau nom de la table (obligatoire) et les clés étrangères des deux tables. Voyons comment elle est utilisée :

L’annotation @JoinTable est utilisée dans la classe EmployeeEntity. Elle déclare qu’une nouvelle table EMPLOYEE_ACCOUNT sera créée avec deux colonnes EMPLOYEE_ID (clé primaire de la table EMPLOYEE) et ACCOUNT_ID (clé primaire de la table ACCOUNT).

Tester les entités ci-dessus génère les requêtes SQL suivantes dans les fichiers journaux:

Hibernate one to one mapping with shared primary key

Dans cette technique, hibernate s’assurera d’utiliser une valeur de clé primaire commune dans les deux tables. De cette façon, la clé primaire de EmployeeEntity peut en toute sécurité être supposée la clé primaire de AccountEntity également.

La structure de la table sera comme ceci:

Dans cette approche, @PrimaryKeyJoinColumn est l’annotation principale à utiliser. Voyons comment l’utiliser.

@OneToOne(cascade = CascadeType.ALL)@PrimaryKeyJoinColumnprivate AccountEntity account;

Du côté de AccountEntity, elle restera dépendante de l’entité propriétaire pour le mapping.

@OneToOne(mappedBy="account", cascade=CascadeType.ALL)private EmployeeEntity employee;

Tester les entités ci-dessus génère les requêtes SQL suivantes dans les fichiers journaux :

Mapping one to one d’Hibernate avec @MapsId

Dans cette technique, hibernate suppose que la source et la cible partagent les mêmes valeurs de clé primaire.

Dans cette approche, @MapsId est l’annotation principale à utiliser. Voyons comment l’utiliser.

@Idprivate Integer employeeId;@OneToOne @MapsIdprivate AccountEntity account;