hibernate Hibernate检索策略(类级别,关联级别,批量检索)详解

Posted 路虽远,梦还在!

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了hibernate Hibernate检索策略(类级别,关联级别,批量检索)详解相关的知识,希望对你有一定的参考价值。

      序言

         很多看起来很难的东西其实并不难,关键是看自己是否花费了时间和精力去看,如果一个东西你能看得懂,同样的,别人也能看得懂,体现不出和别人的差距,所以当你觉得自己看了很多书或者学了很多东西的时候,你要想想,你花费的也就那么一点时间,别人花你这么多时间也能够学到你所学到的东西,所以还是要继续努力。既然不是天才,唯有靠勤奋来弥补。

                                            --WZY

 

一、概述

    检索策略分三大块,类级别检索策略和关联级别检测策略。

        类级别检索策略:get、load、

        关联级别检索策略:order.getCustomer().getName()

        上面这两种应该是看得懂的。很容易去理解,现在就具体来说说这两种其中的细节。

    批量检索解决n+1问题。

二、类级别检索策略

    2.1、立即检索  get

        直接发送sql语句,到数据库中去查询数据。

        例如                

 1 Staff staff = (Staff)session.get(Staff.class, 3);//执行完这句,就会发送sql语句,到数据库表中查询相应的数据加入一级缓存中
 2 
 3 //结果
 4 Hibernate: 
 5     select
 6         staff0_.id as id1_0_,
 7         staff0_.name as name1_0_,
 8         staff0_.deptId as deptId1_0_ 
 9     from
10         staff staff0_ 
11     where
12         staff0_.id=?
View Code

        

    2.2、延迟检索  load

        不会直接发送sql语句,而是等到用的时候在发送sql语句,如果一直没用,就永远不会发送sql语句。

 1         Staff staff = (Staff)session.load(Staff.class, 3);//执行完这句,不会发送sql语句
 2         System.out.println("load后还没发送sql语句,等用到的时候才会发送。");
 3         System.out.println(staff.getName());//现在需要用staff。则会发送sql语句。
 4 
 5 //结果
 6 
 7 load后还没发送sql语句,等用到的时候才会发送。
 8 Hibernate: 
 9     select
10         staff0_.id as id1_0_,
11         staff0_.name as name1_0_,
12         staff0_.deptId as deptId1_0_ 
13     from
14         staff staff0_ 
15     where
16         staff0_.id=?
17 qqq2
View Code

 

    2.3、深入讲解get和load

        上面两个只是简单讲解一下立即加载和延迟加载两个概念。现在来讲点深入的东西。

      1、load检索返回的代理对象,而不是一个pojo对象,get返回的是pojo对象,这个的前提是一级缓存中没有我们要查询的对象。

            

      2、get和load都是先从一级缓存中拿数据,而不是每次都从数据库中拿,也就是说如果一级缓存有我们需要的数据,就不会在发送sql语句了。并且返回就是一级缓存对象中对象的状态,也就是说如果在一级缓存中该对象的状态是pojo对象,那么就算是用load加载的,返回的也就是pojo对象,如果该对象是代理对象,那么就算get加载的,返回的也就是代理对象,不过会将代理对象的数据初始化。也就是会向数据库中发送sql语句查询数据。           解释:代理对象数据初始化:代理对象中包含了我们想要的pojo对象的所有信息。

        例子:一级缓存中的是代理对象,使用get获得

 1         Staff staff = (Staff)session.load(Staff.class, 3);//staff代理对象加入缓存中了
 2         System.out.println("没有发送sql语句,get之后就会发送。");
 3         Staff staff1 = (Staff)session.get(Staff.class, 3);//get获取了缓存中的代理对象,并且初始化
 4 
 5 //结果
 6 没有发送sql语句,get之后就会发送。
 7 Hibernate: 
 8     select
 9         staff0_.id as id1_0_,
10         staff0_.name as name1_0_,
11         staff0_.deptId as deptId1_0_ 
12     from
13         staff staff0_ 
14     where
15         staff0_.id=?
View Code

              

         例子: 一级缓存中是pojo对象,通过load获得

 1         Staff staff = (Staff)session.get(Staff.class, 3);//staff pojo对象加入缓存中了
 2         System.out.println("get后发送sql语句,并且该pojo对象在一级缓存中了。");
 3         Staff staff1 = (Staff)session.load(Staff.class, 3);//load获取了缓存中的pojo对象
 4 
 5 //结果
 6 Hibernate: 
 7     select
 8         staff0_.id as id1_0_,
 9         staff0_.name as name1_0_,
10         staff0_.deptId as deptId1_0_ 
11     from
12         staff staff0_ 
13     where
14         staff0_.id=?
15 get后发送sql语句,并且该pojo对象在一级缓存中了。
View Code

              

 

      3、只有在使用时,代理对象才会初始化,其实还有一种方式可以不使用代理对象而初始化数据,

               

            因为没有初始化代理对象,在关闭session后,在使用staff1,就会报错,报错内容为不能够初始化代码对象,没有session,

                

            使用Hibernate.initialize(proxy);来对代理对象进行初始化,这个的效果和使用代理对象是一样的,但是会使代码看起来更好,如果你在这里system.out.println(代理对象),也有也可以,但是看起来总觉得乖乖的,所以hibernate就有了这个方法来对代理对象进行初始化。

              

      4、可以通过lazy属性来设置让load不延迟加载,而跟get一样立即加载,因为是类级别检索,所以在hbm映射文件中的class位置进行属性设置。

               

            在staff.hbm.xml中设置了lazy=false。意思是让其延迟加载失效,所以在对staff进行查询时,使用load也是立即检索

               

 

      5、我们常说的,get如果查询数据库中没有的记录的话,返回是null,而load将会报错。这句话是正确的,但是概念很模糊,来看下面的路子看会不会报错。

          例子一:查询数据库中没有的数据,id=100,load的时候会不会报错?  报错           

              

          例子二:查询数据库中没有的数据,id=100,并且将其取出id  不抱错

              

          例子三:查询数据库中没有的数据,id=100,并且取出name  报错

              

            总结load:load加载返回的是一个代理对象,并且我们说的用load查询一个数据库中没有的数据,并不是load这条语句报异常,而是在使用时,代理对象在数据库表中找不到数据而报的异常,所以单纯只写load语句,是不会报错的,并且代理对象的id是我们手动输入进去的,不用往数据库中查也知道,所以在代理对象.getId()时也不会发送sql语句,而是拿到我们一开始的id值。

 

       

 

 

    2.4、load和get的区别(面试题)

            1、get是立即加载、load是延迟加载

            2、get和load都是先从缓存中查找对象,如果有该对象的缓存,则不向数据库中查询,并且返回的是缓存中对象的状态(是代理对象就返回代理对象,是pojo对象就返回pojo对象)

            3、在缓存中没有对象时,get返回的是pojo对象,load返回的是代理对象

 

三、关联级别检索策略

    在<set>标签上或者在<many-to-one>上设置两个属性值来控制其检索策略,  fetch、lazy

          fetch:代表检索时的语句的方式,比如左外连接等。

              fetch:join、select 、subselect  

          lazy:是否延迟加载。

              lazy:true、false、extra

    分两种情况

    3.1、一对多或多对多时

        <set fetch="",lazy="">

        fetch = join时,采取迫切左外连接查询  

              lazy不管取什么值都失效,就是取默认值为false。

        fetch=select时,生成多条简单sql查询语句

              lazy=false:立即检索

              lazy=true:延迟检索

              lazy=extra:加强延迟检索,非常懒惰,比延迟检索更加延迟

        fetch=subselect时,生成子查询

              lazy=false:立即检索

              lazy=true;延迟检索

              lazy=extra:加强延迟检索,非常懒惰,比延迟检索更加延迟

 

       实验一:fetch=join 发送左外迫切连接

          一、hql的query查询

                  

        使用hql的query查询,会让fetch=join失效,lazy重新启用。如果生成结果是延迟检索,那么就说明我们说的这个是正确的。

 1         //使用hql查询,fetch=join是无效的,并且lazy重新启用,本来lazy失效的话,
 2         //则使用默认的,就是立即加载,现在因为重新启用了,所以会是延迟加载
 3         Query query = session.createQuery("from Dept where id = 2");
 4         Dept dept = (Dept) query.uniqueResult();
 5         System.out.println("如果sql语句在这句话之上说明是立即加载,如果在之下就是延迟加载");
 6         dept.getStaffSet().size();
 7 
 8 //结果
 9 
10 Hibernate: 
11     select
12         dept0_.id as id0_,
13         dept0_.name as name0_ 
14     from
15         dept dept0_ 
16     where
17         dept0_.id=2
18 如果sql语句在这句话之上说明是立即加载,如果在之下就是延迟加载
19 Hibernate: 
20     select
21         staffset0_.deptId as deptId0_1_,
22         staffset0_.id as id1_,
23         staffset0_.id as id1_0_,
24         staffset0_.name as name1_0_,
25         staffset0_.deptId as deptId1_0_ 
26     from
27         staff staffset0_ 
28     where
29         staffset0_.deptId=?
View Code

          二、使用get查询。fetch=join生效,lazy就会失效,并且会发送左外迫切连接。这里要注意,要看set中存放的东西是什么,而不是看发送的语句是不是含有fetch来判断是不是左外迫切连接,因为hibernate中,左外迫切连接发送的语句跟左外连接发送的语句是一样的,从这里是区分不出来了。如果不信的话,自己可以去尝试一下,手动写一个左外迫切连接,然后看发送的语句是什么样的,我试过了,跟我说的一样

 1         Dept dept = (Dept) session.get(Dept.class, 2);
 2         System.out.println("如果sql语句在这句话之上说明是立即加载,如果在之下就是延迟加载");
 3         Set<Staff> set = dept.getStaffSet();
 4         System.out.println(set);
 5 
 6 //结果
 7 Hibernate: 
 8     select
 9         dept0_.id as id0_1_,
10         dept0_.name as name0_1_,
11         staffset1_.deptId as deptId0_3_,
12         staffset1_.id as id3_,
13         staffset1_.id as id1_0_,
14         staffset1_.name as name1_0_,
15         staffset1_.deptId as deptId1_0_ 
16     from
17         dept dept0_ 
18     left outer join
19         staff staffset1_ 
20             on dept0_.id=staffset1_.deptId 
21     where
22         dept0_.id=?
23 如果sql语句在这句话之上说明是立即加载,如果在之下就是延迟加载
24 [oneToMany.Staff@367e4144, oneToMany.Staff@20a709f3, oneToMany.Staff@1dc39acc, oneToMany.Staff@1aeef34f, oneToMany.Staff@1d82e71, oneToMany.Staff@55a7e5ae, oneToMany.Staff@3da7d559, oneToMany.Staff@782d5c85, oneToMany.Staff@6a155d66]
View Code

          总结第一种情况fetch=join。

              1、注意我们这里讨论的是关联级别的检索方式,所以重点是看关联的时候发送的sql语句,重心不在get和load上面了

              2、fetch=join让lazy失效的前提是使用的不是hql的query查询。

       实验二:fetch=select时 发送简单sql语句

            lazy=false;也就是立即检索,发送简单sql语句

                     

 1         Dept dept = (Dept) session.get(Dept.class, 2);
 2         System.out.println("如果sql语句在这句话之上说明是立即加载,如果在之下就是延迟加载");
 3         Set<Staff> set = dept.getStaffSet();
 4         System.out.println(set);
 5 
 6 //结果
 7 Hibernate: 
 8     select
 9         dept0_.id as id0_0_,
10         dept0_.name as name0_0_ 
11     from
12         dept dept0_ 
13     where
14         dept0_.id=?
15 Hibernate: 
16     select
17         staffset0_.deptId as deptId0_1_,
18         staffset0_.id as id1_,
19         staffset0_.id as id1_0_,
20         staffset0_.name as name1_0_,
21         staffset0_.deptId as deptId1_0_ 
22     from
23         staff staffset0_ 
24     where
25         staffset0_.deptId=?
26 如果sql语句在这句话之上说明是立即加载,如果在之下就是延迟加载
27 [oneToMany.Staff@5091be16, oneToMany.Staff@5c1a555, oneToMany.Staff@753f827a, oneToMany.Staff@6c4d7266, oneToMany.Staff@58e83637, oneToMany.Staff@15dbd461, oneToMany.Staff@1056bfad, oneToMany.Staff@2f41ff3c, oneToMany.Staff@1c8f53b9]
View Code    

            lazy=true;延迟检索,发送简单sql语句

                   

  

 1         Dept dept = (Dept) session.get(Dept.class, 2);
 2         System.out.println("如果sql语句在这句话之上说明是立即加载,如果在之下就是延迟加载");
 3         Set<Staff> set = dept.getStaffSet();
 4         System.out.println(set);
 5 
 6 //结果
 7 Hibernate: 
 8     select
 9         dept0_.id as id0_0_,
10         dept0_.name as name0_0_ 
11     from
12         dept dept0_ 
13     where
14         dept0_.id=?
15 如果sql语句在这句话之上说明是立即加载,如果在之下就是延迟加载
16 Hibernate: 
17     select
18         staffset0_.deptId as deptId0_1_,
19         staffset0_.id as id1_,
20         staffset0_.id as id1_0_,
21         staffset0_.name as name1_0_,
22         staffset0_.deptId as deptId1_0_ 
23     from
24         staff staffset0_ 
25     where
26         staffset0_.deptId=?
27 [oneToMany.Staff@5091be16, oneToMany.Staff@5c1a555, oneToMany.Staff@753f827a, oneToMany.Staff@6c4d7266, oneToMany.Staff@58e83637, oneToMany.Staff@1056bfad, oneToMany.Staff@2f41ff3c, oneToMany.Staff@1c8f53b9, oneToMany.Staff@645c1312]
View Code

            lazy=extra;超级懒惰,能尽量少查就绝对不会多查,比如,size(),就会使用count()函数,而不会全部查表中的字段,就是这个意思

                    

 1         Dept dept = (Dept) session.get(Dept.class, 2);
 2         System.out.println("如果sql语句在这句话之上说明是立即加载,如果在之下就是延迟加载");
 3         Set<Staff> set = dept.getStaffSet();
 4         System.out.println(set.size());
 5 
 6 //结果
 7 Hibernate: 
 8     select
 9         dept0_.id as id0_0_,
10         dept0_.name as name0_0_ 
11     from
12         dept dept0_ 
13     where
14         dept0_.id=?
15 如果sql语句在这句话之上说明是立即加载,如果在之下就是延迟加载
16 Hibernate: 
17     select
18         count(id) 
19     from
20         staff 
21     where
22         deptId =?
23 9
View Code

 

        实验三、fetch=subselect 生成子查询,注意使用get方式不生成子查询,使用query().list().get(),并且数据库表中还得不止一条记录才会生成子查询,如果只有一条记录,hibernate也很聪明,就没必要用子查询了

            lazy=false:立即检索

 1         Dept dept = (Dept) session.createQuery("from Dept").list().get(0);
 2         System.out.println("如果sql语句在这句话之上说明是立即加载,如果在之下就是延迟加载");
 3         Set<Staff> set = dept.getStaffSet();
 4         System.out.println(set);
 5 
 6 //结果
 7 Hibernate: 
 8     select
 9         dept0_.id as id0_,
10         dept0_.name as name0_ 
11     from
12         dept dept0_
13 Hibernate: 
14     select
15         staffset0_.deptId as deptId0_1_,
16         staffset0_.id as id1_,
17         staffset0_.id as id1_0_,
18         staffset0_.name as name1_0_,
19         staffset0_.deptId as deptId1_0_ 
20     from
21         staff staffset0_ 
22     where
23         staffset0_.deptId in (
24             select
25                 dept0_.id 
26             from
27                 dept dept0_
28         )
29 如果sql语句在这句话之上说明是立即加载,如果在之下就是延迟加载
30 [oneToMany.Staff@62c2bff3, oneToMany.Staff@583c72d7, oneToMany.Staff@6897ae82, oneToMany.Staff@19d5f3ea, oneToMany.Staff@3160c0bd, oneToMany.Staff@4af364d4, oneToMany.Staff@4afbc8ce, oneToMany.Staff@5fc81d2c, oneToMany.Staff@3e420e73]
View Code

            lazy=true:延迟检索

            lazy=extra;超级懒惰,比延迟检索还延迟

                这两个其实也就差不多了,自己可以试试

           

    3.2、多对一或一对一时

        fetch可以取值为:join,select

        lazy:false,proxy,no-proxy

        当fetch=join,lazy会失效,生成的sql是迫切左外连接

              如果我们使用query时,hql是我们自己指定的,那么fetch=join是无效的,不会生成迫切左外连接,这时lazy重新启用

        当fetch=select,lazy不失效,生成简单sql语句,

            lazy=false:立即检索

            lazy=proxy:这时关联对象采用什么样的检索策略取决于关联对象的类级别检索策略.就是说参考<class>上的lazy的值

 

        其实跟上面一样,我们是测试一个fetch=select,lazy=proxy的把。

        staff,也就是多方,

            

        dept,也就是一方

                

        按照我们所配置的,关联级别检索应该是延迟检索,结果正如我们所想的。

 1         Staff staff = (Staff) session.createQuery("from Staff").list().get(0);
 2         System.out.println("如果sql语句在这句话之上说明是立即加载,如果在之下就是延迟加载");
 3         Dept dept = staff.getDept();
 4         System.out.println(dept);
 5 //结果
 6 Hibernate: 
 7     select
 8         staff0_.id as id1_,
 9         staff0_.name as name1_,
10         staff0_.deptId as deptId1_ 
11     from
12         staff staff0_
13 如果sql语句在这句话之上说明是立即加载,如果在之下就是延迟加载
14 Hibernate: 
15     select
16         dept0_.id as id0_0_,
17         dept0_.name as name0_0_ 
18     from
19         dept dept0_ 
20     where
21         dept0_.id=?
22 Dept [id=2, name=1部门]
View Code

 

 

        总结:

          1、为什么需要分(一对多,多对多)和(多对一,一对一)两组情况呢?

              注意:这里说的一对多,那么就是单向一对多,也就是占在一的角度去考虑东西,上面说的四种都是从左边往右边看。

              因为一对多和多对多,所拿到的关联对象度是一个集合,查询的记录就有很多个,也就多了一个fetch=subselect这个特性,查询方式的变化也就多一点,

              而多对一,一对一,所拿到的关联对象就是一个对象,也就是一条记录,查询的方式比较单一和简单

              因为上面的原因就把他们两个给分开来以处理不同的情况。达到更高的效率。

          2、为什么需要搞这样的检索方式,不很麻烦吗?

              根据不同的业务需求,来让开发者自己控制用什么样的检索方式,这样让程序的性能更好

 

四、批量检索

      什么叫批量检索,就是多条sql语句才能完成的查询,现在一条sql语句就能解决多条sql语句才能完成的事情,看下面例子就明白了,

      例子:n+1问题,什么叫n+1问题?

         就拿我们上面这个例子来说,Dept和Staff,现在有5个部门,每个部门中的人数可能一样,也可能不一样,要求,查询每个部门中的员工。那么我们写的话就需要发送6条sql语句,哪6条呢?第一条查询部门表中所有的部门,剩下5条,拿到每一个部门的ID,去员工表中查找每个部门中的员工,要查5次,因为有5个部门。本来只有5个部门,现在需要发送6条sql语句,这就是n+1问题,看下面代码

         总之就发送了6条sql语句,我已经数过了。

 1         List<Dept> list = session.createQuery("from Dept").list();
 2         
 3         for(Dept dept : list){
 4             System.out.println(dept.getStaffSet());
 5         }
 6 
 7 //结果
 8 Hibernate: 
 9     select
10         dept0_.id as id0_,
11         dept0_.name as name0_ 
12     from
13         dept dept0_
14 Hibernate: 
15     select
16         staffset0_.deptId as deptId0_1_,
17         staffset0_.id as id1_,
18         staffset0_.id as id1_0_,
19         staffset0_.name as name1_0_,
20         staffset0_.deptId as deptId1_0_ 
21     from
22         staff staffset0_ 
23     where
24         staffset0_.deptId=?
25 [oneToMany.Staff@ffdde88, oneToMany.Staff@1a33cda6, oneToMany.Staff@3160c0bd, oneToMany.Staff@48860e29, oneToMany.Staff@1538c1e3, oneToMany.Staff@339289a7, oneToMany.Staff@3f025aba, oneToMany.Staff@598b4d64, oneToMany.Staff@641cbaeb, oneToMany.Staff@590bcaf1]
26 Hibernate: 
27     select
28         staffset0_.deptId as deptId0_1_,
29         staffset0_.id as id1_,
30         staffset0_.id as id1_0_,
31         staffset0_.name as name1_0_,
32         staffset0_.deptId as deptId1_0_ 
33     from
34         staff staffset0_ 
35     where
36         staffset0_.deptId=?
37 [oneToMany.Staff@650e7ac9, oneToMany.Staff@456ffab9, oneToMany.Staff@3ab5ab4c, oneToMany.Staff@5456df43, oneToMany.Staff@718bc0c4, oneToMany.Staff@7fde1684, oneToMany.Staff@6d0128b0, oneToMany.Staff@157f068f, oneToMany.Staff@55cfffa2, oneToMany.Staff@46e1d5d9, oneToMany.Staff@4d9875b1, oneToMany.Staff@104628c, oneToMany.Staff@4687a14f, oneToMany.Staff@135bd2f7, oneToMany.Staff@149ebdea, oneToMany.Staff@726f6db5, oneToMany.Staff@4a9810b1, oneToMany.Staff@72c5c2e7, oneToMany.Staff@e1cbe19, oneToMany.Staff@671672b8]
38 Hibernate: 
39     select
40         staffset0_.deptId as deptId0_1_,
41         staffset0_.id as id1_,
42         staffset0_.id as id1_0_,
43         staffset0_.name as name1_0_,
44         staffset0_.deptId as deptId1_0_ 
45     from
46         staff staffset0_ 
47     where
48         staffset0_.deptId=?
49 [oneToMany.Staff@5ce4c86b, oneToMany.Staff@23081b81, oneToMany.Staff@132ff4b6, oneToMany.Staff@316ae291, oneToMany.Staff@480955df, oneToMany.Staff@30221872, oneToMany.Staff@6945c41e, oneToMany.Staff@1f43a98b, oneToMany.Staff@634ec390, oneToMany.Staff@e72fd0e]
50 Hibernate: 
51     select
52         staffset0_.deptId as deptId0_1_,
53         staffset0_.id as id1_,
54         staffset0_.id as id1_0_,
55         staffset0_.name as name1_0_,
56         staffset0_.deptId as deptId1_0_ 
57     from
58         staff staffset0_ 
59     where
60         staffset0_.deptId=?
61 [oneToMany.Staff@269c2a55, oneToMany.Staff@4d45222c, oneToMany.Staff@1a66421c, oneToMany.Staff@2f7e49ce, oneToMany.Staff@42c51adb, oneToMany.Staff@5103c049, oneToMany.Staff@c1f8bbe, oneToMany.Staff@75c69e55, oneToMany.Staff@41c7d5a8, oneToMany.Staff@6b0f6d29]
62 Hibernate: 
63     select
64         staffset0_.deptId as deptId0_1_,
65         staffset0_.id as id1_,
66         staffset0_.id as id1_0_,
67         staffset0_.name as name1_0_,
68         staffset0_.deptId as deptId1_0_ 
69     from
70         staff staffset0_ 
71     where
72         staffset0_.

以上是关于hibernate Hibernate检索策略(类级别,关联级别,批量检索)详解的主要内容,如果未能解决你的问题,请参考以下文章

Hibernate学习———— Hibernate检索策略(类级别,关联级别,批量检索)详解

hibernate 检索策略

Hibernate的检索策略

Hibernate检索学习

Hibernate检索策略

hibernate学习——加载策略(优化)