Hibernate关联映射（多对一 --- many-to-one）

转自：https://blog.csdn.net/fengxuezhiye/article/details/7369786?utm_source=blogxgwz9

Hibernate的关联映射关系有：
多对一 ---- many-to-one
一对多 ---- one-to-many
一对一 ---- one-to-one
多对多 ---- many-to-many

比较常用的是多对一和一对一关联映射

多对一关联映射：
场景：用户和组；从用户角度来看，多个用户属于一个组（多对一关联）
使用hibernate开发的思路：先建立对象模型，把实体抽取出来。目前两个实体：用户和组两个实体，多个用户
属于一个组，所有用户实体中应该有一个持有组的引用

对象模型图

关系模型：

关系映射的本质：

将关联关系映射到数据库，所谓的关联关系就是对象模型在内存中的一个或多个引用

User实体类：

 

[html] view plain copy

1. public class User {  
2.     private int id;  
3.     private String name;  
4.     private Group group;  
5.   
6.     public Group getGroup() {  
7.         return group;  
8.     }  
9.        public void setGroup(Group group) {  
10.         this.group = group;  
11.     }  
12.     public int getId() {  
13.         return id;  
14.     }  
15.     public void setId(int id) {  
16.         this.id = id;  
17.     }  
18.     public String getName() {  
19.         return name;  
20.     }  
21.     public void setName(String name) {  
22.         this.name = name;  
23.     }  
24. }  

Group实体类

 

[html] view plain copy

1. public class Group {  
2.     private int id;   
3.     private String name;  
4.     public int getId() {  
5.         return id;  
6.     }  
7.     public void setId(int id) {  
8.         this.id = id;  
9.     }  
10.     public String getName() {  
11.         return name;  
12.     }  
13.     public void setName(String name) {  
14.         this.name = name;  
15.     }  
16. }  

Group实体类映射文件：

 

[html] view plain copy

1. <hibernate-mapping>  
2.     <class name="com.wjt276.hibernate.Group" table="t_group">  
3.         <id name="id" column="id">  
4.             <generator class="native"/>  
5.         </id>  
6.         <property name="name"/>  
7.     </class>  
8. </hibernate-mapping>  

User实体类映射文件：

 

[html] view plain copy

1. <hibernate-mapping>  
2.     <class name="com.wjt276.hibernate.User" table="t_user">  
3.         <id name="id" column="id">  
4.             <generator class="native"/>  
5.         </id>  
6.         <property name="name"/>  
7.         <!--<many-to-one> 关联映射 多对一的关系  
8.             name:是维护的属性(User.group),这样表示在多的一端表里加入一个字段名称为group,  
9.             但group与SQL中的关键字重复，所以需要重新命名字段(column="groupid").  
10.         这样这个字段(groupid)会作为外键参照数据库中group表(t_group也叫一的一端)，也就是就在多的一  
11.             端加入一个外键指向一的一端。  
12.          -->  
13.         <many-to-one name="group" column="groupid"/>  
14.     </class>  
15. </hibernate-mapping>  

<many-to-one>标签

[html] view plain copy

1. <many-to-one name="group" column="groupid" />  

name是维护的属性(User.group),这样表示在多的一端表里加入一个字段名称为group,但group与SQL中的关键字重复，所以需要重新命名字段（column="groupid"）,这样这个字段(groupid)会被作为外键参照数据库中的group表，也就是在多的一端加入一个外键指向一的一端。

多对一的存储（先存储group,再保存user)

[html] view plain copy

1. session = HibernateUtils.getSession();  
2.             tx = session.beginTransaction();  
3.       
4.             Group group = new Group();  
5.             group.setName("wjt276");  
6.             session.save(group); //存储Group对象。  
7.               
8.             User user1 = new User();  
9.             user1.setName("菜10");  
10.             user1.setGroup(group);//设置用户所属的组  
11.               
12.             User user2 = new User();  
13.             user2.setName("容祖儿");  
14.             user2.setGroup(group);//设置用户所属的组  
15.               
16.             //开始存储  
17.             session.save(user1);//存储用户  
18.             session.save(user2);  
19.                           
20.             tx.commit();//提交事务  

注意：如果上面的session.save(group)不执行，则存储不成功。会抛出TransientObjectException异常。因为Group为Transient状，Object的id没有分配值

persistent状态的对象不能引用Transient状态的对象

以上的代码操作，必须首先保存group对象，再保存user对象。我们可以利用cascade(级联)方式，不需要先保存group对象，而是直接保存user对象，这样就可以在存储user之前先把group存储了,  利用cascade属性是解决TransientObjectException的一种手段

cascade(级联)
  级联的意思是指两个对象之间的操作联运关系，对一个对象执行了操作之后，对其指定的级联对象也需要执行相同的操作，取值：all,none,save_update,delete
  1.all:代码在所有情况下都执行级联操作
  2.none:在所有情况下都不执行级联操作
  3.save-update:在保存和更新的情况下执行级联操作
  4.delete:在删除的时候执行级联操作

[html] view plain copy

1. <many-to-one name="groupo" column="groupid" cascade="save_update" />  

多对一 加载数据

[html] view plain copy

1. session = HibernateUtils.getSession();  
2.             tx = session.beginTransaction();  
3.               
4.             User user = (User)session.load(User.class, 3);  
5.             System.out.println("user.name=" + user.getName());  
6.             System.out.println("user.group.name=" + user.getGroup().getName());  
7.           
8.             //提交事务  
9.             tx.commit();  

因为采用了<many-to-one>这个标签，这个标签会在多的一端(User)加一个外键，指向一的一端(Group),也就是它维护了从多到一的这种关系，多指向一的关系。当你加载多一端的数据时，它能把一的这一端的数据加载上来。当加载User对象后hibernate会根据User对象中的groupid再来加载Group信息给User对象中的group属性

来源：https://www.cnblogs.com/sharpest/p/7443788.html