hibernate - 查詢操作

查詢方式

唯一標識OID的檢索方式

session.get(物件.class,OID)

物件的導航方式

獲取物件屬性 User.getOrders()

HQL的檢索方式

Hibernate Query Language -- Hibernate的查詢語言

HQL的介紹

• HQL(Hibernate Query Language) 是面向物件的查詢語言, 它和 SQL 查詢語

  言有些相似

• 在 Hibernate 提供的各種檢索方式中, HQL 是使用最廣的一種檢索方式

HQL與SQL的關系

• HQL 查詢陳述句是面向物件的,Hibernate負責決議HQL查詢陳述句, 然后根據物件-

  ? 關系映射檔案中的映射資訊, 把 HQL 查詢陳述句翻譯成相應的 SQL 陳述句

• HQL 查詢陳述句中的主體是域模型中的類及類的屬性

• SQL 查詢陳述句是與關系資料庫系結在一起的. SQL查詢陳述句中的主體是資料庫

  表及表的欄位

HQL的查詢演示

1. HQL基本的查詢格式

   支持方法鏈的編程，即直接呼叫list()方法

   代碼

   session.createQuery("from Customer").list();
   

2. 使用別名的方式

   session.createQuery("from Customer c").list(); 
   // 相當于select * from Customer c
   // 但是該模式下不支持 select *  可以寫成
   session.createQuery("select c from Customer c").list();
   

3. 分頁查詢

   Hibernate框架提供了分頁的方法，咱們可以呼叫方法來完成分頁

   兩個方法如下

   // 從哪條記錄開始，如果查詢是從第一條開啟，值是0
   setFirstResult(a)   
   // 每頁查詢的記錄條數
   setMaxResults(b)     
   

   演示代碼如下

   List<LinkMan> list = session.createQuery("from LinkMan").setFirstResult(0).setMaxResults().list();
   

4. 排序查詢

   升序

   session.createQuery("from Customer order by cust_id").list();
   

   降序

   session.createQuery("from Customer order by cust_id desc").list();
   

5. 帶條件的查詢

   setParameter("?號的位置，默認從0開始","引數的值"); 不用考慮引數的具體型別

   按位置系結引數的條件查詢（指定下標值，默認從0開始）

   按名稱系結引數的條件查詢（HQL陳述句中的 ? 號換成 :名稱 的方式）

   代碼

    Query query = session.createQuery("from Linkman where lkm_name like ? and lkm_password = :password order by lkm_id desc");
           query.setFirstResult(0).setMaxResults(3);
           query.setParameter(0, "%熊%");
           query.setParameter("password ", "213456");
           List<Linkman> list = query.list();
           for (Linkman linkman : list) {
               System.out.println(linkman);
           }
   

投影查詢

投影查詢就是想查詢某一欄位的值或者某幾個欄位的值

查詢多個欄位

List<Object[]> list = session.createQuery("select c.cust_name,c.cust_level from Customer c").list();
for (Object[] objects : list) {
    System.out.println(Arrays.toString(objects));
}

查詢時封裝到物件

先在持久化類中提供對應欄位的構造方法

使用下面這種HQL陳述句的方式

 List<Customer> list = session.createQuery("select new Customer(c.cust_name,c.cust_level) from Customer c").list();
for (Customer customer : list) {
    System.out.println(customer);
}

注意

session.createQuery("select c from Customer c").list();

相當于select * from Customer c,但是該模式下不支持select * 寫法

聚合函式查詢

獲取總的記錄數

    Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();
    List<Number> list = session.createQuery("select count(c) from Customer c").list();
    Long count = list.get(0).longValue();
    System.out.println(count);
    tr.commit();

獲取某一列資料的和

    Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();
    List<Number> list = session.createQuery("select sum(c.cust_id) from Customer c").list();
    Long count = list.get(0).longValue();
    System.out.println(count);
    tr.commit();

HQL多表查詢

多表的查詢使用HQL陳述句進行查詢，HQL陳述句和SQL陳述句的查詢語法比較類似，

MySql的多表查詢

內連接查詢

// 顯示內連接
select * from customers c inner join orders o on c.cid = o.cno;
// 隱式內連接
select * from customers c,orders o where c.cid = o.cno;

外連接查詢

//左外連接
select * from customers c left join orders o on c.cid = o.cno;
//右外連接
select * from customers c right join orders o on c.cid = o.cno;

HQL的多表查詢

非迫切回傳結果是Object[]

迫切連接回傳的結果是物件，把客戶的資訊封裝到客戶的物件中，把訂單的資訊封裝到客戶的Set集合中，

內連接查詢

// 內連接使用 inner join ，默認回傳的是Object陣列
Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
List<Object[]> list = session.createQuery("from Customer c inner join c.linkmans").list();
for (Object[] objects : list) {
    System.out.println(Arrays.toString(objects));
}
tr.commit();

// 迫切內連接:inner join fetch ，回傳的是物體物件
Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
List<Customer> list = session.createQuery("from Customer c inner join fetch c.linkmans").list();
//去除重復物件
Set<Customer> set = new HashSet<Customer>(list);
for (Customer customer : set) {
   System.out.println(customer);
}
tr.commit();

左外連接查詢

// 左外連接: 封裝成List<Object[]>
// 迫切左外連接
Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
List<Customer> list = session.createQuery("from Customer c left join fetch c.linkmans").list();
Set<Customer> set = new HashSet<Customer>(list);
for (Customer customer : set) {
    System.out.println(customer);
}
tr.commit();

注意點

List<Customer> list = session.createQuery("from Customer c inner join fetch c.linkmans").list();
//去除重復物件
Set<Customer> set = new HashSet<Customer>(list);

QBC的檢索方式

QBC：Query By Criteria 按條件進行查詢

簡單查詢，使用的是Criteria介面

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

排序查詢

需要使用addOrder()的方法來設定引數，引數使用org.hibernate.criterion.Order物件

Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
Criteria criteria = session.createCriteria(Linkman.class);
// 設定排序
criteria.addOrder(Order.desc("lkm_id"));
List<Linkman> list = criteria.list();
for (Linkman linkman : list) {
    System.out.println(linkman);
}
tr.commit();

分頁查詢

QBC的分頁查詢也是使用兩個方法

setFirstResult()

setMaxResults()

Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
Criteria criteria = session.createCriteria(Linkman.class);
// 設定排序
criteria.addOrder(Order.desc("lkm_id"));
criteria.setFirstResult(0);
criteria.setMaxResults(3);
List<Linkman> list = criteria.list();
for (Linkman linkman : list) {
    System.out.println(linkman);
}
tr.commit();

條件查詢

Criterion是查詢條件的介面，Restrictions類是Hibernate框架提供的工具類，使用該工具類來設定查詢條件

條件查詢使用Criteria介面的add方法，用來傳入條件，

使用Restrictions的添加條件的方法，來添加條件

Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
Criteria criteria = session.createCriteria(Linkman.class);
// 設定排序
criteria.addOrder(Order.desc("lkm_id"));
// 設定查詢條件
criteria.add(
    Restrictions.or(
   		 Restrictions.eq("lkm_gender", "男"), 
    	Restrictions.gt("lkm_id", 3L)
    )
);
List<Linkman> list = criteria.list();
for (Linkman linkman : list) {
   System.out.println(linkman);
}
tr.commit();

聚合函式查詢

（Projection的聚合函式的介面，而Projections是Hibernate提供的工具類，使用該工具類設定聚合函式查詢）

使用QBC的聚合函式查詢，需要使用criteria.setProjection()方法

 Session session = HibernateUtils.getCurrentSession();
 Transaction tr = session.beginTransaction();
 Criteria criteria = session.createCriteria(Linkman.class);
 criteria.setProjection(Projections.rowCount());
 List<Number> list = criteria.list();
 Long count = list.get(0).longValue();
 System.out.println(count);
 tr.commit();

離線條件查詢

離線條件查詢使用的是DetachedCriteria介面進行查詢，離線條件查詢物件在創建的時候，不需要使用Session物件，只是在查詢的時候使用Session物件即可，

創建離線條件查詢物件:DetachedCriteria criteria = DetachedCriteria.forClass(Linkman.class);

    Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();

    DetachedCriteria criteria = DetachedCriteria.forClass(Linkman.class);
    // 設定查詢條件
    criteria.add(Restrictions.eq("lkm_gender", "男"));
    // 查詢資料
    List<Linkman> list = criteria.getExecutableCriteria(session).list();
    for (Linkman linkman : list) {
        System.out.println(linkman);
    }
    tr.commit();

SQL檢索方式

    Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();

    SQLQuery sqlQuery = session.createSQLQuery("select * from cst_linkman where lkm_gender = ?");
    sqlQuery.setParameter(0,"男");
    sqlQuery.addEntity(Linkman.class);
    List<Linkman> list = sqlQuery.list();
    System.out.println(list);
    tr.commit();

查詢優化

延遲加載

延遲加載先獲取到代理物件，當真正使用到該物件中的屬性的時候，才會發送SQL陳述句，是Hibernate框架提升性能的方式

類級別的延遲加載

Session物件的load方法默認就是延遲加載

Customer c = session.load(Customer.class, 1L)沒有發送SQL陳述句，當使用該物件的屬性時，才發送SQL陳述句

使類級別的延遲加載失效

在標簽上配置lazy="false"

Hibernate.initialize(Object proxy)

關聯級別的延遲加載

查詢某個客戶，當查看該客戶下的所有聯系人是否是延遲加載

 		Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        Customer c = session.get(Customer.class, 1L);
        System.out.println("=============");
        System.out.println(c.getLinkmans().size());
        tr.commit();

Hibernate策略

Hibernate框架的查詢策略

查詢策略：使用Hibernate查詢一個物件的時候，查詢其關聯物件.應該如何查詢.是Hibernate的一種優化手段!!!

Hibernate框架的檢索策略解決的問題

查詢的時機

Customer c1 = (Customer) session.get(Customer.class, 1);
System.out.println(c1.getLinkmans().size());

lazy屬性解決查詢的時機的問題，需要配置是否采用延遲加載！！

查詢的陳述句形式

List<Customer> list = session.createQuery("from Customer").list();
for(Customer c : list){
     System.out.println(c.getLinkmans());
}

fetch屬性就可以解決查詢陳述句的形式的問題！！

set標簽上配置策略

在標簽上使用fetch和lazy屬性

fetch的取值: 控制SQL陳述句生成的格式

lazy的取值 : 查找關聯物件的時候是否采用延遲!

總結：

set標簽上的默認值是fetch="select"和lazy="true"

Hibernate框架都采用了默認值，開發中基本上使用的都是默認值，特殊的情況，

man-to-one標簽上配置策略

在標簽上使用fetch和lazy屬性

fetch的取值: 控制SQL的格式.

lazy的取值: 控制加載關聯物件是否采用延遲.

proxy理解:

由另一端的上的class上的lazy確定.如果另一端的class上的lazy="true".proxy的值就是true(延遲加載).

如果另一端上的class上的lazy="false".proxy的值就是false(不采用延遲.)

many-to-one標簽上配置策略

默認值是fetch="select"和proxy

標籤：Java

上一篇：hibernate - 查詢操作

下一篇：hibernate 基礎組態檔