Hibernate--检索策略

最新推荐文章于 2020-05-07 16:12:29 发布

小疯子青

最新推荐文章于 2020-05-07 16:12:29 发布

阅读量212

点赞数

分类专栏： Tomcat学习实践过程记录

本文链接：https://blog.csdn.net/a1773570500/article/details/105600207

版权

Tomcat学习实践过程记录专栏收录该内容

57 篇文章 2 订阅

订阅专栏

Hibernate 检索策略

检索数据时的 2 个问题
类级别的检索策略
一对多和多对多的检索策略
多对一和一对一关联的检索策略
- lazy属性
- fetch属性

检索数据时的 2 个问题

1)不浪费内存,加载对象时机的问题
2)更高的查询效率：发送尽可能少的 SQL 语句

类级别的检索策略

1.类级别的检索策略分类

1)立即检索: 立即加载检索方法指定的对象(默认)
2)延迟检索: 延迟加载检索方法指定的对象。在使用具体的属性时，再进行加载

2.类级别的检索策略的设置

可以通过元素的 lazy 属性进行设置

3.使用时机

1)如果程序加载一个对象的目的是为了访问它的属性, 可以采取立即检索.
2)如果程序加载一个持久化对象的目的是仅仅为了获得它的引用, 可以采用延迟检索。注意出现懒加载异常！

4.lazy的生效说明

1)若元素的 lazy 属性为 true 或取默认值, Session 的 load() 方法不会执行查询数据表的 SELECT 语句, 仅返回代理类对象的实例, 该代理类实例有如下特征
—>①由 Hibernate 在运行时采用 CGLIB 工具动态生成
—>②Hibernate 创建代理类实例时, 仅初始化其 OID 属性
—>③在应用程序第一次访问代理类实例的非 OID 属性时, Hibernate 会初始化代理类实例
2)无论元素的 lazy 属性是 true 还是 false, Session 的 get() 方法及 Query 的 list() 方法在类级别总是使用立即检索策略
测试样例：
默认延迟加载

@Test
 public void testMany2OneStrategy(){
  Customer customer=(Customer)session.load(Customer.class, 1);
  System.out.println(customer.getClass());
  System.out.println(customer.getCustomerId());
  System.out.println(customer.getCustomerName());
 }

测试结果：

class com.atguigu.hibernate.strategy.Customer$HibernateProxy$mDJwT4Tb
1
Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ 
    from
        CUSTOMERS customer0_ 
    where
        customer0_.CUSTOMER_ID=?
AA

设置立即加载

<class name="Customer" table="CUSTOMERS" lazy="false">

测试代码

public void testMany2OneStrategy(){
  Customer customer=(Customer)session.load(Customer.class, 1);
  System.out.println(customer.getClass());
  System.out.println(customer.getCustomerId());
  System.out.println(customer.getCustomerName());
 }

测试结果为

Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ 
    from
        CUSTOMERS customer0_ 
    where
        customer0_.CUSTOMER_ID=?
class com.atguigu.hibernate.strategy.Customer
1
AA

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

在映射文件中, 用元素来配置一对多关联及多对多关联关系. 元素有 lazy 和 fetch 属性
1)lazy: 主要决定 set 集合被初始化的时机
2)fetch: 取值为 “select” 或 “subselect” 时, 决定初始化 orders 的查询语句的形式; 若取值为”join”, 则决定 orders 集合被初始化的时机
3)若把 fetch 设置为 “join”, lazy 属性将被忽略
元素的 batch-size 属性：用来为延迟检索策略或立即检索策略设定批量检索的数量. 批量检索能减少 SELECT 语句的数目, 提高延迟检索或立即检索的运行性能

示例代码
1)永久化类

public class Customer {
 private Integer customerId;
 private String customerName;
 private Set<Order> orders = new HashSet<>();
 }

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

2)实体关系配置
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">
<hibernate-mapping package="com.atguigu.hibernate.strategy">
    <class name="Customer" table="CUSTOMERS" lazy="true"> 
        <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">
         <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">
<hibernate-mapping package="com.atguigu.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" fetch="join">
  </many-to-one>
    </class>
</hibernate-mapping>

3)测试
默认采用的事懒加载

public void testMany2OneStrategy(){
  Customer customer=session.get(Customer.class, 1);
  System.out.println(customer.getCustomerName());
  System.out.println(customer.getOrders().size());
 }

运行结果

Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ 
    from
        CUSTOMERS customer0_ 
    where
        customer0_.CUSTOMER_ID=?
AA
Hibernate: 
    select
        orders0_.CUSTOMER_ID as CUSTOMER3_1_0_,
        orders0_.ORDER_ID as ORDER_ID1_1_0_,
        orders0_.ORDER_ID as ORDER_ID1_1_1_,
        orders0_.ORDER_NAME as ORDER_NA2_1_1_,
        orders0_.CUSTOMER_ID as CUSTOMER3_1_1_ 
    from
        ORDERS orders0_ 
    where
        orders0_.CUSTOMER_ID=? 
    order by
        orders0_.ORDER_NAME desc
3

lazy配置

立即加载测试示例
1)配置set的lazy为立即加载，并不建议设置为立即加载

<set name="orders" table="ORDERS" 
         inverse="true" order-by="ORDER_NAME DESC" lazy="false">
         <key column="CUSTOMER_ID"></key>
         <one-to-many class="Order"/>
        </set>

2)测试代码

public void testMany2OneStrategy(){
  Customer customer=session.get(Customer.class, 1);
  System.out.println(customer.getCustomerName());
  System.out.println(customer.getOrders().size());
 }

运行结果：

Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ 
    from
        CUSTOMERS customer0_ 
    where
        customer0_.CUSTOMER_ID=?
Hibernate: 
    select
        orders0_.CUSTOMER_ID as CUSTOMER3_1_0_,
        orders0_.ORDER_ID as ORDER_ID1_1_0_,
        orders0_.ORDER_ID as ORDER_ID1_1_1_,
        orders0_.ORDER_NAME as ORDER_NA2_1_1_,
        orders0_.CUSTOMER_ID as CUSTOMER3_1_1_ 
    from
        ORDERS orders0_ 
    where
        orders0_.CUSTOMER_ID=? 
    order by
        orders0_.ORDER_NAME desc
AA
3

在延迟检索(lazy 属性值为 true) 集合属性时, Hibernate 在以下情况下初始化集合代理类实例
1)应用程序第一次访问集合属性: iterator(), size(), isEmpty(), contains() 等方法
2)通过 Hibernate.initialize() 静态方法显式初始化

Hibernate.initialize(customer.getOrders());

增强的延迟加载
1)配置示例

 <set name="orders" table="ORDERS" 
         inverse="true" order-by="ORDER_NAME DESC" lazy="extra">
         <key column="CUSTOMER_ID"></key>
         <one-to-many class="Order"/>
        </set>

2)测试代码

public void testMany2OneStrategy(){
  Customer customer=session.get(Customer.class, 1);
  System.out.println(customer.getCustomerName());
  System.out.println(customer.getOrders().size());
 }

测试结果

Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ 
    from
        CUSTOMERS customer0_ 
    where
        customer0_.CUSTOMER_ID=?
AA
Hibernate: 
    select
        count(ORDER_ID) 
    from
        ORDERS 
    where
        CUSTOMER_ID =?
3

增强延迟检索(lazy 属性为 extra): 与 lazy=“true” 类似. 主要区别是增强延迟检索策略能进一步延迟 Customer 对象的 orders 集合代理实例的初始化时机：
1)当程序第一次访问 orders 属性的 iterator() 方法时, 会导致 orders 集合代理类实例的初始化
2)当程序第一次访问 order 属性的 size(), contains() 和 isEmpty() 方法时, Hibernate 不会初始化 orders 集合类的实例, 仅通过特定的 select 语句查询必要的信息, 不会检索所有的 Order 对象

batch-size属性

用来为延迟检索策略或立即检索策略设定批量检索的数量. 批量检索能减少 SELECT 语句的数目, 提高延迟检索或立即检索的运行性能。

  <set name="orders" table="ORDERS" 
         inverse="true" order-by="ORDER_NAME DESC" lazy="true" batch-size="3">
         <key column="CUSTOMER_ID"></key>
         <one-to-many class="Order"/>
        </set>

fetch

1)取值为 “select” 或 “subselect” 时, 决定初始化 orders 的查询语句的形式; 若取值为”join”, 则决定 orders 集合被初始化的时机
2)若把 fetch 设置为 “join”, lazy 属性将被忽略
测试代码

public void test(){
  List<Customer> customers=session.createQuery("FROM Customer").list();
  System.out.println("size:"+customers.size());
  for(Customer customer:customers)
  {
   if(customer.getOrders()!=null)
    System.out.println("detailes"+customer.getOrders().size());
  }
 }

1.取值为select
Customer.hbm.xml配置文件

<set name="orders" table="ORDERS" 
         inverse="true" order-by="ORDER_NAME DESC" lazy="true" batch-size="3" fetch="select">
         <key column="CUSTOMER_ID"></key>
         <one-to-many class="Order"/>
        </set>

测试结果

Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_ 
    from
        CUSTOMERS customer0_
size:4
Hibernate: 
    select
        orders0_.CUSTOMER_ID as CUSTOMER3_1_1_,
        orders0_.ORDER_ID as ORDER_ID1_1_1_,
        orders0_.ORDER_ID as ORDER_ID1_1_0_,
        orders0_.ORDER_NAME as ORDER_NA2_1_0_,
        orders0_.CUSTOMER_ID as CUSTOMER3_1_0_ 
    from
        ORDERS orders0_ 
    where
        orders0_.CUSTOMER_ID in (
            ?, ?, ?
        ) 
    order by
        orders0_.ORDER_NAME desc
detailes3
detailes3
detailes3
Hibernate: 
    select
        orders0_.CUSTOMER_ID as CUSTOMER3_1_1_,
        orders0_.ORDER_ID as ORDER_ID1_1_1_,
        orders0_.ORDER_ID as ORDER_ID1_1_0_,
        orders0_.ORDER_NAME as ORDER_NA2_1_0_,
        orders0_.CUSTOMER_ID as CUSTOMER3_1_0_ 
    from
        ORDERS orders0_ 
    where
        orders0_.CUSTOMER_ID=? 
    order by
        orders0_.ORDER_NAME desc
detailes0

2.取值为subselect
Customer.hbm.xml配置文件

<set name="orders" table="ORDERS" 
         inverse="true" order-by="ORDER_NAME DESC" lazy="true" batch-size="2" fetch="subselect">
         <key column="CUSTOMER_ID"></key>
         <one-to-many class="Order"/>
        </set>

测试结果为

Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_ 
    from
        CUSTOMERS customer0_
size:4
Hibernate: 
    select
        orders0_.CUSTOMER_ID as CUSTOMER3_1_1_,
        orders0_.ORDER_ID as ORDER_ID1_1_1_,
        orders0_.ORDER_ID as ORDER_ID1_1_0_,
        orders0_.ORDER_NAME as ORDER_NA2_1_0_,
        orders0_.CUSTOMER_ID as CUSTOMER3_1_0_ 
    from
        ORDERS orders0_ 
    where
        orders0_.CUSTOMER_ID in (
            select
                customer0_.CUSTOMER_ID 
            from
                CUSTOMERS customer0_
        ) 
    order by
        orders0_.ORDER_NAME desc
detailes3
detailes3
detailes3
detailes0

当 fetch 属性为 “subselect” 时
1)假定 Session 缓存中有 n 个 orders 集合代理类实例没有被初始化, Hibernate 能够通过带子查询的 select 语句, 来批量初始化 n 个 orders 集合代理类实例
2)batch-size 属性将被忽略
3)子查询中的 select 语句为查询 CUSTOMERS 表 OID 的 SELECT 语句
3.取值为join
当 fetch 属性为 “join” 时:
1)检索 Customer 对象时, 会采用迫切左外连接(通过左外连接加载与检索指定的对象关联的对象)策略来检索所有关联的 Order 对象
2)lazy 属性将被忽略
3)Query 的list() 方法会忽略映射文件中配置的迫切左外连接检索策略, 而依旧采用延迟加载策略
①Customer.hbm.xml配置文件

<set name="orders" table="ORDERS" 
         inverse="true" order-by="ORDER_NAME DESC" lazy="true" batch-size="2" fetch="join">
         <key column="CUSTOMER_ID"></key>
         <one-to-many class="Order"/>
        </set>

②测试代码

public void test(){
  Customer customer=session.get(Customer.class, 1);
  System.out.println(customer.getOrders().size());
 }

③测试结果

Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ 
    from
        CUSTOMERS customer0_ 
    where
        customer0_.CUSTOMER_ID=?
Hibernate: 
    select
        orders0_.CUSTOMER_ID as CUSTOMER3_1_1_,
        orders0_.ORDER_ID as ORDER_ID1_1_1_,
        orders0_.ORDER_ID as ORDER_ID1_1_0_,
        orders0_.ORDER_NAME as ORDER_NA2_1_0_,
        orders0_.CUSTOMER_ID as CUSTOMER3_1_0_ 
    from
        ORDERS orders0_ 
    where
        orders0_.CUSTOMER_ID=? 
    order by
        orders0_.ORDER_NAME desc
3

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

测试代码

public void test(){
  Order order=session.get(Order.class, 1);
 }

运行结果

Hibernate: 
    select
        order0_.ORDER_ID as ORDER_ID1_1_0_,
        order0_.ORDER_NAME as ORDER_NA2_1_0_,
        order0_.CUSTOMER_ID as CUSTOMER3_1_0_ 
    from
        ORDERS order0_ 
    where
        order0_.ORDER_ID=?

lazy属性

1.设置lazy为false
修改配置文件Order.hbm.xml

<many-to-one name="customer" class="Customer" column="CUSTOMER_ID" lazy="false">
  </many-to-one>

测试结果为

Hibernate: 
    select
        order0_.ORDER_ID as ORDER_ID1_1_0_,
        order0_.ORDER_NAME as ORDER_NA2_1_0_,
        order0_.CUSTOMER_ID as CUSTOMER3_1_0_ 
    from
        ORDERS order0_ 
    where
        order0_.ORDER_ID=?
Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ 
    from
        CUSTOMERS customer0_ 
    where
        customer0_.CUSTOMER_ID=?

fetch属性

修改配置文件Order.hbm.xml

<many-to-one name="customer" class="Customer" column="CUSTOMER_ID" lazy="false" fetch="join">
  </many-to-one>

测试结果

Hibernate: 
    select
        order0_.ORDER_ID as ORDER_ID1_1_0_,
        order0_.ORDER_NAME as ORDER_NA2_1_0_,
        order0_.CUSTOMER_ID as CUSTOMER3_1_0_,
        customer1_.CUSTOMER_ID as CUSTOMER1_0_1_,
        customer1_.CUSTOMER_NAME as CUSTOMER2_0_1_ 
    from
        ORDERS order0_ 
    left outer join
        CUSTOMERS customer1_ 
            on order0_.CUSTOMER_ID=customer1_.CUSTOMER_ID 
    where
        order0_.ORDER_ID=?

总结：

lazy 取值为 proxy 和 false 分别代表对应对应的属性采用延迟检索和立即检索
fetch 取值为 join, 表示使用迫切左外连接的方式初始化 n 关联的 1 的一端的属性忽略 lazy 属性.
batch-size, 该属性需要设置在 1 那一端的 class 元素中:

作用: 一次初始化 1 的这一段代理对象的个数.

小疯子青

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Hibernate--检索策略

Hibernate 检索策略检索数据时的 2 个问题类级别的检索策略1.类级别的检索策略分类2.类级别的检索策略的设置3.使用时机4.lazy的生效说明一对多和多对多的检索策略检索数据时的 2 个问题1)不浪费内存,加载对象时机的问题2)更高的查询效率：发送尽可能少的 SQL 语句类级别的检索策略1.类级别的检索策略分类1)立即检索: 立即加载检索方法指定的对象(默认)2)延迟检索:...
复制链接

扫一扫

专栏目录