Hibernate —— 检索策略
一、Hibernate 的检索策略本质上是为了优化 Hibernate 性能。
二、Hibernate 检索策略包括类级别的检索策略、和关联级别的检索策略（<set> 元素）
三、类级别的检索策略
1. 立即检索、延迟检索
2. 通过 <class> 节点的 lazy 属性来控制。默认为 true，即为延迟检索。
3. 只针对 session 的 load() 方法生效。
默认情况下，通过 load() 方法获取到的对象是一个代理对象，Hibernate 创建代理对象时，仅会初始化 OID。
在第一次访问非 OID 属性时，Hibernate 会初始化代理类实例。
4.测试
（1）<class> 的 lazy 属性为 true
@Test
public void testStrategyClassLevel() {
Customer customer = (Customer) session.load(Customer.class, 5);
System.out.println(customer.getClass());
System.out.println(customer.getCustomerId());
System.out.println("--------------");
System.out.println(customer.getCustomerName());
}class com.nucsoft.strategy.many2one.Customer_$$_javassist_0
5
--------------
Hibernate:
select
customer0_.customer_id as customer1_2_0_,
customer0_.customer_name as customer2_2_0_
from
hibernate.customer customer0_
where
customer0_.customer_id=?
bb （2）<class> 的 lazy 属性为 false
@Test
public void testStrategyClassLevel() {
session.load(Customer.class, 5);
}Hibernate:
select
customer0_.customer_id as customer1_2_0_,
customer0_.customer_name as customer2_2_0_
from
hibernate.customer customer0_
where
customer0_.customer_id=? 四、关联级别的检索策略
1. 指的是用 <set> 元素来配置的多对一和多对多的关联关系。
2. 主要指的是 <set> 元素的三个属性：lazy 、fetch、batch-size。
3. lazy 属性（默认为 true，即采用延迟检索策略）
（1）决定集合被初始化的时机。
（2）取值为 true 时
- Hibernate 会在以下情况下初始化集合代理类实例 访问集合属性、iterator()、size()、isEmpty()、contains() 等方法时
- 通过 Hibernate.initialize() 静态方法显示的初始化
（3）取值为 false 时
（4）取值为 extra 时（增强的延迟检索策略），会尽可能的延迟初始化集合的时机。如：
@Test
public void testSetLazy() {
Category category = (Category) session.get(Category.class, 5);
System.out.println(category.getItems().size());
}Hibernate:
select
category0_.category_id as category1_1_0_,
category0_.category_name as category2_1_0_
from
hibernate.category category0_
where
category0_.category_id=?
Hibernate:
select
count(item_id)
from
hibernate.categories_items
where
category_id =?
2 调用集合的 size() 方法时，是通过 count() 来查询的。
当调用集合的 iterator() 方法时，会初始化集合。
4. fetch 属性（默认为 "select"）
（1）取值为 "select" 或 "subselect" 时，决定初始化集合查询语句的形式。
（2）取值为 "join"，则决定初始化集合的时机。会忽略 "lazy" 属性。
（3）测试
<1>取值为 "select"
@Test
public void testSetLazy() {
List<Category> categories = session.createQuery("from Category").list();
for(Category category : categories) {
System.out.println(category.getItems().size());
}
}Hibernate:
select
customer0_.customer_id as customer1_2_,
customer0_.customer_name as customer2_2_
from
hibernate.customer customer0_
Hibernate:
select
orders0_.customer_id as customer3_2_1_,
orders0_.order_id as order1_4_1_,
orders0_.order_id as order1_4_0_,
orders0_.order_name as order2_4_0_,
orders0_.customer_id as customer3_4_0_
from
hibernate.order orders0_
where
orders0_.customer_id=?
2
Hibernate:
select
orders0_.customer_id as customer3_2_1_,
orders0_.order_id as order1_4_1_,
orders0_.order_id as order1_4_0_,
orders0_.order_name as order2_4_0_,
orders0_.customer_id as customer3_4_0_
from
hibernate.order orders0_
where
orders0_.customer_id=?
2
Hibernate:
select
orders0_.customer_id as customer3_2_1_,
orders0_.order_id as order1_4_1_,
orders0_.order_id as order1_4_0_,
orders0_.order_name as order2_4_0_,
orders0_.customer_id as customer3_4_0_
from
hibernate.order orders0_
where
orders0_.customer_id=?
2
Hibernate:
select
orders0_.customer_id as customer3_2_1_,
orders0_.order_id as order1_4_1_,
orders0_.order_id as order1_4_0_,
orders0_.order_name as order2_4_0_,
orders0_.customer_id as customer3_4_0_
from
hibernate.order orders0_
where
orders0_.customer_id=?
2 <2>取值为 "subselect"，会忽略 batch-size 属性。
Hibernate:
select
category0_.category_id as category1_1_,
category0_.category_name as category2_1_
from
hibernate.category category0_
Hibernate:
select
items0_.category_id as category1_1_1_,
items0_.item_id as item2_0_1_,
item1_.item_id as item1_3_0_,
item1_.item_name as item2_3_0_
from
hibernate.categories_items items0_
inner join
hibernate.item item1_
on items0_.item_id=item1_.item_id
where
items0_.category_id in (
?, ?
)
2
2Hibernate:
select
customer0_.customer_id as customer1_2_,
customer0_.customer_name as customer2_2_
from
hibernate.customer customer0_
Hibernate:
select
orders0_.customer_id as customer3_2_1_,
orders0_.order_id as order1_4_1_,
orders0_.order_id as order1_4_0_,
orders0_.order_name as order2_4_0_,
orders0_.customer_id as customer3_4_0_
from
hibernate.order orders0_
where
orders0_.customer_id in (
select
customer0_.customer_id
from
hibernate.customer customer0_
)
2
2
2
2 通过子查询的方式，通过 in 的方式。
<3>取值为 "join"
- 会采用迫切左外链接（使用左外链接进行查询，同时初始化集合属性）策略来初始化所有关联的对象
- lazy 属性将会被忽略
- Query 的 list() 方法会忽略这个取值，不会忽略 lazy 属性。
- HQL 会忽略取值为 "join" 的取值
@Test
public void testFetch() {
session.get(Customer.class, 5);
}Hibernate:
select
customer0_.customer_id as customer1_2_1_,
customer0_.customer_name as customer2_2_1_,
orders1_.customer_id as customer3_2_3_,
orders1_.order_id as order1_4_3_,
orders1_.order_id as order1_4_0_,
orders1_.order_name as order2_4_0_,
orders1_.customer_id as customer3_4_0_
from
hibernate.customer customer0_
left outer join
hibernate.order orders1_
on customer0_.customer_id=orders1_.customer_id
where
customer0_.customer_id=?5.batch-size 属性，设定批量检索集合的数量。
（1）默认情况下
@Test
public void testSetLazy() {
List<Category> categories = session.createQuery("from Category").list();
for(Category category : categories) {
System.out.println(category.getItems().size());
}
}Hibernate:
select
category0_.category_id as category1_1_,
category0_.category_name as category2_1_
from
hibernate.category category0_
Hibernate:
select
items0_.category_id as category1_1_1_,
items0_.item_id as item2_0_1_,
item1_.item_id as item1_3_0_,
item1_.item_name as item2_3_0_
from
hibernate.categories_items items0_
inner join
hibernate.item item1_
on items0_.item_id=item1_.item_id
where
items0_.category_id=?
2
Hibernate:
select
items0_.category_id as category1_1_1_,
items0_.item_id as item2_0_1_,
item1_.item_id as item1_3_0_,
item1_.item_name as item2_3_0_
from
hibernate.categories_items items0_
inner join
hibernate.item item1_
on items0_.item_id=item1_.item_id
where
items0_.category_id=?
2 （2）设置 batch-size="2"
@Test
public void testSetLazy() {
List<Category> categories = session.createQuery("from Category").list();
for(Category category : categories) {
System.out.println(category.getItems().size());
}
}Hibernate:
select
category0_.category_id as category1_1_,
category0_.category_name as category2_1_
from
hibernate.category category0_
Hibernate:
select
items0_.category_id as category1_1_1_,
items0_.item_id as item2_0_1_,
item1_.item_id as item1_3_0_,
item1_.item_name as item2_3_0_
from
hibernate.categories_items items0_
inner join
hibernate.item item1_
on items0_.item_id=item1_.item_id
where
items0_.category_id in (
?, ?
)
2
2 五、<many-to-one> 元素的 lazy 和 fetch 属性
1.lazy 属性
（1）proxy
采用延迟检索策略。
（2）false
采用立即检索策略。
2.fetch 属性
（1）select（默认）
（2）join
表示使用迫切左外链接的方式，初始化 n 的一端关联的 1 的一端的对象。
同样，HQL 查询会忽略 fetch 的取值为 join 的情况，此种情况下，若想批量初始化 1 的一端的代理对象，可以在 1 的一端的 class 节点添加 batch-size 属性。
六、总结
介绍了 Hibernate 的检索策略，包括累级别的检索策略，和关联级别的检索策略。以及简单介绍了 <many-to-one> 元素的 lazy 和 fetch 属性。
相关推荐
LetonLIU 2020-02-11
abguorui0 2015-03-08
hhboyggyy 2014-08-25
万星明 2013-06-24
haojusheng 2012-12-04
追求 2011-06-28
平步星云 2011-05-05
chenssss 2011-04-05
simon曦 2011-04-02
nameFay 2011-03-29
阳光丶不锈 2010-12-22
chenssss 2010-11-08
TomasEdision 2010-11-08
神儿童 2010-10-19
xhljames 2010-08-11
xing00 2010-05-10
hhboyggyy 2010-04-08
土豆的小秘密 2008-05-22
DOVEty 2008-05-20