2. 程式人生 > >Hibernate快速筆記2

Hibernate快速筆記2

阿新 • • 發佈：2019-01-13

上篇：Hibernate快速筆記1

1.Hibernate的查詢方式
2.Hibernate的抓取策略

Hibernate查詢方式

  1. OID檢索：根據ID查詢物件，Get/Load方法

    session.get(Customer.class，1L)
session.load(Customer.class, 2L)

  2. 物件導航檢索：根據已查詢物件，獲得其關聯物件，例如使用者和角色

    Customer cus = session.get(Customer.class，1L)
LinkMan lkm = cus.getLinkMan()

  3. HQL檢索

    ：使用HQL語句，進行查詢；Hibernate Query Language，面向物件的查詢

    • 簡單查詢

      Query query = session.createQuery("from Customer"); //查詢的是類，不是表
    List<Customer> list = query.list();             //list 鏈式顯示獲取
    for (Customer customer : list) {
        System.out.println(customer);
    }
//支援別名，不支援select *
session.
       
      createQuery("select c from Customer c")

    • 排序查詢：支援Order by 屬性名，預設升序

      List<Customer> list = session.createQuery("from Customer order by cust_id desc").list();

    • 條件查詢：1.按位置繫結； 2.按型別繫結

      //1.按位置繫結
Query query = session.createQuery("from Customer where cust_id = ? and cust_name like ?");
query.setParameter(0, 1L);
query.setParameter(1, "c%");
List<Customer> list = query.list();
//2.按名稱繫結
//冒號後必須緊跟名字，名字可以任意取定
Query query2 = session.createQuery("from Customer where cust_id = :id and cust_name like :name");
query2.setParameter("id", 2L);
query2.setParameter("name", "c%");
List<Customer> list2 = query2.list();

    • 投影查詢：查詢某些列或某些欄位的行

      //單個屬性,返回的Object
Query query = session.createQuery("select c.cust_name from Customer c");
List<Object> list = query.list();
for (Object object : list) {
    System.out.println(object);
}
//多個列，Object陣列
Query query2 = session.createQuery("select c.cust_id, c.cust_name from Customer c");
List<Object[]> list2 = query2.list();
for (Object[] objects : list2) {
    System.out.println(Arrays.toString(objects));
}
//多列，封裝成物件
Query query3 = session.createQuery("select new Customer(c.cust_id, c.cust_name) from Customer c");
List<Customer> list3 = query3.list();

    • 分頁查詢

      Query query = session.createQuery("from LinkMan");
query.setFirstResult(10);   //limit ?,?
query.setMaxResults(10);

    • 分組統計查詢

      //count,max,min,avg等
Query query = session.createQuery("select min(cust_id) from Customer");
Object result = query.uniqueResult();
System.out.println(result);   //也可以使用list,輸出第一個元素
//分組-----注意：lkm_cust_id不是LinkMan的屬性，所以選擇不了
Query query2 = session.createQuery("select customer, count(*) from LinkMan 		group by lkm_cust_id having count(*) > 1");
List<Object[]> list = query2.list();
for (Object[] objects : list) {
    System.out.println(Arrays.toString(objects));
}

  4. QBC檢索：query by criteria，適合多條件查詢

    • 簡單查詢

      //使用criteria
Criteria criteria = session.createCriteria(Customer.class);
List<Customer> list = criteria.list();
for (Customer customer : list) {
	System.out.println(customer);
}	

//使用criteria ,預設升序
Criteria criteria = session.createCriteria(Customer.class);
criteria.addOrder(Order.desc("cust_id"));  //Order為Hibernate物件
List<Customer> list = criteria.list();

    • 條件查詢：add，新增普通條件；addOrder，新增順序；setProjection，新增聚合函式等

      //條件查詢
    Session session = HibernateUtils.getCurrentSession();
    Transaction transaction = session.beginTransaction();
    //條件預設是與，可以改成or
    Criteria criteria = session.createCriteria(Customer.class);
    // eq = ; lt <; gt >; like,and,or,in,between
//		criteria.add(Restrictions.eq("cust_name", "cus3"));		
//		criteria.add(Restrictions.le("cust_id", 2L));

    //or,兩個條件
    //criteria.add(Restrictions.or(Restrictions.eq("cust_name", "cus3"), Restrictions.le("cust_id", 2L)));
    //or多個條件----可以使用between或者in
    Disjunction disjunction = Restrictions.disjunction();
    disjunction.add(Restrictions.eq("cust_name", "cus3"));
    disjunction.add(Restrictions.eq("cust_name", "cus1"));
    disjunction.add(Restrictions.eq("cust_name", "cus1"));
    criteria.add(disjunction);		

    List<Customer> list = criteria.list();

    • 分頁查詢

          Criteria criteria = session.createCriteria(Customer.class);
    criteria.setFirstResult(1);
    criteria.setMaxResults(1);

    List<Customer> list = criteria.list();

    • 分組統計查詢

      Criteria criteria = session.createCriteria(Customer.class);
criteria.setProjection(Projections.rowCount());
//Projections.max,min,avg等，還有having,group by等
Long num = (Long) criteria.uniqueResult();	
System.out.println(num);

  5. QBC離線檢索： 適用於多表、多條件和分頁的查詢情況，一般在SSH模型中使用的到

    離線：DetachedCriteria，脫離session使用；方便在條件查詢時，減輕了JDBC中的引數查詢語句的匹配重複性問題。可以用來在Web層直接操作，不需要在DAO中判斷

    //Web層的操作
    DetachedCriteria dc = DetachedCriteria.forClass(Customer.class);
    dc.add(Restrictions.like("cust_name", "cus%"));

    //到Service繫結session
    Session session = HibernateUtils.getCurrentSession();
    Transaction transaction = session.beginTransaction();
    //執行
    Criteria criteria = dc.getExecutableCriteria(session);
    List<Customer> list = criteria.list();
    for (Customer customer : list) {
        System.out.println(customer);
    }

  6. HQL的多表查詢：QBC也可以，支援功能一般

    a) SQL的多表查詢方式：連線查詢和子查詢

    • 連線查詢：

      • 交叉查詢——不常用，笛卡爾積

      • 內連線；查詢的結果是兩個表的交集，inner可以省略

        select * from A,B where A.id = B.id 隱式

        select * from A inner join B on A.id = B.id 顯式

      • 外連結：查詢結果是某個表與兩個表的交集的並集

        • 左外連線：左表的全部和兩個表的交集，許多右邊欄位為空的結果
        • 右外連線：右表的全部和兩個表的交集，許多左邊欄位為空的結果

    • 子查詢：多表巢狀查詢，相關子查詢，非相關子查詢

    b) HQL的多表查詢：

    • 連線查詢

      • 交叉連線
      • 內連線：顯式、隱式、迫切
      • 外連結：左外、右外、迫切左外

    • 普通內連線和迫切內連線只有一個關鍵字fetch不同，其傳送的SQL語句和查詢的結果集都是一樣的，fetch是Hibernate的內容，主要用來將返回結果自動封裝成物件；在普通內連線中，會將連線查詢的每一條結果分成兩個物件來封裝（下面示例程式碼中，能看見普通的內連線會查詢兩個表），而迫切內連線會將相同的封裝到一個物件中。

      普通查詢：
Transaction transaction = session.beginTransaction();
//SQL的內連線：SELECT * from cst_customer inner join cst_linkman on cst_customer.cust_id = cst_linkman.lkm_cust_id;
//HQL只需關聯類中對於外來鍵的集合即可
//查詢結果會匹配到對應的集合中，若去重加上distinct即可
Query query = session.createQuery("from Customer c inner join c.linkMans");
List<Object[]> list = query.list();
for (Object[] objects : list) {
    System.out.println(Arrays.toString(objects));
}

      在console中能看見：

      Hibernate: 
    select
        customer0_.cust_id as cust_id1_0_0_,
        linkmans1_.lkm_id as lkm_id1_1_1_,
        customer0_.cust_name as cust_nam2_0_0_,
        customer0_.cust_source as cust_sou3_0_0_,
        customer0_.cust_industry as cust_ind4_0_0_,
        customer0_.cust_level as cust_lev5_0_0_,
        customer0_.cust_phone as cust_pho6_0_0_,
        customer0_.cust_mobile as cust_mob7_0_0_,
        linkmans1_.lkm_name as lkm_name2_1_1_,
        linkmans1_.lkm_gender as lkm_gend3_1_1_,
        linkmans1_.lkm_phone as lkm_phon4_1_1_,
        linkmans1_.lkm_mobile as lkm_mobi5_1_1_,
        linkmans1_.lkm_email as lkm_emai6_1_1_,
        linkmans1_.lkm_qq as lkm_qq7_1_1_,
        linkmans1_.lkm_position as lkm_posi8_1_1_,
        linkmans1_.lkm_memo as lkm_memo9_1_1_,
        linkmans1_.lkm_cust_id as lkm_cus10_1_1_ 
    from
        cst_customer customer0_ 
    inner join
        cst_linkman linkmans1_ 
            on customer0_.cust_id=linkmans1_.lkm_cust_id

[Customer [cust_id=1, ...]
[Customer [cust_id=1, ..., linkMans=[LinkMan [...l]
...  //30 行

    • 若使用迫切的內連線查詢，則會返回直接封裝好的結果

      //迫切內連線
Query query = session.createQuery("from Customer c inner join fetch c.linkMans");
List<Customer> list = query.list();  //能直接獲取到Customer的物件
for (Customer customer : list) {
    System.out.println(customer);
}

      我們在console能看到的資訊（若想要看到屬性集合，在tostring函式中新增，否則不會出現linkman）

      Hibernate: 
    select
        customer0_.cust_id as cust_id1_0_0_,
        linkmans1_.lkm_id as lkm_id1_1_1_,
        customer0_.cust_name as cust_nam2_0_0_,
        customer0_.cust_source as cust_sou3_0_0_,
        customer0_.cust_industry as cust_ind4_0_0_,
        customer0_.cust_level as cust_lev5_0_0_,
        customer0_.cust_phone as cust_pho6_0_0_,
        customer0_.cust_mobile as cust_mob7_0_0_,
        linkmans1_.lkm_name as lkm_name2_1_1_,
        linkmans1_.lkm_gender as lkm_gend3_1_1_,
        linkmans1_.lkm_phone as lkm_phon4_1_1_,
        linkmans1_.lkm_mobile as lkm_mobi5_1_1_,
        linkmans1_.lkm_email as lkm_emai6_1_1_,
        linkmans1_.lkm_qq as lkm_qq7_1_1_,
        linkmans1_.lkm_position as lkm_posi8_1_1_,
        linkmans1_.lkm_memo as lkm_memo9_1_1_,
        linkmans1_.lkm_cust_id as lkm_cus10_1_1_,
        linkmans1_.lkm_cust_id as lkm_cus10_1_0__,
        linkmans1_.lkm_id as lkm_id1_1_0__ 
    from
        cst_customer customer0_ 
    inner join
        cst_linkman linkmans1_ 
            on customer0_.cust_id=linkmans1_.lkm_cust_id
Customer [cust_id=1, ..., linkMans=[LinkMan [...]]
Customer [cust_id=1, ..., linkMans=[LinkMan [...]]
...
//30行全部的查詢結果
          
//使用distinct的結果，只有三行

  7. SQL查詢

    //SQL查詢
    SQLQuery sqlQuery = session.createSQLQuery("select * from cst_customer");
    List<Object[]> list = sqlQuery.list();

//		for (Object[] objects : list) {
//			System.out.println(Arrays.toString(objects));
//		}
    //繫結到類---封裝
    sqlQuery.addEntity(Customer.class);
    List<Customer> list2 = sqlQuery.list();
    for (Customer customer : list2) {
        System.out.println(customer);
    }

 

 

Hibernate抓取策略

Hibernate提供了一系列的優化方式，來提高封裝性帶來的效能問題，尤其在獲取關聯物件的時候。例如一級二級快取（二級一般被Redis替代）機制、和抓取策略等，都是一些用來優化的手段。抓取策略主要是對查詢時的語句等做的優化處理。

優化的方式：1）快取怎麼處理；2）查詢的優化（抓取）

  1. 延遲載入：懶載入，執行語句的時候，不直接查詢；當使用到關聯的物件才傳送查詢語句。

    • 類級別的延遲載入：如load方法，可以在xml的class配置檔案中的lazy = ‘true’（預設），若配置為false則load方法也是直接載入，不使用延遲載入。

      <class name="com.leehao.hibernateLearning2.domain.Customer" table="cst_customer" lazy="true">

      • 類級別延遲載入通過<class>上的lazy進行配置，如果讓lazy失效

        • 將lazy設定為false

        • 將持久化類使用final修飾

        • Hibernate. Initialize()

    • 關聯級別的延遲載入：查詢某個物件，獲取物件的關聯物件時。抓取策略往往會和關聯級別的延遲載入一起使用，優化語句。

  2. 抓取策略：通過類載入其關聯物件時，需要傳送SQL語句，如何傳送、什麼時候傳送，與設定的抓取策略有關。可以通過在<set>和<many-to-one>標籤上的fetch屬性來設定。fetch 屬性和lazy屬性一起使用。

<Set>上的fetch和lazy抓取

  1. Fetch控制抓取策略，控制的是傳送的SQL語句的格式

    • select：預設，傳送普通的select語句，來查詢關聯物件；如根據Customer來查詢聯絡人，會發送多次SQL，每一個物件會查一次————可以使用批量查詢的設定解決
    • join：傳送一條迫切的左外連線查詢關聯的物件，只發送一次查詢SQL，這時lazy的控制沒有作用
    • subselect：傳送一條子查詢來查詢關聯的物件，和select唯一的不同就是使用子查詢；也是兩次SQL，第二次將所有關聯的東西放入一個表。“相當於”使用了一次select和一次join。

  2. lazy：延遲載入，控制查詢關聯物件的時候是否使用延遲

    • true：預設，使用延遲載入查詢關聯物件
    • false：不使用延遲載入
    • extra：“極其懶惰？”

  3. 在實際開發中，一般都採用預設值。如果有特殊的需求，可能需要配置join

    //關聯物件的抓取策略----set中，也就是1的一方，如何查詢它關聯的多的一方的集合
//預設set中，<set name="linkMans" fetch="select" lazy="true">
Customer customer = session.get(Customer.class, 1L);
//獲取的時候才會傳送SQL
for (LinkMan linkMan : customer.getLinkMans()) {
    System.err.println(linkMan.getLkm_name());
}

-------------------------------------------------------------
//lazy的false或者extra
//<set name="linkMans" fetch="select" lazy="extra">
Customer customer = session.get(Customer.class, 1L);
//獲取的時候才會傳送SQL
System.out.println(customer.getLinkMans().size());
-------------------------------------------------------------
/**注：使用extra時，傳送的SQL語句如下
Hibernate: 
    select
        count(lkm_id) 
    from
        cst_linkman 
    where
        lkm_cust_id =?*/
<many-to-one>上的fetch和lazy抓取

  1. fetch

    • select：預設
    • join：迫切的左外連線，此時lazy失效

  2. lazy

    • proxy：預設，proxy具體的取值，取決於另一端的<class>上的lazy的值
    • false
    • no-proxy：不使用

  3. 在實際開發中，一般都採用預設值。如果有特殊的需求，可能需要配置join

    //<many-to-one name="customer" fetch="select" lazy="proxy"  class=...
    Session session = HibernateUtils.getCurrentSession();
    Transaction transaction = session.beginTransaction();

    LinkMan linkMan = session.get(LinkMan.class, 1L);
    System.out.println(linkMan.getLkm_name());

    System.out.println(linkMan.getCustomer().getCust_name());
批量抓取

獲取多個使用者的多個聯絡人的資訊，可以想象成抓取兩個表的內連線的結果。

1的一方中，在Set中配置batch-size=“n”即可，表示每次抓取n個，預設是1；反之，如果使用如LinkMan批量查詢Customer，則需要在Customer中的class配置。

//<set name="linkMans" batch-size="3">
		Session session = HibernateUtils.getCurrentSession();
		Transaction transaction = session.beginTransaction();
		
		List<Customer> list = session.createQuery("from Customer").list();
		for (Customer customer : list) {
			System.out.println(customer.getCust_name());
			for (LinkMan linkMan: customer.getLinkMans()) {
				System.out.println(linkMan.getLkm_name());
			}
		}
---------------------------------------------------------
Hibernate: 
    select
        customer0_.cust_id as cust_id1_0_,
        customer0_.cust_name as cust_nam2_0_,
        customer0_.cust_source as cust_sou3_0_,
        customer0_.cust_industry as cust_ind4_0_,
        customer0_.cust_level as cust_lev5_0_,
        customer0_.cust_phone as cust_pho6_0_,
        customer0_.cust_mobile as cust_mob7_0_ 
    from
        cst_customer customer0_
cus1
Hibernate: 
    select
        linkmans0_.lkm_cust_id as lkm_cus10_1_1_,
        linkmans0_.lkm_id as lkm_id1_1_1_,
        linkmans0_.lkm_id as lkm_id1_1_0_,
        linkmans0_.lkm_name as lkm_name2_1_0_,
        linkmans0_.lkm_gender as lkm_gend3_1_0_,
        linkmans0_.lkm_phone as lkm_phon4_1_0_,
        linkmans0_.lkm_mobile as lkm_mobi5_1_0_,
        linkmans0_.lkm_email as lkm_emai6_1_0_,
        linkmans0_.lkm_qq as lkm_qq7_1_0_,
        linkmans0_.lkm_position as lkm_posi8_1_0_,
        linkmans0_.lkm_memo as lkm_memo9_1_0_,
        linkmans0_.lkm_cust_id as lkm_cus10_1_0_ 
    from
        cst_linkman linkmans0_ 
    where
        linkmans0_.lkm_cust_id in (
            ?, ?, ?
        )

相關推薦

Hibernate快速筆記2

上篇：Hibernate快速筆記1 1.Hibernate的查詢方式 2.Hibernate的抓取策略 Hibernate查詢方式 OID檢索：根據ID查詢物件，Get/Load方法 session.get(Customer.class，1L) ses

Hibernate學習筆記2.4（Hibernate核心開發接口和三種狀態）

thread rsa 分享 action let 能力 ima 方法 如果 1.configuration（配置信息管理，產生sessionfactory） sessionfactory管理一系列的連接池 opensession 永遠打開新的，需要手動close get

hibernate 學習筆記2

1.Criteria查詢介面適用於組合多個限制條件來搜尋一個查詢集。 要使用Criteria，需要遵循以下步驟：   *建立查詢介面： Criteria criteria=session.createCriteria(User.class);   *設定查詢條件： criteria.

Hibernate快速筆記1

視訊：Hibernate 資料與文件：領取 提取碼：p3es 路線： Hibernate的概述，原理，簡單的API使用 一級快取和其他API 1vN和NvN的配置 Hibernate的查詢方式和抓取策略 CRM案例

Spring快速筆記2

概述： Spring的概述、SpringIOC入門（XML）、Spring的Bean管理、Spring屬性注入 Spring的IOC的註解方式、Spring的AOP開發（XML） Spring的AOP的註解開發、Spring的宣告式事務、JdbcT

Struts2 快速筆記2

路線： Struts2的概述、Struts2的入門、Struts2常見的配置、Struts2的Action的編寫 Struts2的資料的封裝、結果頁面配置 Struts2的值棧和OGNL表示式 Struts2的標籤庫 上一

hibernate學習筆記(2)------------使用criteria進行查詢

1、讀取配置檔案獲得連線   讀取hibernate.cfg.xml配置檔案，hibernate.cfg.xml檔案放在Classpath下，使用下面的方式讀入該檔案      //Configuration 負責管理hibernate配置資訊      Configurat

Hibernate學習筆記（1）---hibernate快速上手與準備工作

成了 -- 開源 工作 快速 tar ref orm 磁盤 持久層介紹 持久化：將內存中的數據保存在磁盤等存儲設備中。 持久化對象：指已經存儲在數據庫護著磁盤的業務對象 經典的軟件應用體系結構（三層結構） 在三層結構中，由於業務邏輯除了負責業務邏輯以外，還要負責相關的數據

hibernate框架學習筆記2：配置文件詳解

格式化 version validate ret root 主鍵生成策略 -m color 格式 實體類： package domain; public class Customer { private Long cust_id; priva

筆記45 Hibernate快速入門（二）

pre 快速入門 -- ret hbm spa -m int property Hibernate O/R 映射 一、多對一 　　一個Product對應一個Category，一個Category對應多個Product，所以Product和Category是多對一的關系。使用

node.js學習筆記(2)--使用Express快速建立應用

1.安裝express應用生成器 開啟cmd 鍵入如下程式碼 $npm install express-generator -g #全域性安裝安裝成功如下----- 2.express命令 開

Pybrain學習筆記-2 pybrain快速入門

Pybrain學習筆記-2 Pybrain快速入門 注：原創博文，轉載請註明出處：http://blog.csdn.net/m0_37887016 一、安裝pybrain模組 1.安裝numpy 2.安裝scipy 3.安裝pybrain       Py

YII框架分析筆記2：組件和事件行為管理

reac 設置 有變 相關 article class ces col cal Yii是一個基於組件、用於開發大型 Web 應用的高性能 PHP 框架。CComponent幾乎是所有類的基類，它控制著組件與事件的管理，其方法與屬性如下，私有變量$_e數據存放事件(evnet

[.NET] 《Effective C#》快速筆記 - C# 高效編程要點補充

擔心 cti 四十六 catch con 影響 ted 註冊 ref 《Effective C#》快速筆記 - C# 高效編程要點補充 目錄 四十五、盡量減少裝箱拆箱 四十六、為應用程序創建專門的異常類 四十七、使用強異常安全保證 四十八、盡量使用安全的

學習筆記2

建議 coo line 長度 cape 發展 div+css 加載 不兼容 雙標簽： <html><head><title><body><table><tr><td><span>

【css筆記(2)】如何給元素應用規則?

mpi phy yellow ini log min lib second from css選擇器 在介紹之前我麽你先來看看css大致分為幾種選擇器: 1.類型選擇器(元素選擇器) 2.後代選擇器(元素的所有後代) 3.偽類(:active, :hover, :fo

python筆記2-變量

sse imp lob lam cell hat bsp adding 第一個字符 變量 存東西所用 #定義變量 name=‘feifei‘#定義變量，字符串 age=18.9#整型或者小數定義變量不需要加引號 print(name) print(age) name2="w

Jmeter學習筆記2-原件作用域與執行順序

校驗 height sse proc tro 有效 收集 技術分享 控制 1.元件的作用域 （1）配置元件（config elements）:會影響其作用範圍內的所有元件。 （2）前置處理程序（per-processors）：在其作用範圍內的每一個sampler元件之

python學習筆記2：字符串

nbsp 大小 alpha .com format 大小寫 fin 判斷大小 key python學習筆記2：字符串 總結：字符串是不可變變量，不能通過下標修改其值 　　　字符串的方法都不會改變字符串原來的值，而是新生成一個字符串 一、3種寫法——單引號，雙引號，三引號 　

java 學習筆記2 面向對象（上）

awr ges abs nal mage 有效 面向對象 ima col 類和對象 類是某一批對象的抽象，可以把類理解成某種概念。對象是一個具體存在的實體。類和對象是面向對象的核心。 類定義的是多個實例的特征，類不是具體存在，實例才是具體存在。 定義類(class)的語法：