Aujourd’hui, nous examinerons la correspondance un à un dans Hibernate. Nous examinerons un exemple de correspondance un à un dans Hibernate en utilisant à la fois l’annotation et la configuration XML.
Correspondance un à un dans Hibernate
La plupart du temps, les tables de la base de données sont associées les unes aux autres. Il existe de nombreuses formes d’association – un à un, un à plusieurs et plusieurs à plusieurs sont au niveau le plus large. Celles-ci peuvent être ensuite divisées en mappages unidirectionnels et bidirectionnels. Aujourd’hui, nous examinerons la mise en œuvre de la correspondance un à un dans Hibernate en utilisant la configuration XML ainsi que la configuration par annotation.
Exemple de configuration de base de données pour la correspondance un à un dans Hibernate
Tout d’abord, nous aurions besoin de configurer une correspondance un à un dans les tables de la base de données. Nous créerons deux tables pour notre exemple – Transaction et Client. Les deux de ces tables auront une correspondance un à un. La transaction sera la table principale et nous utiliserons la clé étrangère dans la table Client pour la correspondance un à un. Je fournis le script MySQL, c’est la base de données que j’utilise pour ce tutoriel. Si vous utilisez une autre base de données, assurez-vous de modifier le script en conséquence.
-- Créer la table Transaction
CREATE TABLE `Transaction` (
`txn_id` int(11) unsigned NOT NULL AUTO_INCREMENT,
`txn_date` date NOT NULL,
`txn_total` decimal(10,0) NOT NULL,
PRIMARY KEY (`txn_id`)
) ENGINE=InnoDB AUTO_INCREMENT=16 DEFAULT CHARSET=utf8;
-- Créer la table Client
CREATE TABLE `Customer` (
`txn_id` int(11) unsigned NOT NULL,
`cust_name` varchar(20) NOT NULL DEFAULT '',
`cust_email` varchar(20) DEFAULT NULL,
`cust_address` varchar(50) NOT NULL DEFAULT '',
PRIMARY KEY (`txn_id`),
CONSTRAINT `customer_ibfk_1` FOREIGN KEY (`txn_id`) REFERENCES `Transaction` (`txn_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
Le diagramme de relation entité-association (ERD) de la correspondance un à un entre les tables ressemble à l’image ci-dessous. 
Notre configuration de base de données est prête, passons maintenant au projet d’exemple Hibernate One to One.
Structure du projet Hibernate One to One Mapping Example
Créez un projet Maven simple dans votre IDE Java, j’utilise Eclipse. Notre structure de projet final ressemblera à l’image ci-dessous. 
Tout d’abord, nous examinerons un exemple de mappage Hibernate One to One basé sur XML, puis nous implémenterons la même chose en utilisant des annotations.
Dépendances Maven Hibernate
Notre fichier pom.xml final ressemble à ceci.
<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.journaldev.hibernate</groupId>
<artifactId>HibernateOneToOneMapping</artifactId>
<version>0.0.1-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>4.3.5.Final</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.0.5</version>
</dependency>
</dependencies>
</project>
Les dépendances sont uniquement pour Hibernate et le pilote java MySQL. Notez que j’utilise la dernière version de Hibernate 4.3.5.Final et le pilote java MySQL en fonction de la version de mon serveur de base de données MySQL (5.0.5). Hibernate 4 utilise le journal JBoss et il est importé automatiquement en tant que dépendance transitive. Vous pouvez le confirmer dans les dépendances Maven du projet. Si vous utilisez des versions plus anciennes de Hibernate, vous devrez peut-être ajouter des dépendances slf4j.
Classes de modèle de mappage One to One Hibernate
Les classes de modèle pour le mappage One to One Hibernate pour refléter les tables de base de données ressembleraient à ceci.
package com.journaldev.hibernate.model;
import java.util.Date;
public class Txn {
private long id;
private Date date;
private double total;
private Customer customer;
@Override
public String toString(){
return id+", "+total+", "+customer.getName()+", "+customer.getEmail()+", "+customer.getAddress();
}
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public Date getDate() {
return date;
}
public void setDate(Date date) {
this.date = date;
}
public double getTotal() {
return total;
}
public void setTotal(double total) {
this.total = total;
}
public Customer getCustomer() {
return customer;
}
public void setCustomer(Customer customer) {
this.customer = customer;
}
}
package com.journaldev.hibernate.model;
public class Customer {
private long id;
private String name;
private String email;
private String address;
private Txn txn;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public Txn getTxn() {
return txn;
}
public void setTxn(Txn txn) {
this.txn = txn;
}
}
Depuis que nous utilisons une configuration basée sur XML pour le mapping, les classes de modèle ci-dessus sont des classes POJO simples ou des Java Beans avec des méthodes getter-setter. J’utilise le nom de classe Txn pour éviter toute confusion car l’API Hibernate a un nom de classe Transaction.
Configuration de la mise en correspondance un à un de Hibernate
Créons des fichiers de configuration de mise en correspondance un à un de Hibernate pour les tables Txn et Customer. txn.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"https://hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.journaldev.hibernate.model.Txn" table="TRANSACTION" >
<id name="id" type="long">
<column name="txn_id" />
<generator class="identity" />
</id>
<property name="date" type="date">
<column name="txn_date" />
</property>
<property name="total" type="double">
<column name="txn_total" />
</property>
<one-to-one name="customer" class="com.journaldev.hibernate.model.Customer"
cascade="save-update" />
</class>
</hibernate-mapping>
Le point important à noter ci-dessus est l’élément one-to-one de hibernate pour la propriété customer. customer.hbm.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"https://hibernate.org/dtd/hibernate-mapping-3.0.dtd" >
<hibernate-mapping>
<class name="com.journaldev.hibernate.model.Customer" table="CUSTOMER">
<id name="id" type="long">
<column name="txn_id" />
<generator class="foreign">
<param name="property">txn</param>
</generator>
</id>
<one-to-one name="txn" class="com.journaldev.hibernate.model.Txn"
constrained="true"></one-to-one>
<property name="name" type="string">
<column name="cust_name"></column>
</property>
<property name="email" type="string">
<column name="cust_email"></column>
</property>
<property name="address" type="string">
<column name="cust_address"></column>
</property>
</class>
</hibernate-mapping>
la classe de génération=“étrangère” est la partie importante utilisée pour l’implémentation de la clé étrangère de Hibernate.
Fichier de configuration Hibernate
Voici le fichier de configuration Hibernate pour la configuration de mapping Hibernate basée sur XML. hibernate.cfg.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"https://hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.password">pankaj123</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost/TestDB</property>
<property name="hibernate.connection.username">pankaj</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.current_session_context_class">thread</property>
<property name="hibernate.show_sql">true</property>
<mapping resource="txn.hbm.xml"/>
<mapping resource="customer.hbm.xml"/>
</session-factory>
</hibernate-configuration>
Le fichier de configuration Hibernate est simple, il contient des propriétés de connexion à la base de données et des ressources de mapping Hibernate.
Utilitaire SessionFactory Hibernate
Voici la classe utilitaire pour créer une instance SessionFactory Hibernate.
package com.journaldev.hibernate.util;
import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
public class HibernateUtil {
private static SessionFactory sessionFactory;
private static SessionFactory buildSessionFactory() {
try {
// Créer la SessionFactory à partir de hibernate.cfg.xml
Configuration configuration = new Configuration();
configuration.configure("hibernate.cfg.xml");
System.out.println("Hibernate Configuration loaded");
ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).build();
System.out.println("Hibernate serviceRegistry created");
SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
return sessionFactory;
}
catch (Throwable ex) {
System.err.println("Initial SessionFactory creation failed." + ex);
ex.printStackTrace();
throw new ExceptionInInitializerError(ex);
}
}
public static SessionFactory getSessionFactory() {
if(sessionFactory == null) sessionFactory = buildSessionFactory();
return sessionFactory;
}
}
C’est tout, écrivons maintenant un programme de test pour tester la configuration XML de mappage un à un d’hibernate.
Programme de test de configuration XML de mappage un à un d’hibernate
Dans l’exemple de programme de test de mappage un à un d’hibernate, nous allons d’abord créer un objet Txn et le sauvegarder. Une fois qu’il est enregistré dans la base de données, nous utiliserons l’identifiant généré pour récupérer l’objet Txn et l’afficher.
package com.journaldev.hibernate.main;
import java.util.Date;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import com.journaldev.hibernate.model.Customer;
import com.journaldev.hibernate.model.Txn;
import com.journaldev.hibernate.util.HibernateUtil;
public class HibernateOneToOneMain {
public static void main(String[] args) {
Txn txn = buildDemoTransaction();
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try{
//Obtenir la session
sessionFactory = HibernateUtil.getSessionFactory();
session = sessionFactory.getCurrentSession();
System.out.println("Session created");
//Démarrer la transaction
tx = session.beginTransaction();
//Sauvegarder l'objet modèle
session.save(txn);
//Valider la transaction
tx.commit();
System.out.println("Transaction ID="+txn.getId());
//Obtenir les données de transaction enregistrées
printTransactionData(txn.getId(), sessionFactory);
}catch(Exception e){
System.out.println("Exception occured. "+e.getMessage());
e.printStackTrace();
}finally{
if(!sessionFactory.isClosed()){
System.out.println("Closing SessionFactory");
sessionFactory.close();
}
}
}
private static void printTransactionData(long id, SessionFactory sessionFactory) {
Session session = null;
Transaction tx = null;
try{
//Obtenir la session
sessionFactory = HibernateUtil.getSessionFactory();
session = sessionFactory.getCurrentSession();
//Démarrer la transaction
tx = session.beginTransaction();
//Sauvegarder l'objet modèle
Txn txn = (Txn) session.get(Txn.class, id);
//Valider la transaction
tx.commit();
System.out.println("Transaction Details=\n"+txn);
}catch(Exception e){
System.out.println("Exception occured. "+e.getMessage());
e.printStackTrace();
}
}
private static Txn buildDemoTransaction() {
Txn txn = new Txn();
txn.setDate(new Date());
txn.setTotal(100);
Customer cust = new Customer();
cust.setAddress("Bangalore, India");
cust.setEmail("[email protected]");
cust.setName("Pankaj Kumar");
txn.setCustomer(cust);
cust.setTxn(txn);
return txn;
}
}
Maintenant, lorsque nous exécutons le programme de test de mappage un à un d’hibernate ci-dessus, nous obtenons la sortie suivante.
Hibernate Configuration loaded
Hibernate serviceRegistry created
Session created
Hibernate: insert into TRANSACTION (txn_date, txn_total) values (?, ?)
Hibernate: insert into CUSTOMER (cust_name, cust_email, cust_address, txn_id) values (?, ?, ?, ?)
Transaction ID=19
Hibernate: select txn0_.txn_id as txn_id1_1_0_, txn0_.txn_date as txn_date2_1_0_, txn0_.txn_total as txn_tota3_1_0_,
customer1_.txn_id as txn_id1_0_1_, customer1_.cust_name as cust_nam2_0_1_, customer1_.cust_email as cust_ema3_0_1_,
customer1_.cust_address as cust_add4_0_1_ from TRANSACTION txn0_ left outer join CUSTOMER customer1_ on
txn0_.txn_id=customer1_.txn_id where txn0_.txn_id=?
Transaction Details=
19, 100.0, Pankaj Kumar, [email protected], Bangalore, India
Closing SessionFactory
Comme vous pouvez le constater, cela fonctionne bien et nous sommes en mesure de récupérer des données à partir des deux tables en utilisant l’identifiant de transaction. Vérifiez le SQL utilisé par Hibernate en interne pour obtenir les données, il utilise des jointures pour obtenir les données des deux tables.
Mappage un à un avec Hibernate par annotation
Dans la section précédente, nous avons vu comment utiliser une configuration basée sur XML pour le mappage un à un avec Hibernate, voyons maintenant comment nous pouvons utiliser JPA et les annotations Hibernate pour obtenir le même résultat.
Fichier de configuration Hibernate
hibernate-annotation.cfg.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"https://hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.password">pankaj123</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost/TestDB</property>
<property name="hibernate.connection.username">pankaj</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.current_session_context_class">thread</property>
<property name="hibernate.show_sql">true</property>
<mapping class="com.journaldev.hibernate.model.Txn1"/>
<mapping class="com.journaldev.hibernate.model.Customer1"/>
</session-factory>
</hibernate-configuration>
La configuration de Hibernate est simple, comme vous pouvez le voir, j’ai deux classes de modèle que nous utiliserons avec les annotations – Txn1 et Customer1.
Exemple de classes de modèle pour le mappage un à un avec Hibernate par annotation
Pour la configuration d’annotation de mappage Hibernate one to one, les classes modèle sont la partie la plus importante. Voyons à quoi ressemblent nos classes modèle.
package com.journaldev.hibernate.model;
import java.util.Date;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;
import org.hibernate.annotations.Cascade;
@Entity
@Table(name="TRANSACTION")
public class Txn1 {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
@Column(name="txn_id")
private long id;
@Column(name="txn_date")
private Date date;
@Column(name="txn_total")
private double total;
@OneToOne(mappedBy="txn")
@Cascade(value=org.hibernate.annotations.CascadeType.SAVE_UPDATE)
private Customer1 customer;
@Override
public String toString(){
return id+", "+total+", "+customer.getName()+", "+customer.getEmail()+", "+customer.getAddress();
}
// Méthodes Getter-Setter, omises pour des raisons de clarté
}
Remarquez que la plupart des annotations proviennent de l’API de persistance Java car Hibernate fournit sa propre implémentation. Cependant, pour la cascade, nous devrions utiliser l’annotation Hibernate org.hibernate.annotations.Cascade et l’énumération org.hibernate.annotations.CascadeType.
package com.journaldev.hibernate.model;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;
import org.hibernate.annotations.GenericGenerator;
import org.hibernate.annotations.Parameter;
@Entity
@Table(name="CUSTOMER")
public class Customer1 {
@Id
@Column(name="txn_id", unique=true, nullable=false)
@GeneratedValue(generator="gen")
@GenericGenerator(name="gen", strategy="foreign", parameters={@Parameter(name="property", value="txn")})
private long id;
@Column(name="cust_name")
private String name;
@Column(name="cust_email")
private String email;
@Column(name="cust_address")
private String address;
@OneToOne
@PrimaryKeyJoinColumn
private Txn1 txn;
// Méthodes Getter-Setter
}
Remarquez que nous devrions utiliser @GenericGenerator afin que l’identifiant soit utilisé à partir de la transaction plutôt que de le générer.
Classe utilitaire Hibernate SessionFactory
La création de la SessionFactory est indépendante de la manière dont nous fournissons le mappage Hibernate. Notre classe utilitaire pour créer la SessionFactory ressemble à ceci.
package com.journaldev.hibernate.util;
import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
public class HibernateAnnotationUtil {
private static SessionFactory sessionFactory;
private static SessionFactory buildSessionFactory() {
try {
// Créer la SessionFactory à partir de hibernate-annotation.cfg.xml
Configuration configuration = new Configuration();
configuration.configure("hibernate-annotation.cfg.xml");
System.out.println("Hibernate Annotation Configuration loaded");
ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).build();
System.out.println("Hibernate Annotation serviceRegistry created");
SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
return sessionFactory;
}
catch (Throwable ex) {
System.err.println("Initial SessionFactory creation failed." + ex);
ex.printStackTrace();
throw new ExceptionInInitializerError(ex);
}
}
public static SessionFactory getSessionFactory() {
if(sessionFactory == null) sessionFactory = buildSessionFactory();
return sessionFactory;
}
}
Exemple de programme de test Hibernate One to One Mapping Annotation
Voici un programme de test simple pour notre exemple d’annotation de mappage Hibernate one to one.
package com.journaldev.hibernate.main;
import java.util.Date;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import com.journaldev.hibernate.model.Customer1;
import com.journaldev.hibernate.model.Txn1;
import com.journaldev.hibernate.util.HibernateAnnotationUtil;
public class HibernateOneToOneAnnotationMain {
public static void main(String[] args) {
Txn1 txn = buildDemoTransaction();
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try{
//Obtenir Session
sessionFactory = HibernateAnnotationUtil.getSessionFactory();
session = sessionFactory.getCurrentSession();
System.out.println("Session created using annotations configuration");
//démarrer transaction
tx = session.beginTransaction();
//Enregistrer l'objet Modèle
session.save(txn);
//Valider la transaction
tx.commit();
System.out.println("Annotation Example. Transaction ID="+txn.getId());
//Obtenir les données de transaction enregistrées
printTransactionData(txn.getId(), sessionFactory);
}catch(Exception e){
System.out.println("Exception occured. "+e.getMessage());
e.printStackTrace();
}finally{
if(sessionFactory != null && !sessionFactory.isClosed()){
System.out.println("Closing SessionFactory");
sessionFactory.close();
}
}
}
private static void printTransactionData(long id, SessionFactory sessionFactory) {
Session session = null;
Transaction tx = null;
try{
//Obtenir Session
sessionFactory = HibernateAnnotationUtil.getSessionFactory();
session = sessionFactory.getCurrentSession();
//démarrer transaction
tx = session.beginTransaction();
//Enregistrer l'objet Modèle
Txn1 txn = (Txn1) session.get(Txn1.class, id);
//Valider la transaction
tx.commit();
System.out.println("Annotation Example. Transaction Details=\n"+txn);
}catch(Exception e){
System.out.println("Exception occured. "+e.getMessage());
e.printStackTrace();
}
}
private static Txn1 buildDemoTransaction() {
Txn1 txn = new Txn1();
txn.setDate(new Date());
txn.setTotal(100);
Customer1 cust = new Customer1();
cust.setAddress("San Jose, USA");
cust.setEmail("[email protected]");
cust.setName("Pankaj Kr");
txn.setCustomer(cust);
cust.setTxn(txn);
return txn;
}
}
Voici un extrait de la sortie lorsque nous exécutons le programme ci-dessus.
Hibernate Annotation Configuration loaded
Hibernate Annotation serviceRegistry created
Session created using annotations configuration
Hibernate: insert into TRANSACTION (txn_date, txn_total) values (?, ?)
Hibernate: insert into CUSTOMER (cust_address, cust_email, cust_name, txn_id) values (?, ?, ?, ?)
Annotation Example. Transaction ID=20
Hibernate: select txn1x0_.txn_id as txn_id1_1_0_, txn1x0_.txn_date as txn_date2_1_0_, txn1x0_.txn_total as txn_tota3_1_0_,
customer1x1_.txn_id as txn_id1_0_1_, customer1x1_.cust_address as cust_add2_0_1_, customer1x1_.cust_email as cust_ema3_0_1_,
customer1x1_.cust_name as cust_nam4_0_1_ from TRANSACTION txn1x0_ left outer join CUSTOMER customer1x1_ on
txn1x0_.txn_id=customer1x1_.txn_id where txn1x0_.txn_id=?
Annotation Example. Transaction Details=
20, 100.0, Pankaj Kr, [email protected], San Jose, USA
Closing SessionFactory
Remarquez que la sortie est similaire à la configuration XML de hibernate one to one. C’est tout pour l’exemple de mappage Hibernate One to One, vous pouvez télécharger le projet final via le lien ci-dessous et l’explorer davantage.
Source:
https://www.digitalocean.com/community/tutorials/hibernate-one-to-one-mapping-example-annotation