（三）Hibernate之Session總結

說到Hibernate那麼最核心的就是它的有關數據庫的增刪改查操作了，而這些操作中增刪改無不依賴着一個關鍵的對象session,那麼提到session就不得不提session中對象的四個狀態

 看圖便知道，通常情況下，大家都認爲session中的對象存在三種狀態：瞬時(transitent)、持久化(persistent)以及

託管(detached)。不過有時還存一種觀點，認爲應該是四種狀態，即還存在一種移除(removed)狀態。對於這兩種觀點呢我們暫不追究到底以哪個爲依據，因爲到現在還沒統一的定論

  本篇文章中，爲了全面講解，所以移除狀態我也也涉及到

  Session中對象的狀態
 1) 瞬時狀態(transient): 新創建的對象。沒有和某個Session進行關聯。沒有對象標識符(OID)。
 2) 持久化狀態(persistent): 與某個session進行關聯。有對象標識符。數據庫表中有對應的記錄。
    session在清理緩存時，會把此對象的數據與數據庫表的數據進行同步。
 3) 脫管狀態(detached): 脫離了Session的管理。有對象標識符。數據庫表中有對應的記錄。
          不保證此對象的數據與數據庫表的數據是否同步。
 4) 移除狀態(removed): 與某個session進行關聯。有對象標識符，數據庫表中有對應的記錄。
    session在清理緩存時，會把數據庫表對應的記錄刪除掉。這個對象不能再去使用它.

針對這些解釋呢，基於第一篇文章中的類和配置文件，這裏只提供一個測試類，方法上都有更詳細的解釋

<span style="font-size: medium;"><span style="font-size: large;">package com.javacrazyer.test;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.junit.BeforeClass;
import org.junit.Test;

import com.javacrazyer.common.HibernateUtil;
import com.javacrazyer.domain.Student;

/**
 * 使用Hibernate API完成CRUD 更復雜的持久化操作需要使用到Query接口
 *
 */
public class HibernateTest {

    private static SessionFactory factory;

    @BeforeClass
    public static void init() {
        factory = HibernateUtil.getSessionFactory();
    }

    @Test
    public void testSessionCache() {
        Session session = factory.openSession();
        Transaction tx = session.beginTransaction();

        Student stu = (Student) session.get(Student.class, 1);
        System.out.println(stu);

        Student stu2 = (Student) session.get(Student.class, 1);
        System.out.println(stu2);

        stu2.setName("xkk");
        System.out.println(stu2);
        /*flush()將數據庫與緩存中的數據同步,不是必須調用的*/
        session.flush(); // 手動清理緩存

        /*
         * clear()寫在flush後面，執行後纔會引起緩存數據變化，session.flush()的調用牽扯到事務，
         * 首先我們知道在執行事務之前都會將AutoCommit設置爲false【手動提交方式，因爲默認是true
         * 自動提交的】 當AutoCommit 爲false時我們執行完事務就要調用到session.flush();
         * session.clear();一切處理完後我們要close掉當前的這個session
         */
        session.clear();

        stu2.setScore(77.00);
        System.out.println(stu2);

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

    @Test
    public void testObjectStatus() {
        Student stu = new Student(); // transient瞬時狀態
        stu.setName("ww");
        stu.setGender(false);
        stu.setAge(38);
        stu.setScore(65.5);

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

        session.save(stu); // persistent持久化狀態
        System.out.println(stu);

        tx.commit();
        session.close();

        System.out.println(stu); // detached 脫管

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

        session2.save(stu);
        System.out.println(stu);// 脫管狀態--> 持久化狀態 (不建議用save方法來操作脫管對象)

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

    /*
     * get()方法：先查找session緩存中是否已經存在此標識符指定的對象,如果存在,直接使用.
     * 否則發出SQL語句從數據庫中獲取.如果數據庫中也不存在,返回null
     */
    @Test
    public void testGet() {

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

        Student stu = (Student) session.get(Student.class, 1);

        System.out.println(stu);

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

    /*
     * load()方法先查找session緩存中是否已經存在此標識符指定的對象,如果存在,直接使用.
     * 否則Hibernate會爲此標識符對象產生一個代理對象,實現延遲加載(懶加載)的功能。這個代理對象包含有OID。
     * 當要使用到此對象的非OID屬性值，才發出SQL語句去數據庫中獲取。
     * 如果數據庫中也不存在，返回InvocationTargetException異常。
     */
    @Test
    public void testLoad() {
        Session session = factory.openSession();
        session.beginTransaction();

        Student stu = (Student) session.load(Student.class, 5);

        System.out.println(stu.getId());

        System.out.println(stu);

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

    /*
     * delete()方法:持久化狀態 --> 移除狀態 .
     *  注意:處理移除狀態的對象不要再去使用它,因爲,在session清理緩存時,數據庫表中對應的數據會被刪除掉.
     */
    @Test
    public void testDelete() {

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

        Student stu = (Student) session.load(Student.class, 7);

        session.delete(stu);

        System.out.println(stu);

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

        System.out.println(stu);
    }

    @Test
    /* update()方法: 重附被修改的脫管對象,成爲持久化對象 */
    public void testUpdate() {
        Session session = factory.openSession();
        session.beginTransaction();

        Student stu = (Student) session.load(Student.class, 8);

        stu.setName("更新持久化狀態的對象");

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

        System.out.println(stu);
        stu.setName("修改脫管對象");

        Session session2 = factory.openSession();
        session2.beginTransaction();
        session2.update(stu);
        session2.getTransaction().commit();
        session2.close();
    }

    @Test
    /*
     * saveOrUpdate()方法：
     * 1) 瞬時對象，執行類似save()的功能
     * 2) 脫管對象，如果在當前session緩存中不存在同OID的對象，就執行類似update()的功能。否則，拋出異常。
     */
    public void testSaveOrUpdate() {

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

        Student stu = (Student) session.get(Student.class, 9);

        System.out.println(stu);

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

        // 處理脫管狀態
        stu.setName("9哥");

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

        session2.saveOrUpdate(stu);
        System.out.println(stu);

        session2.getTransaction().commit();
        session2.close();

        System.out.println(stu);
    }

    @Test
    public void testSaveOrUpdate2() {

        Student stu = new Student();
        stu.setId(19); // 對象沒有與session關聯，並且OID有值，就被認爲是脫管對象

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

        session.saveOrUpdate(stu);

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

    @Test
    public void testSaveOrUpdate3() {
        Student stu = new Student();
        stu.setId(9); // 對象沒有與session關聯，並且OID有值，就被認爲是脫管對象
        stu.setName("su");

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

        session.get(Student.class, 9);

        session.saveOrUpdate(stu);

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

    @Test
    /*
     * merge()方法：
     * 1) 瞬時對象，執行類似save()的功能
     * 2)脫管對象：如果在當前session緩存中不存在同OID的對象，就執行類似update()的功能。
     * 否則，把傳入的對象數據合併到緩存中的對象，返回緩存中的對象。
     * 3) 經常用來替代update()和saveOrUpdate()方法。
     */
    public void testmerge() {
        Student stu = new Student();
        stu.setId(9); // 對象沒有與session關聯，並且OID有值，就被認爲是脫管對象
        stu.setName("su");

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

        session.get(Student.class, 9);

        stu = (Student) session.merge(stu);

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

}</span></span>

 

補充說明：sessionFactory.getCurrentSession()和sessionFactory.openSesion()的區別介紹

  1. 如果使用的是getCurrentSession來創建session的話，在commit後，session就自動被關閉了，也就是不用再session.close()了。但是如果使用的是openSession方法創建的session的話，那麼必須顯示的關閉session，也就是調用session.close()方法。這樣commit後，session並沒有關閉

 2.getCurrentSession創建的session會和綁定到當前線程,而openSession不會。getCurrentSession創建的線程會在事務回滾或事物提交後自動關閉,而openSession必須手動關閉, 

 3.  使用SessionFactory.getCurrentSession()需要在hibernate.cfg.xml中如下配置：
  * 如果採用jdbc獨立引用程(本地事務：JDBC事務)序配置如下：
    <property name="hibernate.current_session_context_class">thread</property>
  * 如果採用了JTA事務配置(全局事務：JTA事務)如下 
    <property name="hibernate.current_session_context_class">jta</property>

4.getCurrentSession () 使用當前的session 

openSession() 重新建立一個新的session 

總結：

 getCurrentSession和openSession無論是那種方式，如果是純JDBC項目的話，那你必須手動寫上事務的開啓和提交，openSession事務提交後還得手動寫session.close()關閉，儘管是這樣也不一定真的關了；getCurrentSession提交事務後會自動關閉session所以不用手動寫session.close()

 其實際項目(我指的是SSH項目)中由於在Spring中配置有事務管理，所以我們用getCurrentSession時手動寫的關於事務的代碼配置都不用寫了

<span style="font-size: large;">//openSession()方法的測試，必須在事務提交後關閉session
@Test
    public void openSessionDelete(){
        Session session = factory.openSession();
        Transaction tx = session.beginTransaction();
        Student stu = (Student) session.get(Student.class, 1);
        session.delete(stu);
        tx.commit();
        session.close();
    }
//getCurrentSession()方法，不需要關閉session
    @Test
    public void getCurrentSessionDelete(){
            Session session = factory.getCurrentSession();
            Transaction tx = session.beginTransaction();
            Student stu = (Student) session.get(Student.class,2);
            session.delete(stu);
            tx.commit();
    }</span>

 

相比之下getCurrentSession()還是最適合的

這句紅色標記的話我要用下面的話來解釋下：

    在一個應用程序中，如果DAO 層使用Spring 的hibernate 模板，通過Spring 來控制session 的生命週期，則首選getCurrentSession ()。 

使用Hibernate的大多數應用程序需要某種形式的“上下文相關的” session，特定的session在整個特定的上下文範圍內始終有效。然而，對不同類型的應用程序而言，要爲什麼是組成這種“上下文”下一個定義通常是困難的；不同的上下文對“當前”這個概念定義了不同的範圍。在3.0版本之前，使用Hibernate的程序要麼採用自行編寫的基於 ThreadLocal的上下文session，要麼採用HibernateUtil這樣的輔助類，要麼採用第三方框架（比如Spring或Pico)，它們提供了基於代理(proxy)或者基於攔截器(interception)的上下文相關session。 

    從3.0.1版本開始，Hibernate增加了SessionFactory.getCurrentSession()方法。一開始，它假定了採用JTA事務，JTA事務定義了當前session的範圍和上下文(scope and context)。Hibernate開發團隊堅信，因爲有好幾個獨立的JTA TransactionManager實現穩定可用，不論是否被部署到一個J2EE容器中，大多數(假若不是所有的）應用程序都應該採用JTA事務管理。基於這一點，採用JTA的上下文相關session可以滿足一切需要。 

    在 SessionFactory 啓動的時候， Hibernate 會根據配置創建相應的 CurrentSessionContext ，在 getCurrentSession() 被調用的時候，實際被執行的方法是 CurrentSessionContext.currentSession() 。在 currentSession() 執行時，如果當前 Session 爲空， currentSession 會調用 SessionFactory 的 openSession 。所以 getCurrentSession() 對於 Java EE 來說是更好的獲取Session 的方法。 

    

    那麼跟跟openSession相比,getCurrentSession在使用上有什麼注意的呢? 到現在發現的一個就是,由於getCurrentSession方法返回的session在做事務的commit時, session可能會自動給關掉,這樣若自己的代碼中再調用session.close時就拋出了"Session was already closed"異常。 

在HB3.X 版本中提供了一個getCurrentSession() 這個方法，這個方法和早期使用的openSession() 是有區別的。

openSession() ，表示創建了一個新的session 對象，當你使用完了以後就要必須調用close 方法來關閉當前的session 。getCurrentSession() ，總是會返回“ 當前的” 工作單元。Session 在第一次被使用的時候，即第一次調用getCurrentSession() 的時候，其生命週期就開始。然後她被Hibernate 綁定到當前線程。當事物結束的時候，不管是提交還是回滾，Hibernate 會自動把Session 從當前線程剝離，並且關閉。若在次調用getCurrentSession() ，會得到一個新的Session, 並且開始一個新的工作單元。這是Hibernate 最廣泛的thread-bound model ，支持代碼靈活分層( 事物劃分和數據訪問代碼的分離)