Hibernate--fetch抓取策略

最新推荐文章于 2019-05-21 09:13:42 发布
最新推荐文章于 2019-05-21 09:13:42 发布
阅读量6k 收藏 7
点赞数 1
CC 4.0 BY-SA版权
分类专栏： hibernate 文章标签： hibernate fetch策略
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u012411414/article/details/50482405
本文介绍了Hibernate的fetch策略，包括默认的懒加载和全加载（fetch=join）。重点讨论了如何通过xml和注解配置fetch策略以减少SQL查询次数，如设置batch-size以提高性能。同时提到了fetch=join不能与count(*)一起使用的情况以及在HQL查询时的注意事项。此外，还提出了在不同场景下优化fetch策略的方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

有几个需要注意的地方：

1 在xml配置中 是默认懒加载的（fetch=select），也就是在使用到懒加载对象的属性时候  才会发出SQL语句，不使用的话就发一个SQL即可，若遍历时使用关联对象的属性，那么会发出大量SQL，而这是我们不希望看见的

很多情况下 我们是要希望能使用fetch=Join 也就是实现全部加载 只发出一条SQL，即使没有显示的使用关联对象属性仍然全部加载，此SQL使用left join连接表。省的在遍历时调用关联对象属性的时候 再发出大量SQL 给数据库造成巨大压力（反正是要把数据都取出来的）

2 annatation中是默认对象fetchType=eager 也就是join 而不是select懒加载，即全部加载

3 这是加载多端对象 想要加载全部

 默认在xml中会发出3条SQL语句 一条区student 一条取classroom 一条取special
 通过设置student的xml中的<many-to-one name="classroom"  column="cid" fetch="join"/>
 同样要对classroom进行设置 join抓取special
  可以完成对抓取的设置

            session=HibernateUtil.openSession();
            Student stu=(Student)session.load(Student.class,1);
            System.err.println(stu.getName()+","+
            stu.getClassroom().getName()+","+stu.getClassroom().getSpecial().getName());
4 使用fetch=join虽然可以把关联的对象全部抓取出来  但是如果不使用关联对象 也会一并查询出来
    这样也会占用内存 数据库等资源
    此时延迟加载就失效了 

<span style="white-space:pre">	</span>    session=HibernateUtil.openSession();
            Student stu=(Student)session.load(Student.class,2);
            System.err.println(stu.getName());
5 因为fetch＝ｊｏｉｎ仅仅对Load时候有用 对ＨＱＬ没有作用　用到了再发SQL
   所以此时使用默认方式ｆｅｔｃｈ＝ｓｅｌｅｃｔ
   从多端级联查询一端解决方案2中：

1设置对象抓取的batch size在班级中设置 比如=20 表示加载student对象时一次取20个班 默认是一次一个班 
               相当于一下子把关联的很多班级都取了出来 功能上=fetch=join
              <class name="Classroom" table="t_cla" batch-size="3">
                但是占内存多 且session关闭额 就数据消失了

  <span style="white-space:pre">	</span>List<Student> stus=session.createQuery("from Student").list();
            for (Student student : stus)
            {
                System.out.println(student.getName()+student.getClassroom());
            }
        2  重要 ：在HQL中使用fetch来指定抓取 可以做到只对关联对象查一次 完全类似join在Load中的功能

        这是加载关联对象时候只会发出一条SQL  但是join fetch不能和count(*)同时使用  我们计数时候 把fetch去掉就是了

            session=HibernateUtil.openSession();
            List<Student> stus=session.createQuery("select stu from Student stu join fetch stu.classroom").list();
            for (Student student : stus)
            {
                System.out.println(student.getName()+student.getClassroom());
            }

6对于从一端加载的情况  从一端fetch的情况 默认延迟加载 

 session=HibernateUtil.openSession();
            Classroom cla=(Classroom)session.load(Classroom.class,1);
            System.out.println(cla.getName());//延迟加载发出一条SQL
            for (Student student : cla.getStudents())//延迟加载 cla.getStudents()会发一条SQL 取出所有students
            {
                System.out.println(student.getName());
            }
7 注意：多对一时候 从多端懒加载一对象（目的是为了全部加载多端对象）
        在一端加batch-size=3 表示3个一端对象对应的所有多端对象全部加载 比如3个班的所有学生加载  减少发出的SQL
同理： 一对多时候 从一端延迟加载多端对象 在一端set中batch-size="3"表示3个一端对象对应的所有多端对象全部延迟加载

 8 对于通过HQL取班级列表并且获取相应学生列表时候  fetch=join 就无效 还是select懒加载模式
      （一端取被多端关联的对象 注意和第五条区别） 2种方案解决这个问题 因为我们的目的是要尽可能一次性全部加载（通过join连接） 不要懒加载（每用一次发个SQL）

          1 在一的一端set中加入batch-size 见test08

      <set name="students" inverse="true" lazy="extra" fetch="subselect" batch-size="2">
			<key column="cid" />
			<one-to-many class="Student"/>
      </set>
           2 第二种方案可以设置fetch=sub-select 通过子查询 自动查出的班级再通过子查询查所有对应的学生
             这是个非常好的解决方法 1条SQL搞定 很好

9 batsize都是在一端设置 多级联查询一时候 在xml的class上添加  ，一级联查询多时候  在set 上添加

下面是配置文件和 测试代码

<?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 package="com.itany.model">

	<class name="Student" table="t_stu">
		<!--  <cache usage="read-only" /> -->
		<id name="id">
			<generator class="native"></generator>
		</id>
		<!-- 注意：version 一定要加在ID后面 property前面 -->
		<version name="version" />
		<property name="name" />
		<property name="sex" />
		<many-to-one name="classroom" column="cid" fetch="join" />
	</class>

</hibernate-mapping>

<?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 package="com.itany.model">

<!-- 注意：多对一时候 从多端懒加载一对象（目的是为了全部加载多端对象）
           在一端加batch-size=3 表示3个一端对象对应的所有多端对象全部加载 比如3个班的所有学生加载  减少发出的SQL
	 同理： 一对多时候 从一端延迟加载多端对象 在一端set中batch-size="3"表示3个一端对象对应的所有多端对象全部延迟加载-->
	<class name="Classroom" table="t_cla" batch-size="3">
		<id name="id" >
		 <generator class="native"></generator>
		</id>
		<property name="name" />
		<property name="grade" />
		<!-- 表示一次加载2个classroom的所有学生 -->
		<set name="students" inverse="true" lazy="extra" fetch="subselect" batch-size="2">
			<key column="cid" />
			<one-to-many class="Student"/>
		</set>
		<many-to-one name="special"  column="spec_id" fetch="join"/>
	 
	</class>

</hibernate-mapping>

<?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 package="com.itany.model">

	<class name="Special" table="t_spec">
		<id name="id" >
		 <generator class="native"></generator>
		</id>
		<property name="name" />
		<property name="type" />
		<set name="clas" inverse="true" lazy="extra">
			<key column="spec_id" />
			<one-to-many class="Classroom" />
		</set>
	 
	</class>

</hibernate-mapping>
public class TestFetch
{
    @Test
    public void test01()
    {
        Session session=null;
        Transaction trans=null;
        try 
        {
            /*
             * 默认在xml中会发出3条SQL语句 一条区student 一条取classroom 一条取special
             * 通过设置student的xml中的<many-to-one name="classroom"  column="cid" fetch="join"/>
             * 同样要对classroom进行设置 join抓取special
             * 可以完成对抓取的设置
             */
            session=HibernateUtil.openSession();
            Student stu=(Student)session.load(Student.class,1);
            System.err.println(stu.getName()+","+
            stu.getClassroom().getName()+","+stu.getClassroom().getSpecial().getName());
            
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }
    @Test
    public void test02()
    {
        Session session=null;
        Transaction trans=null;
        try 
        {
            /*
             * 使用fetch=join虽然可以把关联的对象全部抓取出来  但是如果不使用关联对象 也会一并查询出来
             * 这样也会占用内存 数据库等资源
             * 此时延迟加载就失效了 
             */
            session=HibernateUtil.openSession();
            Student stu=(Student)session.load(Student.class,2);
            System.err.println(stu.getName());
            
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }
    @Test
    public void test03() 
    {
        Session session=null;
        Transaction trans=null;
        try 
        {
            /*
             * 此时虽然在xml中设置了fetch=join 结果仍然发出了取classroom得SQL语句 没有合并成一句执行(即立即全部查出关联对象)
             * 因为fetch＝ｊｏｉｎ仅仅对Load时候有用 对ＨＱＬ没有作用　用到了再发
             * 所以此时使用默认方式ｆｅｔｃｈ＝ｓｅｌｅｃｔ　所以此时发出查询班级的ＳＱＬ　
             * 
             * 解决方案：２种
             * 1 设置对象抓取的batch size在班级中设置 比如=20 表示加载student对象时一次取20个班 默认是一次一个班 
             *   相当于一下子把关联的很多班级都取了出来 功能上=fetch=join
             *   <class name="Classroom" table="t_cla" batch-size="3">
             *   但是占内存多 且session关闭额 就数据消失了
             * 2  重要 ：在HQL中使用fetch来指定抓取 可以做到只对关联对象查一次 完全类似join在Load中的功能
             * 例子见test04
             */
            session=HibernateUtil.openSession();
            List<Student> stus=session.createQuery("from Student").list();
            for (Student student : stus)
            {
                System.out.println(student.getName()+student.getClassroom());
            }
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }
    @Test
    public void test04() 
    {
        Session session=null;
        Transaction trans=null;
        try 
        {
            /*
             * 此时在普通的from Student stu join fetch stu.classroom
             * 这是加载关联对象时候只会发出一条SQL
             * 但是join fetch不能和count(*)同时使用
             * 我们计数时候 把fetch去掉就是了
             */
            session=HibernateUtil.openSession();
            List<Student> stus=session.createQuery("select stu from Student stu join fetch stu.classroom").list();
            for (Student student : stus)
            {
                System.out.println(student.getName()+student.getClassroom());
            }
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }
    //从一端fetch的情况 默认延迟加载
    @Test
    public void test05() 
    {
        Session session=null;
        Transaction trans=null;
        try 
        {
            /*
             */
            session=HibernateUtil.openSession();
            Classroom cla=(Classroom)session.load(Classroom.class,1);
            System.out.println(cla.getName());//延迟加载发出一条SQL
            for (Student student : cla.getStudents())//延迟加载 cla.getStudents()会发一条SQL 取出所有students
            {
                System.out.println(student.getName());
            }
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }
  //双向：以下都是。从一端fetch的情况 fetch=join
    @Test
    public void test06() 
    {
        Session session=null;
        Transaction trans=null;
        try 
        {
            /*
             */
            session=HibernateUtil.openSession();
            Classroom cla=(Classroom)session.load(Classroom.class,1);
            System.out.println(cla.getName());//一共就一条SQL 此时全部加载关联对象 虽然没有显示调用 
            for (Student student : cla.getStudents())//
            {
                System.out.println(student.getName());
            }
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }
    @Test
    public void test07() 
    {
        Session session=null;
        Transaction trans=null;
        try 
        {
            /*对于通过HQL取班级列表并且获取相应学生列表时候  fetch=join 就无效 还是select懒加载模式
             * 2种方案解决这个问题 因为我们的目的是要尽可能一次性全部加载（通过join连接） 不要懒加载（每用一次发个SQL）
             *  1 在一的一端set中加入batch-size 见test08
             *  2 第二种方案可以设置fetch=sub-select 通过子查询 自动查出的班级再通过子查询查所有对应的学生
             *  这是个非常好的解决方法 1条SQL搞定 很好
             */
            session=HibernateUtil.openSession();
            List<Classroom> clas=session.createQuery("from Classroom").list();//执行完这步 会发一句SQL 查询所有classroom
            for (Classroom classroom : clas)
            {
                System.out.println(classroom.getName());
                for (Student student : classroom.getStudents())//每一个classroom懒加载该id的所有学生 一共发出10次 因为有10个班级
                {
                    System.out.println(student.getName());
                }
            }
            
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }
    @Test
    public void test08() 
    {
        Session session=null;
        Transaction trans=null;
        try 
        {
            /*在classroom 中set中设置batch-size=2 在一的一端进行设置
             */
            session=HibernateUtil.openSession();
            List<Classroom> clas=session.createQuery("from Classroom").list();//
            for (Classroom classroom : clas)
            {
                System.out.println(classroom.getName());
                for (Student student : classroom.getStudents())//
                                                               //
                {
                    System.out.println(student.getName());//
                }
            }
            
        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }
}





Hibernate Fetch 的作用
03-24
正确理解hibernate fetch 的作用
day36 07-Hibernate抓取策略：many-to-one上的抓取策略
04-26
为了解决这个问题，我们可以使用预加载（eager loading）或者子集加载（fetch plan）等抓取策略。 在"many-to-one"关系中，一个实体可以与多个其他实体相关联。默认情况下，Hibernate会设置这种关联为懒加载，即...
Hibernate的抓取策略
热门推荐
Laurence的技术博客
05-05 1万+
1.制定合理的抓取策略对系统性能的提升有很大的作用。Hibernate推荐的原则是：通常情况下，我们并不使用映射文档进行抓取策略的定制。更多的是，保持其默认值，然后在特定的事务中， 使用 HQL 的左连接抓取（left join fetch） 对其进行重载。 hibernate推荐的做法也是最佳实践：把所有对象关联的抓取都设为lazy!然后在特定事务中重载！ 这种考虑是基于：对象图
hibernate抓取策略fetch=select /join/subselect
smile725775的专栏
11-07 690
一、hibernate抓取策略（单端代理的批量抓取fetch=select(默认）/join） 测试用例： Student student = (Student)session.get(Student.class, 1);     System.out.println(student.getName());     System.out.println(student.getClasses
Hibernate的Fetch
我的世界我的梦
11-23 1860
越来越发现其实掌握 hibernate并不容易，Spring用起来其实简单多了，但是在用hibernate的时候真的是需要一定的时间积累，对一个项目组来说如果采用hibernate最好有一个对hibernate比较清楚的人否则碰到问题就会成为项目的风险。我想告诉各位的是，掌握hibernate可能比你预期的难多了，当你轻松的告诉我，hibernate很简单的时候该是你自己多反省了. （只有一种情况
关于Hibernate中fetch作用描述
一个情绪猿的脖克...
09-04 8434
"fetch"连接允许仅仅使用一个选择语句就将相关联的对象或一组值的集合随着他们的父对象的初始化而被初始化，这种方法在使用到集合的情况下尤其有用，对于关联和集合来说，它有效的代替了映射文件中的外联接 与延迟声明（lazy declarations）.  from Cat as cat     inner join fetch cat.mate    left join fetch cat.kit
Hibernate many-to-one抓取策略详解与实践
### Hibernate抓取策略：many-to-one上的抓取策略 Hibernate是一个流行的Java ORM（对象关系映射）框架，它允许开发者用Java对象的形式操作数据库，而不需要直接编写SQL语句。在数据库操作中，实体关系的处理是一个...
day36 08-Hibernate抓取策略：批量抓取
04-26
本篇主要关注的是Hibernate的抓取策略，特别是批量抓取技术，这对于提高应用程序性能至关重要。批量抓取能够减少数据库交互次数，从而优化查询效率。 首先，我们要理解什么是抓取策略。在Hibernate中，抓取策略是指...
day36 06-Hibernate抓取策略：set集合上的抓取策略
04-26
今天我们将深入探讨"day36 06-Hibernate抓取策略"，特别是针对set集合的抓取策略。在阅读这篇博客文章（链接：https://364232252.iteye.com/blog/2368811）后，我们将了解到如何优化数据加载，以避免N+1查询问题，...
hibernate的抓取策略
Gray_humor的博客
03-16 272
一、hibernate抓取策略概述 Hibernate抓取策略（fetching strategy）是指：当应用程序需要在（Hibernate实体对象图的）关联关系间进行导航的时候， Hibernate如何获取关联对象的策略。抓取策略可以在O/R映射的元数据中声明，也可以在特定的HQL 或条件查询（Criteria Query）中重载声明。 需要注意的是：hibernate的抓...
hibernate 中 fetch
heisekankan的专栏
02-18 555
fetch ,可以设置fetch = "select" 和 fetch = "join" 用一对多来举例： fetch ="select"是在查询的时候先查询出一端的实体，然后在根据一端的查询出多端的实体，会产生1+n条sql语句; fetch = "join"是在查询的时候使用外连接进行查询，不会差生1+n的现象。 lazy大家应该都熟悉了，就是延迟加载，可以设置lazy = "
Hibernate中fetch介绍
Midnight_yard_farm的博客
06-12 308
    fetch ,指定关联对象抓取的方式，可以设置fetch = "select" 和 fetch = "join"。select方式时先查询返回要查询的主体对象（列表），再根据关联外键id，每一个对象发一个select查询，获取关联的对象，形成n+1次查询；而join方式，主体对象和关联对象用一句外键关联的sql同时查询出来，不会形成多次查询。在映射文档中定义的抓取策略将会有产生以下影响：（...
Hibernate中的fetch
HotSunMoon的专栏
08-22 633
hibernate抓取策略，单端代理的批量抓取 保持默认，同fetch="select"，如： fetch="select",另外发送一条select语句加载当前对象的关联对象或集合 fetch为select或join不影响hql，它影响的是load，get方法 Emp emp = (Emp) session.get(Emp.class, new Short("7369"));
hibernate中的fetch
qq_37158147的博客
05-21 462
hibernate抓取策略（单端代理的批量抓取） 保持默认，同fetch=“select”,如： fetch=“select”,另外发送一条select语句抓取当前对象关联实体或集合 2.hibernate抓取策略（单端代理的批量抓取） 设置fetch=“join”,如： fetch=“join”,hibernate会通过select语句使用外连接来加载其关联实体或集合 此时lazy会失效 3...
Hibernate的fetch
午夜精灵
07-30 133
hibernate抓取策略fetch详解一、hibernate抓取策略（单端代理的批量抓取fetch=select(默认）/join）测试用例：Student student = (Student)session.get(Student.class, 1);System.out.println(student.getName());System.out.println(student.getCl...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值