上回 说了 Hibernate中的单向一对多关联 和 Hibernate中的单向多对一关联。这次针对这两个“单向”进行整合即可实现双向的多对一关联。如：学生与班级的关系。
在Grade类中需要添加 Set集合保存Student对象，并且在Grade.hbm.xml的映射配置文件中，针对Set集合添加如下配置：
<span style="font-size:18px;"><span style="font-size:18px;"><!-- 配置单向的一对多关联关系 -->
<set name="students" table="student">
<!-- 指定关联的外键列 -->
<key column="gid"></key>
<one-to-many class="com.imooc.entity.Student"/>
</set></span></span>
这是针对 班级对学生 的关联关系，即单向一对多的关联关系。
在Student类中需要添加 Grade 对象属性，并且在 Student.hbm.xml的映射配置文件中，针对Grade对象添加如下配置：
<span style="font-size:18px;"><span style="font-size:18px;"><!-- 配置多对一关联关系 -->
<many-to-one name="grade" class="com.imooc.entity.Grade" column="gid"></many-to-one></span></span>
这是针对 学生对班级 的关联关系，即单向多对一的关联关系。
整合两种单向的同时，还需要在程序中实现双向才可以。
如： Test.java 修改为：
<span style="font-size:18px;"><span style="font-size:18px;">package com.imooc.test;
/**
* Created by DreamBoy on 2016/5/18.
*/
import com.imooc.entity.Grade;
import com.imooc.entity.Student;
import com.imooc.util.HibernateUtil;
import org.hibernate.Session;
import org.hibernate.Transaction;
import java.util.Set;
/**
* //单向多对一（学生---》班级）
* 双向多对一
*/
public class Test {
public static void main(String[] args) {
save();
}
//保存
public static void save() {
Grade g = new Grade("Java一班", "Java软件开发一班");
Student stu1 = new Student("哈", "女");
Student stu2 = new Student("哇", "男");
//设置关联关系，指定多到一的关联关系
stu1.setGrade(g);
stu2.setGrade(g);
//设置关联关系，指定一到多的关联关系
g.getStudents().add(stu1);
g.getStudents().add(stu2);
Session session = HibernateUtil.getSession();
Transaction tx = session.beginTransaction();
session.save(g);
session.save(stu1);
session.save(stu2);
tx.commit();
HibernateUtil.closeSession(session);
}
}</span><span style="font-size:18px;">
</span></span>
运行结果如下：
从运行结果来看，我们发现 在insert 完两条Student数据后，Student数据就已经含有对应班级的值了，可是却还是同样会有 update 语句再一次对Student数据的班级gid字段进行更新。从性能上看，影响的系统性能。
那么update语句是在哪里产生的呢？按照程序顺序执行的特点来看，update 语句应该源于以下语句：
<span style="font-size:18px;"><span style="font-size:18px;">//设置关联关系，指定一到多的关联关系
g.getStudents().add(stu1);
g.getStudents().add(stu2);</span></span>
即设置 班级到学生 关联关系的时候。
这是为什么呢？
原因在于 Grade.hbm.xml 配置文件中设置的 set 节点有一个inverse属性，而这个inverse属性默认值为false。那这个inverse属性有什么用呢？
<set>节点的inverse 属性指定关联关系的控制方向，那么当 inverse 为false，表示的是 这种关联关系由 one 方来维护（一方来维护）；当 inverse 为tue，表示的是这种关联关系由 many 方来维护（多方来维护）。（“维护”的含义我们可以简单地理解为：需要保证many方与one方的关联，如会使用update来维护关系，不管是否已经建立了关联。）
inverse属性 从英文意思来看，是“相反的”的意思。那么我们也可以简单地理解为 inverse = true 表示要反转的，即关联关系由多方维护；invere = false 表示不反转，即关联关系由一方维护。（默认由一方维护）
在一对多关联（需要是双向的）中，设置 one 方的inverse 为true，这将有助于性能的改善。
那么设置 inverse 属性为true后：
Grade.hbm.xml
<span style="font-size:18px;"><?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.imooc.entity.Grade" table="grade">
<id name="gid" column="gid" type="java.lang.Integer">
<generator class="increment"/>
</id>
<property name="gname" type="java.lang.String">
<column name="gname" length="20" not-null="true"/>
</property>
<property name="gdesc">
<column name="gdesc"/>
</property>
<!-- 配置单向的一对多关联关系，设置inverse属性为true，由多方维护关联关系 -->
<set name="students" table="student" inverse="true">
<!-- 指定关联的外键列 -->
<key column="gid"></key>
<one-to-many class="com.imooc.entity.Student"/>
</set>
</class>
</hibernate-mapping></span>
运行结果如下：
现在就 没有因为 one方（一方）需要维护关联关系而出现的 update 语句了。同时还保证了 一方与多方 的关联关系。
这里同样还有一个问题，当 Grade 对象进行保存的时候，我们还需要进行显式地保存学生对象吗？答案当然是否定的，因为 Grade 对象具有保存学生对象的Set集合属性，Grade对象知道它所拥有的学生对象，所以在保存Grade对象时，Grade对象应该可以关联到它所包含的学生对象，对于数据库中没有的学生对象数据就进行隐式地保存。但是前提需要我们在 Grade.hbm.xml 映射配置文件中 的set节点 设置 cascade 属性，用于级联操作。
当设置了cascade属性不为none 时，Hibernate 会自动持久化所关联的对象。cascade属性的设置会带来性能上的变动，需谨慎设置。
| 属性值 | 含义和作用 |
| all | 对所有操作进行级联操作 |
| save-update | 执行保存和更新操作时进行级联操作 |
| delete | 执行删除操作时进行级联操作 |
| none | 对所有操作不进行级联操作 |
在Grade.hbm.xml设置级联操作：
<span style="font-size:18px;"><?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.imooc.entity.Grade" table="grade">
<id name="gid" column="gid" type="java.lang.Integer">
<generator class="increment"/>
</id>
<property name="gname" type="java.lang.String">
<column name="gname" length="20" not-null="true"/>
</property>
<property name="gdesc">
<column name="gdesc"/>
</property>
<!-- 配置单向的一对多关联关系，设置inverse属性为true，由多方维护关联关系；
设置cascade属性，当进行保存和更新时级联操作所关联的对象-->
<set name="students" table="student" inverse="true" cascade="save-update">
<!-- 指定关联的外键列 -->
<key column="gid"></key>
<one-to-many class="com.imooc.entity.Student"/>
</set>
</class>
</hibernate-mapping></span>
对测试 Test.java 进行修改（可以不用显式地保存学生对象了）：
<span style="font-size:18px;">package com.imooc.test;
/**
* Created by DreamBoy on 2016/5/18.
*/
import com.imooc.entity.Grade;
import com.imooc.entity.Student;
import com.imooc.util.HibernateUtil;
import org.hibernate.Session;
import org.hibernate.Transaction;
import java.util.Set;
/**
* //单向多对一（学生---》班级）
* 双向多对一
*/
public class Test {
public static void main(String[] args) {
save();
}
//保存
public static void save() {
Grade g = new Grade("Java一班", "Java软件开发一班");
Student stu1 = new Student("哈", "女");
Student stu2 = new Student("哇", "男");
//设置关联关系，指定多到一的关联关系
stu1.setGrade(g);
stu2.setGrade(g);
//设置关联关系，指定一到多的关联关系
g.getStudents().add(stu1);
g.getStudents().add(stu2);
Session session = HibernateUtil.getSession();
Transaction tx = session.beginTransaction();
session.save(g);
//设置级联操作后，可以不用显式地保存学生对象，当保存班级时，会自动操作关联的学生，此时会保存未保存过的学生。
//session.save(stu1);
//session.save(stu2);
tx.commit();
HibernateUtil.closeSession(session);
}
}
</span>
（当然，在Student这一边同样也可以设置 级联操作，如 在保存学生对象时，如果学生对应的班级在数据库中不存在，程序就会隐式地自动添加这个班级记录。）
设置完成后，同样运行 Test.java 测试类，运行结果如下：（同样保存了两条学生记录）
之前，在“Hibernate中的单向一对多关联”中提到：单向一对多，举例：一个班级对多个学生，可以通过班级查找班级所拥有的学生，但是无法通过学生查找到它所处的班级信息。
在实现了双向一对多或者双向多对一后，我们就可以通过学生查找到它所处的班级信息了。如：
Test.java
package com.imooc.test;
/**
* Created by DreamBoy on 2016/5/18.
*/
import com.imooc.entity.Grade;
import com.imooc.entity.Student;
import com.imooc.util.HibernateUtil;
import org.hibernate.Session;
import org.hibernate.Transaction;
import java.util.Set;
/**
* //单向多对一（学生---》班级）
* 双向多对一
* 实际上已经建立了双向一对多，也称为双向多对一。
* 既可以方便地由学生查找到对应的班级信息，也可以方便地由班级查找到其所包含的学生信息
*/
public class Test {
public static void main(String[] args) {
//save();
findGradeByStudent();
}
//保存
public static void save() {
Grade g = new Grade("Java一班", "Java软件开发一班");
Student stu1 = new Student("哈", "女");
Student stu2 = new Student("哇", "男");
//设置关联关系，指定多到一的关联关系
stu1.setGrade(g);
stu2.setGrade(g);
//设置关联关系，指定一到多的关联关系
g.getStudents().add(stu1);
g.getStudents().add(stu2);
Session session = HibernateUtil.getSession();
Transaction tx = session.beginTransaction();
session.save(g);
//设置级联操作后，可以不用显式地保存学生对象，当保存班级时，会自动操作关联的学生，此时会保存未保存过的学生。
//session.save(stu1);
//session.save(stu2);
tx.commit();
HibernateUtil.closeSession(session);
}
//查询学生所在班级信息
public static void findGradeByStudent() {
Session session = HibernateUtil.getSession();
Student stu = (Student) session.get(Student.class, 2);
System.out.println(stu.getSid() + ", " + stu.getSname() + ", " + stu.getSex());
Grade g = stu.getGrade();
System.out.println(g.getGid() + ", " + g.getGname() + ", " + g.getGdesc());
HibernateUtil.closeSession(session);
}
}
总的来说：
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)
