Hibernate抓取策略

最新推荐文章于 2019-03-16 17:32:11 发布
最新推荐文章于 2019-03-16 17:32:11 发布
阅读量509 收藏
点赞数
分类专栏： 框架

官方文档相关部分：提升性能


抓取策略指多表关联查询的时候，Hibernate会发出多条sql进行查询，但如果设置了抓取策略，将多条SQL变成一条SQL执行，实际上就是使用join等关联查询。

 

如在一对多即示例Classes与Student的关联查询中：

代码：

Java代码   收藏代码
  1. public void testLoad(){  
  2.         Session session = null;  
  3.         try {  
  4.           
  5.             session = HibernateUtil.getSession();  
  6.             session.beginTransaction();  
  7.             //从classes得到student  
  8.             Classes cls = (Classes)session.load(Classes.class, 1);  
  9.             System.out.println(cls.getName());  
  10.             Set set = cls.getStudents();  
  11.             for (Iterator iterator = set.iterator(); iterator.hasNext();) {  
  12.                 Student object = (Student) iterator.next();  
  13.                 System.out.println(object.getName());  
  14.                   
  15.             }  
  16.               
  17.             HibernateUtil.commit(session);  
  18.         } catch (Exception e) {  
  19.             HibernateUtil.roolback(session);  
  20.         }finally{  
  21.             HibernateUtil.close(session);  
  22.         }  
  23.     }  

 

可以看到上面要打印出classes.name和classes.student.name那么默认情况下输出的SQL是：

Java代码   收藏代码
  1. Hibernate: select classes0_.id as id0_0_, classes0_.name as name0_0_ from t_classes classes0_ where classes0_.id=?  
  2. classes1  
  3. Hibernate: select students0_.class_id as class3_0_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.name as name1_0_, students0_.class_id as class3_1_0_ from t_student students0_ where students0_.class_id=?  
  4. stu4  
  5. stu2  
  6. stu1  
  7. stu0  
  8. stu3  

 

 

 

而我们可以使用抓取策略：

更改Classes.hbm.xml.在set中增加fetch属性

Java代码   收藏代码
  1. <hibernate-mapping package="com.lwf.hibernate.pojo">  
  2.     <class name="Classes" table="t_classes">  
  3.         <id name="id">  
  4.             <generator class="native"/>  
  5.         </id>  
  6.         <property name="name"/>  
  7.         <set name="students" fetch="join">  
  8.             <key column="class_id"/>  
  9.             <one-to-many class="Student"/>  
  10.         </set>  
  11.     </class>  
  12. </hibernate-mapping>  

 更改完后再测试上面的代码，只发出一条sql，结果为：

Java代码   收藏代码
  1. Hibernate: select classes0_.id as id0_1_, classes0_.name as name0_1_, students1_.class_id as class3_0_3_, students1_.id as id3_, students1_.id as id1_0_, students1_.name as name1_0_, students1_.class_id as class3_1_0_ from t_classes classes0_ left outer join t_student students1_ on classes0_.id=students1_.class_id where classes0_.id=?  
  2. classes1  
  3. stu2  
  4. stu4  
  5. stu1  
  6. stu3  
  7. stu0  

 

显然上面比较使用抓取策略后执行的SQL语句少了，性能也跟着提高了。。

上面我们是从Classes端得到Student所以在Classes.hbm.xml中的set里面加了fetch属性。

那么如果我们从Student端得到Classes要使用fetch怎么做呢？

测试方法：

Java代码   收藏代码
  1. public void testLoad1(){  
  2.         Session session = null;  
  3.         try {  
  4.           
  5.             session = HibernateUtil.getSession();  
  6.             session.beginTransaction();  
  7.               
  8.             Student s = (Student)session.load(Student.class, 1);  
  9.             System.out.println(s.getName());  
  10.             System.out.println(s.getClasses().getName());  
  11.               
  12.               
  13.             HibernateUtil.commit(session);  
  14.         } catch (Exception e) {  
  15.             HibernateUtil.roolback(session);  
  16.         }finally{  
  17.             HibernateUtil.close(session);  
  18.         }  
  19.     }  

 

默认情况下执行：发出两条SQL

Java代码   收藏代码
  1. Hibernate: select student0_.id as id1_0_, student0_.name as name1_0_, student0_.class_id as class3_1_0_ from t_student student0_ where student0_.id=?  
  2. stu0  
  3. Hibernate: select classes0_.id as id0_0_, classes0_.name as name0_0_ from t_classes classes0_ where classes0_.id=?  
  4. classes1  

 而要执行抓取策略，更改Student.hbm.xml的many-to-one

Java代码   收藏代码
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping package="com.lwf.hibernate.pojo">  
  6.     <class name="Student" table="t_student">  
  7.     <!-- <cache usage="read-only"/> -->  
  8.         <id name="id">  
  9.             <generator class="native"/>  
  10.         </id>  
  11.         <property name="name"/>  
  12.         <many-to-one name="classes" column="class_id" fetch="join"></many-to-one>  
  13.     </class>  
  14. </hibernate-mapping>  

 

上面我们增加了fetch="join"属性

结果：

Java代码   收藏代码
  1. Hibernate: select student0_.id as id1_1_, student0_.name as name1_1_, student0_.class_id as class3_1_1_, classes1_.id as id0_0_, classes1_.name as name0_0_ from t_student student0_ left outer join t_classes classes1_ on student0_.class_id=classes1_.id where student0_.id=?  
  2. stu0  
  3. classes1  

 

现在只执行一条SQL了。。。

 

需要提示的是其实默认情况下fetch="select"


在Classes与Student一对多映射中，我们将Set里面的fetch属性设置为subselect来实现子查询。

如下示例

首先看一下set中fetch="select"即默认情况下：

生成数据类：

Java代码   收藏代码
  1. package com.bjsxt.hibernate;  
  2.   
  3. import org.hibernate.Session;  
  4.   
  5. public class InitData {  
  6.   
  7.     public static void main(String[] args) {  
  8.         Session session = HibernateUtils.getSession();  
  9.         try {  
  10.             session.beginTransaction();  
  11.             for(int i=0; i<10; i++){  
  12.                 Classes classes = new Classes();  
  13.                 classes.setName("班级"+i);  
  14.                 session.save(classes);  
  15.                 for(int j=0; j<10; j++){  
  16.                     Student student = new Student();  
  17.                     student.setName("班级"+i+"的学生"+j);  
  18.                     //在内存中建立由student指向classes的引用  
  19.                     student.setClasses(classes);  
  20.                     session.save(student);  
  21.                 }  
  22.             }  
  23.             session.getTransaction().commit();  
  24.         } catch (Exception e) {  
  25.             e.printStackTrace();  
  26.             session.getTransaction().rollback();  
  27.         } finally{  
  28.             HibernateUtils.closeSession(session);  
  29.         }  
  30.     }  
  31.   
  32. }  

 

测试类：

Java代码   收藏代码
  1. package com.bjsxt.hibernate;  
  2.   
  3. import java.io.Serializable;  
  4. import java.util.Iterator;  
  5. import java.util.List;  
  6. import java.util.Set;  
  7.   
  8. import org.hibernate.Session;  
  9.   
  10. import junit.framework.TestCase;  
  11.   
  12. public class FetchTest extends TestCase {  
  13.   
  14.     public void testFetch1() {  
  15.         Session session = null;  
  16.         try {  
  17.             session = HibernateUtils.getSession();  
  18.             Classes classes = (Classes)session.load(Classes.class, 1);  
  19.             System.out.println("班级:" + classes.getName());  
  20.             Set students = classes.getStudents();  
  21.             for (Iterator iter = students.iterator(); iter.hasNext();) {  
  22.                 Student student = (Student)iter.next();  
  23.                 System.out.println(student.getName());  
  24.             }  
  25.         }catch(Exception e) {  
  26.             e.printStackTrace();  
  27.         }finally {  
  28.             HibernateUtils.closeSession(session);  
  29.         }  
  30.     }  
  31.       
  32.     public void testFetch2() {  
  33.         Session session = null;  
  34.         try {  
  35.             session = HibernateUtils.getSession();  
  36.             List Classes = session.createQuery("select c from Classes c where c.id in(1, 2, 3)").list();  
  37.             for (Iterator iter = Classes.iterator(); iter.hasNext();) {  
  38.                 Classes cls = (Classes)iter.next();  
  39.                 System.out.println("班级：" + cls.getName());  
  40.                 for (Iterator iter1 = cls.getStudents().iterator(); iter1.hasNext();) {  
  41.                     Student student = (Student)iter1.next();  
  42.                     System.out.println(student.getName());  
  43.                 }  
  44.             }  
  45.         }catch(Exception e) {  
  46.             e.printStackTrace();  
  47.         }finally {  
  48.             HibernateUtils.closeSession(session);  
  49.         }  
  50.     }  
  51.       
  52. }  

 

分别列出方法一与方法二的测试结果：

Java代码   收藏代码
  1. Hibernate: select classes0_.id as id0_0_, classes0_.name as name0_0_ from t_classes classes0_ where classes0_.id=?  
  2. 班级:班级0  
  3. Hibernate: select students0_.classid as classid0_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.name as name1_0_, students0_.classid as classid1_0_ from t_student students0_ where students0_.classid=?  
  4. 班级0的学生8  
  5. 班级0的学生1  
  6. 班级0的学生7  
  7. 班级0的学生5  
  8. 班级0的学生3  
  9. 班级0的学生4  
  10. 班级0的学生0  
  11. 班级0的学生6  
  12. 班级0的学生9  
  13. 班级0的学生2  

 

Java代码   收藏代码
  1. Hibernate: select classes0_.id as id0_, classes0_.name as name0_ from t_classes classes0_ where classes0_.id in (1 , 2 , 3)  
  2. 班级：班级0  
  3. Hibernate: select students0_.classid as classid0_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.name as name1_0_, students0_.classid as classid1_0_ from t_student students0_ where students0_.classid=?  
  4. 班级0的学生7  
  5. 班级0的学生2  
  6. 班级0的学生3  
  7. 班级0的学生1  
  8. 班级0的学生0  
  9. 班级0的学生9  
  10. 班级0的学生4  
  11. 班级0的学生8  
  12. 班级0的学生6  
  13. 班级0的学生5  
  14. 班级：班级1  
  15. Hibernate: select students0_.classid as classid0_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.name as name1_0_, students0_.classid as classid1_0_ from t_student students0_ where students0_.classid=?  
  16. 班级1的学生9  
  17. 班级1的学生0  
  18. 班级1的学生6  
  19. 班级1的学生8  
  20. 班级1的学生7  
  21. 班级1的学生2  
  22. 班级1的学生5  
  23. 班级1的学生3  
  24. 班级1的学生1  
  25. 班级1的学生4  
  26. 班级：班级2  
  27. Hibernate: select students0_.classid as classid0_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.name as name1_0_, students0_.classid as classid1_0_ from t_student students0_ where students0_.classid=?  
  28. 班级2的学生6  
  29. 班级2的学生9  
  30. 班级2的学生3  
  31. 班级2的学生1  
  32. 班级2的学生2  
  33. 班级2的学生7  
  34. 班级2的学生8  
  35. 班级2的学生4  
  36. 班级2的学生0  
  37. 班级2的学生5  

 

下面更改fetch="subselect"

Java代码   收藏代码
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping>  
  6.     <class name="com.bjsxt.hibernate.Classes" table="t_classes">  
  7.         <id name="id">  
  8.             <generator class="native"/>  
  9.         </id>  
  10.         <property name="name"/>  
  11.         <!--   
  12.             <set name="students" cascade="all" order-by="id">  
  13.          -->  
  14.          <set name="students" inverse="true" fetch="subselect">  
  15.             <key column="classid"/>  
  16.             <one-to-many class="com.bjsxt.hibernate.Student"/>  
  17.         </set>  
  18.     </class>  
  19. </hibernate-mapping>  

 

同样，将两个方法的测试结果列出如下：

Java代码   收藏代码
  1. Hibernate: select classes0_.id as id0_0_, classes0_.name as name0_0_ from t_classes classes0_ where classes0_.id=?  
  2. 班级:班级0  
  3. Hibernate: select students0_.classid as classid0_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.name as name1_0_, students0_.classid as classid1_0_ from t_student students0_ where students0_.classid=?  
  4. 班级0的学生3  
  5. 班级0的学生1  
  6. 班级0的学生9  
  7. 班级0的学生7  
  8. 班级0的学生5  
  9. 班级0的学生0  
  10. 班级0的学生6  
  11. 班级0的学生2  
  12. 班级0的学生8  
  13. 班级0的学生4  

 

Java代码   收藏代码
  1. Hibernate: select classes0_.id as id0_, classes0_.name as name0_ from t_classes classes0_ where classes0_.id in (1 , 2 , 3)  
  2. 班级：班级0  
  3. Hibernate: select students0_.classid as classid0_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.name as name1_0_, students0_.classid as classid1_0_ from t_student students0_ where students0_.classid in (select classes0_.id from t_classes classes0_ where classes0_.id in (1 , 2 , 3))  
  4. 班级0的学生5  
  5. 班级0的学生1  
  6. 班级0的学生0  
  7. 班级0的学生8  
  8. 班级0的学生7  
  9. 班级0的学生2  
  10. 班级0的学生9  
  11. 班级0的学生6  
  12. 班级0的学生4  
  13. 班级0的学生3  
  14. 班级：班级1  
  15. 班级1的学生5  
  16. 班级1的学生1  
  17. 班级1的学生0  
  18. 班级1的学生7  
  19. 班级1的学生4  
  20. 班级1的学生9  
  21. 班级1的学生8  
  22. 班级1的学生3  
  23. 班级1的学生6  
  24. 班级1的学生2  
  25. 班级：班级2  
  26. 班级2的学生0  
  27. 班级2的学生5  
  28. 班级2的学生1  
  29. 班级2的学生8  
  30. 班级2的学生6  
  31. 班级2的学生9  
  32. 班级2的学生4  
  33. 班级2的学生7  
  34. 班级2的学生3  
  35. 班级2的学生2  

 

比较两次测试的结果我们发现，方法二的输出结果不同，当fetch="subselect"的时候，方法二进行了子查询

如：

Java代码   收藏代码
  1. Hibernate: select students0_.classid as classid0_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.name as name1_0_, students0_.classid as classid1_0_ from t_student students0_ where students0_.classid in (select classes0_.id from t_classes classes0_ where classes0_.id in (1 , 2 , 3))  

Joyyiwei
关注
专栏目录
Hibernate的抓取策略
nayao-net
05-17 131
一、Hibernate的抓取策略 Hibernate抓取策略是指当应用程序需要在关联关系间进行导航的时候，Hibernate如何获取关联对象的策略。 Hibernate有如下几种抓取策略： 1、链接抓取(Join fetching)：Hibernate 通过在select语句中使用out join来获取对象的关联实例或者关联集合。 2、查询...
hibernate抓取策略
u012709361的专栏
04-25 305
一、hibernate抓取策略（单端代理的批量抓取fetch=select(默认）/join） 测试用例： [java] view plaincopy Student student = (Student)session.get(Student.class, 1);  System.out.println(student.getName());  System.out
hibernate抓取策略fetch=select /join/subselect
Mirage520的专栏
03-18 1745
转贴：http://hi.baidu.com/fytcm/blog/item/769854f59614fe2ebd3109c3.html一、hibernate抓取策略（单端代理的批量抓取fetch=select(默认）/join）测试用例：Student student = (Student)session.get(Student.class, 1);    System.ou
day36 06-Hibernate抓取策略：set集合上的抓取策略
04-26
今天我们将深入探讨"day36 06-Hibernate抓取策略"，特别是针对set集合的抓取策略。在阅读这篇博客文章（链接：https://364232252.iteye.com/blog/2368811）后，我们将了解到如何优化数据加载，以避免N+1查询问题，...
day36 08-Hibernate抓取策略：批量抓取
04-26
本篇主要关注的是Hibernate的抓取策略，特别是批量抓取技术，这对于提高应用程序性能至关重要。批量抓取能够减少数据库交互次数，从而优化查询效率。 首先，我们要理解什么是抓取策略。在Hibernate中，抓取策略是指...
day36 07-Hibernate抓取策略：many-to-one上的抓取策略
04-26
今天我们要讨论的是Hibernate框架中的一个关键概念——抓取策略，特别是针对"many-to-one"关系的抓取策略。这篇博客将深入剖析这个主题，帮助你更好地理解和应用Hibernate。 Hibernate是Java领域中最流行的对象关系...
hibernate抓取策略和懒加载案例
11-08
在Java的持久化框架Hibernate中，数据访问优化是至关重要的，而抓取策略（Fetch Strategy）和懒加载（Lazy Loading）则是实现这一目标的关键技术。本文将深入探讨这两个概念，并通过具体的案例进行分析。 首先，让...
抓取策略（Fetching strategies）
数据库天地
05-06 671
转自：http://sishuok.com/forum/blogPost/list/3805.html 实例A引用实例B，B如果是代理的话（比如多对一关联中）：如果遍历A的查询结果集（假设有10条记录），在遍历A的时候，访问B变量，将会导致n次查询语句的发出！这个时候，如果在B一端的class上配置batch-size，hibernate将会减少SQL语句的数量。 Hib...
hibernate的抓取策略
Gray_humor的博客
03-16 223
一、hibernate抓取策略概述 Hibernate抓取策略（fetching strategy）是指：当应用程序需要在（Hibernate实体对象图的）关联关系间进行导航的时候， Hibernate如何获取关联对象的策略。抓取策略可以在O/R映射的元数据中声明，也可以在特定的HQL 或条件查询（Criteria Query）中重载声明。 需要注意的是：hibernate的抓...
Hibernate--fetch抓取策略
nupt_Wang的专栏
01-08 6029
有几个需要注意的地方： 1 在xml配置中 是默认懒加载的（fetch=select），也就是在使用到懒加载对象的属性时候  才会发出SQL语句，不使用的话就发一个SQL即可，若遍历时使用关联对象的属性，那么会发出大量SQL，而这是我们不希望看见的 很多情况下 我们是要希望能使用fetch=Join 也就是实现全部加载 只发出一条SQL，即使没有显示的使用关联对象属性仍然全部加载，此SQL使用
学习之路-抓取策略
wtuxnz的博客
09-25 828
一、什么是抓取策略 Hibernate如何获取主体对象的关联属性的策略。 抓取策略可以在ORM映射文件中声明，也可以在特定的HQL 或条件查询（Criteria Query）中重载声明 二、分类 查询抓取(fetch=“select”)   当关联属性为延迟加载时，如需加载将另外发送一条SELECT语句抓取当前对象的关联实体或集合。 连接抓取(fetch=“join”)
Hibernate框架之抓取策略
C8WATER
09-18 226
抓取策略是表与表之间的关联之间才能体现出来的, 这里介绍一对多跟多对一的情况, 因为多对多可以看成是两个一对多, 一对一也是一对多里面的一种特殊情况 多对一的单端抓取: "Emp.hbm.xml"配置文件: &lt;?xml version="1.0"?&gt; &lt;!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibe...
【Hibernate学习】 —— 抓取策略(注解方式)
信息技术提高班第九期
10-18 3335
当应用程序需要在关联关系间进行导航的时候，hibernate如何获取关联对象的策略。 抓取策略的方式：           FetchType.LAZY：懒加载，加载一个实体时，定义懒加载的属性不会马上从数据库中加载。           FetchType.EAGER：急加载，加载一个实体时，定义急加载的属性会立即从数据库中加载。             在项目中的体现，我这里有
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值