重拾Java EE——Hibernate（3）進階篇（下）

1 Hibernate的關聯關系映射:(多對多)

以Student 與Course為例，是一個經典的多對多的例子

1.1建立實體和映射:

• Student:

public class Student {
    private Integer sid;
    private String sname;
    // 學生選擇多門課程.
    private Set<Course> courses = new HashSet<Course>();
...
}
           

• Course:

public class Course {
    private Integer cid;
    private String cname;
    // 課程可以被多個學生選擇:
    private Set<Student> students = new HashSet<Student>();
...
}
           

1.2配置檔案

• Student.hbm.xml

<hibernate-mapping>
    <class name="cn.itcast.demo3.Student" table="student">
        <id name="sid" column="sid">
            <generator class="native"/>
        </id>
        <property name="sname" column="sname"/>
        <!-- 配置多對多關聯關系 -->
        <set name="courses" table="stu_cour">
            <key column="sno"/>
            <many-to-many class="cn.itcast. demo3.Course" column="cno"/>
        </set>
    </class>
</hibernate-mapping>
           

• Course.hbm.xml

<hibernate-mapping>
    <class name="cn.itcast. demo3.Course" table="course">
        <id name="cid" column="cid">
            <generator class="native"/>
        </id>
        <property name="cname" column="cname"/>

        <!-- 配置多對多關聯關系映射 -->
        <set name="students" table="stu_cour">
            <key column="cno"/>
            <many-to-many class="cn.itcast. demo3.Student" column="sno"/>
        </set>
    </class>
</hibernate-mapping>
           

2 抓取政策（優化）

2.1 檢索方式

• 立即檢索：立即查詢，在執行查詢語句時，立即查詢所有的資料。
• 延遲檢索：延遲查詢，在執行查詢語句之後，在需要時在查詢。（懶加載）

2.2 檢查政策

• 類級别檢索：目前的類的屬性擷取是否需要延遲。
• 關聯級别的檢索：目前類 關聯 另一個類是否需要延遲。

2.3 類級别檢索

• get：立即檢索。get方法一執行，立即查詢所有字段的資料。

• load：延遲檢索。預設情況，load方法執行後，如果隻使用OID的值不進行查詢，如果要使用其他屬性值将查詢 。 Customer.hbm.xml

  lazy 預設值true，表示延遲檢索，如果設定false表示立即檢索。

  

  @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, );
  
  
  
      //列印
      System.out.println(customer.getCid());
      System.out.println(customer.getCname());
  
      session.getTransaction().commit();
      session.close();
  }
             

2.4 關聯級别檢索

2.4.1 一對多或多對多

2.4.1.1 介紹

• 容器 提供兩個屬性：fetch、lazy

  fetch：确定使用sql格式

  lazy：關聯對象是否延遲。

• fetch：join、select、subselect

  join：底層使用迫切左外連接配接

  select：使用多個select語句（預設值）

  subselect：使用子查詢

• lazy：false、true、extra

  false：立即

  true：延遲（預設值）

  extra：極其懶惰

  

2.4.1.2 fetch=”join”

• fetch=”join” ，lazy無效。底層使用迫切左外連接配接，使用一條select将所有内容全部查詢。

“`java

@Test

public void demo03() {

//關聯級别：一對多，

// * Customer.hbm.xml

// * 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();
}
           

“`

2.4.1.3 fetch=”select”

• 目前對象 和 關聯對象 使用多條select語句查詢。
• lazy=”false” , 立即，先查詢客戶select，立即查詢訂單select
• lazy=”true”,延遲，先查詢客戶select，需要訂單時，再查詢訂單select
• lazy=”extra”，極其懶惰（延遲），先查詢客戶select， 如果隻需要訂單數，使用聚合函數（不查詢詳情）

  

2.4.1.4 fetch=”subselect”

• 将使用子查詢。注意：必須使用Query否則看不到效果。
• lazy= 同上

  @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();
      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();
  }
             

  

2.4.2 多對一

2.4.2.1 介紹

• ()

• fetch取值：join、select

  join：底層使用迫切左外連接配接

  select：多條select語句

• lazy取值：false、proxy、no-proxy

  false：立即

  proxy：采用關聯對象 類級别檢索的政策。

  訂單 關聯 客戶 （多對一）

  訂單 立即獲得 客戶，需要在客戶Customer.hbm.xml

  訂單 延遲獲得 客戶，需要在客戶Customer.hbm.xml

  no-proxy 不研究

  

2.4.2.2 fetch=”join”

• fecth=”join” select語句使用左外連接配接，此時lazy無效。

  

@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, );
        System.out.println(order.getPrice());

        //2 查詢訂單客戶資訊
        Customer customer = order.getCustomer();
        System.out.println(customer.getCname());


        session.getTransaction().commit();
        session.close();
    }
           

2.4.2.3 fetch=”select”

• 将采用多條select語句，lazy=”proxy”是否延遲，取決關聯對象 類級别檢索政策。
• lazy=”false”

  

• lazy=”proxy”

2.5 批量查詢

• 當客戶 關聯查詢 訂單，給每一個客戶生産一個select語句查詢訂單。批量查詢使用in語句減少查詢訂單語句個數。

  預設：select * from t_order where customer_id = ?

  批量：select * from t_order where customer_id in (?,?,?,?)

• 5表示括号中?個數。

  

  “`java

  @Test

  public void demo06() {

  //批量查詢

  Session session = factory.openSession();

  session.beginTransaction();

  //1 查詢所有客戶
  List<Customer> allCustomer = session.createQuery("from Customer").list();
  
  //2周遊
  for (Customer customer : allCustomer) {
      System.out.println(customer.getCname());
      System.out.println(customer.getOrderSet().size());
  }
  
  
  session.getTransaction().commit();
  session.close();
             

  }

## 2.6  檢索總結

![](https://upload-images.jianshu.io/upload_images/-d869c74acfae53.png?imageMogr2/auto-orient/strip%CimageView2//w/)




# 3 查詢方式總結
## 1.通過OID檢索（查詢）
    get（）立即、如果沒有資料傳回null
    load（）延遲，如果沒有資料抛異常。
## 2.導航對象圖檢索方式：關聯查詢
    customer.getOrderSet()
    user.getPost().getDepartment().getDepName();
## 3.原始sql語句
    SQLQuery sqlQuery = session.createSQLQuery("sql 語句")   --->表，表字段（列）
        sqlQuery.list() 查詢所有
        sqlQuery.uniqueResult() 查詢一個
## 4.HQL（hibernate query language） hibernate 查詢語言
    Query query = session.createQuery("hql語句")  --> 對象，對象屬性
## 5.QBC（query by criteria ）純面對對象查詢語言





# 4 HQL【掌握】
## 4.1  介紹
 ![](https://upload-images.jianshu.io/upload_images/-e1f7b8931ed07295.png?imageMogr2/auto-orient/strip%CimageView2//w/)

## 4.2  查詢所有客戶
```java
@Test
public void demo01(){
        // 查詢所有
        Session session = factory.openSession();
        session.beginTransaction();

        //  使用簡單類名 ， 存在自動導包
        // * Customer.hbm.xml <hibernate-mapping auto-import="true">
//      Query query = session.createQuery("from Customer");
        // 使用全限定類名
        Query query = session.createQuery("from com.itheima.a_init.Customer");

        List<Customer> allCustomer = query.list();
        for (Customer customer : allCustomer) {
            System.out.println(customer);
        }

        session.getTransaction().commit();
        session.close();
    }




<div class="se-preview-section-delimiter"></div>
           

4.3 選擇查詢

@Test
public void demo02(){
        //2 簡單條件查詢
        Session session = factory.openSession();
        session.beginTransaction();


        //1 指定資料，cid OID名稱
//      Query query = session.createQuery("from Customer where cid = 1");
        //2 如果使用id，也可以（了解）
//      Query query = session.createQuery("from Customer where id = 1");
        //3 對象别名 ,格式： 類 [as] 别名
//      Query query = session.createQuery("from Customer as c where c.cid = 1");
        //4 查詢所有項，mysql--> select * from...
        Query query = session.createQuery("select c from Customer as c where c.cid = 1");

        Customer customer = (Customer) query.uniqueResult();
        System.out.println(customer);

        session.getTransaction().commit();
        session.close();
    }




<div class="se-preview-section-delimiter"></div>
           

4.4 投影查詢（部分）

@Test
public void demo04(){
        //4 投影
        Session session = factory.openSession();
        session.beginTransaction();

        //1 預設
        //如果單列 ，select c.cname from，需要List<Object>
        //如果多列，select c.cid,c.cname from ，需要List<Object[]>  ,list存放每行，Object[]多列
//      Query query = session.createQuery("select c.cid,c.cname from Customer c");
        //2 将查詢部分資料，設定Customer對象中
        // * 格式：new Customer(c.cid,c.cname)
        // * 注意：Customer必須提供相應的構造方法。
        // * 如果投影使用oid，結果脫管态對象。
        Query query = session.createQuery("select new Customer(c.cid,c.cname) from Customer c");

        List<Customer> allCustomer = query.list();
        for (Customer customer : allCustomer) {
            System.out.println(customer.getCid() + " : " + customer.getOrderSet().size());
        }

        session.getTransaction().commit();
        session.close();
    }




<div class="se-preview-section-delimiter"></div>
           

4.5 排序

@Test
public void demo03(){
        //3排序 ，mysql--> select... order by 字段  [asc]|desc ,....
        Session session = factory.openSession();
        session.beginTransaction();

        Query query = session.createQuery("from Customer order by cid desc");

        List<Customer> allCustomer = query.list();
        for (Customer customer : allCustomer) {
            System.out.println(customer.getCid());
        }

        session.getTransaction().commit();
        session.close();
    }




<div class="se-preview-section-delimiter"></div>
           

4.6 分頁

@Test
public void demo05(){
        //分頁
        Session session = factory.openSession();
        session.beginTransaction();

        Query query = session.createQuery("from Customer");
        // * 開始索引 , startIndex 算法： startIndex = (pageNum - 1) * pageSize;
        // *** pageNum 目前頁（之前的 pageCode）
        query.setFirstResult();
        // * 每頁顯示個數 ， pageSize
        query.setMaxResults();

        List<Customer> allCustomer = query.list();
        for (Customer customer : allCustomer) {
            System.out.println(customer.getCid());
        }

        session.getTransaction().commit();
        session.close();
    }




<div class="se-preview-section-delimiter"></div>
           

4.7 綁定參數

@Test
public void demo06(){
        /* 6 綁定參數
         * 方式1：占位符，使用? 在hql語句替換具體參數
         *      設定參數 query.setXxx(int , object)
         *          參數1：?位置，從0開始。
         *          參數2：實際參數
         *      例如：String --> query.setString(int,String)
         * 方式2：别名 , 格式 “屬性= :别名 ”
         *      設定參數 query.setXxx(String,object)
         *          參數1：别名
         *          參數2：實際參數
         *      例如：Integer --> query.setInteger(String,Integer)
         * 提供公共設定方法
         *  setParameter(int|string , Object)
         */
        Session session = factory.openSession();
        session.beginTransaction();

        Integer cid = ;

        //方式1
//      Query query = session.createQuery("from Customer where cid = ?");
//      query.setInteger(0, cid);
        //方式2
        Query query = session.createQuery("from Customer where cid = :xxx");
//      query.setInteger("xxx", cid);
        query.setParameter("xxx", cid);

        Customer customer = (Customer) query.uniqueResult();
        System.out.println(customer);

        session.getTransaction().commit();
        session.close();
    }




<div class="se-preview-section-delimiter"></div>
           

4.8 聚合函數和分組

@Test
public void demo07(){
        /* 7  聚合函數
         */
        Session session = factory.openSession();
        session.beginTransaction();

        //1 
//      Query query = session.createQuery("select count(*) from Customer");
        //2 别名
//      Query query = session.createQuery("select count(c) from Customer c");
        //3 oid
        Query query = session.createQuery("select count(cid) from Customer");

        Long numLong = (Long) query.uniqueResult();
        int num = numLong.intValue();

        System.out.println(num);


        session.getTransaction().commit();
        session.close();
    }




<div class="se-preview-section-delimiter"></div>
           

4.9 連接配接查詢

1.交叉連接配接 ，等效 sql 笛卡爾積

2.隐式内連接配接，等效 sql 隐式内連接配接

3.内連接配接，等效sql内連接配接

4.迫切内連接配接，hibernate底層使用 内連接配接。

5.左外連接配接，等效sql左外連接配接

6.迫切左外連接配接，hibernate底層使用 左外連接配接

7.右外連接配接，等效sql右外連接配接

内連接配接和迫切内連接配接？

左外連接配接和迫切左外連接配接？

@Test
public void demo08(){
        /* 8 連結查詢 ： 左外連接配接和迫切左外連接配接？
         * * 左外連接配接 , left outer join
         *      底層使用sql的左外連接配接，hibernate進行資料自動封裝，将一條記錄，封裝給兩個對象（Customer，Order）
         *      将兩個對象添加到一個對象數組中Object[Customer,Order]
         * * 迫切左外連結 left outer join fetch
         *      底層使用sql的左外連接配接，hibernate将一條記錄封裝給Customer，講order資料封裝Order，并将order關聯到Customer
         *          customer.getOrderSet().add(order)
         *      預設查詢的資料重複
         */
        Session session = factory.openSession();
        session.beginTransaction();

        //左外連接配接
//      List list = session.createQuery("from Customer c left outer join c.orderSet ").list();
        //迫切左外連結 (預設資料重複)
//      List list = session.createQuery("from Customer c left outer join fetch c.orderSet ").list();
        //迫切左外連結 (去重複)
        List list = session.createQuery("select distinct c from Customer c left outer join fetch c.orderSet ").list();


        session.getTransaction().commit();
        session.close();
    }




<div class="se-preview-section-delimiter"></div>
           

4.10 命名查詢

• 思想：将HQL從java源碼中，提取到配置檔案中。
• 分類：全局、布局

• 配置

  全局：*.hbm.xml HQL語句

  

局部： HQL

• 獲得

  全局：

  session.getNamedQuery(“queryName”)

  局部：

  session.getNamedQuery(“className.queryName”) 需要使用類的全限定名稱

  

  “`java

  @Test

  public void demo09(){

  Session session = factory.openSession();

  session.beginTransaction();

  //全局
  //List list = session.getNamedQuery("findAll").list();
  //局部
  List list = session.getNamedQuery("com.itheima.a_init.Customer.findAll").list();
  
  System.out.println(list.size());
  
  session.getTransaction().commit();
  session.close();
             

  }

<div class="se-preview-section-delimiter"></div>

# 5 QBC【了解】





<div class="se-preview-section-delimiter"></div>

## 5.1  QBC查詢:
> QBC:Query By Criteria條件查詢.面向對象的查詢的方式.





<div class="se-preview-section-delimiter"></div>

## 5.2  QBC簡單的查詢:




<div class="se-preview-section-delimiter"></div>

```java
        // 簡單查詢:
        List<Customer> list = session.createCriteria(Customer.class).list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
           

5.3 QBC分頁的查詢:

Criteria criteria = session.createCriteria(Order.class);
        criteria.setFirstResult();
        criteria.setMaxResults();
        List<Order> list = criteria.list();
           

5.4 QBC排序查詢:

Criteria criteria = session.createCriteria(Customer.class);
//      criteria.addOrder(org.hibernate.criterion.Order.asc("age"));
        criteria.addOrder(org.hibernate.criterion.Order.desc("age"));
        List<Customer> list = criteria.list();
           

5.5 QBC條件查詢:

// 按名稱查詢:
        /*Criteria criteria = session.createCriteria(Customer.class);
        criteria.add(Restrictions.eq("cname", "tom"));
        List<Customer> list = criteria.list();*/

        // 模糊查詢;
        /*Criteria criteria = session.createCriteria(Customer.class);
        criteria.add(Restrictions.like("cname", "t%"));
        List<Customer> list = criteria.list();*/

        // 條件并列查詢
        Criteria criteria = session.createCriteria(Customer.class);
        criteria.add(Restrictions.like("cname", "t%"));
        criteria.add(Restrictions.ge("age", ));
        List<Customer> list = criteria.list();
           

5.6 離線查詢(了解)

• DetachedCriteria 離線查詢對象，不需要使用Session就可以拼湊查詢條件。一般使用在web層或service層拼湊。将此對象傳遞給dao層，此時将與session進行綁定執行查詢。
• 離線查詢條件與QBC一樣的。

“`java

@Test

public void demo10(){

//web & service
    DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class);
    detachedCriteria.add(Restrictions.eq("cid", 1));

    //---------------dao

    Session session = factory.openSession();
    session.beginTransaction();

    // 離線Criteria 與session綁定
    Criteria criteria = detachedCriteria.getExecutableCriteria(session);
    List<Customer> allCustomer = criteria.list();
    System.out.println(allCustomer.size());

    session.getTransaction().commit();
    session.close();
}
           

# 6 常見配置
## 6.1  整合c3p0(連接配接池) （了解）

![](https://upload-images.jianshu.io/upload_images/-a661fa96e951540.png?imageMogr2/auto-orient/strip%CimageView2//w/)

- 步驟一：導入c3p0 jar包
        ![](https://upload-images.jianshu.io/upload_images/-f2158de16fc1ef0.png?imageMogr2/auto-orient/strip%CimageView2//w/)

- 步驟二：hibernate.cfg.xml 配置
        hibernate.connection.provider_class org.hibernate.connection.C3P0ConnectionProvider
         ![](https://upload-images.jianshu.io/upload_images/-f1f479dfd4821afe.png?imageMogr2/auto-orient/strip%CimageView2//w/)

-  c3p0具體配置參數
 C3P0 Connection Pool
```xml
hibernate.c3p0.max_size 
hibernate.c3p0.min_size 
hibernate.c3p0.timeout 
hibernate.c3p0.max_statements 
hibernate.c3p0.idle_test_period 
hibernate.c3p0.acquire_increment 
hibernate.c3p0.validate false




<div class="se-preview-section-delimiter"></div>

           

6.2 事務

6.2.1 回顧

• 事務：一組業務操作，要麼全部成功，要麼全部不成功。

• 特性：ACID

  原子性：整體

  一緻性：資料

  隔離性：并發

  持久性：結果

• 隔離問題：

  髒讀：一個事務讀到另一個事務未送出的内容

  不可重複讀：一個事務讀到另一個事務已送出的内容（insert）

  虛讀（幻讀）：一個事務讀到另一個事務已送出的内容（update）

• 隔離級别–解決問題

  read uncommittd，讀未送出。存在3個問題。

  read committed，讀已送出。解決：髒讀。存在2個問題。

  repeatable read ，可重複讀。解決：髒讀、不可重複讀。存在1個問題。

  serializable，串行化。單事務。沒有問題。

6.2.2 hibernate設定隔離級别

• 在hibernate.cfg.xml 配置

  hibernate.connection.isolation 4

  

6.2.3 lost update 丢失更新

- 悲觀鎖：丢失更新肯定會發生。

采用資料庫鎖機制。

讀鎖：共享鎖。

select …. from … lock in share mode;

寫鎖：排他鎖。（獨占）

select … from …. for update

- 樂觀鎖：丢失更新肯定不會發生

在表中提供一個字段（版本字段），用于辨別記錄。如果版本不一緻，不允許操作。

6.2.4 hibernate處理丢失更新

• 悲觀鎖：寫鎖

@Test
public void demo01(){
        //1 查詢所有
        Session session = factory.openSession();
        session.beginTransaction();

        Customer customer = (Customer) session.get(Customer.class,  ,LockMode.UPGRADE);
        System.out.println(customer);

        session.getTransaction().commit();
        session.close();
    }




<div class="se-preview-section-delimiter"></div>
           

![](https://upload-images.jianshu.io/upload_images/3034232-6823404c2cbc4aa3.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
           

• 樂觀鎖：

  在PO對象（javabean）提供字段，表示版本字段。一般Integer

  在*.hbm.xml 檔案配置

步驟一：

步驟二：

步驟三：測試

@Test
public void demo02(){
        //1 查詢所有
        Session session = factory.openSession();
        session.beginTransaction();

//      Order order = new Order();
//      order.setPrice(998d);
//      session.save(order);

        Order order = (Order) session.get(Order.class, );
        order.setPrice(d);


        session.getTransaction().commit();
        session.close();
    }