（十一）Hibernate的检索策略

一、简介

Session的缓存中可以存放相互关联的对象。当Hibernate从数据库中加载对象时，如果同时自动加载与之关联的所有对象，那么这些关联的对象就浪费了很多的内存空间。而我们可以设置检索策略，来优化检索性能。

Hibernate提供了三种检索策略

 

?
1
2
3
4
5
-立即检索策略：检索对象时立即加载对象以及关联的对象。
 
-延迟检索策略：使用时才会加载对象以及关联的对象。能避免多余加载不需要的对象。
 
-迫切左外连接检索策略 ：利用SQL的外连接查询功能，能够减少select语句的数目。

　这里写图片描述　

 

二、类级别检索策略

?
1
2
3
4
5
6
7
8
定义：只加载某个类对象
 
类级别的检索策略包括立即检索和延迟检索。默认为延迟检索。
 
Hibernate中允许在映射文件中配置检索策略。
类级别检索策略，可以配置<class>元素中的lazy属性。属性可选值：true(延迟检索) false（立即检索）。默认值为true。
 
类级别检索策略会影响Session的load方法。

　　

例子：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
我们来做一个小例子，在load方法加断点
    public class Demo {
        private Session session;
 
        @Test
        public void test() {
            //读取配置文件
            Configuration conf=new Configuration().configure();
 
            //根据配置创建factory
            SessionFactory sessionfactory=conf.buildSessionFactory();
            session = sessionfactory.openSession();
             Transaction ts=session.beginTransaction();
 
             Customer c=session.load(Customer.class, 7);//此处加断点来观察效果
             System.out.println(c.getName());
 
            ts.commit();
            session.close();
            sessionfactory.close();
        }
 
    }
 
    当lazy属性为true时，调用load方法什么都不输出，使用对象时才输出select语句。
    当lazy属性为false时，调用load方法会直接输出select语句。

　原理：　

当为延迟检索策略时，执行load方法时，是返回当前对象的代理对象，这个代理对象由Hibernate动态生成，

代理对象继承了当前对象，仅仅初始化了OID属性，其他属性都为null，当程序访问代理类属性时，

Hibernate才会初始化代理对象，初始化过程执行select语句，从数据库加载所有数据。

 

三、一对多关联级别的策略策略

关联级别检索策略:查询有关联关系的对象时，加载对象时是否需要将关联的对象加载。

在映射文件中，使用< set >元素来配置一对多或者多对多的关联关系。

< set >元素中有lazy和fetch属性决定加载策略。

 

?
1
2
3
4
5
6
lazy属性：和类级别加载策略一致。
         默认值为true。即使用延迟检索。
 
         当lazy为false时，使用立即检索。
 
         当lazy为extra时，采用加强延迟检索策略，它尽可能的延迟集合被初始化的时机。例如程序访问集合的一些属性时，如访问size()、contains()、isEmpty()这些方法时，如果指定了extra，就不会加载集合，仅通过特定的语句查询必要的信息。

 

　　

例子 ：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
        public class Demo {
            private Session session;
 
            @Test
            public void test() {
                //读取配置文件
                Configuration conf=new Configuration().configure();
 
                //根据配置创建factory
                SessionFactory sessionfactory=conf.buildSessionFactory();
                session = sessionfactory.openSession();
                 Transaction ts=session.beginTransaction(); 
                 //加载Customer对象
                 Customer c=(Customer)session.get(Customer.class, 7);
                 //加载Customer关联的Order对象
                 for(Order o:c.getOrders()){
                     System.out.println(o.getName());
                 }
 
                ts.commit();
                session.close();
                sessionfactory.close();
            }
 
        }
 
当我们lazy属性为false时，在执行get方法时，会使用立即检索策略，会执行两个select语句，加载Customer和关联的Orders集合。
 
当我们lazy属性为true时，执行get方法，只会执行一句select语句，此时Customer的Orders属性引用一个没有被初始化的集合代理类，此时Orders集合中不存在任何Order对象，当我们使用order时，才会初始化集合代理类，才会到数据库中检索所有关联的Order对象

 

 

?
1
2
3
4
5
6
7
fetch属性：决定加载集合时查询语句的格式。取值为：select 、subselect、join
 
          select：（默认值）使用普通的select语句进行查询。
 
          subselect：使用子查询加载集合数据。当查找多个对象时才有用，例如查找多个用户，每个用户有多个订单
 
          join：采用迫切左外连接检索策略进行查询。fetch属性设为join，lazy属性将被忽略，在查询对象时一定会加载与之关联的对象。  

　　

例子：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class Demo {
 
            private Session session;
 
            @Test
            public void test() {
                //读取配置文件
                Configuration conf=new Configuration().configure();
 
                //根据配置创建factory
                SessionFactory sessionfactory=conf.buildSessionFactory();
                session = sessionfactory.openSession();
                 Transaction ts=session.beginTransaction();
 
                //加载Customer对象
                 Customer c=(Customer)session.get(Customer.class, 7);
 
                 //加载关联的Order对象
                 for(Order o:c.getOrders()){
                     System.out.println(o.getName());
                 }
 
                ts.commit();
                session.close();
                sessionfactory.close();
            }
 
        }

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
当fetch属性为默认值(select)时，打印的sql语句
        Hibernate:
            select
                customer0_.id as id1_0_0_,
                customer0_.name as name2_0_0_
            from
                customer customer0_
            where
                customer0_.id=?
        Hibernate:
            select
                orders0_.cid as cid3_1_0_,
                orders0_.id as id1_1_0_,
                orders0_.id as id1_1_1_,
                orders0_.name as name2_1_1_,
                orders0_.cid as cid3_1_1_
            from
                orders orders0_
            where
                orders0_.cid=?

　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
当fetch属性为join时，打印select语句,采用左外连接的查询语句，减少select语句
        Hibernate:
            select
                customer0_.id as id1_0_0_,
                customer0_.name as name2_0_0_,
                orders1_.cid as cid3_1_1_,
                orders1_.id as id1_1_1_,
                orders1_.id as id1_1_2_,
                orders1_.name as name2_1_2_,
                orders1_.cid as cid3_1_2_
            from
                customer customer0_
            left outer join
                orders orders1_
                    on customer0_.id=orders1_.cid
            where
                customer0_.id=?

　　

　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
演示fetch属性为subselect时，我们查询所有Customer，然后使用每一个Customer的Orders集合
        public class Demo {
 
            private Session session;
            @Test
            public void test() {
                //读取配置文件
                Configuration conf=new Configuration().configure();
 
                //根据配置创建factory
                SessionFactory sessionfactory=conf.buildSessionFactory();
                session = sessionfactory.openSession();
                 Transaction ts=session.beginTransaction();
 
                 //查找所有Customer
                List<Customer> customerlist=session.createQuery("from Customer").list(); 
                //加载每个Customer关联的Orders集合
                for(Customer c:customerlist){
                    System.out.println(c.getOrders().size());
                }
                ts.commit();
                session.close();
                sessionfactory.close();
            }
 
        }

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
打印的语句，使用了子查询语句
当fetch属性为subselect时，Hibernate能够通过带有子查询的select语句，来整批量的初始化多个对象的集合中的实例。   
 
 
    Hibernate:
        select
            customer0_.id as id1_0_,
            customer0_.name as name2_0_
        from
            customer customer0_
    Hibernate:
        select
            orders0_.cid as cid3_1_1_,
            orders0_.id as id1_1_1_,
            orders0_.id as id1_1_0_,
            orders0_.name as name2_1_0_,
            orders0_.cid as cid3_1_0_
        from
            orders orders0_
        where
            orders0_.cid in (
                select
                    customer0_.id
                from
                    customer customer0_
            )

　　

fetch和lazy结合

这里写图片描述

 

四、多对一关联级别的策略策略

?
1
2
3
4
和<set>元素一样，<many-to-one>元素中也有lazy和fetch属性。
 
 lazy的可选值有false(立即检索),proxy(延迟检索),no-proxy(无代理延迟检索)
 fetch属性可选值为select 和 join 

　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
例子：设置订单配置文件中fetch属性为join
    public class Demo {
 
        private Session session;
 
        @Test
        public void test() {
            //读取配置文件
            Configuration conf=new Configuration().configure();
 
            //根据配置创建factory
            SessionFactory sessionfactory=conf.buildSessionFactory();
            session = sessionfactory.openSession(); 
             Transaction ts=session.beginTransaction();
            //加载订单对象
             Order c=(Order)session.get(Order.class, 6);
             //加载关联的Customer对象
             System.out.println(c.getCustomer().getName());
 
 
            ts.commit();
            session.close();
            sessionfactory.close();
        }
 
    }

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
则在执行get方法时，会直接使用外连接查询。忽略lazy。
            Hibernate:
                select
                    order0_.id as id1_1_0_,
                    order0_.name as name2_1_0_,
                    order0_.cid as cid3_1_0_,
                    customer1_.id as id1_0_1_,
                    customer1_.name as name2_0_1_
                from
                    orders order0_
                left outer join
                    customer customer1_
                        on order0_.cid=customer1_.id
                where
                    order0_.id=?

　　

五、批量检索

　　< class >和< set >元素中包含batch-size属性。设定批量检索的数量。可选值为正整数，默认为1。 
仅用于关联级别的立即检索和批量检索

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
我们在Customer配置文件中设置批量延迟检索
<set name="orders" lazy="true" batch-size="3">
 
public class Demo {
 
    private Session session;
 
    @Test
    public void test() {
        //读取配置文件
        Configuration conf=new Configuration().configure();
 
        //根据配置创建factory
        SessionFactory sessionfactory=conf.buildSessionFactory();
        session = sessionfactory.openSession();
         Transaction ts=session.beginTransaction();
         //加载所有Customer对象
        List<Customer> customerlist=session.createQuery("from Customer").list();
        for(Customer c:customerlist){
            System.out.println(c.getOrders().size());
        }
        ts.commit();
        session.close();
        sessionfactory.close();
    }
 
}

　　

?
1
2
3
4
5
6
7
我们使用延迟检索，当使用到每个Customer的orders时，才加载Orders，每执行一次循环，就打印一个select语句。
 
如果有很多Customer对象，那么就会打印很多的select语句。
 
所以我们可以使用批量检索。只需要将<set>的batch-size属性设置为3. 
 
所以会批量初始化三个Orders集合，使用in语句。这样当用到第一个第二个第三个对象的集合时，就不会再发送语句。

　　

　

 

　　

 

posted @   跃小云  阅读(207)  评论(0)  编辑  收藏  举报
编辑推荐：
· 从 HTTP 原因短语缺失研究 HTTP/2 和 HTTP/3 的设计差异
· AI与.NET技术实操系列：向量存储与相似性搜索在 .NET 中的实现
· 基于Microsoft.Extensions.AI核心库实现RAG应用
· Linux系列：如何用heaptrack跟踪.NET程序的非托管内存泄露
· 开发者必知的日志记录最佳实践
阅读排行：
· winform 绘制太阳，地球，月球 运作规律
· AI与.NET技术实操系列（五）：向量存储与相似性搜索在 .NET 中的实现
· 超详细：普通电脑也行Windows部署deepseek R1训练数据并当服务器共享给他人
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 上周热点回顾（3.3-3.9）
点击右上角即可分享
微信分享提示