四、Hibernate的查詢方式

時間 2019-11-10

原文原文鏈接

1、Hibernate的查詢方式：OID查詢

一、OID檢索：Hibernate根據對象的OID（主鍵）進行檢索

1-一、使用get方法java

Customer customer = session.get(Customer.class,1L);

1-二、使用load方法sql

Customer customer = session.load(Customer.class,1L);

三、對象導航檢索：Hibernate根據一個已經查詢到的對象，得到其關聯的對象的一種查詢方式。

Customer customer = session.get(Customer.class,1L); Set<LinkMan> linkManSet = customer.getLinkMans();

4-一、HQL查詢

Hibernate Query Language，Hibernate的查詢語言，是一種面向對象的方式的查詢語言，語法相似SQL。經過session.createQuery()，用於接收一個HQL進行查詢方式。session

package com.turtle.test; import java.util.Arrays; import java.util.List; import com.turtle.dao.Customer; import com.turtle.dao.LinkMan; import com.turtle.utils.HibernateUtils; import org.hibernate.Query; import org.hibernate.Session; import org.hibernate.Transaction; import org.junit.Test; /** * HQL的查詢方式的測試類 * * @author jt * */
public class Hibernater_01 { @Test /** * 初始化數據 */
    public void demo1() { Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); // 建立一個客戶
        Customer customer = new Customer(); customer.setCust_name("李向文"); for (int i = 1; i <= 10; i++) { LinkMan linkMan = new LinkMan(); linkMan.setLkm_name("王東" + i); linkMan.setCustomer(customer); customer.getLinkMans().add(linkMan); session.save(linkMan); } session.save(customer); tx.commit(); } @Test /** * HQL的簡單查詢 */
    public void demo2() { Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); // 簡單的查詢
        Query query = session.createQuery("from Customer"); List<Customer> list = query.list(); // sql中支持*號的寫法：select * from cst_customer; 可是在HQL中不支持*號的寫法。
        /* * Query query = session.createQuery("select * from Customer");// 報錯 * List<Customer> list = query.list(); */

        for (Customer customer : list) { System.out.println(customer); } tx.commit(); } @Test /** * 別名查詢 */
    public void demo3() { Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); // 別名的查詢
        /* * Query query = session.createQuery("from Customer c"); List<Customer> * list = query.list(); */ Query query = session.createQuery("select c from Customer c"); List<Customer> list = query.list(); for (Customer customer : list) { System.out.println(customer); } tx.commit(); } @Test /** * 排序查詢 */
    public void demo4() { Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); // 排序的查詢 // 默認狀況 // List<Customer> list = session.createQuery("from Customer order by // cust_id").list(); // 設置降序排序 升序使用asc 降序使用desc
        List<Customer> list = session.createQuery("from Customer order by cust_id desc").list(); for (Customer customer : list) { System.out.println(customer); } tx.commit(); } @Test /** * 條件查詢 */
    public void demo5() { Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); // 條件的查詢 // 1、按位置綁定：根據參數的位置進行綁定。 // 一個條件
        /* * Query query = session.createQuery("from Customer where cust_name = ?"); * query.setParameter(0, "李兵"); * List<Customer> list = query.list(); */

        // 多個條件
        /* * Query query = session.createQuery( * "from Customer where cust_source = ? and cust_name like ?"); * query.setParameter(0, "小廣告"); * query.setParameter(1, "李%"); * List<Customer> list = query.list(); */

        // 2、按名稱綁定
        Query query = session.createQuery("from Customer where cust_source = :aaa and cust_name like :bbb"); // 設置參數:
        query.setParameter("aaa", "朋友推薦"); query.setParameter("bbb", "李%"); List<Customer> list = query.list(); for (Customer customer : list) { System.out.println(customer); } tx.commit(); } @Test /** * 投影查詢 */
    public void demo6() { Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); // 投影查詢 // 單個屬性
        /* * List<Object> list = session.createQuery("select c.cust_name from Customer c").list(); * for (Object object :list) { * System.out.println(object); * } */

        // 多個屬性:
        /* * List<Object[]> list = session.createQuery( * "select c.cust_name,c.cust_source from Customer c").list(); for * (Object[] objects : list) { * System.out.println(Arrays.toString(objects)); } */

        // 查詢多個屬性，可是我想封裝到對象中。
        List<Customer> list = session.createQuery("select new Customer(cust_name,cust_source) from Customer").list(); for (Customer customer : list) { System.out.println(customer); } tx.commit(); } @Test /** * 分頁查詢 */
    public void demo7() { Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); // 分頁查詢
        Query query = session.createQuery("from LinkMan"); query.setFirstResult(20); query.setMaxResults(10); List<LinkMan> list = query.list(); for (LinkMan linkMan : list) { System.out.println(linkMan); } tx.commit(); } @Test /** * 分組統計查詢 */
    public void demo8() { Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); // 聚合函數的使用：count(),max(),min(),avg(),sum()
        Object object = session.createQuery("select count(*) from Customer").uniqueResult(); System.out.println(object); // 分組統計：
        List<Object[]> list = session.createQuery("select cust_source,count(*) from Customer group by cust_source") .list(); for (Object[] objects : list) { System.out.println(Arrays.toString(objects)); } tx.commit(); } @Test /** * HQL的多表查詢 */
    public void demo9() { Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); // SQL:SELECT * FROM cst_customer c INNER JOIN cst_linkman l ON // c.cust_id = l.lkm_cust_id; // HQL:內鏈接 from Customer c inner join c.linkMans
        /* * List<Object[]> list = session.createQuery("from Customer c inner join c.linkMans").list(); * for (Object[] objects : list) { * System.out.println(Arrays.toString(objects)); * } */

        // HQL:迫切內鏈接 其實就在普通的內鏈接inner join後添加一個關鍵字fetch. from Customer c inner // join fetch c.linkMans
        List<Customer> list = session.createQuery("select distinct c from Customer c inner join fetch c.linkMans") .list();// 通知hibernate，將另外一個對象的數據封裝到該對象中

        for (Customer customer : list) { System.out.println(customer); } tx.commit(); } }

4-二、 HQL的多表查詢

SQL的多表查詢函數

鏈接查詢測試

交叉鏈接：笛卡爾積fetch

select * from A,B;優化

內鏈接 :inner join (inner 能夠省略)spa

隱式內鏈接：hibernate

select * from A,B where A.id = B.aid;code

顯示內鏈接：

select * from A inner join B on A.id = B.aid;

外鏈接 :

左外鏈接:left outer join(outer 能夠省略)

select * from A left outer join B on A.id= B.aid;

右外鏈接:right outer join(outer 能夠省略)

select * from A right outer join B on A.id = B.aid;

子查詢

HQL的多表查詢

鏈接查詢

交叉鏈接

內鏈接

顯示內鏈接

隱式內鏈接

迫切內鏈接

外鏈接

左外鏈接

右外鏈接

迫切左外鏈接

五、QBC查詢：Query By Criteria，條件查詢。是一種更加面向對象化的查詢的方式。

package com.turtle.test; import java.util.List; import com.turtle.dao.Customer; import com.turtle.dao.LinkMan; import com.turtle.utils.HibernateUtils; import org.hibernate.Criteria; import org.hibernate.Session; import org.hibernate.Transaction; import org.hibernate.criterion.DetachedCriteria; import org.hibernate.criterion.Order; import org.hibernate.criterion.Projections; import org.hibernate.criterion.Restrictions; import org.junit.Test; /** * QBC的查詢 * @author jt * */
public class Hibernater_02 { @Test /** * 簡單的查詢 */
    public void demo1(){ Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); // 得到Criteria的對象
        Criteria criteria = session.createCriteria(Customer.class); List<Customer> list = criteria.list(); for (Customer customer : list) { System.out.println(customer); } tx.commit(); } @Test /** * 排序查詢 */
    public void demo2(){ Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); // 排序查詢
        Criteria criteria = session.createCriteria(Customer.class); // criteria.addOrder(Order.asc("cust_id")); // 升序
        criteria.addOrder(Order.desc("cust_id")); // 降序
        List<Customer> list = criteria.list(); for (Customer customer : list) { System.out.println(customer); } tx.commit(); } @Test /** * 分頁查詢 */
    public void demo3(){ Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); // 分頁查詢
        Criteria criteria = session.createCriteria(LinkMan.class); criteria.setFirstResult(10); criteria.setMaxResults(10); List<LinkMan> list = criteria.list(); for (LinkMan linkMan : list) { System.out.println(linkMan); } tx.commit(); } @Test /** * 條件查詢 */
    public void demo4(){ Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); // 條件查詢
        Criteria criteria = session.createCriteria(Customer.class); // 設置條件:
        /** * = eq * > gt * >= ge * < lt * <= le * <> ne * like * in * and * or */ criteria.add(Restrictions.eq("cust_source", "小廣告")); // criteria.add(Restrictions.or(Restrictions.like("cust_name", "李%")));
        criteria.add(Restrictions.like("cust_name", "李%")); List<Customer> list = criteria.list(); for (Customer customer : list) { System.out.println(customer); } tx.commit(); } @Test /** * 統計查詢 */
    public void demo5(){ Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); Criteria criteria = session.createCriteria(Customer.class); /** * add :普通的條件。where後面條件 * addOrder :排序 * setProjection :聚合函數 和 group by having */ criteria.setProjection(Projections.rowCount()); Long num = (Long) criteria.uniqueResult(); System.out.println(num); tx.commit(); } @Test /** * 離線條件查詢 */
    public void demo6(){ DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class); detachedCriteria.add(Restrictions.like("cust_name", "李%")); Session session = HibernateUtils.getCurrentSession(); Transaction transaction = session.beginTransaction(); Criteria criteria = detachedCriteria.getExecutableCriteria(session); List<Customer> list = criteria.list(); for (Customer customer : list) { System.out.println(customer); } transaction.commit(); } }

六、SQL查詢：經過使用sql語句進行查詢

package com.turtle.test; import java.util.Arrays; import java.util.List; import com.turtle.dao.Customer; import com.turtle.utils.HibernateUtils; import org.hibernate.SQLQuery; import org.hibernate.Session; import org.hibernate.Transaction; import org.junit.Test; /** * SQL查詢 * @author jt * */
public class Hibernate_03 { @Test public void demo1(){ Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); /*SQLQuery sqlQuery = session.createSQLQuery("select * from cst_customer"); List<Object[]> list = sqlQuery.list(); for (Object[] objects : list) { System.out.println(Arrays.toString(objects)); }*/ SQLQuery sqlQuery = session.createSQLQuery("select * from cst_customer"); // 這樣就能夠操做對應的對象了
        sqlQuery.addEntity(Customer.class); List<Customer> list = sqlQuery.list(); for (Customer customer : list) { System.out.println(customer); } tx.commit(); } }

2、 Hibernate的抓取策略（優化）

一、延遲加載

什麼是延遲加載

延遲加載：lazy（懶加載）。執行到該行代碼的時候，不會發送語句去進行查詢，在真正使用這個對象的屬性的時候纔會發送SQL語句進行查詢。

延遲加載的分類

類級別的延遲加載

指的是經過load方法查詢某個對象的時候，是否採用延遲。session.load(Customer.class,1l);

類級別延遲加載經過<class>上的lazy進行配置，若是讓lazy失效

將lazy設置爲false

將持久化類使用final修飾

Hibernate. Initialize()

關聯級別的延遲加載

指的是在查詢到某個對象的時候，查詢其關聯的對象的時候，是否採用延遲加載。

Customer customer = session.get(Customer.class,1l);

customer.getLinkMans();----經過客戶得到聯繫人的時候，聯繫人對象是否採用了延遲加載，稱爲是關聯級別的延遲。

抓取策略每每會和關聯級別的延遲加載一塊兒使用，優化語句。

package com.turtle.test2; import com.turtle.dao.Customer; import com.turtle.utils.HibernateUtils; import org.hibernate.Hibernate; import org.hibernate.Session; import org.hibernate.Transaction; import org.junit.Test; /** * Hibernate的延遲加載 * @author jt * */
public class Hibernate_01 { @Test /** * 類級別的延遲加載 * * 在<class>的標籤上配置的lazy */
    public void demo1(){ Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); Customer customer = session.load(Customer.class, 1L); Hibernate.initialize(customer); System.out.println(customer); tx.commit(); } }

二、抓取策略

抓取策略的概述

經過一個對象抓取到關聯對象須要發送SQL語句，SQL語句如何發送，發送成什麼樣格式經過策略進行配置。

經過<set>或者<many-to-one>上經過fetch屬性進行設置

fetch和這些標籤上的lazy如何設置優化發送的SQL語句

2-1 <set>上的fetch和lazy

fetch：抓取策略，控制SQL語句格式

select ：默認值，發送普通的select語句，查詢關聯對象

join ：發送一條迫切左外鏈接查詢關聯對象

subselect ：發送一條子查詢查詢其關聯對象

lazy ：延遲加載，控制查詢關聯對象的時候是否採用延遲

true ：默認值，查詢關聯對象的時候，採用延遲加載

false ：查詢關聯對象的時候，不採用延遲加載

extra ：及其懶惰。

在實際開發中，通常都採用默認值。若是有特殊的需求，可能須要配置join。

package com.turtle.test2; import java.util.List; import com.turtle.dao.Customer; import com.turtle.dao.LinkMan; import com.turtle.utils.HibernateUtils; import org.hibernate.Session; import org.hibernate.Transaction; import org.junit.Test; /** * 在<set>上的fetch和lazy * @author jt * */
public class Hibernate_02 { @Test /** * 默認狀況： */
    public void demo1(){ Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); // 查詢1號客戶
        Customer customer = session.get(Customer.class, 1L);// 發送一條查詢客戶的SQL
 System.out.println(customer.getCust_name()); // 查看1號客戶的每一個聯繫人的信息
        for (LinkMan linkMan : customer.getLinkMans()) {// 發送一條根據客戶ID查詢聯繫人的SQL
 System.out.println(linkMan.getLkm_name()); } tx.commit(); } @Test /** * 設置fetch="select" lazy="true" */
    public void demo2(){ Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); // 查詢1號客戶
        Customer customer = session.get(Customer.class, 1l);// 發送一條查詢客戶的SQL
 System.out.println(customer.getCust_name()); // 查看1號客戶的每一個聯繫人的信息
        for (LinkMan linkMan : customer.getLinkMans()) {// 發送一條根據客戶ID查詢聯繫人的SQL
 System.out.println(linkMan.getLkm_name()); } tx.commit(); } @Test /** * 設置 fetch="select" lazy="false" */
    public void demo3(){ Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); // 查詢1號客戶
        Customer customer = session.get(Customer.class, 1l);// 發送兩條SQL語句：查詢客戶的名稱，查詢客戶關聯聯繫人
 System.out.println(customer.getCust_name()); /*// 查看1號客戶的每一個聯繫人的信息 for (LinkMan linkMan : customer.getLinkMans()) {// System.out.println(linkMan.getLkm_name()); }*/ System.out.println(customer.getLinkMans().size()); tx.commit(); } @Test /** * 設置fetch="select" lazy="extra" */
    public void demo4(){ Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); // 查詢1號客戶
        Customer customer = session.get(Customer.class, 1l);// 發送一條查詢1號客戶的SQL語句
 System.out.println(customer.getCust_name()); System.out.println(customer.getLinkMans().size());// 發送一條select count() from ...;
 tx.commit(); } @Test /** * 設置fetch="join" lazy=失效 */
    public void demo5(){ Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); // 查詢1號客戶
        Customer customer = session.get(Customer.class, 1l);// 發送一條迫切左外鏈接查詢記錄
 System.out.println(customer.getCust_name()); System.out.println(customer.getLinkMans().size());// 不發送
 tx.commit(); } @SuppressWarnings("unchecked") @Test /** * 設置fetch="subselect" lazy="true" */
    public void demo6(){ Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); List<Customer> list = session.createQuery("from Customer").list();// 發送查詢全部客戶的SQL
        for (Customer customer : list) { System.out.println(customer.getCust_name()); System.out.println(customer.getLinkMans().size());// 發送一條子查詢
 } tx.commit(); } @SuppressWarnings("unchecked") @Test /** * 設置fetch="subselect" lazy="false" */
    public void demo7(){ Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); List<Customer> list = session.createQuery("from Customer").list();// 發送查詢全部客戶的SQL，發送一條子查詢
        for (Customer customer : list) { System.out.println(customer.getCust_name()); System.out.println(customer.getLinkMans().size());//  } tx.commit(); } }

2-1<many-to-one>上的fetch和lazy

fetch ：抓取策略，控制SQL語句格式。

　　 select ：默認值，發送普通的select語句，查詢關聯對象。

　　 join ：發送一條迫切左外鏈接。

lazy ：延遲加載，控制查詢關聯對象的時候是否採用延遲。

　　 proxy ：默認值，proxy具體的取值，取決於另外一端的<class>上的lazy的值。

　　false ：查詢關聯對象，不採用延遲。

　　no-proxy ：（不會使用）

在實際開發中，通常都採用默認值。若是有特殊的需求，可能須要配置join。

package com.turtle.test2; import com.turtle.dao.LinkMan; import com.turtle.utils.HibernateUtils; import org.hibernate.Session; import org.hibernate.Transaction; import org.junit.Test; /** * many-to-one上的fetch和lazy測試 * @author jt * */
public class Hibernate_03 { @Test /** * 默認值 */
    public void demo1(){ Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); LinkMan linkMan = session.get(LinkMan.class, 1l);// 發送一條查詢聯繫人語句
 System.out.println(linkMan.getLkm_name()); System.out.println(linkMan.getCustomer().getCust_name());// 發送一條select語句查詢聯繫人所關聯的客戶
 tx.commit(); } @Test /** * fetch="select" lazy="proxy" */
    public void demo2(){ Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); LinkMan linkMan = session.get(LinkMan.class, 1l);// 發送一條查詢聯繫人語句
 System.out.println(linkMan.getLkm_name()); System.out.println(linkMan.getCustomer().getCust_name());// 發送一條select語句查詢聯繫人所關聯的客戶
 tx.commit(); } @Test /** * fetch="select" lazy="false" */
    public void demo3(){ Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); LinkMan linkMan = session.get(LinkMan.class, 1l);// 發送一條查詢聯繫人語句,發送一條select語句查詢聯繫人所關聯的客戶
 System.out.println(linkMan.getLkm_name()); System.out.println(linkMan.getCustomer().getCust_name());//  tx.commit(); } @Test /** * fetch="join" lazy=失效 */
    public void demo4(){ Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); LinkMan linkMan = session.get(LinkMan.class, 1l);// 發送一條迫切左外鏈接查詢聯繫人所關聯的客戶。
 System.out.println(linkMan.getLkm_name()); System.out.println(linkMan.getCustomer().getCust_name());//  tx.commit(); } }

三、批量抓取，一批關聯對象一塊兒抓取，batch-size

package com.turtle.test2; import java.util.List; import com.turtle.dao.Customer; import com.turtle.dao.LinkMan; import com.turtle.utils.HibernateUtils; import org.hibernate.Session; import org.hibernate.Transaction; import org.junit.Test; /** * 批量抓取 * @author jt * */
public class Hibernate_04 { @SuppressWarnings("unchecked") @Test /** * 獲取客戶的時候，批量抓取聯繫人 * 在Customer.hbm.xml中set上配置batch-size */
    public void demo1(){ Session session = HibernateUtils.getCurrentSession(); Transaction tx = 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()); } } tx.commit(); } @SuppressWarnings("unchecked") @Test /** * 獲取聯繫人的時候，批量抓取客戶 * * 在Customer.hbm.xml中<class>上配置 */
    public void demo2(){ Session session = HibernateUtils.getCurrentSession(); Transaction tx = session.beginTransaction(); List<LinkMan> list = session.createQuery("from LinkMan").list(); for (LinkMan linkMan : list) { System.out.println(linkMan.getLkm_name()); System.out.println(linkMan.getCustomer().getCust_name()); } tx.commit(); } }