Hibernate中提供了5種查詢方式:

1. OID查詢
2. 對象導航查詢
3. HQL檢索
4. QBC檢索
5. SQL檢索

OID檢索：

Hibernate根據對象的oid（表中主鍵）

• 使用get方法 Customer customer = new Customer(Customer.class , 1l);
• 使用load方法

對象導航檢索：

Hibernate根據一個已經查詢到的對象，獲得其關聯對象的一種查詢方式

LinkMan linkman = session.get(LinkMan.class , 1l);

linkman,getCustomer();

HQL檢索：Hibernate Query Language

一種面向對象的查詢語言，session.createQuery(hql);

• HQL的簡單查詢
• HQL的排序查詢
• HQL的條件查詢
• HQL的投影查詢 ： 查詢對象的某個或某些屬性
• HQL的分組統計查詢
• HQL的分頁查詢

/**
 * HQL查詢方式測試類
 */
public class demo1 {
    @Test
    /**
     * 初始化數據
     */
    public void demo1() {

        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction 
 
= session.beginTransaction();
        Customer customer = new Customer();
        customer.setCust_name("啥幾把");
        for (int i = 0; i < 10; i++) {
            LinkMan linkMan = new LinkMan();
            linkMan.setLkm_name("啊實打" + i);
            linkMan.setCustomer(customer);
            ;
            session.save(linkMan);
        }
        session.save(customer);
        transaction.commit();
    }

    @Test
    
 
/**
     * HQL的簡單查詢,sql支持*，HQL不支持*，但是聚合函數裏面可以用,比如count(*)
     */
    public void demo2() {

        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        Query query = session.createQuery("from Customer");
        List<Customer> list = query.list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        transaction.commit();
    }

    @Test
    /**
     * HQL的別名查詢
     */
    public void demo3() {

        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        Query query = session.createQuery("select c from Customer c");
        List<Customer> list = query.list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        transaction.commit();
    }

    @Test
    /**
     * HQL的排序查詢,升序asc，降序desc
     */
    public void demo4() {

        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        // HQL的排序查詢
        List<Customer> list = session.createQuery("from Customer order by cust_id desc ").list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        transaction.commit();
    }

    @Test
    /**
     * HQL的條件查詢，按位置綁定，按名稱綁定
     */
    public void demo5() {

        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        // 按位置綁定
        /*
         * Query query = session.
         * createQuery("from Customer where cust_name like ? and cust_id = ? ");
         * query.setParameter(0, "李兵"); query.setParameter(1, 1l);
         */
        // 按名稱綁定
        Query query = session.createQuery("from Customer where cust_name like :aaa and cust_id = :bbb ");
        query.setParameter("aaa", "李%");
        query.setParameter("bbb", 1l);
        List<Customer> list = query.list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        transaction.commit();
    }

    @Test
    /**
     * HQL的投影查詢，查詢對象的某個或者某些屬性
     */
    public void demo6() {

        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        // 投影查詢,單個屬性
        // List<Object> list = session.createQuery("select c.cust_name from
        // Customer c ").list();
        // 投影查詢,多個屬性,封裝到數組
        /*
         * List<Object[]> list =
         * session.createQuery("select c.cust_name,c.cust_id from Customer c ").
         * list(); for (Object[] objects : list) {
         * System.out.println(Arrays.toString(objects)); }
         */
        // 投影查詢,多個屬性,封裝到對象(需要提供構造)
        List<Customer> list = session.createQuery("select new Customer(cust_id,cust_name) from Customer ").list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        transaction.commit();
    }

    @Test
    /**
     * HQL的分頁查詢
     */
    public void demo7() {

        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = 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);
        }
        transaction.commit();
    }

    @Test
    /**
     * HQL的分組統計查詢,聚合函數：count(),min(),avg(),max()
     */
    public void demo8() {

        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        // HQL的分組統計查詢,得到唯一結果用uniqueResult,否則用list
        /*
         * Object object =
         * session.createQuery("select count(*) from LinkMan").uniqueResult();
         * System.out.println(object);
         */
        // 分組統計：按來源，且統計大於1的
        List<Object[]> list = session
                .createQuery("select cust_source,count(*) from Customer group by cust_source having count(*) > 1")
                .list();
        for (Object[] objects : list) {
            System.out.println(Arrays.toString(objects));
        }

        transaction.commit();


    }
}

QBC查詢：

Query By Criteria：條件查詢，更加面向對象的查詢方式，並不是所有方式都能用

• 簡單查詢
• 排序查詢
• 分頁查詢
• 條件查詢
• 統計查詢
• 離線條件查詢 DetachedCriteria（SSH整合經常用到這個模版），離線：脫離Session使用，適合條件多的查詢，免於拼接JDBC語句

/**
 *QBC查詢
 */
public class HibernateDemo2 {
   @Test
   /**
    * 簡單查詢
    */
    public void demo1(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        Criteria criteria = session.createCriteria(Customer.class);
        List<Customer> list = criteria.list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        transaction.commit();
   }
    
   @Test
   /**
    * 排序查詢
    */
   public void demo2(){
       Session session = HibernateUtils.getCurrentSession();
       Transaction transaction = session.beginTransaction();
       Criteria criteria = session.createCriteria(Customer.class);
       criteria.addOrder(Order.desc("cust_id"));
       List<Customer> list = criteria.list();
       for (Customer customer : list) {
        System.out.println(customer);
    }
       transaction.commit();
   }
   
   @Test
   /**
    * 分頁查詢
    */
   public void demo3(){
       Session session = HibernateUtils.getCurrentSession();
       Transaction transaction = session.beginTransaction();
       Criteria criteria = session.createCriteria(LinkMan.class);
       criteria.setFirstResult(10);
       criteria.setMaxResults(5);
       List<LinkMan> list = criteria.list();
       for (LinkMan linkMan : list) {
        System.out.println(linkMan);
    }
       transaction.commit();
   }
   @Test
   /**
    * 條件查詢
    */
   public void demo4(){
       Session session = HibernateUtils.getCurrentSession();
       Transaction transaction = session.beginTransaction();
       Criteria criteria = session.createCriteria(Customer.class);
       /**
        * 設置條件：
        * =  eq
        * >  gt
        * >= gq
        * <  lt
        * <= le
        * <> ne
        * like
        * in
        * and 
        * or
        */
       criteria.add(Restrictions.eq("cust_source", "小廣告"));
       criteria.add(Restrictions.like("cust_name", "李%"));
       List<Customer> list = criteria.list();
       for (Customer customer : list) {
        System.out.println(customer);
    }
       transaction.commit();
   }
   @Test
   /**
    * 條件查詢
    */
   public void demo5(){
       Session session = HibernateUtils.getCurrentSession();
       Transaction transaction = session.beginTransaction();
       Criteria criteria = session.createCriteria(Customer.class);
       /**
        * 設置條件：
        * =  eq
        * >  gt
        * >= gq
        * <  lt
        * <= le
        * <> ne
        * like
        * in
        * and 
        * or
        */
       criteria.add(Restrictions.eq("cust_source", "小廣告"));
       criteria.add(Restrictions.like("cust_name", "李%"));
       List<Customer> list = criteria.list();
       for (Customer customer : list) {
           System.out.println(customer);
       }
       transaction.commit();
   }
   
   @Test
   /**
    * 統計查詢
    */
   public void demo6(){
       Session session = HibernateUtils.getCurrentSession();
       Transaction transaction = 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);
       transaction.commit();
   }
   @Test
   /**
    * 離線條件查詢
    */
   public void demo7(){
       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();
   }
   
   
}

七 Hibernate5種查詢檢索方式,單表&多表