Hibernate之lazy延迟加载

爱被打了一巴掌 2021-07-24 15:14 747阅读 0赞

# 一.延迟加载的概念 #

当Hibernate从数据库中加载某个对象时，不加载关联的对象，而只是生成了代理对象，获取使用session中的load的方法(在没有改变lazy属性为false的情况下)获取到的也是代理对象，所以在上面这几种场景下就是延迟加载。

# 二.理解立即加载的概念 #

当Hibernate从数据库中加载某个对象时，加载关联的对象，生成的实际对象，获取使用session中的get的方法获取到的是实际对象。

# 三.为什么要使用延迟加载 #

延迟加载策略能避免加载应用程序不需要访问的关联对象，以提高应用程序的性能。

# 四.立即加载的缺点 #

Hibernate在查询某个对象时，立即查询与之关联的对象，我们可以看出这种加载策略存在两大不足：

1.select的语句数目太多，需要频繁的访问数据库，会影响查询的性能。

2.在应用程序只需要访问要的对象，而不需要访问与他关联的对象的场景下，加载与之关联的对象完全是多余的操作，这些多余的操作是会占内存，这就造成了内存空间的浪费。

# 五.什么时候使用延迟加载什么时候使用立即加载 #

如果程序加载一个持久化对象的目的是为访问他的属性，则可以采用立即加载。如果程序加载一个持久化对象的目的仅仅是为了获得他的引用，则可以采用延迟加载。

# 六.Hibernate在对象-关系映射问价中配置加载策略 #

##    I.类级别： ##

<class>元素中lazy属性的可选值为true(延迟加载)和false(立即加载)；

<class>元素中的lazy属性的默认值为true

##    II.一对多关联级别： ##

<set>元素中的lazy属性的可选值为:true(延迟加载),extra(增强延迟加载)和false(立即加载);

<set>元素中的lazy属性的默认值为true

##    III.多对一关联级别： ##

<many-to-one>元素中lazy属性的可选值为：proxy(延迟加载)，no-proxy(无代理延迟加载)和false(立即加载)

<many-to-one>元素中的lazy属性的默认值为proxy

在下面的一些案例中都会以员工（Emp）的部门（Dept）的例子讲解：

员工和部门是多对一的关系：

关于员工和部门的Hibernate配置就不啰嗦了：可以看我的这篇博客：http://www.cnblogs.com/heyongjun1997/p/5767187.html

## I.1类级别的查询策略： ##

###    01.立即加载案例： ###

需求：通过Session的load()方法加载Dept对象时：

首先在Dept.hbm.xml文件中配置lazy属性为false，表示立即加载。

![20191020094705713.png][]

@Test
    public void loadDept()
    {
        // 获取Session对象
        Session session = HibernateUtil.currentSession();
        // 如果通过load方式加载Dept对象
        Dept dept = (Dept) session.load(Dept.class, 12);
        // 关闭session
        HibernateUtil.closeSession();
    }

我们知道使用Load方法加载的是代理对象，只会在属性里保存一个OID，但是如果在Dept映射文件中配置了类级别的lazy为false就代表加载该对象时立即加载，也就是立即检索一道数据库，发出sql：

![20191020094945756.png][]

![20191020095012283.png][]

###  02.延迟加载案例： ###

同样是获取Dept对象，但是要把Dept.hbm.xml配置文件的类级别的lazy属性改为lazy=”true” 或者不写，应为类级别的lazy属性默认就是true，

![20191020095113226.png][]

@Test
    public void loadDept()
    {
        // 获取Session对象
        Session session = HibernateUtil.currentSession();
        // 如果通过load方式加载Dept对象
        session.load(Dept.class, 12);
        // 关闭session
        HibernateUtil.closeSession();
    }

此时Dept.hbm.xml配置文件的类级别的lazy属性为true，则是延迟加载，那么load方法获取的知识Dept的代理对象，所以他不会去检索数据库。

![20191020095329227.png][]

## II.1一对多和多对多关联的查询策略 ##

###   01.立即加载案例： ###

在获取部门对象的时候同时获取员工对象：

设置Dept.hbm.xml 类级别的lazy属性为false；表示立即加载：

设置<set>元素的lazy属性为false，表示在加载部门的同时立即加载员工：

![20191020095531651.png][]

![20191020095550849.png][]

控制台输出结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70][]

当你想获取一的一方(Dept)的对象同时，你也要加载多的一方(Emp)的对象，那么你要在一的一方(Emp)的<set>的节点上加上lazy="false"表示立即加载，所以在使用Load方式加载Dept对象的时候，Emp对象也会不加载出来，所以程序在运行到Dept dept=(Dept)session.load(Dept.class, 12);会发出两条sql语句：

第一条是查询部门的信息，第二条sql是根据部门编号去数据库中检索员工信息。

###   02.延迟加载： ###

如果把上面的案例<set>节点的属性lazy改为trur，或者默认不写，那么在加载Dept对象的时候，就不会再去加载Emp对象，而且只会发出一条sql，这条sql就是指检索部门的信息。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 1][]

###   03.增强延迟加载： ###

当<set>元素中配置lazy的属性为extra，表明是增强延迟加载策略。

![20191020100540462.png][]

其实增强延迟加载策略与一般的延迟加载策略lazy="true"非常相似。他们主要区别在于，我们看到这个名词增强延迟加载，顾名思义就是这个策略能在进一步的帮我延迟加载这个对象，也就是代理对象的初始化时机。

**演示案例：**

01. 当set节点的lazy属性为true，或者不写的话（取默认值），那么执行以下语句：

@Test
    public void loadDept()
    {
        // 获取Session对象
        Session session = HibernateUtil.currentSession();
        // 如果通过load方式加载Dept对象
        Dept dept = (Dept) session.load(Dept.class, 12);
        //拿该部门下的员工的人数：也就是集合的大小
        dept.getEmps().size();
        // 关闭session
        HibernateUtil.closeSession();
    }

输出结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 2][]

02. 当set节点的lazy属性为extra那么执行该语句：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 3][]

##  III.1多对一关联的查询策略 ##

在映射文件中，<many-to-one>元素用来设置多对一的关系，在Emp.hbm.xml文件中表明Emp类到Dept类的多对一的关联关系：

![20191020101231414.png][]

###  01.延迟加载 ###

需求：获取Emp对象，但是并不去加载与之关联的Dept对象。

首先要设置<many-to-one>节点的lazy属性为proxy，表示延迟加载。

@Test
    public void loadEmp() {
        // 获取Session对象
        Session session = HibernateUtil.currentSession();
        // 如果通过load方式加载Dept对象
        Emp emp=(Emp)session.get(Emp.class, 1);
        //获取Dept对象，因为此时的配置文件lazy是proxy，所以是代理对象
        Dept dept=emp.getDept();
        // 关闭session
        HibernateUtil.closeSession();
    }

控制台输出结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 4][]

结果大家可想而知：<many-to-one>节点的lazy属性为proxy，表示延迟加载。在加载Emp对象的时候会发出sql去查询数据库，但是在获取Dept对象的时候延迟加载了，所以不会发出sql。

###  02.无代理延迟加载： ###

在<many-to-one>元素中配置lazy属性为no-proxy，表示无代理延迟加载。

![20191020101820514.png][]

@Test
    public void loadEmp()
    {
        // 获取Session对象
        Session session = HibernateUtil.currentSession();
        // 如果通过load方式加载Dept对象
        Emp emp=(Emp)session.get(Emp.class, 1);
        //获取Dept对象，因为此时的配置文件lazy是no-proxy，所以是非代理延迟加载
        Dept dept=emp.getDept();
        // 关闭session
        HibernateUtil.closeSession();
    }

此程序在加载的Emp对象dept属性为NULL，当程序运行到第3行的时候将触发Hibernate执行查询Dept表的select语句，，从而加载Dept对象，由此可见，当lazy属性为proxy时，可以延长延迟加载Dept代理对象的时间，而lazy属性为no-proxy时，则可以避免使用由Hibernate提供的Dept代理类实例，是Hibernate对程序提供更加透明的持久化服务。

###  03.立即加载： ###

首先要设置<many-to-one>节点的lazy属性为false，表示立即加载。

![2019102010233756.png][]

@Test
    public void loadEmp() {
        // 获取Session对象
        Session session = HibernateUtil.currentSession();
        // 如果通过load方式加载Dept对象
        Emp emp=(Emp)session.get(Emp.class, 1);
        //获取Dept对象，因为此时的配置文件lazy是false，所以是实际对象
        Dept dept=emp.getDept();
        // 关闭session
        HibernateUtil.closeSession();
    }

控制台输出结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 5][]

**原文地址：**[https://www.cnblogs.com/heyongjun1997/p/5775033.html][https_www.cnblogs.com_heyongjun1997_p_5775033.html]

**（感谢原本作者的分享）**

[20191020094705713.png]: /images/20210724/fd63ca196d874fe3986b97ff1ef90d66.png
[20191020094945756.png]: /images/20210724/84cff6bb2a0c439d8c1e26fa70d8904c.png
[20191020095012283.png]: /images/20210724/b4c6cdcfb2fb44eb9b0fba1aba5bc7c9.png
[20191020095113226.png]: /images/20210724/b82edf90da4f405db52044185e87b8af.png
[20191020095329227.png]: /images/20210724/85d20fd518164a3f8487dd3601a77359.png
[20191020095531651.png]: /images/20210724/83303794eb0346bb81c97a1287ef41a9.png
[20191020095550849.png]: /images/20210724/7dcd368121e24e0f8843dc394d1d3758.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70]: /images/20210724/6e146ca1e6474176914a6837c4f1a642.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 1]: /images/20210724/d9014600161e40d5a3f36dd8c9630478.png
[20191020100540462.png]: /images/20210724/2a9d5b14f12d42bdbc85193166a72e47.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 2]: /images/20210724/e6bfeae938104907996b8de5d4f915fd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 3]: /images/20210724/c17aa4f0deb5424a8ced195126c299ca.png
[20191020101231414.png]: /images/20210724/2605e1ff66b342ef83fff86feb5201a3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 4]: /images/20210724/91687e3c2d1648c19f5478e9b5550652.png
[20191020101820514.png]: /images/20210724/250706126a214b5fbd8baf92e31fae0e.png
[2019102010233756.png]: /images/20210724/dbf2902354e746a58f31e9cfefc18bb7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 5]: /images/20210724/f9815fe4741d415d80b0975268d58136.png
[https_www.cnblogs.com_heyongjun1997_p_5775033.html]: https://www.cnblogs.com/heyongjun1997/p/5775033.html