Hibernate（9）- hibernate_检索策略（两种获取方式（get和load）和lazy、fetch、batch-size等）

最新推荐文章于 2019-10-07 15:02:35 发布
最新推荐文章于 2019-10-07 15:02:35 发布
阅读量177 收藏
点赞数
分类专栏： Hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yiguang_820/article/details/100436614
版权

一、概述

检索策略分2大块，类级别检索策略和关联级别检测策略。

  • 类级别检索策略：get、load
  • 关联级别检索策略：order.getCustomer().getName()

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

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

hibernate中的延迟加载(lazyload)分属性的延迟加载和关系的延迟加载 

  • 属性的延迟加载: 当使用load的方式来获取对象的时候，只有访问了这个对象的属性，hibernate才会到数据库中进行查询。否则不会访问数据库，load就属于属性的延迟加载。
  • 延迟加载又叫lazyload，在one-many many-many的时候都可以使用关系的延迟加载

 

二、类级别检索策略

  1. 立即检索  get：直接发送sql语句，到数据库中去查询数据。
    例如 
    Staff staff = (Staff)session.get(Staff.class, 3);//执行完这句，就会发送sql语句，到数据库表中查询相应的数据加入一级缓存中
 
//结果
Hibernate: 
    select
        staff0_.id as id1_0_,
        staff0_.name as name1_0_,
        staff0_.deptId as deptId1_0_ 
    from
        staff staff0_ 
    where
        staff0_.id=?
  2. 延迟检索  load：load方式是延迟加载，不会直接发送sql语句，而是等到用的时候在发送sql语句，如果一直没用，就永远不会发送sql语句。
    例如 
            Staff staff = (Staff)session.load(Staff.class, 3);//执行完这句，不会发送sql语句
        System.out.println("load后还没发送sql语句，等用到的时候才会发送。");
        System.out.println(staff.getName());//现在需要用staff。则会发送sql语句。
 
//结果
 
load后还没发送sql语句，等用到的时候才会发送。
Hibernate: 
    select
        staff0_.id as id1_0_,
        staff0_.name as name1_0_,
        staff0_.deptId as deptId1_0_ 
    from
        staff staff0_ 
    where
        staff0_.id=?
qqq2
  3. 区别分别在于 
    1. 延迟加载 
    2. 对于id不存在的时候的处理
      都通过id=500（数据库不存在的数据）去获取对象 
      1. get方式会返回null 
      2. load方式会抛出异常

 

三.深入讲解get和load

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

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

　　　　　　　　　　　　

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

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

        Staff staff = (Staff)session.load(Staff.class, 3);//staff代理对象加入缓存中了
        System.out.println("没有发送sql语句，get之后就会发送。");
        Staff staff1 = (Staff)session.get(Staff.class, 3);//get获取了缓存中的代理对象，并且初始化
 
//结果
没有发送sql语句，get之后就会发送。
Hibernate: 
    select
        staff0_.id as id1_0_,
        staff0_.name as name1_0_,
        staff0_.deptId as deptId1_0_ 
    from
        staff staff0_ 
    where
        staff0_.id=?

　　　　　

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

        Staff staff = (Staff)session.get(Staff.class, 3);//staff pojo对象加入缓存中了
        System.out.println("get后发送sql语句，并且该pojo对象在一级缓存中了。");
        Staff staff1 = (Staff)session.load(Staff.class, 3);//load获取了缓存中的pojo对象
 
//结果
Hibernate: 
    select
        staff0_.id as id1_0_,
        staff0_.name as name1_0_,
        staff0_.deptId as deptId1_0_ 
    from
        staff staff0_ 
    where
        staff0_.id=?
get后发送sql语句，并且该pojo对象在一级缓存中了。

　　　　　　　　

 

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值。

 　　　　

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重新启用。如果生成结果是延迟检索，那么就说明我们说的这个是正确的。

//使用hql查询，fetch=join是无效的，并且lazy重新启用，本来lazy失效的话，
        //则使用默认的，就是立即加载，现在因为重新启用了，所以会是延迟加载
        Query query = session.createQuery("from Dept where id = 2");
        Dept dept = (Dept) query.uniqueResult();
        System.out.println("如果sql语句在这句话之上说明是立即加载，如果在之下就是延迟加载");
        dept.getStaffSet().size();
 
//结果
 
Hibernate: 
    select
        dept0_.id as id0_,
        dept0_.name as name0_ 
    from
        dept dept0_ 
    where
        dept0_.id=2
如果sql语句在这句话之上说明是立即加载，如果在之下就是延迟加载
Hibernate: 
    select
        staffset0_.deptId as deptId0_1_,
        staffset0_.id as id1_,
        staffset0_.id as id1_0_,
        staffset0_.name as name1_0_,
        staffset0_.deptId as deptId1_0_ 
    from
        staff staffset0_ 
    where
        staffset0_.deptId=?

 

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

Dept dept = (Dept) session.get(Dept.class, 2);
        System.out.println("如果sql语句在这句话之上说明是立即加载，如果在之下就是延迟加载");
        Set<Staff> set = dept.getStaffSet();
        System.out.println(set);
 
//结果
Hibernate: 
    select
        dept0_.id as id0_1_,
        dept0_.name as name0_1_,
        staffset1_.deptId as deptId0_3_,
        staffset1_.id as id3_,
        staffset1_.id as id1_0_,
        staffset1_.name as name1_0_,
        staffset1_.deptId as deptId1_0_ 
    from
        dept dept0_ 
    left outer join
        staff staffset1_ 
            on dept0_.id=staffset1_.deptId 
    where
        dept0_.id=?
如果sql语句在这句话之上说明是立即加载，如果在之下就是延迟加载
[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]

总结第一种情况fetch=join。

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

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

 

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

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

　

Dept dept = (Dept) session.get(Dept.class, 2);
        System.out.println("如果sql语句在这句话之上说明是立即加载，如果在之下就是延迟加载");
        Set<Staff> set = dept.getStaffSet();
        System.out.println(set);
 
//结果
Hibernate: 
    select
        dept0_.id as id0_0_,
        dept0_.name as name0_0_ 
    from
        dept dept0_ 
    where
        dept0_.id=?
Hibernate: 
    select
        staffset0_.deptId as deptId0_1_,
        staffset0_.id as id1_,
        staffset0_.id as id1_0_,
        staffset0_.name as name1_0_,
        staffset0_.deptId as deptId1_0_ 
    from
        staff staffset0_ 
    where
        staffset0_.deptId=?
如果sql语句在这句话之上说明是立即加载，如果在之下就是延迟加载
[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]

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

　

Dept dept = (Dept) session.get(Dept.class, 2);
        System.out.println("如果sql语句在这句话之上说明是立即加载，如果在之下就是延迟加载");
        Set<Staff> set = dept.getStaffSet();
        System.out.println(set);
 
//结果
Hibernate: 
    select
        dept0_.id as id0_0_,
        dept0_.name as name0_0_ 
    from
        dept dept0_ 
    where
        dept0_.id=?
如果sql语句在这句话之上说明是立即加载，如果在之下就是延迟加载
Hibernate: 
    select
        staffset0_.deptId as deptId0_1_,
        staffset0_.id as id1_,
        staffset0_.id as id1_0_,
        staffset0_.name as name1_0_,
        staffset0_.deptId as deptId1_0_ 
    from
        staff staffset0_ 
    where
        staffset0_.deptId=?
[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]

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

　　

Dept dept = (Dept) session.get(Dept.class, 2);
        System.out.println("如果sql语句在这句话之上说明是立即加载，如果在之下就是延迟加载");
        Set<Staff> set = dept.getStaffSet();
        System.out.println(set.size());
 
//结果
Hibernate: 
    select
        dept0_.id as id0_0_,
        dept0_.name as name0_0_ 
    from
        dept dept0_ 
    where
        dept0_.id=?
如果sql语句在这句话之上说明是立即加载，如果在之下就是延迟加载
Hibernate: 
    select
        count(id) 
    from
        staff 
    where
        deptId =?
9

 

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

lazy=false：立即检索

Dept dept = (Dept) session.createQuery("from Dept").list().get(0);
        System.out.println("如果sql语句在这句话之上说明是立即加载，如果在之下就是延迟加载");
        Set<Staff> set = dept.getStaffSet();
        System.out.println(set);
 
//结果
Hibernate: 
    select
        dept0_.id as id0_,
        dept0_.name as name0_ 
    from
        dept dept0_
Hibernate: 
    select
        staffset0_.deptId as deptId0_1_,
        staffset0_.id as id1_,
        staffset0_.id as id1_0_,
        staffset0_.name as name1_0_,
        staffset0_.deptId as deptId1_0_ 
    from
        staff staffset0_ 
    where
        staffset0_.deptId in (
            select
                dept0_.id 
            from
                dept dept0_
        )
如果sql语句在这句话之上说明是立即加载，如果在之下就是延迟加载
[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]

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，也就是一方

　　　　　　　　　　　　　　　　

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

 

Staff staff = (Staff) session.createQuery("from Staff").list().get(0);
        System.out.println("如果sql语句在这句话之上说明是立即加载，如果在之下就是延迟加载");
        Dept dept = staff.getDept();
        System.out.println(dept);
//结果
Hibernate: 
    select
        staff0_.id as id1_,
        staff0_.name as name1_,
        staff0_.deptId as deptId1_ 
    from
        staff staff0_
如果sql语句在这句话之上说明是立即加载，如果在之下就是延迟加载
Hibernate: 
    select
        dept0_.id as id0_0_,
        dept0_.name as name0_0_ 
    from
        dept dept0_ 
    where
        dept0_.id=?
Dept [id=2, name=1部门]

总结：　

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语句，我已经数过了。

List<Dept> list = session.createQuery("from Dept").list();
        
        for(Dept dept : list){
            System.out.println(dept.getStaffSet());
        }
 
//结果
Hibernate: 
    select
        dept0_.id as id0_,
        dept0_.name as name0_ 
    from
        dept dept0_
Hibernate: 
    select
        staffset0_.deptId as deptId0_1_,
        staffset0_.id as id1_,
        staffset0_.id as id1_0_,
        staffset0_.name as name1_0_,
        staffset0_.deptId as deptId1_0_ 
    from
        staff staffset0_ 
    where
        staffset0_.deptId=?
[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]
Hibernate: 
    select
        staffset0_.deptId as deptId0_1_,
        staffset0_.id as id1_,
        staffset0_.id as id1_0_,
        staffset0_.name as name1_0_,
        staffset0_.deptId as deptId1_0_ 
    from
        staff staffset0_ 
    where
        staffset0_.deptId=?
[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]
Hibernate: 
    select
        staffset0_.deptId as deptId0_1_,
        staffset0_.id as id1_,
        staffset0_.id as id1_0_,
        staffset0_.name as name1_0_,
        staffset0_.deptId as deptId1_0_ 
    from
        staff staffset0_ 
    where
        staffset0_.deptId=?
[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]
Hibernate: 
    select
        staffset0_.deptId as deptId0_1_,
        staffset0_.id as id1_,
        staffset0_.id as id1_0_,
        staffset0_.name as name1_0_,
        staffset0_.deptId as deptId1_0_ 
    from
        staff staffset0_ 
    where
        staffset0_.deptId=?
[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]
Hibernate: 
    select
        staffset0_.deptId as deptId0_1_,
        staffset0_.id as id1_,
        staffset0_.id as id1_0_,
        staffset0_.name as name1_0_,
        staffset0_.deptId as deptId1_0_ 
    from
        staff staffset0_ 
    where
        staffset0_.deptId=?
[oneToMany.Staff@1cf8338b, oneToMany.Staff@7beca583, oneToMany.Staff@5fb369e2, oneToMany.Staff@532cb84e, oneToMany.Staff@6afff988, oneToMany.Staff@1d8df66a, oneToMany.Staff@52ae002e, oneToMany.Staff@6b8dce4, oneToMany.Staff@5f45cd73, oneToMany.Staff@4b578699]

 

解决：使用一个属性，batch-size。

　　1、从部门查员工。也就是从单向一对多，从一方查多方，查询每个部门中的员工有哪些这样的问题？，那么就在映射文件中的set中设置batch-size。有多少个部门，就至少设置多少，意思就是一次性查询多少个。从上面的例子中可以看出，发送了5条对staff的查询语句，所以这里batch-size至少为5，大于5可以，浪费了，小于5的话，又会多发sql语句。所以如果能够确定查询多少个，那么就写确定值，如果不能确定，那么就写稍微大一点；

　　　

　　可以看结果，只发送两条sql语句，第一条是查询部门的，第二条是一看，使用关键字 IN 来将所有的部门ID含括在内，我们应该就知道了，原来原理是这样，这样就只需要发送一条sql语句，来达到发送5条sql语句才能完成的功能。 这就是批量检索，其实原理很简单

List<Dept> list = session.createQuery("from Dept").list();
        
        for(Dept dept : list){
            System.out.println(dept.getStaffSet());
        }
//结果，只发送两条sql语句
Hibernate: 
    select
        dept0_.id as id0_,
        dept0_.name as name0_ 
    from
        dept dept0_
Hibernate: 
    select
        staffset0_.deptId as deptId0_1_,
        staffset0_.id as id1_,
        staffset0_.id as id1_0_,
        staffset0_.name as name1_0_,
        staffset0_.deptId as deptId1_0_ 
    from
        staff staffset0_ 
    where
        staffset0_.deptId in (
            ?, ?, ?, ?, ?
        )
[oneToMany.Staff@4d9875b1, oneToMany.Staff@3ab5ab4c, oneToMany.Staff@456ffab9, oneToMany.Staff@5456df43, oneToMany.Staff@135bd2f7, oneToMany.Staff@6d0128b0, oneToMany.Staff@7177600e, oneToMany.Staff@199f55f4, oneToMany.Staff@4a9810b1, oneToMany.Staff@671672b8]
[oneToMany.Staff@4d6a54b0, oneToMany.Staff@41c65839, oneToMany.Staff@718bc0c4, oneToMany.Staff@7fde1684, oneToMany.Staff@1538c1e3, oneToMany.Staff@4d2d1f6d, oneToMany.Staff@157f068f, oneToMany.Staff@1ce89199, oneToMany.Staff@46e1d5d9, oneToMany.Staff@414128f7, oneToMany.Staff@104628c, oneToMany.Staff@4687a14f, oneToMany.Staff@149ebdea, oneToMany.Staff@68aee2a2, oneToMany.Staff@726f6db5, oneToMany.Staff@72c5c2e7, oneToMany.Staff@e1cbe19, oneToMany.Staff@88f2363, oneToMany.Staff@31a12f5f, oneToMany.Staff@590bcaf1]
[oneToMany.Staff@59bd770a, oneToMany.Staff@3402d895, oneToMany.Staff@23081b81, oneToMany.Staff@79897ed0, oneToMany.Staff@26d938e0, oneToMany.Staff@7f250e0c, oneToMany.Staff@31e4c806, oneToMany.Staff@25d25f8d, oneToMany.Staff@44ca27eb, oneToMany.Staff@167f3561]
[oneToMany.Staff@5ce4c86b, oneToMany.Staff@132ff4b6, oneToMany.Staff@316ae291, oneToMany.Staff@480955df, oneToMany.Staff@30221872, oneToMany.Staff@6945c41e, oneToMany.Staff@6040b6ef, oneToMany.Staff@1f43a98b, oneToMany.Staff@634ec390, oneToMany.Staff@e72fd0e]
[oneToMany.Staff@3f574c4a, oneToMany.Staff@56a88251, oneToMany.Staff@7c51aec2, oneToMany.Staff@4d45222c, oneToMany.Staff@38aa3647, oneToMany.Staff@1a66421c, oneToMany.Staff@42c51adb, oneToMany.Staff@5103c049, oneToMany.Staff@2ed18c61, oneToMany.Staff@75c69e55]

2、上面是从一查多，batch-size放在set中。从多查一呢，在many-to-one中并没有batch-size这个属性。注意了，此时batch-size放在一方的class中。看下图

　　

　　先不着急看批量检索后的结果，先来看看如果没有该属性，会怎么发送sql语句。发送多少条。

　　查询每个员工所属的部门信息。一想，如果每个员工都到部门表中查一次，包括开始查询自己员工的信息，也是n+1问题，比如有10个员工，那么就会发送11个sql语句，如果你这样想，就误解了这个n+1的意思。这个n+1的意思跟上面从部门查询员工的n+1的意思是一样的，因为不管有多少个员工，其中总会有一些员工是在同一个部门，既然在同一个部门，那么就不用一直发送重复的sql语句了，而是相同部门的员工，就只查询一次就足够了。所以，不管有多少员工，发送的sql语句还是部门的数量加1.也就是n+1，这才是真正的n+1问题。来看不用批量检索时，员工查询部门是不是发送6条sql语句

　　　

List<Staff> list = session.createQuery("from Staff").list();
        
        for(Staff staff : list){
            System.out.println(staff.getName()+","+staff.getDept());
        }
//结果
Hibernate: 
    select
        staff0_.id as id1_,
        staff0_.name as name1_,
        staff0_.deptId as deptId1_ 
    from
        staff staff0_
Hibernate: 
    select
        dept0_.id as id0_0_,
        dept0_.name as name0_0_ 
    from
        dept dept0_ 
    where
        dept0_.id=?
qqq,Dept [id=2, name=2部门]
qqq1,Dept [id=2, name=2部门]
qqq2,Dept [id=2, name=2部门]
qqq3,Dept [id=2, name=2部门]
qqq4,Dept [id=2, name=2部门]
qqq5,Dept [id=2, name=2部门]
qqq6,Dept [id=2, name=2部门]
qqq7,Dept [id=2, name=2部门]
qqq8,Dept [id=2, name=2部门]
qqq9,Dept [id=2, name=2部门]
Hibernate: 
    select
        dept0_.id as id0_0_,
        dept0_.name as name0_0_ 
    from
        dept dept0_ 
    where
        dept0_.id=?
yyy0,Dept [id=1, name=1部门]
yyy1,Dept [id=1, name=1部门]
yyy2,Dept [id=1, name=1部门]
yyy3,Dept [id=1, name=1部门]
yyy4,Dept [id=1, name=1部门]
yyy5,Dept [id=1, name=1部门]
yyy6,Dept [id=1, name=1部门]
yyy7,Dept [id=1, name=1部门]
yyy8,Dept [id=1, name=1部门]
yyy9,Dept [id=1, name=1部门]
yyy0,Dept [id=2, name=2部门]
yyy1,Dept [id=2, name=2部门]
yyy2,Dept [id=2, name=2部门]
yyy3,Dept [id=2, name=2部门]
yyy4,Dept [id=2, name=2部门]
yyy5,Dept [id=2, name=2部门]
yyy6,Dept [id=2, name=2部门]
yyy7,Dept [id=2, name=2部门]
yyy8,Dept [id=2, name=2部门]
yyy9,Dept [id=2, name=2部门]
Hibernate: 
    select
        dept0_.id as id0_0_,
        dept0_.name as name0_0_ 
    from
        dept dept0_ 
    where
        dept0_.id=?
yyy0,Dept [id=3, name=3部门]
yyy1,Dept [id=3, name=3部门]
yyy2,Dept [id=3, name=3部门]
yyy3,Dept [id=3, name=3部门]
yyy4,Dept [id=3, name=3部门]
yyy5,Dept [id=3, name=3部门]
yyy6,Dept [id=3, name=3部门]
yyy7,Dept [id=3, name=3部门]
yyy8,Dept [id=3, name=3部门]
yyy9,Dept [id=3, name=3部门]
Hibernate: 
    select
        dept0_.id as id0_0_,
        dept0_.name as name0_0_ 
    from
        dept dept0_ 
    where
        dept0_.id=?
yyy0,Dept [id=4, name=4部门]
yyy1,Dept [id=4, name=4部门]
yyy2,Dept [id=4, name=4部门]
yyy3,Dept [id=4, name=4部门]
yyy4,Dept [id=4, name=4部门]
yyy5,Dept [id=4, name=4部门]
yyy6,Dept [id=4, name=4部门]
yyy7,Dept [id=4, name=4部门]
yyy8,Dept [id=4, name=4部门]
yyy9,Dept [id=4, name=4部门]
Hibernate: 
    select
        dept0_.id as id0_0_,
        dept0_.name as name0_0_ 
    from
        dept dept0_ 
    where
        dept0_.id=?
yyy0,Dept [id=5, name=5部门]
yyy1,Dept [id=5, name=5部门]
yyy2,Dept [id=5, name=5部门]
yyy3,Dept [id=5, name=5部门]
yyy4,Dept [id=5, name=5部门]
yyy5,Dept [id=5, name=5部门]
yyy6,Dept [id=5, name=5部门]
yyy7,Dept [id=5, name=5部门]
yyy8,Dept [id=5, name=5部门]
yyy9,Dept [id=5, name=5部门]

自己数一下，确实是发送的6条sql语句，然后在Dept的class中加上batch-size属性。

　　　　　　　　　　　　　　

　　　　　　　　　　　　　　结果就发送两条sql语句。

List<Staff> list = session.createQuery("from Staff").list();
        
        for(Staff staff : list){
            System.out.println(staff.getName()+","+staff.getDept());
        }
//结果
Hibernate: 
    select
        staff0_.id as id1_,
        staff0_.name as name1_,
        staff0_.deptId as deptId1_ 
    from
        staff staff0_
Hibernate: 
    select
        dept0_.id as id0_0_,
        dept0_.name as name0_0_ 
    from
        dept dept0_ 
    where
        dept0_.id in (
            ?, ?, ?, ?, ?
        )
qqq,Dept [id=2, name=2部门]
qqq1,Dept [id=2, name=2部门]
qqq2,Dept [id=2, name=2部门]
qqq3,Dept [id=2, name=2部门]
qqq4,Dept [id=2, name=2部门]
qqq5,Dept [id=2, name=2部门]
qqq6,Dept [id=2, name=2部门]
qqq7,Dept [id=2, name=2部门]
qqq8,Dept [id=2, name=2部门]
qqq9,Dept [id=2, name=2部门]
yyy0,Dept [id=1, name=1部门]
yyy1,Dept [id=1, name=1部门]
yyy2,Dept [id=1, name=1部门]
yyy3,Dept [id=1, name=1部门]
yyy4,Dept [id=1, name=1部门]
yyy5,Dept [id=1, name=1部门]
yyy6,Dept [id=1, name=1部门]
yyy7,Dept [id=1, name=1部门]
yyy8,Dept [id=1, name=1部门]
yyy9,Dept [id=1, name=1部门]
yyy0,Dept [id=2, name=2部门]
yyy1,Dept [id=2, name=2部门]
yyy2,Dept [id=2, name=2部门]
yyy3,Dept [id=2, name=2部门]
yyy4,Dept [id=2, name=2部门]
yyy5,Dept [id=2, name=2部门]
yyy6,Dept [id=2, name=2部门]
yyy7,Dept [id=2, name=2部门]
yyy8,Dept [id=2, name=2部门]
yyy9,Dept [id=2, name=2部门]
yyy0,Dept [id=3, name=3部门]
yyy1,Dept [id=3, name=3部门]
yyy2,Dept [id=3, name=3部门]
yyy3,Dept [id=3, name=3部门]
yyy4,Dept [id=3, name=3部门]
yyy5,Dept [id=3, name=3部门]
yyy6,Dept [id=3, name=3部门]
yyy7,Dept [id=3, name=3部门]
yyy8,Dept [id=3, name=3部门]
yyy9,Dept [id=3, name=3部门]
yyy0,Dept [id=4, name=4部门]
yyy1,Dept [id=4, name=4部门]
yyy2,Dept [id=4, name=4部门]
yyy3,Dept [id=4, name=4部门]
yyy4,Dept [id=4, name=4部门]
yyy5,Dept [id=4, name=4部门]
yyy6,Dept [id=4, name=4部门]
yyy7,Dept [id=4, name=4部门]
yyy8,Dept [id=4, name=4部门]
yyy9,Dept [id=4, name=4部门]
yyy0,Dept [id=5, name=5部门]
yyy1,Dept [id=5, name=5部门]
yyy2,Dept [id=5, name=5部门]
yyy3,Dept [id=5, name=5部门]
yyy4,Dept [id=5, name=5部门]
yyy5,Dept [id=5, name=5部门]
yyy6,Dept [id=5, name=5部门]
yyy7,Dept [id=5, name=5部门]
yyy8,Dept [id=5, name=5部门]
yyy9,Dept [id=5, name=5部门]


 

疑问一：为什么从一到多，batch-size就放在set中，而从多到一，batch-size也是放在一方的class中？

　　这样去想：一方查多方，在一方的set中就代表着多方的对象，将batch-size放在set中，就可以理解查多方的时候，就使用批量检索了。

　　多方查一方，在一方的class中设置batch-size。可以理解，当多方查到一方时，在一方的映射文件中的class部分遇到了batch-size就知道查询一方时需要批量检索了

　　这样应该更好理解和记忆。

　　　　　　　　

五、总结

这一章节分析的是三大检索方式。其目的是让开发者自己能够调节性能，就三大块内容

　　1、类级别检索

　　　　get和load的区别，和原理。

　　2、关联级别检索

　　　　fetch和lazy属性的用法。 这里面要理解的前提是对sql语句比较了解，要知道什么是左外连接，才能进一步讨论迫切左外连接是什么。

　　　　　　　一对多和多对多一组讨论其用法

　　　　　　　多对一和一对一为一组讨论其用法

　　3、批量检索

　　　　解决n+1问题，要知道n+1描述的是什么问题。

 

　　差不多就到这里了，一定不要因为学了这章导致基本的hibernate查询度不会了，这个只是为了调节性能而深入讨论的东西。平常该怎么用就怎么用，该怎么用hql或者qbc查询就怎么查询。只是在get、load查询或者关联级别查询时留个心眼就足够了。



转载于：https://www.cnblogs.com/whgk/p/6164862.html

 

yigg
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hibernate的fetch="join" 和 fetch="select" 的一点搜集
我的世界我的梦
08-23 3984
fetch参数指定了关联对象抓取的方式是select查询还是join查询，select方式时先查询返回要查询的主体对象（列表），再根据关联外键id，每一个对象发一个select查询，获取关联的对象，形成n+1次查询； 而join方式，主体对象和关联对象用一句外键关联的sql同时查询出来，不会形成多次查询。 如果你的关联对象是延迟加载的，它当然不会去查询关联对象。 另外，在hql查询中配置文件中设置
9.0 hibernate_检索策略(lazy、fetch、batch-size等)
yiguang_820的博客
01-19 317
一、概述 检索策略分三大块，类级别检索策略和关联级别检测策略。 类级别检索策略：get、load、关联级别检索策略：order.getCustomer().getName() 上面这两种应该是看得懂的。很容易去理解，现在就具体来说说这两种其中的细节。 批量检索解决n+1问题。 二、类级别检索策略 2.1、立即检索  get 直接发送sql语句，
hibernate抓取策略fetch=select /join/subselect
行动起来
04-10 188
出处：http://blog.csdn.net/ychatou1220/article/details/6489881 一、hibernate抓取策略（单端代理的批量抓取fetch=select(默认）/join） 测试用例： Student student = (Student)session.get(Student.class, 1);    System.out.println(st...
hibernate中的fetch
YDDMAX
01-04 493
本文转载自：http://blog.csdn.net/tianlincao/article/details/6084141 hibernate抓取策略fetch详解 一、hibernate抓取策略（单端代理的批量抓取fetch=select(默认）/join） 测试用例： Student student = (Student)session.get(Student.class, 1);
在Hibernate应用中如何处理批量更新和批量删除？
zhaopengfei8023的专栏
08-21 839
<br />在Hibernate应用中如何处理批量更新和批量删除？<br />选自<<精通Hibernate：Java对象持久化技术详解>> 作者：孙卫琴 来源:www.javathinker.org<br />如果转载，请标明出处，谢谢<br />9.4 批量处理数据<br /> <br />通常，在一个Session对象的缓存中只存放数量有限的持久化对象，等到Session对象处理事务完毕，还要关闭Session对象，从而及时释放Session的缓存占用的内存。<br />批量处理数据是指在一个事务中处
SSH笔记-检索策略(lazy、fetch、batch-size)
04-19
hibernate的类级别检索策略和检索策略的lazy、fetch、batch-size属性使用
v-img::camera_with_flash:使用webp和lazyload图像
04-25
用法< v xss=removed xss=removed> 提供者组件使用provider选择图像处理策略，以下是可用值： 阿里巴巴（默认值，与华为云兼容） 秦牛自己没有任何默认情况下使用阿里巴巴OSS服务，因此，如果您在阿里巴巴OSS上托管...
lazy-snapping--master.zip_lazy-snapping
09-23
基于lazy-snapping的图片分割代码
mediawiki-lazyload:扩展以延迟在MediaWiki页面上加载图像
05-07
Lazyload扩展需要MediaWiki 1.25或更高版本。 安装 要安装扩展，请将整个Lazyload目录放置在MediaWiki extensions目录中，然后Lazyload添加到LocalSettings.php文件中： wfLoadExtension ( 'Lazyload' ); 如果您在...
vue-lazyload使用总结(推荐)
10-17
vue项目用到vue-lazyload做图片懒加载，这篇文章主要介绍了vue-lazyload使用总结，解决这个插件的坑，非常具有实用价值，需要的朋友可以参考下
fetch="join" 和 fetch="select" 的区别
qingfengxia2013的专栏
03-19 515
http://www.javaeye.com/topic/77475 在hibernate3里面多了 fetch的选项，文档里面说得很简单，我知道lazy参数才是决定是否在查询主表的时候去查询子表，但是这个 fetch又起什么作用呢？我测试了一下，发现无论是 fetch="join" 还是 fetch="select",hibernate向数据库发送的 SQL都是一样的。 以一个简单的一对多做例...
hibernate fetch的select 和 join的区别
lbxhappy的专栏
03-11 148
join 查询的时候，是用一条语句查处所有记录，包括关联表记录，select查出的是N+1条记录，两个都是差不多的，但是如果用了lazy=true，延迟加载的话，select在查询时只会查出主表记录，也就是1，如果其他地方也用到了数据，此时就会自动在执行查询，查出N，可以降低内存消耗 .还有，hibernate是的session是轻量级的，创建和销毁都不花很多资源，查询数据也很快，这里fetch主...
Hibernate--批量抓取batch-size
吴声子夜歌的博客
10-07 925
批量抓取 在抓取策略中有一种叫做批量抓取，就是同时查询多个对象的关联对象的时候，可以采用批量抓取进行优化。 如果要实现批量抓取效果，可以通过batch-size来完成。 创建表 cst_customer与cst_linkman是一对多关系，cust_id为外键。 cst_customer表： cst_linkman表： 创建实体类 Customer类： public class Custome...
Hibernate - fetch和select两种抓取方式对比
SteveJrong's Blog
09-02 2380
Hibernate - fetch和select两种抓取方式对比 在Hibernate的类的映射文件中，在存在关系的情况之下，会看到标签后有一个fetch属性，它是用来指定如何查询关联对象的。   select join 执行过程 另外发送一条select语句抓取当前对象关联实体或集合 会通过select语句使用外连接来
@Fetch FetchMode=select/join/subselect
邹浩阳的专栏
08-26 6393
最近看到了hibernate的fetch mode ，想着以前用的是fetch=fetchType.LAZY/EAGER 。就去网上查了一下，发现都是设定关联对象的加载策略。 FetchType.LAZY: 懒加载，在访问关联对象的时候加载(即从数据库读入内存) FetchType.EAGER:立刻加载，在查询主对象的时候同时加载关联对象。 @Fetch(FetchMode.JO
fetch="join" 和 fetch="select"
我的java笔记库
11-04 203
Fetching 策略用来决定如何读取那些关联子对象。 代码 List list=session.createQuery("from PostThread").list(); 在配置中使用fetch=“join” ，Hibernate将在同一个select中返回关联子对象或集合,能够利用Oracle 或 Sybase类型outer joins能够提高性能 fetch=“...
fetch="select" 与lazy="false"
小青青的技术之家
05-18 862
当我用fetch="select时" 网上书店模块可以正常显示，因为人家显示新书籍不需要显示书目。但是显示二手货信息就不能正常显示。因为tbType那个全部都为空的，后来在info.hbm.xml中设置了                                                 就能正常显示了
vue-lazyload 怎么做用图片链接发起get请求获取数据后解密生成图片地址
最新发布
05-31
首先，你需要在 Vue 项目中安装 `axios` 和 `crypto-js` 两个库，可以使用以下命令安装： ```bash npm install axios crypto-js --save ``` 然后，在需要使用懒加载的组件中，可以通过 `axios` 发起 GET 请求获取...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值