hibernate一对多单向和双向映射

原創 曼迪--- 2020-07-03 14:58

本文转自：http://quicker.iteye.com/blog/657795

一、一对多单向关联

多对一与一对多类似
一对多映射中,只需要在一方的POJO中加入Set.
在一方的映射中加入:
<set name="students">
 <key column="class_id"></key>
 <one-to-many class="Student"/>
</set>
起到指示作用,指示在多方的表中加入一个外键.

Java代码  收藏代码
  1. Hibernate一对多单向关联映射  
  2.   
  3. 这种映射的本质是利用了多对一的关联映射的原理  
  4.   
  5. 多对一关联映射：是在多的一端添加一个外键维护多指向一的关联引用  
  6. 一对多关联映射：是在多的一端添加一个外键维护一指向多的关联引用  
  7.   
  8. 也就是说，一对多和多对一的映射策略是一致的，只是站的角度不同  
  9.   
  10. 缺点：  
  11.   * 更新student表中的classesid字段时，需要对每一个student发出一个update的sql，  
  12.     来更新classesid字段  
  13.   * 如果将t_student表中的classesis设置为非空，则不能保存student数据,因为关系是由  
  14.     classes维护的，在保存student时，还没有对应的classesid被生成     

 

 

具体示例如下:

Java代码  收藏代码
  1. package com.lwf.hibernate.pojo;  
  2.   
  3. import java.util.HashSet;  
  4. import java.util.Set;  
  5.   
  6. public class Classes {  
  7.   
  8.     private int id;  
  9.     private String name;  
  10.     private Set students = new HashSet();  
  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.     public Set getStudents() {  
  25.         return students;  
  26.     }  
  27.     public void setStudents(Set students) {  
  28.         this.students = students;  
  29.     }  
  30.       
  31. }  

 

Java代码  收藏代码
  1. package com.lwf.hibernate.pojo;  
  2.   
  3. public class Student {  
  4.   
  5.     private int id;  
  6.     private String name;  
  7.     private int age;  
  8.   
  9.       
  10.     public int getId() {  
  11.         return id;  
  12.     }  
  13.     public void setId(int id) {  
  14.         this.id = id;  
  15.     }  
  16.     public String getName() {  
  17.         return name;  
  18.     }  
  19.     public void setName(String name) {  
  20.         this.name = name;  
  21.     }  
  22.     public int getAge() {  
  23.         return age;  
  24.     }  
  25.     public void setAge(int age) {  
  26.         this.age = age;  
  27.     }  
  28.       
  29. }  

 

Classes.hbm.xml

Java代码  收藏代码
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5.     <hibernate-mapping package="com.lwf.hibernate.pojo">  
  6.       
  7.         <class name="Classes" table="t_classes">  
  8.             <id name="id">  
  9.                 <generator class="native"/>  
  10.             </id>  
  11.             <property name="name"/>  
  12.             <set name="students" >  
  13.                 <key column="class_id" ></key>  
  14.                 <one-to-many class="Student" />  
  15.             </set>  
  16.               
  17.         </class>  
  18.     </hibernate-mapping>  

 Student.hbm.xml

Java代码  收藏代码
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5.     <hibernate-mapping package="com.lwf.hibernate.pojo">  
  6.         <class name="Student" table="t_student">  
  7.             <id name="id">  
  8.                 <generator class="native"/>  
  9.             </id>  
  10.             <property name="name"/>  
  11.             <property name="age"/>  
  12.               
  13.         </class>  
  14.           
  15.     </hibernate-mapping>  

  

具体的数据库结构:

 

Java代码  收藏代码
  1. mysql> desc student;  
  2. +----------+--------------+------+-----+---------+----------------+  
  3. | Field    | Type         | Null | Key | Default | Extra          |  
  4. +----------+--------------+------+-----+---------+----------------+  
  5. | id       | int(11)      | NO   | PRI | NULL    | auto_increment |  
  6. | name     | varchar(255) | YES  |     | NULL    |                |  
  7. | class_id | int(11)      | YES  | MUL | NULL    |                |  
  8. +----------+--------------+------+-----+---------+----------------+  
  9. 3 rows in set (0.06 sec)  
  10.   
  11. mysql> desc t_class;  
  12. +-------+--------------+------+-----+---------+----------------+  
  13. | Field | Type         | Null | Key | Default | Extra          |  
  14. +-------+--------------+------+-----+---------+----------------+  
  15. | id    | int(11)      | NO   | PRI | NULL    | auto_increment |  
  16. | name  | varchar(255) | YES  |     | NULL    |                |  
  17. +-------+--------------+------+-----+---------+----------------+  

 

 测试方法：

Java代码  收藏代码
  1. package com.lwf.hibernate.test;  
  2.   
  3. import java.util.HashSet;  
  4. import java.util.Iterator;  
  5. import java.util.Set;  
  6.   
  7. import junit.framework.TestCase;  
  8.   
  9. import org.hibernate.Session;  
  10.   
  11. import com.lwf.hibernate.pojo.Classes;  
  12. import com.lwf.hibernate.pojo.Student;  
  13. import com.lwf.hibernate.util.HibernateUtil;  
  14.   
  15. public class One2Many_Test extends TestCase{  
  16.   
  17.     //从classes这一端来维护，即在单方维护，会产生insert和update语句．  
  18.     public void testClasses(){  
  19.         Session session = HibernateUtil.getSession();  
  20.         session.beginTransaction();  
  21.         try{  
  22.               
  23.             Set students = new HashSet();  
  24.             for(int i=0;i<5;i++){  
  25.                 Student s = new Student();  
  26.                 s.setName("name" + i);  
  27.                 s.setAge((10 + i));  
  28.                 students.add(s);  
  29.                 session.save(s);  
  30.             }  
  31.               
  32.               
  33.             Classes cla = new Classes();  
  34.             cla.setName("class1");  
  35.             cla.setStudents(students);  
  36.             session.save(cla);  
  37.             //先保存，最后根据class_id更新Student  
  38.               
  39.             HibernateUtil.commit(session);  
  40.         }catch(Exception e){  
  41.             HibernateUtil.roolback(session);  
  42.         }finally{  
  43.             HibernateUtil.closeSession(session);  
  44.         }  
  45.     }  
  46.       
  47.       
  48.     public void testLoad(){  
  49.         Session session = HibernateUtil.getSession();  
  50.         session.beginTransaction();  
  51.         try{  
  52.             Classes s = (Classes)session.load(Classes.class, 1);  
  53.             Set student = s.getStudents();  
  54.             for (Iterator iterator = student.iterator(); iterator.hasNext();) {  
  55.                 Student stu = (Student) iterator.next();  
  56.                 System.out.println(stu.getName());  
  57.             }  
  58.             HibernateUtil.commit(session);  
  59.         }catch(Exception e){  
  60.             HibernateUtil.roolback(session);  
  61.         }finally{  
  62.             HibernateUtil.closeSession(session);  
  63.         }  
  64.     }  
  65.       
  66.       
  67. }  

 

 

注意保存生成的语句：

Java代码  收藏代码
  1. Hibernate: insert into t_student (name, age) values (?, ?)  
  2. Hibernate: insert into t_student (name, age) values (?, ?)  
  3. Hibernate: insert into t_student (name, age) values (?, ?)  
  4. Hibernate: insert into t_student (name, age) values (?, ?)  
  5. Hibernate: insert into t_student (name, age) values (?, ?)  
  6. Hibernate: insert into t_classes (name) values (?)  
  7. Hibernate: update t_student set class_id=? where id=?  
  8. Hibernate: update t_student set class_id=? where id=?  
  9. Hibernate: update t_student set class_id=? where id=?  
  10. Hibernate: update t_student set class_id=? where id=?  
  11. Hibernate: update t_student set class_id=? where id=?  

 

先保存student，再保存classes最后根据classes的id更新student的class_id

这实际上是由classes这方来维护两者的关联关系．

正常情况下关系应该由多的一方来维护，在双向关联中我们从多方来维护两者的关系．这样就可以避免update语句的出现．而是直接insert即可．

 

二、一对多双向关联

 

下面我们看看双向的一对多映射，实际上就是把一对多与多对一结合起来看．

Java代码  收藏代码
  1. Hibernate 一对多双向关联映射  
  2.   
  3. 一对多双向关联映射的方法：  
  4.   
  5. 在一一端：  
  6. 在集合标签里面使用<key>标签来表明需要在对方的表中添加一个外键指向一一端。  
  7.   
  8. 在多一端：  
  9. 使用<many-to-one>标签来映射。  
  10.   
  11. 需要注意：<key>标签所指定的外键字段名需要与<many-to-one>标签定义的外键字段名一致，否则便会造成引用数据的  
  12. 丢失!  
  13.   
  14. --------------------------------------------------------------------------------------  
  15. 如果从一端来维护一对多双向关联的关系，hibernate会发出多余的update语句，所以  
  16. 一般地情况下，我们便会从多一端来维护其关联关系！  
  17. －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－  

  

 

 在单向映射的基础上加上多对一关联即可．更改的文件：

Java代码  收藏代码
  1. package com.lwf.hibernate.pojo;  
  2.   
  3. public class Student {  
  4.   
  5.     private int id;  
  6.     private String name;  
  7.     private int age;  
  8.     private Classes classes;  
  9.       
  10.     public int getId() {  
  11.         return id;  
  12.     }  
  13.     public void setId(int id) {  
  14.         this.id = id;  
  15.     }  
  16.     public String getName() {  
  17.         return name;  
  18.     }  
  19.     public void setName(String name) {  
  20.         this.name = name;  
  21.     }  
  22.     public int getAge() {  
  23.         return age;  
  24.     }  
  25.     public void setAge(int age) {  
  26.         this.age = age;  
  27.     }  
  28.     public Classes getClasses() {  
  29.         return classes;  
  30.     }  
  31.     public void setClasses(Classes classes) {  
  32.         this.classes = classes;  
  33.     }  
  34.       
  35. }  

 

Student.hbm.xml

Java代码  收藏代码
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5.     <hibernate-mapping package="com.lwf.hibernate.pojo">  
  6.         <class name="Student" table="t_student">  
  7.             <id name="id">  
  8.                 <generator class="native"/>  
  9.             </id>  
  10.             <property name="name"/>  
  11.             <property name="age"/>  
  12.             <many-to-one name="classes" column="class_id"></many-to-one>  
  13.         </class>  
  14.           
  15.     </hibernate-mapping>  

 

即从Student的角度就是多对一，而从Classes角度就是一对多．

此时的表结构与单向的时候是一样的．

Java代码  收藏代码
  1. package com.lwf.hibernate.test;  
  2.   
  3. import java.util.HashSet;  
  4. import java.util.Iterator;  
  5. import java.util.Set;  
  6.   
  7. import junit.framework.TestCase;  
  8.   
  9. import org.hibernate.Session;  
  10.   
  11. import com.lwf.hibernate.pojo.Classes;  
  12. import com.lwf.hibernate.pojo.Student;  
  13. import com.lwf.hibernate.util.HibernateUtil;  
  14.   
  15. public class One2Many_Test extends TestCase{  
  16.   
  17.     //从classes这一端来维护，即在单方维护，会产生insert和update语句．  
  18.     public void testClasses(){  
  19.         Session session = HibernateUtil.getSession();  
  20.         session.beginTransaction();  
  21.         try{  
  22.               
  23.             Set students = new HashSet();  
  24.             for(int i=0;i<5;i++){  
  25.                 Student s = new Student();  
  26.                 s.setName("name" + i);  
  27.                 s.setAge((10 + i));  
  28.                 students.add(s);  
  29.                 session.save(s);  
  30.             }  
  31.               
  32.               
  33.             Classes cla = new Classes();  
  34.             cla.setName("class1");  
  35.             cla.setStudents(students);  
  36.             session.save(cla);  
  37.             //先保存，最后根据class_id更新Student  
  38.               
  39.             HibernateUtil.commit(session);  
  40.         }catch(Exception e){  
  41.             HibernateUtil.roolback(session);  
  42.         }finally{  
  43.             HibernateUtil.closeSession(session);  
  44.         }  
  45.     }  
  46.       
  47.       
  48.     //由于配置了双向关联，所以下面先保存了classes再保存student只有insert语句，没有update语句  
  49.     public void testStudent(){  
  50.         Session session = HibernateUtil.getSession();  
  51.         session.beginTransaction();  
  52.         try{  
  53.             Classes cla = new Classes();  
  54.             cla.setName("class111");  
  55.             session.save(cla);  
  56.             for (int i = 0; i < 5; i++) {  
  57.                 Student s  = new Student();  
  58.                 s.setName("name111"+i);  
  59.                 s.setClasses(cla);  
  60.                 session.save(s);  
  61.             }  
  62.             HibernateUtil.commit(session);  
  63.         }catch(Exception e){  
  64.             HibernateUtil.roolback(session);  
  65.         }finally{  
  66.             HibernateUtil.closeSession(session);  
  67.         }  
  68.               
  69.     }  
  70.       
  71.     //从classes得到student，主要测试单向关联  
  72.     public void testLoadClass(){  
  73.         Session session = HibernateUtil.getSession();  
  74.         session.beginTransaction();  
  75.         try{  
  76.             Classes s = (Classes)session.load(Classes.class, 1);  
  77.             Set student = s.getStudents();  
  78.             for (Iterator iterator = student.iterator(); iterator.hasNext();) {  
  79.                 Student stu = (Student) iterator.next();  
  80.                 System.out.println(stu.getName());  
  81.             }  
  82.             HibernateUtil.commit(session);  
  83.         }catch(Exception e){  
  84.             HibernateUtil.roolback(session);  
  85.         }finally{  
  86.             HibernateUtil.closeSession(session);  
  87.         }  
  88.     }  
  89.       
  90.     //从student得到classes，配置了双向关联后的测试  
  91.     public void testLoadStudent(){  
  92.         Session session = HibernateUtil.getSession();  
  93.         session.beginTransaction();  
  94.         try{  
  95.             Student s = (Student)session.load(Student.class, 1);  
  96.             System.out.println(s.getName());  
  97.             System.out.println(s.getClasses().getName());  
  98.             HibernateUtil.commit(session);  
  99.         }catch(Exception e){  
  100.             HibernateUtil.roolback(session);  
  101.         }finally{  
  102.             HibernateUtil.closeSession(session);  
  103.         }  
  104.     }  
  105.       
  106.       
  107. }  

主要区别：

由于配置了双向关联，所以下面先保存了classes再保存student只有insert语句，没有update语句

以下是testStudent方法产生的ＳＱＬ语句

Java代码  收藏代码
  1. Hibernate: insert into t_classes (name) values (?)  
  2. Hibernate: insert into t_student (name, age, class_id) values (?, ?, ?)  
  3. Hibernate: insert into t_student (name, age, class_id) values (?, ?, ?)  
  4. Hibernate: insert into t_student (name, age, class_id) values (?, ?, ?)  
  5. Hibernate: insert into t_student (name, age, class_id) values (?, ?, ?)  
  6. Hibernate: insert into t_student (name, age, class_id) values (?, ?, ?)  

 

 

 

三、下面讨论一下关于ＩＮＶＥＲＳＥ的用法：

Java代码  收藏代码
  1. 关于inverse属性：  
  2. inverse属性可以被设置到集合标签<set>上，表示在存储双向一对多关联映射的时候，  
  3. 存储的是那一方的关联引用。默认情况下，inverse＝“false”，所以，我们可以从一一端  
  4. 或者多一端来维护两者之间的关系；如果我们设置inverse＝“true”，则只能通过多一端来  
  5. 维护两者之间的关系。inverse属性可以被用在一对多和多对多双向关联中;  
  6.   
  7. 注意:inverse属性只是在将数据持久化到数据库的过程中发挥作用.  

 

主要看看上面双向关联中testClasses方法，当classes.hbm.xml文件如下时

Java代码  收藏代码
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5.     <hibernate-mapping package="com.lwf.hibernate.pojo">  
  6.       
  7.         <class name="Classes" table="t_classes">  
  8.             <id name="id">  
  9.                 <generator class="native"/>  
  10.             </id>  
  11.             <property name="name"/>  
  12.             <set name="students" >  
  13.                 <key column="class_id" ></key>  
  14.                 <one-to-many class="Student" />  
  15.             </set>  
  16.               
  17.         </class>  
  18.     </hibernate-mapping>  

 我们知道上面的testClasses方法产生的sql语句是先insert再update，上面已经讲到是从一方来维护关联关系的．那么现在我们把classes.hbm.xml的set上面增加inverse="true"即

Java代码  收藏代码
  1. <set name="students" inverse="true">  
  2.     <key column="class_id" ></key>  
  3.     <one-to-many class="Student" />  
  4. </set>  
  5.               

 那么这时候testClasses方法产生的ＳＱＬ语句是？

Java代码  收藏代码
  1. Hibernate: insert into t_student (name, age, class_id) values (?, ?, ?)  
  2. Hibernate: insert into t_student (name, age, class_id) values (?, ?, ?)  
  3. Hibernate: insert into t_student (name, age, class_id) values (?, ?, ?)  
  4. Hibernate: insert into t_student (name, age, class_id) values (?, ?, ?)  
  5. Hibernate: insert into t_student (name, age, class_id) values (?, ?, ?)  
  6. Hibernate: insert into t_classes (name) values (?)  

 

虽然只产生了insert语句，但因为t_classes插入语句在后，所以数据库里面对应的t_student的记录：

Java代码  收藏代码
  1. mysql> select * from t_student;  
  2. +----+-------+------+----------+  
  3. | id | name  | age  | class_id |  
  4. +----+-------+------+----------+  
  5. |  1 | name0 |   10 |     NULL |  
  6. |  2 | name1 |   11 |     NULL |  
  7. |  3 | name2 |   12 |     NULL |  
  8. |  4 | name3 |   13 |     NULL |  
  9. |  5 | name4 |   14 |     NULL |  
  10. +----+-------+------+----------+  

 显然class_id为空．没有更新．

即用了ＩＮＶＥＲＳＥ，将强制要求从多的一方来维护关系．即当设置了ＩＮＶＥＲＳＥ属性后，要求使用testStudent方法来做保存．

而ＩＮＶＥＲＳＥ属性没有设置时，对于双向的一对多关联，我们即可以使用testClasses又可以使用testStudent方法进行保存，但是他们的区别是testClasses操作中有insert和update语句，而testStudent只有insert语句．显然使用testStudent即从多方来维护关联关系节约了资源．．．

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

hibernate映射文件中的fetch 和 lazy 属性配置

fetch 和 lazy 配置用於數據的查詢 lazy 參數值常見有 false 和 true，Hibernate3 映射文件中默認lazy = true ； fetch 指定了關聯對象抓取的方式，參數值常見是select和join，默認

lpch0825 2020-06-27 20:25:19

hibernate单向N-N关系映射

覆水难收。 2020-02-23 01:37:56

hibernate单向1-1无表连接级联

覆水难收。 2020-02-23 01:37:45

Hibernate 映射基础

麒麟木木 2020-02-21 09:09:54

hibernate之映射关系一对一（2种方式）

e生态_修身 2020-02-21 00:45:57

hibernate3.6映射，取当前时间，设置默认值等

sqlife_cn 2020-02-20 20:41:17

hibernate映射文件中的fetch 和 lazy 属性配置

fetch 和 lazy 配置用於數據的查詢 lazy 參數值常見有 false 和 true，Hibernate3 映射文件中默認lazy = true ； fetch 指定了關聯對象抓取的方式，參數值常見是select和join，默認

lpch0825 2020-06-27 20:25:19

hibernate单向N-N关系映射

覆水难收。 2020-02-23 01:37:56

hibernate单向1-1无表连接级联

覆水难收。 2020-02-23 01:37:45

Hibernate 映射基础

麒麟木木 2020-02-21 09:09:54

hibernate之映射关系一对一（2种方式）

e生态_修身 2020-02-21 00:45:57

hibernate3.6映射，取当前时间，设置默认值等

sqlife_cn 2020-02-20 20:41:17

HIBERNATE的映射类型【转】

IT_small_bird 2018-09-06 01:05:36

hibernate 一对多，多对一 mappedBy用法详解

吕佳瑞 2018-09-01 21:45:34