Hibernate 检索策略

概述

　　检索数据时的2个问题：

不浪费内存：当Hibernate从数据库中加载Customer对象时，如果同时加载所有关联的Order对象，而程序实际上仅仅需要访问Customer对象，那么那些关联的Order对象就白白浪费了许多内存
更好的查询效率：发送尽可能少的SQL语句

Hibernate的检索策略主要分为三类：

类级别的检索策略
一对多和多对多的检索策略
多对一和一对一关联的检索策略

下面分情况介绍这三种检索策略。

类级别的检索策略

类级别可选的检索策略包括立即检索和延迟检索，默认为延迟检索

　　　　-立即检索：立即加载检索方法指定的对象
　　　　-延迟检索：延迟加载检索方法制定的对象.在使用具体的属性时，再进行加载

类级别的检索策略可以通过<class>元素的lazy属性进行设置
如果程序加载一个对象的目的是为了访问它的属性，可以采取立即检索。如果程序加载一个持久化对象的目的是仅仅为了获得它的引用，可以采用延迟检索，注意出现懒加载异常！
无论<class>元素的lazy属性时true还是false，Session的get()方法及Query的list()方法在类级别总是使用立即检索策略
若<class>元素的lazy属性为true或去默认值，Session的load()方法不会执行查询数据库表的SELECT语句，仅返回代理类对象的实例，该代理类实例有如下特征：

　　　　-由Hibernate在运行时采用CGLIB工具动态生成
　　　　-Hibernate创建代理类实例时，仅初始化其OID属性
　　　　-在应用程序第一次访问代理类实例的非OID属性时，Hibernate会初始化代理类实例

---注意：类级别检索策略仅适用与load()方法

--------------------------------------------------------------------------------------------

一对多和多对多的检索策略

在映射文件中，用<set>元素来配置一对多关联及多对多关联关系。<set>元素有lazy和fetch属性

　　　　-lazy：主要决定orders集合被初始化的时机。即到底是在加载Customer对象时就被初始化，还是在程序访问orders集合时被初始化
　　　　-fetch：取值为"select"或"subselect"时，决定初始化orders的查询语句的形式；若取值为"join"，则决定orders集合被初始化的时机
　　　　-若把fetch设置为"join"。lazy属性将被忽略
　　　　-<set>元素的batch-size属性：用来为延迟检索策略或立即检索策略设定批量检索的数量。批量检索能减少SELECT语句的数目，提高延迟检索或立即检索的运行性能

延迟检索和增强延迟检索

　　　　在延迟检索(lazy属性值为true)集合属性时，Hibernate在以下情况下初始化集合代理类实例：

　　　　　　-应用程序第一次访问集合属性：iterator(),size(), isEmpty(), contains()等方法

　　　　　　-通过Hibernate.initialize()静态方法显式初始化

　　　　增加延迟检索(lazy属性为extra)：与lazy="true"类似。主要区别是增强延迟检索策略能进一步延迟Customer对象的orders集合代理实例的初始化时机：

　　　　　　-当程序第一次访问orders属性的iterator()方法时，会导致orders集合代理类实例的初始化

　　　　　　-当程序第一次访问orders属性的size(),contains()和isEmpty()方法时，Hibernate不会初始化orders集合类的实例，仅通过特定的select语句查询必要的信息，不会检索所有的Order对象

<set>元素的batch-size属性

　　　　<set>元素有一个batch-size属性，用来为延迟检索策略或立即检索策略设定批量检索的数量。批量检索能减少SELECT语句的数目，提高延迟检索或立即检索的运行性能

用带子查询的select语句整批量初始化orders集合(fetch属性为"subselect")

　　　　<set>元素的fetch属性:取值为"select"或"subselect"时，决定初始化orders的查询语句的形式；若取值为"join"，则决定orders集合被初始化的时机，默认值为select

　　　　当fetch属性为"subselect"时：

　　　　　　-假定Session缓存中有n个orders集合代理类实例没有被初始化，Hibernate能够通过带子查询的select语句，来批量初始化n个orders集合代理类实例

　　　　　　-batch-size属性将被忽略

　　　　　　-子查询中的select语句为最初查询CUTOMERS表OID的SELECT语句

迫切左外连接检索(fetch属性值设为"join")

　　　　<set>元素的fetch属性：取值为"select"或"subselect"时，决定初始化orders的查询语句的形式；若取值为"join"，则决定orders集合被初始化的时机，默认值为select

　　　　当fetch属性为"join"时：

　　　　　　-检索Customer对象时，或采用迫切左外连接(通过左外连接加载与检索指定的对象关联的对象)策略来检索所有关联的Order对象

　　　　　　-lazy属性将被忽略

　　　　　　-Query的list()方法会忽略映射文件中配置的迫切左外连接检索策略，而依旧采用延迟加载策略

-------------------------------------------------------------------------------------

多对一和一对一关联的检索策略

和<set>一样，<many-to-one>元素也有一个lazy属性和fetch属性

lazy属性(默认值为proxy)	fetch属性(默认值为select)	检索Order对象时对关联的Customer对象使用的检索策略
proxy	未显式设置(取默认值select)	采用延迟检索
no-proxy	未显式设置(取默认值select)	无代理延迟检索
FALSE	未显式设置(取默认值select)	立即检索
未显式设置(取默认值proxy)	join	迫切左外连接策略

Query的list方法会忽略映射文件配置的迫切左外连接检索策略，而采用延迟检索策略
如果在关联级别使用了延迟加载或立即加载检索策略，可以设定批量检索的大小，以帮助提高延迟检索或立即检索的运行性能
Hibernate允许在应用程序中覆盖映射文件中设定的检索策略

============================代码区===================================

Customer.java

 1 package com.yl.hibernate.strategy;
 2 
 3 import java.util.HashSet;
 4 import java.util.Set;
 5 
 6 public class Customer {
 7     
 8     private Integer customerId;
 9     private String customerName;
10 
11     private Set<Order> orders = new HashSet<Order>();
12     
13     public Integer getCustomerId() {
14         return customerId;
15     }
16     public void setCustomerId(Integer customerId) {
17         this.customerId = customerId;
18     }
19     public String getCustomerName() {
20         return customerName;
21     }
22     public void setCustomerName(String customerName) {
23         this.customerName = customerName;
24     }
25     public Set<Order> getOrders() {
26         return orders;
27     }
28     public void setOrders(Set<Order> orders) {
29         this.orders = orders;
30     }
31     
32     
33 }

Order.java

 1 package com.yl.hibernate.strategy;
 2 
 3 public class Order {
 4     
 5     private Integer orderId;
 6     private String orderName;
 7     
 8     private Customer customer;
 9 
10     public Integer getOrderId() {
11         return orderId;
12     }
13 
14     public void setOrderId(Integer orderId) {
15         this.orderId = orderId;
16     }
17 
18     public String getOrderName() {
19         return orderName;
20     }
21 
22     public void setOrderName(String orderName) {
23         this.orderName = orderName;
24     }
25 
26     public Customer getCustomer() {
27         return customer;
28     }
29 
30     public void setCustomer(Customer customer) {
31         this.customer = customer;
32     }
33 
34     @Override
35     public int hashCode() {
36         final int prime = 31;
37         int result = 1;
38         result = prime * result + ((orderId == null) ? 0 : orderId.hashCode());
39         return result;
40     }
41 
42     @Override
43     public boolean equals(Object obj) {
44         if (this == obj)
45             return true;
46         if (obj == null)
47             return false;
48         if (getClass() != obj.getClass())
49             return false;
50         Order other = (Order) obj;
51         if (orderId == null) {
52             if (other.orderId != null)
53                 return false;
54         } else if (!orderId.equals(other.orderId))
55             return false;
56         return true;
57     }
58     
59     
60 }

Customer.hbm.xml

 1 <?xml version="1.0"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 4 <!-- Generated 2014-11-26 19:19:40 by Hibernate Tools 3.4.0.CR1 -->
 5 <hibernate-mapping package="com.yl.hibernate.strategy">
 6     <class name="Customer" table="CUSTOMERS" lazy="false" batch-size="5">
 7         <id name="customerId" type="java.lang.Integer">
 8             <column name="CUSTOMER_ID" />
 9             <generator class="native" />
10         </id>
11         <property name="customerName" type="java.lang.String">
12             <column name="CUSTOMER_NAME" />
13         </property>
14         
15         <set name="orders" table="ORDERS" 
16             inverse="true" order-by="ORDER_NAME DESC" lazy="true" batch-size="2" fetch="subselect">
17             <!-- key：指定多的表汇总的外键列的名字 -->
18             <key column="CUSTOMER_ID"></key>
19             <!-- 指定映射类型 -->
20             <one-to-many class="Order"/>
21         </set>
22     </class>
23 </hibernate-mapping>

Order.hbm.xml

 1 <?xml version="1.0"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 4 <!-- Generated 2014-11-26 19:19:40 by Hibernate Tools 3.4.0.CR1 -->
 5 <hibernate-mapping package="com.yl.hibernate.strategy">
 6     <class name="Order" table="ORDERS">
 7         <id name="orderId" type="java.lang.Integer">
 8             <column name="ORDER_ID" />
 9             <generator class="native" />
10         </id>
11         <property name="orderName" type="java.lang.String">
12             <column name="ORDER_NAME" />
13         </property>
14         
15         <many-to-one name="customer" class="Customer" column="CUSTOMER_ID" lazy="false" fetch="join">
16         </many-to-one>
17        
18     </class>
19 </hibernate-mapping>

测试类：

  1 package com.yl.hibernate.strategy;
  2 
  3 
  4 import java.util.List;
  5 
  6 import org.hibernate.Hibernate;
  7 import org.hibernate.Session;
  8 import org.hibernate.SessionFactory;
  9 import org.hibernate.Transaction;
 10 import org.hibernate.cfg.Configuration;
 11 import org.hibernate.service.ServiceRegistry;
 12 import org.hibernate.service.ServiceRegistryBuilder;
 13 import org.junit.After;
 14 import org.junit.Before;
 15 import org.junit.Test;
 16 
 17 public class HibernateTest {
 18 
 19     private SessionFactory sessionFactory;
 20     private Session session;
 21     private Transaction transaction;
 22     
 23     @Before
 24     public void init() {
 25         Configuration configuration = new Configuration().configure();
 26         ServiceRegistry serviceRegistry = 
 27                 new ServiceRegistryBuilder().applySettings(configuration.getProperties())
 28                                             .buildServiceRegistry();
 29 
 30         sessionFactory = configuration.buildSessionFactory(serviceRegistry);
 31         
 32         session = sessionFactory.openSession();
 33 
 34         transaction = session.beginTransaction();
 35     }
 36     @After
 37     public void destory() {
 38         transaction.commit();
 39         
 40         session.close();
 41         
 42         sessionFactory.close();
 43     }
 44     
 45     @Test
 46     public void testClassLevelStrategy() {
 47         Customer customer = (Customer) session.load(Customer.class, 1);
 48         System.out.println(customer.getClass());
 49     }
 50     
 51     @Test
 52     public void testOne2ManyLevelStrategy() {
 53         Customer customer = (Customer) session.get(Customer.class, 1);
 54         System.out.println(customer.getCustomerName());
 55         
 56         System.out.println(customer.getOrders().size());
 57         Order order = new Order();
 58         order.setOrderId(1);
 59         System.out.println(customer.getOrders().contains(order));
 60         
 61         Hibernate.initialize(customer.getOrders());
 62         
 63         //----------------set 的lazy属性-----------------------------
 64         //1. 1-n 或 n-n 的集合属性默认使用懒加载检索策略
 65         //2. 可以通过设置set的lazy属性来修改默认的检索策略,默认为true，并不建议设置为false
 66         //3. lazy还可以设置为extra。增强的延迟检索, 该取值或尽可能的延迟集合初始化的时机！
 67     }
 68     
 69     @Test
 70     public void testSetBatchSize() {
 71         List<Customer> customers = session.createQuery("FROM Customer").list();
 72         
 73         System.out.println(customers.size());
 74         
 75         for (Customer customer : customers) {
 76             if (customer.getOrders() != null) {
 77                 System.out.println(customer.getOrders().size());
 78             }
 79         }
 80         
 81         //set元素的batch-size属性： 设定一次初始化set 集合的数量
 82     }
 83     
 84     @Test
 85     public void testSetFetch() {
 86         List<Customer> customers = session.createQuery("FROM Customer").list();
 87         
 88         System.out.println(customers.size());
 89         
 90         for (Customer customer : customers) {
 91             if (customer.getOrders() != null) {
 92                 System.out.println(customer.getOrders().size());
 93             }
 94         }
 95         //set 集合的fetch属性：确定初始化Orders集合的方式
 96         //1.默认值为select，通过正常的方式来初始化set元素
 97         //2.可以取值为subselect，通过子查询的方式来初始化所有的 set 集合。子查询作为where 子句的 in 的条件出现，子查询查询所有1的一端的ID
 98         //此时lazy有效，但是batch-size无效
 99         //3.若取值为join。 则
100         // 3.1  在加载1的一端的对象时，使用迫切左外连接(使用做外连接进行查询，且把集合属性进行初始化)的方式检索n的一端的集合属性
101         // 3.2 忽略lazy属性
102         // 3.3 HQL 查询忽略fetch=join 的取值
103     }
104     
105     @Test
106     public void testSetFetch2() {
107         Customer customer = (Customer) session.get(Customer.class, 1);
108         System.out.println(customer.getOrders().size());
109     }
110     
111     @Test
112     public void testMany2OneStrategy() {
113         /*Order order = (Order) session.get(Order.class, 1);
114         System.out.println(order.getCustomer().getCustomerName());
115         */
116         
117         //1. lazy 取值为proxy 和 flase 分别代表对应的属性采用延迟检索和立即检索
118         //2. fetch取值为join，表示使用迫切左外连接的犯法初始化n关联的1的一端的属性
119         //忽略lazy属性
120         List<Order> orders = session.createQuery("FROM Order o").list();
121         for (Order order : orders) {
122             if (order.getCustomer() != null) {
123                 System.out.println(order.getCustomer().getCustomerName());
124             }
125         }
126         
127         //3. batch-size，该属性需要设置在1那一端的class元素汇总：
128         //<class name="Customer" table="CUSTOMERS" lazy="false" batch-size="5">
129         //作用：一次初始化1的这一端代理对象的个数
130     }
131     
132     
133     
134 }