Hibernate 检索策略

1. 概述

　　检索数据时的2个问题：

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

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

1. 类级别的检索策略
2. 一对多和多对多的检索策略
3. 多对一和一对一关联的检索策略

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

类级别的检索策略

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

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

• 类级别的检索策略可以通过<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

package com.yl.hibernate.strategy;

import java.util.HashSet;
import java.util.Set;

public class Customer {
    
    private Integer customerId;
    private String customerName;

    private Set<Order> orders = new HashSet<Order>();
    
    public Integer getCustomerId() {
        return customerId;
    }
    public void setCustomerId(Integer customerId) {
        this.customerId = customerId;
    }
    public String getCustomerName() {
        return customerName;
    }
    public void setCustomerName(String customerName) {
        this.customerName = customerName;
    }
    public Set<Order> getOrders() {
        return orders;
    }
    public void setOrders(Set<Order> orders) {
        this.orders = orders;
    }
    
    
}

Order.java

package com.yl.hibernate.strategy;

public class Order {
    
    private Integer orderId;
    private String orderName;
    
    private Customer customer;

    public Integer getOrderId() {
        return orderId;
    }

    public void setOrderId(Integer orderId) {
        this.orderId = orderId;
    }

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

    public Customer getCustomer() {
        return customer;
    }

    public void setCustomer(Customer customer) {
        this.customer = customer;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((orderId == null) ? 0 : orderId.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Order other = (Order) obj;
        if (orderId == null) {
            if (other.orderId != null)
                return false;
        } else if (!orderId.equals(other.orderId))
            return false;
        return true;
    }
    
    
}

Customer.hbm.xml

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

Order.hbm.xml

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

测试类：

package com.yl.hibernate.strategy;


import java.util.List;

import org.hibernate.Hibernate;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class HibernateTest {

    private SessionFactory sessionFactory;
    private Session session;
    private Transaction transaction;
    
    @Before
    public void init() {
        Configuration configuration = new Configuration().configure();
        ServiceRegistry serviceRegistry = 
                new ServiceRegistryBuilder().applySettings(configuration.getProperties())
                                            .buildServiceRegistry();

        sessionFactory = configuration.buildSessionFactory(serviceRegistry);
        
        session = sessionFactory.openSession();

        transaction = session.beginTransaction();
    }
    @After
    public void destory() {
        transaction.commit();
        
        session.close();
        
        sessionFactory.close();
    }
    
    @Test
    public void testClassLevelStrategy() {
        Customer customer = (Customer) session.load(Customer.class, 1);
        System.out.println(customer.getClass());
    }
    
    @Test
    public void testOne2ManyLevelStrategy() {
        Customer customer = (Customer) session.get(Customer.class, 1);
        System.out.println(customer.getCustomerName());
        
        System.out.println(customer.getOrders().size());
        Order order = new Order();
        order.setOrderId(1);
        System.out.println(customer.getOrders().contains(order));
        
        Hibernate.initialize(customer.getOrders());
        
        //----------------set 的lazy属性-----------------------------
        //1. 1-n 或 n-n 的集合属性默认使用懒加载检索策略
        //2. 可以通过设置set的lazy属性来修改默认的检索策略,默认为true，并不建议设置为false
        //3. lazy还可以设置为extra。增强的延迟检索, 该取值或尽可能的延迟集合初始化的时机！
    }
    
    @Test
    public void testSetBatchSize() {
        List<Customer> customers = session.createQuery("FROM Customer").list();
        
        System.out.println(customers.size());
        
        for (Customer customer : customers) {
            if (customer.getOrders() != null) {
                System.out.println(customer.getOrders().size());
            }
        }
        
        //set元素的batch-size属性： 设定一次初始化set 集合的数量
    }
    
    @Test
    public void testSetFetch() {
        List<Customer> customers = session.createQuery("FROM Customer").list();
        
        System.out.println(customers.size());
        
        for (Customer customer : customers) {
            if (customer.getOrders() != null) {
                System.out.println(customer.getOrders().size());
            }
        }
        //set 集合的fetch属性：确定初始化Orders集合的方式
        //1.默认值为select，通过正常的方式来初始化set元素
        //2.可以取值为subselect，通过子查询的方式来初始化所有的 set 集合。子查询作为where 子句的 in 的条件出现，子查询查询所有1的一端的ID
        //此时lazy有效，但是batch-size无效
        //3.若取值为join。 则
        // 3.1  在加载1的一端的对象时，使用迫切左外连接(使用做外连接进行查询，且把集合属性进行初始化)的方式检索n的一端的集合属性
        // 3.2 忽略lazy属性
        // 3.3 HQL 查询忽略fetch=join 的取值
    }
    
    @Test
    public void testSetFetch2() {
        Customer customer = (Customer) session.get(Customer.class, 1);
        System.out.println(customer.getOrders().size());
    }
    
    @Test
    public void testMany2OneStrategy() {
        /*Order order = (Order) session.get(Order.class, 1);
        System.out.println(order.getCustomer().getCustomerName());
        */
        
        //1. lazy 取值为proxy 和 flase 分别代表对应的属性采用延迟检索和立即检索
        //2. fetch取值为join，表示使用迫切左外连接的犯法初始化n关联的1的一端的属性
        //忽略lazy属性
        List<Order> orders = session.createQuery("FROM Order o").list();
        for (Order order : orders) {
            if (order.getCustomer() != null) {
                System.out.println(order.getCustomer().getCustomerName());
            }
        }
        
        //3. batch-size，该属性需要设置在1那一端的class元素汇总：
        //<class name="Customer" table="CUSTOMERS" lazy="false" batch-size="5">
        //作用：一次初始化1的这一端代理对象的个数
    }
    
    
    
}