Hibernate的七种映射关系

　　这7中关系是：

• 单向一对一 
• 单向一对多 
• 单向多对一 
• 单向多对多 
• 双向一对一 
• 双向一对多 （双向多对一）
• 双向多对多

1. 单向一对一关联映射（one-to-one）

两个对象之间一对的关系，例如：Person（人）-IdCard（身份证） 。有两种策略可以实现一对一的关联映射： 

（1）主键关联：即让两个对象具有相同的主键值，以表明它们之间的一一对应的关系；数据库表不会有额外的字段来维护它们之间的关系，仅通过表的主键来关联。如下图：

 代码示例如下。

// IdCard.java类
public class IdCard { 
　　private int id; 
　　private String cardNo; 
　　public int getId() { 
　　　　return id; 
　　} 
　　public void setId(int id) { 
　　　　this.id = id; 
　　} 
　　public String getCardNo() { 
　　　　return cardNo; 
　　} 
　　public void setCardNo(String cardNo) { 
　　　　this.cardNo = cardNo; 
　　} 
} 
// Person.java类
public class Person { 
　　private int id; 
　　private String name; 
　　private IdCard idCard; 
　　public int getId() { 
　　　　return id; 
　　}
　　public void setId(int id) { 
　　　　this.id = id; 
　　} 
　　public String getName() { 
　　　　return name; 
　　} 
　　public void setName(String name) { 
　　　　this.name = name; 
　　} 
　　public IdCard getIdCard() { 
　　　　return idCard; 
　　} 
　　public void setIdCard(IdCard idCard) { 
　　　　this.idCard = idCard; 
　　} 
} 

IdCard.hbm.xml映射文件

<?xml version="1.0"?> 
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN" 
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 
<hibernate-mapping> 
　　<class name="com.hibernate.IdCard" table="t_idCard"> 
　　　　<id name="id"> 
　　　　　　<generator class="native"> 
　　　　　　</generator> 
　　　　</id> 
　　　　<property name="cardNo"/> 
　　</class> 
</hibernate-mapping> 

Person.hbm.xml映射文件

<?xml version="1.0"?> 
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN" 
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 
<hibernate-mapping> 
　　<class name="com.hibernate.Person" table="t_person"> 
　　　　<id name="id"> 
　　　　　　<!-- 采用foreign生成策略，foreign会取得关联对象的标识 --> 
　　　　　　<generator class="foreign"> 
　　　　　　　　<!-- property只关联对象 --> 
　　　　　　　　<param name="property">idCard</param> 
　　　　　　</generator> 
　　　　</id> 
　　　　<property name="name"/> 
　　　　<!-- one-to-one指示hibernate如何加载其关联对象，默认根据主键加载也就是拿到关系字段值，根据对端的主键来加载关联对象--> 
　　　　<one-to-one name="idCard" constrained="true"/> 
　　</class> 
</hibernate-mapping> 

hibernate.cfg.xml配置文件

<!DOCTYPE hibernate-configuration PUBLIC 
"-//Hibernate/Hibernate Configuration DTD 3.0//EN" 
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> 

<hibernate-configuration> 
　　<session-factory> 
　　　　<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> 
　　　　<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_one2one_pk_1</property> 
　　　　<property name="hibernate.connection.username">root</property> 
　　　　<property name="hibernate.connection.password">root</property> 
　　　　<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> 
　　　　<property name="hibernate.show_sql">true</property> 

　　　　<mapping resource="com/hibernate/Person.hbm.xml"/> 
　　　　<mapping resource="com/hibernate/IdCard.hbm.xml"/> 
　　</session-factory> 
</hibernate-configuration> 

One2OneTest.java测试类

public void testSave1(){ 
　　Session session = null; 
　　try{ 
　　　　session = HibernateUtils.getSession(); 
　　　　session.beginTransaction(); 

　　　　IdCard idCard = new IdCard(); 
　　　　idCard.setCardNo("1111111111111111111"); 

　　　　Person person = new Person(); 
　　　　person.setName("张三"); 
　　　　//建立关联 
　　　　person.setIdCard(idCard); 

　　　　//没有抛出TransientObjectException 
　　　　//是由一对一关联映射的特性决定的，它必须先保存关联对象IdCard 
　　　　//这样它采用foreign映射策略才能取得关联对象的标识 
　　　　//也就是它默认了cascade属性 
　　　　session.save(person); 

　　　　session.getTransaction().commit(); 
　　}catch(Exception e){ 
　　　　e.printStackTrace(); 
　　　　session.getTransaction().rollback(); 
　　}finally{ 
　　　　HibernateUtils.closeSession(session); 
　　} 
}

测试结果（发出的sql语句）：

Hibernate: insert into t_idCard (cardNo) values (?) 
Hibernate: insert into t_person (name, id) values (?, ?)

（2）唯一外键关联：外键关联，本来是用于多对一的配置，但是加上唯一的限制之后（采用<many-to-one>标签来映射，指定多的一端unique为true，这样就限制了多的一端的多重性为一），也可以用来表示一对一关联关系，其实它就是多对一的特殊情况。如下图：

 

// IdCard.java类
public class IdCard { 
　　private int id; 
　　private String cardNo; 
　　public int getId() { 
　　　　return id; 
　　} 
　　public void setId(int id) { 
　　　　this.id = id; 
　　} 

　　public String getCardNo() { 
　　　　return cardNo; 
　　} 

　　public void setCardNo(String cardNo) { 
　　　　this.cardNo = cardNo; 
　　} 
} 

// Person.java类
public class Person { 
　　private int id; 
　　private String name; 
　　private IdCard idCard; 
　　public int getId() { 
　　　　return id; 
　　} 
　　public void setId(int id) { 
　　　　this.id = id; 
　　} 
　　public String getName() { 
　　　　return name; 
　　} 
　　public void setName(String name) { 
　　　　this.name = name; 
　　} 
　　public IdCard getIdCard() { 
　　　　return idCard; 
　　} 
　　public void setIdCard(IdCard idCard) { 
　　　　this.idCard = idCard; 
　　} 
} 

IdCard.hbm.xml映射文件

<?xml version="1.0"?> 
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN" 
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 
<hibernate-mapping> 
　　<class name="com.hibernate.IdCard" table="t_idCard"> 
　　　　<id name="id"> 
　　　　　　<generator class="native"> 
　　　　　　</generator> 
　　　　</id> 
　　　　<property name="cardNo"/> 
　　</class> 
</hibernate-mapping> 

Person.hbm.xml映射文件

<?xml version="1.0"?> 
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN" 
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 
<hibernate-mapping> 
　　<class name="com.bjpowernode.hibernate.Person" table="t_person"> 
　　　　<id name="id"> 
　　　　　　<generator class="native"> 
　　　　　　　　<!-- property只关联对象 --> 
　　　　　　　　<param name="property">idCard</param> 
　　　　　　</generator> 
　　　　</id> 
　　　　<property name="name"/> 
　　　　<many-to-one name="idCard" unique="true"/> 
　　</class> 
</hibernate-mapping> 

hibernate.cfg.xml配置文件

<!DOCTYPE hibernate-configuration PUBLIC 
"-//Hibernate/Hibernate Configuration DTD 3.0//EN" 
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> 
<hibernate-configuration> 
　　<session-factory> 
　　　　<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> 
　　　　<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_one2one_ufk</property> 
　　　　<property name="hibernate.connection.username">root</property> 
　　　　<property name="hibernate.connection.password">root</property> 
　　　　<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> 
　　　　<property name="hibernate.show_sql">true</property> 

　　　　<mapping resource="com/hibernate/Person.hbm.xml"/> 
　　　　<mapping resource="com/hibernate/IdCard.hbm.xml"/> 
　　</session-factory> 
</hibernate-configuration> 

One2OneTest.java测试类

public void testSave1(){ 
　　Session session = null; 
　　try{ 
　　　　session = HibernateUtils.getSession(); 
　　　　session.beginTransaction(); 

　　　　IdCard idCard = new IdCard(); 
　　　　idCard.setCardNo("1111111111111111111"); 
　　　　session.save(idCard); 

　　　　Person person = new Person(); 
　　　　person.setName("张三"); 
　　　　person.setIdCard(idCard); 

　　　　session.save(person); 

　　　　session.getTransaction().commit(); 
　　}catch(Exception e){ 
　　　　e.printStackTrace(); 
　　　　session.getTransaction().rollback(); 
　　}finally{ 
　　　　HibernateUtils.closeSession(session); 
　　} 
}

测试结果（发出的sql语句）：

Hibernate: insert into t_idCard (cardNo) values (?) 
Hibernate: insert into t_person (name, idCard) values (?, ?) 

注意：因为一对一的主键关联映射扩展性不好，当我们的需要发生改变想要将其变为一对多的时候变无法操作了，所以我们遇到一对一关联的时候经常会采用唯一外键关联来解决问题，而很少使用一对一主键关联。

2. 单向多对一关联映射（many-to-one）

多对一关联映射原理：在多的一端加入一个外键，指向一的一端，如下图：

在多的一端加入如下标签映射：<many-to-one name="group" column="groupid"/>

3. 单向一对多关联映射（one-to-many）

一对多关联映射和多对一关联映射原理是一致的，都是在多的一端加入一个外键，指向一的一端。如下图（学生和班级）：

注意：它与多对一的区别是维护的关系不同

多对一维护的关系是：多指向一的关系，有了此关系，加载多的时候可以将一加载上来。

一对多维护的关系是：一指向多的关系，有了此关系，在加载一的时候可以将多加载上来 。

简单说，一对多由一来维护关系，多对一由多维护关系。在一的一端加入如下标签映射：

<set name="students"> 
　　<key column="classesid"/> 
　　<one-to-many class="com.hibernate.Student"/> 
</set> 

缺陷：因为多的一端Student不知道Classes的存在（也就是Student没有维护与Classes的关系）所以在保存Student的时候关系字段classesid是为null的，如果将该关系字段设置为非空，则将无法保存数据，常用解决办法是改用双向关联映射，参见6。

4. 单向多对多映射（many-to-many）

多对多关联映射新增加一张表才完成基本映射，如下图：

 可以在User的一端加入如下标签映射：

<set name="roles" table="t_user_role"> 
　　<key column="user_id"/> 
　　<many-to-many class="com.hibernate.Role" column="role_id"/> 
</set>

5. 双向一对一关联映射

对比单向一对一映射，需要在IdCard加入<one-to-one>标签，它不影响，只影响加载。如下图：

双向一对一主键映射关键映射代码——在IdCard端新加入如下标签映射：<one-to-one name="person"/>。

双向一对一唯一外键映射关键映射代码——在IdCard端新加入如下标签映射：<one-to-one name="person" property-ref="idCard"/> 。

注意：一对一唯一外键关联双向采用<one-to-one>标签映射，必须指定<one-to-one>标签中的property-ref属性为关系字段的名称 。

6. 双向一对多关联映射（非常重要）

采用一对多双向关联映射的目的主要是为了主要是为了解决一对多单向关联的缺陷而不是需求驱动的。 

一对多双向关联的映射方式：

• 在一的一端的集合上采用<key>标签，在多的一端加入一个外键
• 在多的一端采用<many-to-one>标签 

注意：<key>标签和<many-to-one>标签加入的字段保持一直，否则会产生数据混乱。

关键映射代码：

在Classes的一端加入如下标签映射：

<set name="students"inverse="true"> 
　　<key column="classesid"/> 
　　<one-to-many class="com.hibernate.Student"/> 
</set> 

 在Student的一端加入如下标签映射： 

<many-to-one name="classes" column="classesid"/>

注释：inverse属性

inverse属性可以用在一对多和多对多双向关联上，inverse属性默认为false，为false表示本端可以维护关系，如果inverse为true，则本端不能维护关系，会交给另一端维护关系，本端失效。所以一对多关联映射我们通常在多的一端维护关系，让一的一端失效。 inverse是控制方向上的反转，只影响存储 。

7. 双向多对多关联映射

双向的目的就是为了两端都能将对方加载上来，和单向多对多的区别就是双向需要在两端都加入标签映射，需要注意的是： 

• 生成的中间表名称必须一样 
• 生成的中间表中的字段必须一样 

Role（角色）端关键映射代码：

<set name="users" table="t_user_role"> 
　　<key column="role_id"/> 
　　<many-to-many class="com.hibernate.User" column="user_id"/> 
<set> 

User（用户）端关键映射代码：

<set name="roles" table="t_user_role"> 
　　<key column="user_id"/> 
　　<many-to-many class="com. hibernate.Role" column="role_id"/> 
<set> 

总结：对于上面这七种关联映射中，最重要的就是一对多的映射，因为它更贴近我们的现实生活，比如：教室和学生就可以是典型的一对多的关系等。

---