hibernate一对多单向和双向映射配置实例源码说明

hibernate一对多单向和双向映射配置实例源码说明，一对多单向和双向映射。

一、hibernate一对多单向关联

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

Java代码  收藏代码
  1. Hibernate一对多单向关联映射
  3. hibernate这种映射的本质是利用了多对一的关联映射的原理
  5. 多对一关联映射：是在多的一端添加一个外键维护多指向一的关联引用
  6. 一对多关联映射：是在多的一端添加一个外键维护一指向多的关联引用
  8. 一对多和多对一的映射策略是一致的，只是站的角度不同
  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;
  3. import java.util.HashSet;
  4. import java.util.Set;
  6. public class Classes {
  8.     private int id;
  9.     private String name;
  10.     private Set students = new HashSet();
  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.     }
  31. }

 

Java代码  收藏代码
  1. package com.lwf.hibernate.pojo;
  3. public class Student {
  5.     private int id;
  6.     private String name;
  7.     private int age;
  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.     }
  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”>
  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>
  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”/>
  13.         </class>
  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)
  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;
  3. import java.util.HashSet;
  4. import java.util.Iterator;
  5. import java.util.Set;
  7. import junit.framework.TestCase;
  9. import org.hibernate.Session;
  11. import com.lwf.hibernate.pojo.Classes;
  12. import com.lwf.hibernate.pojo.Student;
  13. import com.lwf.hibernate.util.HibernateUtil;
  15. public class One2Many_Test extends TestCase{
  17.     //从classes这一端来维护，即在单方维护，会产生insert和update语句．
  18.     public void testClasses(){
  19.         Session session = HibernateUtil.getSession();
  20.         session.beginTransaction();
  21.         try{
  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.             }
  33.             Classes cla = new Classes();
  34.             cla.setName(“class1″);
  35.             cla.setStudents(students);
  36.             session.save(cla);
  37.             //先保存，最后根据class_id更新Student
  39.             HibernateUtil.commit(session);
  40.         }catch(Exception e){
  41.             HibernateUtil.roolback(session);
  42.         }finally{
  43.             HibernateUtil.closeSession(session);
  44.         }
  45.     }
  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.     }
  67. }

 

注意保存生成的hibernate语句：

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

 

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

Java代码  收藏代码
  1. package com.lwf.hibernate.pojo;
  3. public class Student {
  5.     private int id;
  6.     private String name;
  7.     private int age;
  8.     private Classes classes;
  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.     }
  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>
  15.     </hibernate-mapping>

 

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

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

Java代码  收藏代码
  1. package com.lwf.hibernate.test;
  3. import java.util.HashSet;
  4. import java.util.Iterator;
  5. import java.util.Set;
  7. import junit.framework.TestCase;
  9. import org.hibernate.Session;
  11. import com.lwf.hibernate.pojo.Classes;
  12. import com.lwf.hibernate.pojo.Student;
  13. import com.lwf.hibernate.util.HibernateUtil;
  15. public class One2Many_Test extends TestCase{
  17.     //从classes这一端来维护，即在单方维护，会产生insert和update语句．
  18.     public void testClasses(){
  19.         Session session = HibernateUtil.getSession();
  20.         session.beginTransaction();
  21.         try{
  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.             }
  33.             Classes cla = new Classes();
  34.             cla.setName(“class1″);
  35.             cla.setStudents(students);
  36.             session.save(cla);
  37.             //先保存，最后根据class_id更新Student
  39.             HibernateUtil.commit(session);
  40.         }catch(Exception e){
  41.             HibernateUtil.roolback(session);
  42.         }finally{
  43.             HibernateUtil.closeSession(session);
  44.         }
  45.     }
  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.         }
  69.     }
  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.     }
  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.     }
  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属性可以被用在一对多和多对多双向关联中;
  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”>
  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>
  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>

那么这时候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一对多单向和双向映射配置实例源码说明

Related posts:

  1. hibernate联合主键的创建方法实例
  2. hibernate联合主键的创建方法实例源码
  3. Hibernate一对多单向配置详细说明实例教程inverse属性用法
  4. Hibernate Annotation配置多对一双向关联实例说明
  5. hibernate3 二级缓存的实现实例源码讲解
  6. Mysql数据库操作的常用命令有哪些 总结
  7. insert语句：插入数据命令SQL
  8. java网站如何统计访问量和在线人数实例源码