Hibernate检索策略与检索方式

2022-11-14 16:18:19

hibernate的Session在加载Java对象时，一般都会把鱼这个对象相关联的其他Java对象也都加载到缓存中，以方便程序的调用。但很多情况下，我们不需要加载太多无用的对象到缓存中，一来会占用大量的内存，二来会增加数据库的访问次数，使得程序的运行效率降低。为了合理的使用缓存，Hibernate提供了不同的检索策略来解决这些问题。

作用域

在说检索策略之前，先了解一下检索策略的作用域，它分为：类级别和关联级别。类级别的作用域在检索数据时，检索的数据只包含一个类对象，不涉及与该类关联的其他对象。关联级别的作用域检索的数据包含相关联的多个类的对象，例如，Customer对象与Orders对象存在关系，检索到一个Customer对象后，还会涉及与之关联的Orders对象。

Hibernate检索策略与检索方式

作用域对比

检索策略

Hibernate的检索策略分为三种，立即检索、延迟检索、左外连接检索。

立即检索

采用立即检索策略，会把被检索的对象，以及和这个对象关联的一对多对象都加载到缓存中。Session的get方法就使用的立即检索策略。这种策略的优点在于，频繁使用的对象会被加载到缓存中，程序调用很方便，也很及时。缺点就是，占用的内存过多，而且数据库访问的次数也会很频繁，效率低下。

延迟检索

采用延迟检索策略，就不会加载关联对象的内容。直到第一次调用关联对象时，才去加载关联对象。在不涉及关联类操作时，延迟检索策略只适用于Session的load方法。涉及关联类操作时，延迟检索策略也能够适用于get，list等操作。

在类级别操作时， 延迟检索策略，只加载类的OID不加载类的其他属性，只用当第一次访问其他属性时，才回访问数据库去加载内容。（这里使用了CGLIB生成了类的代理类）
在关联级别操作时，延迟检索策略，只加载类本身，不加载关联类，直到第一次调用关联对象时，才去加载关联对象。

程序模式都是用延迟加载策略。如果需要指定使用延迟加载策略。在配置文件中设置<class>的lazy=true，<set>的lazy=true或extra（增强延迟）<many-to-one>的lazy=proxy和no-proxy。

这种策略的优点在于，由程序决定加载哪些类和内容，而不必全部都加载，避免了内存的大量占用和数据库的频繁访问。缺点就是在Session关闭后，就不能访问关联类对象了。 需要确保Session一直处于打开状态，调用关联对象，最后在关闭Session对象。

左外连接检索

采用左外连接检索，能够使用Sql的外连接查询，将需要加载的关联对象加载在缓存中。<set>fetch设置为join，<many-to-one>的fetch设置为join。

这种策略的优点在于，对应用程序完全透明，不管对象处于持久化状态，还是游离状态，应用程序都可以方便的从一个对象导航到与它关联的对象。使用了外连接，select语句数目少。缺点就是可能会加载应用程序不需要访问的对象，白白浪费许多内存空间。复杂的数据库表连接也会影响检索性能。

Hibernate检索策略与检索方式

三种策略运行机制

检索方式

Hibernate提供的检索方式为5种，分为导航对象图检索方式、OID检索方式、HQL检索方式、QBC检索方式、本地SQL检索方式。

导航对象图检索方式

利用类与类之间的关系来检索对象。譬如我们要查找一份订单，就可以由订单对象自动导航找到订单所属的客户对象。当然，前提是必须在对象-关系映射文件上配置了它们的多对一的关系。

OID检索方式

主要指用Session的get()和load()方法加载某条记录对应的对象。

HQL检索方式

HQL（Hibernate Query Language）是面向对象的查询语言，它和SQL查询语言有些相似。在Hibernate提供的各种检索方式中，HQL是使用最广的一种检索方式。它具有以下功能：

在查询语句中设定各种查询条件。
        支持投影查询，即仅检索出对象的部分属性。
        支持分页查询。
        支持分组查询，允许使用group by和having关键字。
        提供内置聚集函数，如sum()、min()和max()。
        能够调用用户定义的SQL函数。
        支持子查询，即嵌套查询。
        支持动态绑定参数。

Session类的Qurey接口支持HQL检索方式，它提供了以上列出的各种查询功能。

注：Qurey接口支持方法链编程风格，它的set方法都返回自身实例，而不是返回void类型。方法链编程风格能使程序代码更加简洁。

QBC检索方式

采用HQL检索方式时，在应用程序中需要定义基于字符串形式的HQL查询语句。QBC API提供了检索对象的另一种方式，它主要由Criteria接口、Criterion接口和Expression类组成，它支持在运行时动态生成查询语句。

本地SQL检索方式

采用HQL或QBC检索方式时，Hibernate生成标准的SQL查询语句，使用于所有的数据库平台，因此这两种检索方式都是跨平台的。有的应用程序可能需要根据底层数据库的SQL方言，来生成一些特殊的查询语句。在这种情况下，可以利用Hibernate提供的SQL检索方式。

抓取策略（优化）

1.检索方式

立即检索：立即查询，在执行查询语句时，立即查询所有的数据。

延迟检索：延迟查询，在执行查询语句之后，在需要时在查询。（懒加载）

 

2.检查策略

类级别检索：当前的类的属性获取是否需要延迟。

关联级别的检索：当前类 关联 另一个类是否需要延迟。

 

3.类级别检索

get：立即检索。get方法一执行，立即查询所有字段的数据。

load：延迟检索。默认情况，load方法执行后，如果只使用OID的值不进行查询，如果要使用其他属性值将查询 。 Customer.hbm.xml <class  lazy="true |false">

lazy默认值true，表示延迟检索，如果设置false表示立即检索。

1. get/load
get: 立即查询数据库,将数据初始化
load:  hbm文件中,class元素的lazy属性决定类级别load方法的加载策略
true:先返回一个代理对象.使用代理对象的属性时,才去查询数据库.
false: 与get一致,会立即加载数据

  1. @Test
  2. public void demo02() {
  3. //类级别
  4. Session session = factory.openSession();
  5. session.beginTransaction();
  6. //1立即
  7. //      Customer customer = (Customer) session.get(Customer.class, 1);
  8. //2延迟
  9. Customer customer = (Customer) session.load(Customer.class, 1);
  10. //打印
  11. System.out.println(customer.getCid());
  12. System.out.println(customer.getCname());
  13. session.getTransaction().commit();
  14. session.close();
  15. }

case：

  1. package com.itheima.b_lazy;
  2. import org.hibernate.Session;
  3. import org.junit.Test;
  4. import com.itheima.domain.Course;
  5. import com.itheima.domain.Customer;
  6. import com.itheima.domain.Student;
  7. import com.itheima.utils.HibernateUtils;
  8. public class Demo {
  9. @Test
  10. //类级别懒加载
  11. //load方法
  12. // class lazy属性
  13. // 默认值: true load获得时,会返回代理对象,不查询数据库.使用时才查询
  14. public void fun1(){
  15. Session session = HibernateUtils.openSession();
  16. session.beginTransaction();
  17. //------------------------------------------------
  18. Customer c = (Customer) session.load(Customer.class, 1);
  19. System.out.println(c.getName());
  20. //------------------------------------------------
  21. session.getTransaction().commit();
  22. session.close(); // 游离状态
  23. }
  24. @Test
  25. //类级别懒加载
  26. //load方法
  27. // class lazy属性
  28. // lazy: false  load方法执行就会发送sql语句.与get方法一致.
  29. public void fun2(){
  30. Session session = HibernateUtils.openSession();
  31. session.beginTransaction();
  32. //------------------------------------------------
  33. Customer c = (Customer) session.load(Customer.class, 1);
  34. System.out.println(c.getName());
  35. //------------------------------------------------
  36. session.getTransaction().commit();
  37. session.close(); // 游离状态
  38. }
  39. }

4.关联级别检索

(1)一对多或多对多

介绍：

l  容器<set> 提供两个属性：fetch、lazy

fetch：确定使用sql格式

lazy：关联对象是否延迟。

l  fetch：join、select、subselect

join：底层使用迫切左外连接

select：使用多个select语句（默认值）

subselect：使用子查询

l  lazy：false、true、extra

false：立即

true：延迟（默认值）

extra：极其懒惰

Hibernate检索策略与检索方式

 
 
 
 
 
fetch="join"

l  fetch="join" ，lazy无效。底层使用迫切左外连接，使用一条select将所有内容全部查询。

Hibernate检索策略与检索方式

 
  1. @Test
  2. public void demo03() {
  3. //关联级别：一对多，
  4. // * Customer.hbm.xml  <set fetch="join">
  5. // *** select语句使用左外连接，一次性查询所有
  6. Session session = factory.openSession();
  7. session.beginTransaction();
  8. //1 查询客户
  9. Customer customer = (Customer) session.get(Customer.class, 1);
  10. System.out.println(customer.getCname());
  11. //2 查询客户订单数
  12. Set<Order> orderSet = customer.getOrderSet();
  13. System.out.println(orderSet.size());
  14. //3 查询客户订单详情
  15. for (Order order : orderSet) {
  16. System.out.println(order);
  17. }
  18. session.getTransaction().commit();
  19. session.close();
  20. }

fetch="select"

l  当前对象 和 关联对象 使用多条select语句查询。

l  lazy="false" , 立即，先查询客户select，立即查询订单select

l  lazy="true",延迟，先查询客户select，需要订单时，再查询订单select

l  lazy="extra"，极其懒惰（延迟），先查询客户select， 如果只需要订单数，使用聚合函数（不查询详情）

Hibernate检索策略与检索方式

 

Hibernate检索策略与检索方式

 
Hibernate检索策略与检索方式
 

fetch="subselect"

l  将使用子查询。注意：必须使用Query否则看不到效果。

l  lazy= 同上

  1. @Test
  2. public void demo04() {
  3. //关联级别：一对多，
  4. // 演示3：* Customer.hbm.xml  <set fetch="subselect">
  5. Session session = factory.openSession();
  6. session.beginTransaction();
  7. //1 查询客户
  8. List<Customer> allCustomer = session.createQuery("from Customer").list();
  9. Customer customer = allCustomer.get(0);
  10. System.out.println(customer.getCname());
  11. //2 查询客户订单数
  12. Set<Order> orderSet = customer.getOrderSet();
  13. System.out.println(orderSet.size());
  14. //3 查询客户订单详情
  15. for (Order order : orderSet) {
  16. System.out.println(order);
  17. }
  18. session.getTransaction().commit();
  19. session.close();
  20. }
 

Hibernate检索策略与检索方式

 

Hibernate检索策略与检索方式

 
Hibernate检索策略与检索方式
 
关联级别加载策略
在查询有关联关系的数据时,加载一方的数据是否需要将另一方立即查询出.
默认: 与我关联的数据,在使用时才会加载.
集合(一对多):
set 
lazy: 是否对set数据使用懒加载
true:(默认值) 对集合使用才加载
false: 集合将会被立即加载
extra: 极其懒惰,如果使用集合时,之调用size方法查询数量, Hibernate会发送count语句,只查询数量.不加载集合内数据.
fetch : 决定加载集合使用的sql语句种类
select: (默认值) 普通select查询
join: 表链接语句查询集合数据
subselect: 使用子查询 一次加载多个Customer的订单数据
Hibernate检索策略与检索方式
case：
 
配置：
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC
  3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  4. "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
  5. <hibernate-mapping package="com.itheima.domain" >
  6. <class name="Customer" table="t_customer"   >
  7. <id name="id" column="id"    >
  8. <generator class="native"></generator>
  9. </id>
  10. <!-- 告诉Hibernate , 乐观锁的版本号的属性名 -->
  11. <version name="version"></version>
  12. <property name="name" column="name" type="string" ></property>
  13. <!--
  14. lazy : 是否对set数据使用懒加载
  15. fetch : 决定加载集合使用的sql语句种类
  16. -->
  17. <set name="orders" batch-size="2"  >
  18. <!--
  19. key 用来描述外键
  20. column : 外键的值
  21. -->
  22. <key column="cid" ></key>
  23. <!-- one-to-many 表达, Customer 与orders 的关系是一对多
  24. class: 表达关联的另一方的完整类名
  25. -->
  26. <one-to-many class="Order" />
  27. </set>
  28. <!-- 局部配置 -->
  29. <query name="bcd"><![CDATA[from Order]]></query>
  30. </class>
  31. <!-- 全局配置 -->
  32. <query name="abc"><![CDATA[from Customer]]></query>
  33. </hibernate-mapping>
 
Test：
  1. package com.itheima.b_lazy;
  2. import java.util.List;
  3. import org.hibernate.Session;
  4. import org.junit.Test;
  5. import com.itheima.domain.Customer;
  6. import com.itheima.domain.Order;
  7. import com.itheima.utils.HibernateUtils;
  8. public class Demo2 {
  9. @Test
  10. //关联级别懒加载
  11. //默认: 与我关联的数据,在使用时才会加载.
  12. public void fun1(){
  13. Session session = HibernateUtils.openSession();
  14. session.beginTransaction();
  15. //------------------------------------------------
  16. Customer c = (Customer) session.get(Customer.class, 1);
  17. for(Order o : c.getOrders()){
  18. System.out.println(o.getName());
  19. }
  20. //------------------------------------------------
  21. session.getTransaction().commit();
  22. session.close(); // 游离状态
  23. }
  24. @Test
  25. //关联级别懒加载
  26. //lazy: false
  27. public void fun2(){
  28. Session session = HibernateUtils.openSession();
  29. session.beginTransaction();
  30. //------------------------------------------------
  31. Customer c = (Customer) session.get(Customer.class, 1);
  32. for(Order o : c.getOrders()){
  33. System.out.println(o.getName());
  34. }
  35. //------------------------------------------------
  36. session.getTransaction().commit();
  37. session.close(); // 游离状态
  38. }
  39. @Test
  40. //关联级别懒加载
  41. //lazy: false/true
  42. //fetch:join
  43. public void fun3(){
  44. Session session = HibernateUtils.openSession();
  45. session.beginTransaction();
  46. //------------------------------------------------
  47. Customer c = (Customer) session.get(Customer.class, 1);
  48. for(Order o : c.getOrders()){
  49. System.out.println(o.getName());
  50. }
  51. //------------------------------------------------
  52. session.getTransaction().commit();
  53. session.close(); // 游离状态
  54. }
  55. @Test
  56. //关联级别懒加载
  57. //lazy:true
  58. //fetch:subselect
  59. public void fun4(){
  60. Session session = HibernateUtils.openSession();
  61. session.beginTransaction();
  62. //------------------------------------------------
  63. List<Customer> list = session.createQuery("from Customer").list();
  64. for(Customer c:list){
  65. System.out.println(c.getName()+"下单数量:"+c.getOrders().size());
  66. }
  67. //------------------------------------------------
  68. session.getTransaction().commit();
  69. session.close(); // 游离状态
  70. }
  71. @Test
  72. //关联级别懒加载
  73. //lazy:false
  74. //fetch:subselect
  75. public void fun5(){
  76. Session session = HibernateUtils.openSession();
  77. session.beginTransaction();
  78. //------------------------------------------------
  79. List<Customer> list = session.createQuery("from Customer").list();
  80. for(Customer c:list){
  81. System.out.println(c.getName()+"下单数量:"+c.getOrders().size());
  82. }
  83. //------------------------------------------------
  84. session.getTransaction().commit();
  85. session.close(); // 游离状态
  86. }
  87. @Test
  88. //关联级别懒加载
  89. //lazy:extra
  90. //fetch:select
  91. public void fun6(){
  92. Session session = HibernateUtils.openSession();
  93. session.beginTransaction();
  94. //------------------------------------------------
  95. //查询Customer
  96. Customer c = (Customer) session.get(Customer.class, 1);
  97. //查询Customer下订单 数量
  98. System.out.println(c.getOrders().size());
  99. //真正使用订单中的数据
  100. for(Order o : c.getOrders()){
  101. System.out.println(o.getName());
  102. }
  103. //------------------------------------------------
  104. session.getTransaction().commit();
  105. session.close(); // 游离状态
  106. }
  107. @SuppressWarnings("unchecked")
  108. @Test
  109. //关联级别懒加载
  110. //lazy:extra
  111. //fetch:subselect
  112. public void fun7(){
  113. Session session = HibernateUtils.openSession();
  114. session.beginTransaction();
  115. //------------------------------------------------
  116. List<Customer> list = session.createQuery("from Customer").list();
  117. for(Customer c:list){
  118. System.out.println(c.getName()+"下单数量:"+c.getOrders().size());
  119. }
  120. for(Customer c:list){
  121. for(Order o : c.getOrders()){
  122. System.out.println(c.getName()+"下单名称:"+o.getName());
  123. }
  124. }
  125. //------------------------------------------------
  126. session.getTransaction().commit();
  127. session.close(); // 游离状态
  128. }
  129. }

(2)多对一

介绍：

l  <many-to-one fetch="" lazy="">  (<one-to-one>)

l  fetch取值：join、select

join：底层使用迫切左外连接

select：多条select语句

l  lazy取值：false、proxy、no-proxy

false：立即

proxy：采用关联对象 类级别检索的策略。

订单 关联 客户 （多对一）

订单 立即获得 客户，需要在客户Customer.hbm.xml <class lazy="false">

订单 延迟获得 客户，需要在客户Customer.hbm.xml <classlazy="true">

no-proxy不研究

Hibernate检索策略与检索方式

fetch="join"

l  fecth="join" select语句使用左外连接，此时lazy无效。

  1. @Test
  2. public void demo05() {
  3. //关联级别：多对一，
  4. // 演示1：* Order.hbm.xml  <set fetch="join">  lazy无效
  5. // * 注意：检查Customer.hbm.xml 和 Order.hbm.xml 没有额外的配置
  6. Session session = factory.openSession();
  7. session.beginTransaction();
  8. //1 查询订单
  9. Order order = (Order) session.get(Order.class, 1);
  10. System.out.println(order.getPrice());
  11. //2 查询订单客户信息
  12. Customer customer = order.getCustomer();
  13. System.out.println(customer.getCname());
  14. session.getTransaction().commit();
  15. session.close();
  16. }

fetch="select"

l  将采用多条select语句，lazy="proxy"是否延迟，取决关联对象 类级别检索策略。

l  lazy="false"

Hibernate检索策略与检索方式

l  lazy="proxy"

Hibernate检索策略与检索方式

 
Hibernate检索策略与检索方式
 
 
多对一:
lazy
  false  加载订单时,会立即加载客户
  proxy  看客户对象的类加载策略来决定
  no-proxy : 不做研究. 
  fetch=
select  : (默认值)使用普通select加载
join : 使用表链接加载数据
 
Hibernate检索策略与检索方式
 
case：
配置：
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC
  3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  4. "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
  5. <hibernate-mapping package="com.itheima.domain" >
  6. <class name="Order" table="t_order"  >
  7. <id name="id" column="id"    >
  8. <generator class="native"></generator>
  9. </id>
  10. <property name="name" column="name" type="string" ></property>
  11. <!--
  12. lazy
  13. false
  14. proxy
  15. no-proxy : 不做研究.
  16. fetch=
  17. select
  18. join
  19. -->
  20. <many-to-one name="customer" column="cid" class="Customer"   ></many-to-one>
  21. </class>
  22. </hibernate-mapping>
Test：
  1. package com.itheima.b_lazy;
  2. import java.util.List;
  3. import org.hibernate.Session;
  4. import org.junit.Test;
  5. import com.itheima.domain.Customer;
  6. import com.itheima.domain.Order;
  7. import com.itheima.utils.HibernateUtils;
  8. //多对一检索策略
  9. public class Demo3 {
  10. @Test
  11. //fetch: select
  12. //lazy: false
  13. public void fun1(){
  14. Session session = HibernateUtils.openSession();
  15. session.beginTransaction();
  16. //------------------------------------------------
  17. Order o = (Order) session.get(Order.class, 2);
  18. System.out.println(o.getCustomer().getName());
  19. //------------------------------------------------
  20. session.getTransaction().commit();
  21. session.close(); // 游离状态
  22. }
  23. @Test
  24. //fetch: select
  25. //lazy: proxy
  26. // Customer lazy:false
  27. public void fun2(){
  28. Session session = HibernateUtils.openSession();
  29. session.beginTransaction();
  30. //------------------------------------------------
  31. Order o = (Order) session.get(Order.class, 2);
  32. System.out.println(o.getCustomer().getName());
  33. //------------------------------------------------
  34. session.getTransaction().commit();
  35. session.close(); // 游离状态
  36. }
  37. @Test
  38. //fetch: select
  39. //lazy: proxy
  40. // Customer lazy:true
  41. public void fun3(){
  42. Session session = HibernateUtils.openSession();
  43. session.beginTransaction();
  44. //------------------------------------------------
  45. Order o = (Order) session.get(Order.class, 2);
  46. System.out.println(o.getCustomer().getName());
  47. //------------------------------------------------
  48. session.getTransaction().commit();
  49. session.close(); // 游离状态
  50. }
  51. @Test
  52. //fetch: join
  53. //lazy: proxy|false
  54. public void fun4(){
  55. Session session = HibernateUtils.openSession();
  56. session.beginTransaction();
  57. //------------------------------------------------
  58. Order o = (Order) session.get(Order.class, 2);
  59. System.out.println(o.getCustomer().getName());
  60. //------------------------------------------------
  61. session.getTransaction().commit();
  62. session.close(); // 游离状态
  63. }
  64. }
上一篇：企业QQ 增加在线交谈链接


下一篇：自己个儿写的循环分配txt中的内容