Hibernate中的双向多对一关联以及 inverse属性、cascade属性的用法

最新推荐文章于 2019-04-10 18:23:32 发布

葡萄干是个程序员

最新推荐文章于 2019-04-10 18:23:32 发布

阅读量3.9k

点赞数 1

分类专栏： JavaEE 文章标签： java hibernate 双向多对一关联 inverse 属性 cascade属性

本文链接：https://blog.csdn.net/qq_15096707/article/details/51454142

版权

JavaEE 专栏收录该内容

43 篇文章 2 订阅

订阅专栏

上回说了 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);
    }
}

总的来说：

葡萄干是个程序员

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Hibernate中的双向多对一关联以及 inverse属性、cascade属性的用法

上回说了 Hibernate中的单向一对多关联和 Hibernate中的单向多对一关联。这次针对这两个“单向”进行整合即可实现双向的多对一关联。如：学生与班级的关系。在Grade类中需要添加 Set集合保存Student对象，并且在Grade.hbm.xml的映射配置文件中，针对Set集合添加如下配置：
复制链接

扫一扫