Hibernate檢索策略與檢索方式
hibernate的Session在加載Java對象時,一般都會把魚這個對象相關聯的其他Java對象也都加載到緩存中,以方便程序的調用。但很多情況下,我們不需要加載太多無用的對象到緩存中,一來會占用大量的內存,二來會增加數據庫的訪問次數,使得程序的運行效率降低。為了合理的使用緩存,Hibernate提供了不同的檢索策略來解決這些問題。
作用域
在說檢索策略之前,先了解一下檢索策略的作用域,它分為:類級別和關聯級別。類級別的作用域在檢索數據時,檢索的數據只包含一個類對象,不涉及與該類關聯的其他對象。關聯級別的作用域檢索的數據包含相關聯的多個類的對象,例如,Customer對象與Orders對象存在關系,檢索到一個Customer對象後,還會涉及與之關聯的Orders對象。
作用域對比
檢索策略
Hibernate的檢索策略分為三種,立即檢索、延遲檢索、左外連接檢索。
立即檢索
采用立即檢索策略,會把被檢索的對象,以及和這個對象關聯的一對多對象都加載到緩存中。Session的get方法就使用的立即檢索策略。這種策略的優點在於,頻繁使用的對象會被加載到緩存中,程序調用很方便,也很及時。缺點就是,占用的內存過多,而且數據庫訪問的次數也會很頻繁,效率低下。
延遲檢索
采用延遲檢索策略,就不會加載關聯對象的內容。直到第一次調用關聯對象時,才去加載關聯對象。在不涉及關聯類操作時,延遲檢索策略只適用於Session的load方法。涉及關聯類操作時,延遲檢索策略也能夠適用於get,list等操作。
在類級別操作時, 延遲檢索策略,只加載類的OID不加載類的其他屬性,只用當第一次訪問其他屬性時,才回訪問數據庫去加載內容。(這裏使用了CGLIB生成了類的代理類)
在關聯級別操作時,延遲檢索策略,只加載類本身,不加載關聯類,直到第一次調用關聯對象時,才去加載關聯對象。
程序模式都是用延遲加載策略。如果需要指定使用延遲加載策略。在配置文件中設置<class>的lazy=true,<set>的lazy=true或extra(增強延遲)<many-to-one>的lazy=proxy和no-proxy。
這種策略的優點在於,由程序決定加載哪些類和內容,而不必全部都加載,避免了內存的大量占用和數據庫的頻繁訪問。缺點就是在Session關閉後,就不能訪問關聯類對象了。 需要確保Session一直處於打開狀態,調用關聯對象,最後在關閉Session對象。
左外連接檢索
采用左外連接檢索,能夠使用Sql的外連接查詢,將需要加載的關聯對象加載在緩存中。<set>fetch設置為join,<many-to-one>的fetch設置為join。
這種策略的優點在於,對應用程序完全透明,不管對象處於持久化狀態,還是遊離狀態,應用程序都可以方便的從一個對象導航到與它關聯的對象。使用了外連接,select語句數目少。缺點就是可能會加載應用程序不需要訪問的對象,白白浪費許多內存空間。復雜的數據庫表連接也會影響檢索性能。
三種策略運行機制
檢索方式
Hibernate提供的檢索方式為5種,分為導航對象圖檢索方式、OID檢索方式、HQL檢索方式、QBC檢索方式、本地SQL檢索方式。
導航對象圖檢索方式
利用類與類之間的關系來檢索對象。譬如我們要查找一份訂單,就可以由訂單對象自動導航找到訂單所屬的客戶對象。當然,前提是必須在對象-關系映射文件上配置了它們的多對一的關系。
OID檢索方式
主要指用Session的get()和load()方法加載某條記錄對應的對象。
HQL檢索方式
HQL(Hibernate Query Language)是面向對象的查詢語言,它和SQL查詢語言有些相似。在Hibernate提供的各種檢索方式中,HQL是使用最廣的一種檢索方式。它具有以下功能:
在查詢語句中設定各種查詢條件。
支持投影查詢,即僅檢索出對象的部分屬性。
支持分頁查詢。
支持分組查詢,允許使用group by和having關鍵字。
提供內置聚集函數,如sum()、min()和max()。
能夠調用用戶定義的SQL函數。
支持子查詢,即嵌套查詢。
支持動態綁定參數。
Session類的Qurey接口支持HQL檢索方式,它提供了以上列出的各種查詢功能。
註:Qurey接口支持方法鏈編程風格,它的set方法都返回自身實例,而不是返回void類型。方法鏈編程風格能使程序代碼更加簡潔。
QBC檢索方式
采用HQL檢索方式時,在應用程序中需要定義基於字符串形式的HQL查詢語句。QBC API提供了檢索對象的另一種方式,它主要由Criteria接口、Criterion接口和Expression類組成,它支持在運行時動態生成查詢語句。
本地SQL檢索方式
采用HQL或QBC檢索方式時,Hibernate生成標準的SQL查詢語句,使用於所有的數據庫平臺,因此這兩種檢索方式都是跨平臺的。有的應用程序可能需要根據底層數據庫的SQL方言,來生成一些特殊的查詢語句。在這種情況下,可以利用Hibernate提供的SQL檢索方式。
抓取策略(優化)
1.檢索方式
立即檢索:立即查詢,在執行查詢語句時,立即查詢所有的數據。
延遲檢索:延遲查詢,在執行查詢語句之後,在需要時在查詢。(懶加載)
2.檢查策略
類級別檢索:當前的類的屬性獲取是否需要延遲。
關聯級別的檢索:當前類 關聯 另一個類是否需要延遲。
3.類級別檢索
get:立即檢索。get方法一執行,立即查詢所有字段的數據。
load:延遲檢索。默認情況,load方法執行後,如果只使用OID的值不進行查詢,如果要使用其他屬性值將查詢 。 Customer.hbm.xml <class lazy="true |false">
lazy默認值true,表示延遲檢索,如果設置false表示立即檢索。
1. get/load
get: 立即查詢數據庫,將數據初始化
load: hbm文件中,class元素的lazy屬性決定類級別load方法的加載策略
true:先返回一個代理對象.使用代理對象的屬性時,才去查詢數據庫.
false: 與get一致,會立即加載數據
[java] view plain copy
- @Test
- public void demo02() {
- //類級別
- Session session = factory.openSession();
- session.beginTransaction();
- //1立即
- // Customer customer = (Customer) session.get(Customer.class, 1);
- //2延遲
- Customer customer = (Customer) session.load(Customer.class, 1);
- //打印
- System.out.println(customer.getCid());
- System.out.println(customer.getCname());
- session.getTransaction().commit();
- session.close();
- }
case:
[java] view plain copy
- package com.itheima.b_lazy;
- import org.hibernate.Session;
- import org.junit.Test;
- import com.itheima.domain.Course;
- import com.itheima.domain.Customer;
- import com.itheima.domain.Student;
- import com.itheima.utils.HibernateUtils;
- public class Demo {
- @Test
- //類級別懶加載
- //load方法
- // class lazy屬性
- // 默認值: true load獲得時,會返回代理對象,不查詢數據庫.使用時才查詢
- public void fun1(){
- Session session = HibernateUtils.openSession();
- session.beginTransaction();
- //------------------------------------------------
- Customer c = (Customer) session.load(Customer.class, 1);
- System.out.println(c.getName());
- //------------------------------------------------
- session.getTransaction().commit();
- session.close(); // 遊離狀態
- }
- @Test
- //類級別懶加載
- //load方法
- // class lazy屬性
- // lazy: false load方法執行就會發送sql語句.與get方法一致.
- public void fun2(){
- Session session = HibernateUtils.openSession();
- session.beginTransaction();
- //------------------------------------------------
- Customer c = (Customer) session.load(Customer.class, 1);
- System.out.println(c.getName());
- //------------------------------------------------
- session.getTransaction().commit();
- session.close(); // 遊離狀態
- }
- }
4.關聯級別檢索
(1)一對多或多對多
介紹:l 容器<set> 提供兩個屬性:fetch、lazy
fetch:確定使用sql格式
lazy:關聯對象是否延遲。
l fetch:join、select、subselect
join:底層使用迫切左外連接
select:使用多個select語句(默認值)
subselect:使用子查詢
l lazy:false、true、extra
false:立即
true:延遲(默認值)
extra:極其懶惰
fetch="join"l fetch="join" ,lazy無效。底層使用迫切左外連接,使用一條select將所有內容全部查詢。
[java] view plain copy- @Test
- public void demo03() {
- //關聯級別:一對多,
- // * Customer.hbm.xml <set fetch="join">
- // *** select語句使用左外連接,一次性查詢所有
- Session session = factory.openSession();
- session.beginTransaction();
- //1 查詢客戶
- Customer customer = (Customer) session.get(Customer.class, 1);
- System.out.println(customer.getCname());
- //2 查詢客戶訂單數
- Set<Order> orderSet = customer.getOrderSet();
- System.out.println(orderSet.size());
- //3 查詢客戶訂單詳情
- for (Order order : orderSet) {
- System.out.println(order);
- }
- session.getTransaction().commit();
- session.close();
- }
fetch="select"
l 當前對象 和 關聯對象 使用多條select語句查詢。
l lazy="false" , 立即,先查詢客戶select,立即查詢訂單select
l lazy="true",延遲,先查詢客戶select,需要訂單時,再查詢訂單select
l lazy="extra",極其懶惰(延遲),先查詢客戶select, 如果只需要訂單數,使用聚合函數(不查詢詳情)
fetch="subselect"
l 將使用子查詢。註意:必須使用Query否則看不到效果。
l lazy= 同上
[java] view plain copy- @Test
- public void demo04() {
- //關聯級別:一對多,
- // 演示3:* Customer.hbm.xml <set fetch="subselect">
- Session session = factory.openSession();
- session.beginTransaction();
- //1 查詢客戶
- List<Customer> allCustomer = session.createQuery("from Customer").list();
- Customer customer = allCustomer.get(0);
- System.out.println(customer.getCname());
- //2 查詢客戶訂單數
- Set<Order> orderSet = customer.getOrderSet();
- System.out.println(orderSet.size());
- //3 查詢客戶訂單詳情
- for (Order order : orderSet) {
- System.out.println(order);
- }
- session.getTransaction().commit();
- session.close();
- }
關聯級別加載策略
在查詢有關聯關系的數據時,加載一方的數據是否需要將另一方立即查詢出.
默認: 與我關聯的數據,在使用時才會加載.
集合(一對多):
set
lazy: 是否對set數據使用懶加載
true:(默認值) 對集合使用才加載
false: 集合將會被立即加載
extra: 極其懶惰,如果使用集合時,之調用size方法查詢數量, Hibernate會發送count語句,只查詢數量.不加載集合內數據.
fetch : 決定加載集合使用的sql語句種類
select: (默認值) 普通select查詢
join: 表鏈接語句查詢集合數據
subselect: 使用子查詢 一次加載多個Customer的訂單數據 case: 配置: [html] view plain copy
- <?xml version="1.0" encoding="UTF-8"?>
- <!DOCTYPE hibernate-mapping PUBLIC
- "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
- "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
- <hibernate-mapping package="com.itheima.domain" >
- <class name="Customer" table="t_customer" >
- <id name="id" column="id" >
- <generator class="native"></generator>
- </id>
- <!-- 告訴Hibernate , 樂觀鎖的版本號的屬性名 -->
- <version name="version"></version>
- <property name="name" column="name" type="string" ></property>
- <!--
- lazy : 是否對set數據使用懶加載
- fetch : 決定加載集合使用的sql語句種類
- -->
- <set name="orders" batch-size="2" >
- <!--
- key 用來描述外鍵
- column : 外鍵的值
- -->
- <key column="cid" ></key>
- <!-- one-to-many 表達, Customer 與orders 的關系是一對多
- class: 表達關聯的另一方的完整類名
- -->
- <one-to-many class="Order" />
- </set>
- <!-- 局部配置 -->
- <query name="bcd"><![CDATA[from Order]]></query>
- </class>
- <!-- 全局配置 -->
- <query name="abc"><![CDATA[from Customer]]></query>
- </hibernate-mapping>
Test: [java] view plain copy
- package com.itheima.b_lazy;
- import java.util.List;
- import org.hibernate.Session;
- import org.junit.Test;
- import com.itheima.domain.Customer;
- import com.itheima.domain.Order;
- import com.itheima.utils.HibernateUtils;
- public class Demo2 {
- @Test
- //關聯級別懶加載
- //默認: 與我關聯的數據,在使用時才會加載.
- public void fun1(){
- Session session = HibernateUtils.openSession();
- session.beginTransaction();
- //------------------------------------------------
- Customer c = (Customer) session.get(Customer.class, 1);
- for(Order o : c.getOrders()){
- System.out.println(o.getName());
- }
- //------------------------------------------------
- session.getTransaction().commit();
- session.close(); // 遊離狀態
- }
- @Test
- //關聯級別懶加載
- //lazy: false
- public void fun2(){
- Session session = HibernateUtils.openSession();
- session.beginTransaction();
- //------------------------------------------------
- Customer c = (Customer) session.get(Customer.class, 1);
- for(Order o : c.getOrders()){
- System.out.println(o.getName());
- }
- //------------------------------------------------
- session.getTransaction().commit();
- session.close(); // 遊離狀態
- }
- @Test
- //關聯級別懶加載
- //lazy: false/true
- //fetch:join
- public void fun3(){
- Session session = HibernateUtils.openSession();
- session.beginTransaction();
- //------------------------------------------------
- Customer c = (Customer) session.get(Customer.class, 1);
- for(Order o : c.getOrders()){
- System.out.println(o.getName());
- }
- //------------------------------------------------
- session.getTransaction().commit();
- session.close(); // 遊離狀態
- }
- @Test
- //關聯級別懶加載
- //lazy:true
- //fetch:subselect
- public void fun4(){
- Session session = HibernateUtils.openSession();
- session.beginTransaction();
- //------------------------------------------------
- List<Customer> list = session.createQuery("from Customer").list();
- for(Customer c:list){
- System.out.println(c.getName()+"下單數量:"+c.getOrders().size());
- }
- //------------------------------------------------
- session.getTransaction().commit();
- session.close(); // 遊離狀態
- }
- @Test
- //關聯級別懶加載
- //lazy:false
- //fetch:subselect
- public void fun5(){
- Session session = HibernateUtils.openSession();
- session.beginTransaction();
- //------------------------------------------------
- List<Customer> list = session.createQuery("from Customer").list();
- for(Customer c:list){
- System.out.println(c.getName()+"下單數量:"+c.getOrders().size());
- }
- //------------------------------------------------
- session.getTransaction().commit();
- session.close(); // 遊離狀態
- }
- @Test
- //關聯級別懶加載
- //lazy:extra
- //fetch:select
- public void fun6(){
- Session session = HibernateUtils.openSession();
- session.beginTransaction();
- //------------------------------------------------
- //查詢Customer
- Customer c = (Customer) session.get(Customer.class, 1);
- //查詢Customer下訂單 數量
- System.out.println(c.getOrders().size());
- //真正使用訂單中的數據
- for(Order o : c.getOrders()){
- System.out.println(o.getName());
- }
- //------------------------------------------------
- session.getTransaction().commit();
- session.close(); // 遊離狀態
- }
- @SuppressWarnings("unchecked")
- @Test
- //關聯級別懶加載
- //lazy:extra
- //fetch:subselect
- public void fun7(){
- Session session = HibernateUtils.openSession();
- session.beginTransaction();
- //------------------------------------------------
- List<Customer> list = session.createQuery("from Customer").list();
- for(Customer c:list){
- System.out.println(c.getName()+"下單數量:"+c.getOrders().size());
- }
- for(Customer c:list){
- for(Order o : c.getOrders()){
- System.out.println(c.getName()+"下單名稱:"+o.getName());
- }
- }
- //------------------------------------------------
- session.getTransaction().commit();
- session.close(); // 遊離狀態
- }
- }
(2)多對一
介紹:l <many-to-one fetch="" lazy=""> (<one-to-one>)
l fetch取值:join、select
join:底層使用迫切左外連接
select:多條select語句
l lazy取值:false、proxy、no-proxy
false:立即
proxy:采用關聯對象 類級別檢索的策略。
訂單 關聯 客戶 (多對一)
訂單 立即獲得 客戶,需要在客戶Customer.hbm.xml <class lazy="false">
訂單 延遲獲得 客戶,需要在客戶Customer.hbm.xml <classlazy="true">
no-proxy不研究
fetch="join"
l fecth="join" select語句使用左外連接,此時lazy無效。
[java] view plain copy- @Test
- public void demo05() {
- //關聯級別:多對一,
- // 演示1:* Order.hbm.xml <set fetch="join"> lazy無效
- // * 註意:檢查Customer.hbm.xml 和 Order.hbm.xml 沒有額外的配置
- Session session = factory.openSession();
- session.beginTransaction();
- //1 查詢訂單
- Order order = (Order) session.get(Order.class, 1);
- System.out.println(order.getPrice());
- //2 查詢訂單客戶信息
- Customer customer = order.getCustomer();
- System.out.println(customer.getCname());
- session.getTransaction().commit();
- session.close();
- }
fetch="select"
l 將采用多條select語句,lazy="proxy"是否延遲,取決關聯對象 類級別檢索策略。
l lazy="false"
l lazy="proxy"
多對一:lazy
false 加載訂單時,會立即加載客戶
proxy 看客戶對象的類加載策略來決定
no-proxy : 不做研究.
fetch=
select : (默認值)使用普通select加載
join : 使用表鏈接加載數據 case: 配置: [html] view plain copy
- <?xml version="1.0" encoding="UTF-8"?>
- <!DOCTYPE hibernate-mapping PUBLIC
- "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
- "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
- <hibernate-mapping package="com.itheima.domain" >
- <class name="Order" table="t_order" >
- <id name="id" column="id" >
- <generator class="native"></generator>
- </id>
- <property name="name" column="name" type="string" ></property>
- <!--
- lazy
- false
- proxy
- no-proxy : 不做研究.
- fetch=
- select
- join
- -->
- <many-to-one name="customer" column="cid" class="Customer" ></many-to-one>
- </class>
- </hibernate-mapping>
Test: [java] view plain copy
- package com.itheima.b_lazy;
- import java.util.List;
- import org.hibernate.Session;
- import org.junit.Test;
- import com.itheima.domain.Customer;
- import com.itheima.domain.Order;
- import com.itheima.utils.HibernateUtils;
- //多對一檢索策略
- public class Demo3 {
- @Test
- //fetch: select
- //lazy: false
- public void fun1(){
- Session session = HibernateUtils.openSession();
- session.beginTransaction();
- //------------------------------------------------
- Order o = (Order) session.get(Order.class, 2);
- System.out.println(o.getCustomer().getName());
- //------------------------------------------------
- session.getTransaction().commit();
- session.close(); // 遊離狀態
- }
- @Test
- //fetch: select
- //lazy: proxy
- // Customer lazy:false
- public void fun2(){
- Session session = HibernateUtils.openSession();
- session.beginTransaction();
- //------------------------------------------------
- Order o = (Order) session.get(Order.class, 2);
- System.out.println(o.getCustomer().getName());
- //------------------------------------------------
- session.getTransaction().commit();
- session.close(); // 遊離狀態
- }
- @Test
- //fetch: select
- //lazy: proxy
- // Customer lazy:true
- public void fun3(){
- Session session = HibernateUtils.openSession();
- session.beginTransaction();
- //------------------------------------------------
- Order o = (Order) session.get(Order.class, 2);
- System.out.println(o.getCustomer().getName());
- //------------------------------------------------
- session.getTransaction().commit();
- session.close(); // 遊離狀態
- }
- @Test
- //fetch: join
- //lazy: proxy|false
- public void fun4(){
- Session session = HibernateUtils.openSession();
- session.beginTransaction();
- //------------------------------------------------
- Order o = (Order) session.get(Order.class, 2);
- System.out.println(o.getCustomer().getName());
- //------------------------------------------------
- session.getTransaction().commit();
- session.close(); // 遊離狀態
- }
- }
Hibernate檢索策略與檢索方式