首页 > 代码库 > Hibernate —— 检索策略
Hibernate —— 检索策略
一、Hibernate 的检索策略本质上是为了优化 Hibernate 性能。
二、Hibernate 检索策略包括类级别的检索策略、和关联级别的检索策略（<set> 元素）
三、类级别的检索策略
1. 立即检索、延迟检索
2. 通过 <class> 节点的 lazy 属性来控制。默认为 true，即为延迟检索。
3. 只针对 session 的 load() 方法生效。
默认情况下，通过 load() 方法获取到的对象是一个代理对象，Hibernate 创建代理对象时，仅会初始化 OID。
在第一次访问非 OID 属性时，Hibernate 会初始化代理类实例。
4.测试
（1）<class> 的 lazy 属性为 true
@Testpublic 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_05--------------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
@Testpublic 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 时（增强的延迟检索策略），会尽可能的延迟初始化集合的时机。如：
@Testpublic 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"
@Testpublic 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=?2Hibernate: 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=?2Hibernate: 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=?2Hibernate: 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 ( ?, ? )22
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 in ( select customer0_.customer_id from hibernate.customer customer0_ )2222通过子查询的方式，通过 in 的方式。
<3>取值为 "join"
- 会采用迫切左外链接（使用左外链接进行查询，同时初始化集合属性）策略来初始化所有关联的对象
- lazy 属性将会被忽略
- Query 的 list() 方法会忽略这个取值，不会忽略 lazy 属性。
- HQL 会忽略取值为 "join" 的取值
@Testpublic 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）默认情况下
@Testpublic 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=?2Hibernate: 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"
@Testpublic 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 ( ?, ? )22
五、<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 属性。
Hibernate —— 检索策略
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。