2. 程式人生 > >open session and Hibernate事務處理機制

open session and Hibernate事務處理機制

阿新 • • 發佈：2019-02-05

在沒有使用Spring提供的Open Session In View情況下，因需要在service(or Dao)層裡把session關閉，所以lazy loading 為true的話，要在應用層內把關係集合都初始化，如 company.getEmployees()，否則Hibernate拋session already closed Exception;    Open Session In View提供了一種簡便的方法，較好地解決了lazy loading問題.

它有兩種配置方式OpenSessionInViewInterceptor和OpenSessionInViewFilter(具體參看

SpringSide)，功能相同，只是一個在web.xml配置，另一個在application.xml配置而已。

    Open Session In View在request把session繫結到當前thread期間一直保持hibernate session在open狀態，使session在request的整個期間都可以使用，如在View層裡PO也可以lazy loading資料，如 ${ company.employees }。當View 層邏輯完成後，才會通過Filter的doFilter方法或Interceptor的postHandle方法自動關閉session。

OpenSessionInViewInterceptor配置
  1. <beans>
  2. <bean name="openSessionInViewInterceptor"
  3. class="org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor">
  4. <property name="sessionFactory">
  5. <ref bean="sessionFactory"/>
  6. </property>
  7. </bean>
  8. <bean id="urlMapping"
  9. class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping"
    >
  10. <property name="interceptors">
  11. <list>
  12. <ref bean="openSessionInViewInterceptor"/>
  13. </list>
  14. </property>
  15. <property name="mappings">
  16. ...
  17. </property>
  18. </bean>
  19. ...
  20. </beans>
OpenSessionInViewFilter配置
  1. <web-app>
  2. ...
  3. <filter>
  4. <filter-name>hibernateFilter</filter-name>
  5. <filter-class>
  6. org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
  7. </filter-class>
  8. <!-- singleSession預設為true,若設為false則等於沒用OpenSessionInView -->
  9. <init-param>
  10. <param-name>singleSession</param-name>
  11. <param-value>true</param-value>
  12. </init-param>
  13. </filter>
  14. ...
  15. <filter-mapping>
  16. <filter-name>hibernateFilter</filter-name>
  17. <url-pattern>*.do</url-pattern>
  18. </filter-mapping>
  19. ...
  20. </web-app>

很多人在使用OpenSessionInView過程中提及一個錯誤：

  1. org.springframework.dao.InvalidDataAccessApiUsageException: Write operations
  2. are not allowed in read-only mode (FlushMode.NEVER) - turn your Session into
  3. FlushMode.AUTO or remove 'readOnly' marker from transaction definition

看看OpenSessionInViewFilter裡的幾個方法

  1. protected void doFilterInternal(HttpServletRequest request,
    HttpServletResponse response,FilterChain filterChain)
    throws ServletException, IOException     {
    　SessionFactory sessionFactory = lookupSessionFactory();
    　logger.debug("Opening Hibernate Session in OpenSessionInViewFilter");
    　Session session = getSession(sessionFactory);
    　TransactionSynchronizationManager.bindResource    (
    　　sessionFactory, new SessionHolder(session));
    　try     {
    　　filterChain.doFilter(request, response);
    　    }
    　finally     {
    　TransactionSynchronizationManager.unbindResource(sessionFactory);
    　logger.debug("Closing Hibernate Session in OpenSessionInViewFilter");
    　closeSession(session, sessionFactory);
    　    }
    }
  2. protected Session getSession(SessionFactory sessionFactory)
    throws DataAccessResourceFailureException     {
    　Session session = SessionFactoryUtils.getSession(sessionFactory, true);
    　session.setFlushMode(FlushMode.NEVER);
    　return session;
    }

  3. protected     void closeSession(Session session, SessionFactory sessionFactory)
    throws CleanupFailureDataAccessException     {
    　SessionFactoryUtils.closeSessionIfNecessary(session, sessionFactory);
    }

           關於繫結session的方式，通過看spring裡TransactionSynchronizationManager的實現，發現：它維護一個java.lang.ThreadLocal型別的resources，resources負責持有執行緒區域性變數，這裡resources持有的是一個HashMap，通過TransactionSynchronizationManager.bindResource()方法在map裡繫結和執行緒相關的所有變數到他們的標識上，包括如上所述的繫結在sessionFactory上的執行緒區域性session。sessionHolder只不過是存放可以hold一個session並可以和transtaction同步的容器。可以看到OpenSessionInViewFilter在getSession的時候,會把獲取回來的session的flush mode 設為FlushMode.NEVER。然後把該sessionFactory繫結到TransactionSynchronizationManager，使request的整個過程都使用同一個session，在請求過後再接除該sessionFactory的繫結，最後closeSessionIfNecessary根據該session是否已和transaction繫結來決定是否關閉session。繫結以後，就可以防止每次不會新開一個Session呢？看看HibernateDaoSupport的情況：

        我們的DAO將使用這個template進行操作.

public abstract class BaseHibernateObjectDao extends HibernateDaoSupport
implements BaseObjectDao {
     protected BaseEntityObject getByClassId(final long id) {
                BaseEntityObject obj =(BaseEntityObject) getHibernateTemplate().execute(new HibernateCallback() {
                        public Object doInHibernate(Session session) throws HibernateException {
                                    return session.get(getPersistentClass(),new Long(id));
                        }
                });
                return obj;
      }
     public void save(BaseEntityObject entity) {
                  getHibernateTemplate().saveOrUpdate(entity);
     }

    public void remove(BaseEntityObject entity) {
              try {
                     getHibernateTemplate().delete(entity);
              } catch (Exception e) {
                      throw new FlexEnterpriseDataAccessException(e);
             }
     }

      public void refresh(final BaseEntityObject entity) {
               getHibernateTemplate().execute(new HibernateCallback() {
                          public Object doInHibernate(Session session) throws HibernateException {
                                      session.refresh(entity);
                                      return null;
                          }
               });
      }

     public void replicate(final Object entity) {
                getHibernateTemplate().execute(new HibernateCallback() {
                          public Object doInHibernate(Session session)throws HibernateException {
                                      session.replicate(entity,ReplicationMode.OVERWRITE);
                                      return null;
               }
                });
      }
}

        而HibernateTemplate試圖每次在execute之前去獲得Session，執行完就力爭關閉Session

      而這個SessionFactoryUtils能否得到當前的session以及closeSessionIfNecessary是否真正關閉session，端取決於這個session是否用sessionHolder和這個sessionFactory在我們最開始提到的TransactionSynchronizationManager繫結。

     public static void closeSessionIfNecessary(Session session, SessionFactory sessionFactory)

  1. throws CleanupFailureDataAccessException {
  2. if (session == null ||
    TransactionSynchronizationManager.hasResource(sessionFactory)) {
  3. return;
  4. }
  5. logger.debug("Closing Hibernate session");
  6. try {
  7. session.close();
  8. }
  9. catch (JDBCException ex) {
  10. // SQLException underneath
  11. throw new CleanupFailureDataAccessException("Could not close Hibernate session", ex.getSQLException());
  12. }
  13. catch (HibernateException ex) {
  14. throw new CleanupFailureDataAccessException("Could not close Hibernate session", ex);
  15. }
  16. }

    在這個過程中，若HibernateTemplate 發現自當前session有不是readOnly的transaction，就會獲取到FlushMode.AUTO Session，使方法擁有寫許可權。也即是，如果有不是readOnly的transaction就可以由Flush.NEVER轉為Flush.AUTO,擁有insert,update,delete操作許可權，如果沒有transaction，並且沒有另外人為地設flush model的話，則doFilter的整個過程都是Flush.NEVER。所以受transaction保護的方法有寫許可權，沒受保護的則沒有。

  1. 可能的解決方式有：
    1、將singleSession設為false，這樣只要改web.xml，缺點是Hibernate Session的Instance可能會大增，使用的JDBC Connection量也會大增，如果Connection Pool的maxPoolSize設得太小，很容易就出問題。
    2、在控制器中自行管理Session的FlushMode，麻煩的是每個有Modify的Method都要多幾行程式。
          session.setFlushMode(FlushMode.AUTO);
          session.update(user);
          session.flush();
    3、Extend OpenSessionInViewFilter，Override protected Session getSession(SessionFactory sessionFactory)，將FlushMode直接改為Auto。
    4、讓方法受Spring的事務控制。這就是常使用的方法：

採用spring的事務宣告,使方法受transaction控制

  1.   <bean id="baseTransaction"
    class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
              abstract="true">
            <property name="transactionManager" ref="transactionManager"/>
            <property name="proxyTargetClass" value="true"/>
            <property name="transactionAttributes">
                <props>
                    <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
                    <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
                    <prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>
                    <prop key="save*">PROPAGATION_REQUIRED</prop>
                    <prop key="add*">PROPAGATION_REQUIRED</prop>
                    <prop key="update*">PROPAGATION_REQUIRED</prop>
                    <prop key="remove*">PROPAGATION_REQUIRED</prop>
                </props>
            </property>
        </bean>
  2.     <bean id="userService" parent="baseTransaction">
            <property name="target">
                <bean class="com.phopesoft.security.service.impl.UserServiceImpl"/>
            </property>
        </bean>

對於上例，則以save,add,update,remove開頭的方法擁有可寫的事務，如果當前有某個方法，如命名為importExcel()，則因沒有transaction而沒有寫許可權，這時若方法內有insert,update,delete操作的話，則需要手動設定flush model為Flush.AUTO,如

  1. session.setFlushMode(FlushMode.AUTO);
  2. session.save(user);
  3. session.flush();

     儘管Open Session In View看起來還不錯，其實副作用不少。看回上面OpenSessionInViewFilter的doFilterInternal方法程式碼，這個方法實際上是被父類的doFilter呼叫的，因此，我們可以大約瞭解的OpenSessionInViewFilter呼叫流程: request(請求)->open session並開始transaction->controller->View(Jsp)->結束transaction並close session.

     一切看起來很正確，尤其是在本地開發測試的時候沒出現問題，但試想下如果流程中的某一步被阻塞的話，那在這期間connection就一直被佔用而不釋放。最有可能被阻塞的就是在寫Jsp這步，一方面可能是頁面內容大，response.write的時間長，另一方面可能是網速慢，伺服器與使用者間傳輸時間久。當大量這樣的情況出現時，就有連線池連線不足，造成頁面假死現象。

Open Session In View是個雙刃劍，放在公網上內容多流量大的網站請慎用。

另外：這樣會產生一點危險性，畢竟把資料庫訪問的環境放到了表現層。（：用VO）

        Hibernate是對JDBC的輕量級物件封裝，Hibernate本身是不具備Transaction處理功能的，Hibernate的Transaction實際上是底層的JDBC Transaction的封裝，或者是JTA Transaction的封裝，下面我們詳細的分析：

　　Hibernate可以配置為JDBCTransaction或者是JTATransaction，這取決於你在hibernate.properties中的配置:

#hibernate.transaction.factory_class
net.sf.hibernate.transaction.JTATransactionFactory
#hibernate.transaction.factory_class
net.sf.hibernate.transaction.JDBCTransactionFactory
　　如果你什麼都不配置，預設情況下使用JDBCTransaction，如果你配置為：

hibernate.transaction.factory_class
net.sf.hibernate.transaction.JTATransactionFactory
　　將使用JTATransaction，不管你準備讓Hibernate使用JDBCTransaction，還是JTATransaction，我的忠告就是什麼都不配，將讓它保持預設狀態，如下：

#hibernate.transaction.factory_class
net.sf.hibernate.transaction.JTATransactionFactory
#hibernate.transaction.factory_class
net.sf.hibernate.transaction.JDBCTransactionFactory
　　在下面的分析中我會給出原因。

　　一、JDBC Transaction

　　看看使用JDBC Transaction的時候我們的程式碼例子：

Session session = sf.openSession();
Transaction tx = session.beginTransactioin();
...
session.flush();
tx.commit();
session.close();
　　這是預設的情況，當你在程式碼中使用Hibernate的Transaction的時候實際上就是JDBCTransaction。那麼JDBCTransaction究竟是什麼東西呢？來看看原始碼就清楚了：

　　Hibernate2.0.3原始碼中的類

　　net.sf.hibernate.transaction.JDBCTransaction:

public void begin() throws HibernateException {
...
if (toggleAutoCommit) session.connection().setAutoCommit(false);
...
}
　　這是啟動Transaction的方法，看到 connection().setAutoCommit(false) 了嗎？是不是很熟悉？

　　再來看

public void commit() throws HibernateException {
...
try {
if ( session.getFlushMode()!=FlushMode.NEVER ) session.flush();
try {
session.connection().commit();
committed = true;
}
...
toggleAutoCommit();
}
　　這是提交方法，看到connection().commit() 了嗎？下面就不用我多說了，這個類程式碼非常簡單易懂，通過閱讀使我們明白Hibernate的Transaction都在幹了些什麼？我現在把用Hibernate寫的例子翻譯成JDBC，大家就一目瞭然了：

Connection conn = ...;               <--- session = sf.openSession();
conn.setAutoCommit(false);   <--- tx = session.beginTransactioin();
... <--- ...
conn.commit();                           <--- tx.commit(); (對應左邊的兩句)
conn.setAutoCommit(true);
conn.close();                              <--- session.close();
　　看明白了吧，Hibernate的JDBCTransaction根本就是conn.commit而已，根本毫無神祕可言，只不過在Hibernate中，Session開啟的時候，就會自動conn.setAutoCommit(false)，不像一般的JDBC，預設都是true，所以你最後不寫commit也沒有關係，由於Hibernate已經把AutoCommit給關掉了，所以用Hibernate的時候，你在程式中不寫Transaction的話，資料庫根本就沒有反應。 

 二、JTATransaction

如果你在EJB中使用Hibernate，或者準備用JTA來管理跨Session的長事務，那麼就需要使用JTATransaction，先看一個例子：

javax.transaction.UserTransaction tx = new InitialContext().lookup("javax.transaction.UserTransaction");

Session s1 = sf.openSession();
...
s1.flush();
s1.close();
...

Session s2 = sf.openSession();
...
s2.flush();
s2.close();

tx.commit();

這是標準的使用JTA的程式碼片斷，Transaction是跨Session的，它的生命週期比Session要長。如果你在EJB中使用Hibernate，那麼是最簡單不過的了，你什麼Transaction程式碼統統都不要寫了，直接在EJB的部署描述符上配置某某方法是否使用事務就可以了。

現在我們來分析一下JTATransaction的原始碼， net.sf.hibernate.transaction.JTATransaction:

public void begin(InitialContext context, ...
...
ut = (UserTransaction) context.lookup(utName);
...

看清楚了嗎？ 和我上面寫的程式碼 tx = new Initial Context?().lookup("javax.transaction.UserTransaction"); 是不是完全一樣？

public void commit() ...
...
if (newTransaction) ut.commit();
...

JTATransaction的控制稍微複雜，不過仍然可以很清楚的看出來Hibernate是如何封裝JTA的Transaction程式碼的。

但是你現在是否看到了什麼問題？ 仔細想一下，Hibernate Transaction是從Session中獲得的，tx = session.beginTransaction()，最後要先提交tx，然後再session.close，這完全符合JDBC的Transaction的操作順序，但是這個順序是和JTA的Transactioin操作順序徹底矛盾的！！！ JTA是先啟動Transaction，然後啟動Session，關閉Session，最後提交Transaction，因此當你使用JTA的Transaction的時候，那麼就千萬不要使用Hibernate的Transaction，而是應該像我上面的JTA的程式碼片斷那樣使用才行。

總結：
1、在JDBC上使用Hibernate

必須寫上Hibernate Transaction程式碼，否則資料庫沒有反應。此時Hibernate的Transaction就是Connection.commit而已

2、在JTA上使用Hibernate

寫JTA的Transaction程式碼，不要寫Hibernate的Transaction程式碼，否則程式會報錯

3、在EJB上使用Hibernate

什麼Transactioin程式碼都不要寫，在EJB的部署描述符裡面配置

|---CMT(Container Managed Transaction)
|
|---BMT(Bean Managed Transaction)
|
|----JDBC Transaction
|
|----JTA Transaction

關於session：

1.  servlet的session機制基於cookies,關閉瀏覽器的cookies則session失效即不能用網站的登入功能。

2.  Hibernate Session.

      1>. session 清理快取時，按照以下順序執行SQL語句：

            session.save()的實體insert

實體的update

            對集合的delete

            集合元素的delete，update，insert

            集合的insert

            session.delete()的先後，執行實體的delete

       2>. 預設時，session在以下時間點清理快取：

              net.sf.hibernate.Transaction.commit():先清理快取，再向資料庫提交事務                                                          

              Session.find()或iterate()時，若快取中持久化物件的屬性發生了變化，就會先清快取，以保證查詢結果正確

       3>.  Session的commit()和flush()的區別：flush()只執行SQL語句，不提交事務；commit()先呼叫flush()，再提交事務

       4>.  Session.setFlushMode()用於設定清理快取的時間點。

清理快取的模式 Session的查詢方法 Session.commit() Session.flush()
FlushMode.AUTO 清理 清理 清理
FlushMode.COMMIT 不清理 清理 清理
FlushMode.NEVER 不清理 不清理 清理

相關推薦

open session and Hibernate事務處理機制

在沒有使用Spring提供的Open Session In View情況下，因需要在service(or Dao)層裡把session關閉，所以lazy loading 為true的話，要在應用層內把關係集合都初始化，如 company.getEmployees()，否則Hi

hibernate的事務處理機制以及flush方法的作用

關於在使用hibernate在提交事務時常遇到的異常：        an assertion failure occured (this may indicate a bug in Hibernate, butis more likely due to unsafe us

Hibernate的事務處理機制和flush方法的用法

注：轉自http://www.cnblogs.com/wangkai1990/p/5704529.html。 首先來看下，session的生命週期 Hibernate中java物件的三種狀態： 1、臨時狀態（transient）：用new語句建立，還沒有被持久化，不處於Se

Hibernate事務處理

事務:  事務通俗說就是邏輯上的一組操作,要麼全都成功,要麼全都失敗!!!   事務有四個特性，簡稱為ACID： 原子性（Atomicity）：事務一組操作不可分割. 一致性（Consistency）：事務的執行前後,資料完整性要保持一致. 隔離性（Isolatio

rocketmq介紹和訊息佇列事務處理機制

RocketMQ介紹 rocketmq是支援釋出(Pub)和訂閱(Sub)，可靠的先進先出、嚴格順序、億級訊息堆積能力的分散式訊息佇列 rocketmq訊息佇列包含Producer、Name Serv

Spring事務處理機制

常用的事務處理方式：   手動處理事務   註解式事務   AOP宣告事務資料庫訪問時，就不需要開啟Session、開啟事務，提交事務、關閉 Session。由AOP指定的事務管理器，在方法（資料庫訪

Spring多資料來源事務處理機制

最近有spring配置多資料來源，中間用了aop來完成動態的切換，發現一些地方不是很明白，在AbstractRoutingDataSource這個類中有determineCurrentLookupKey的方法，另外我在所有DAO層方法上添加了before的切面，按理說，如果

分散式系統常見的事務處理機制

為保障系統的可用性、可靠性以及效能，在分散式系統中，往往會設定資料冗餘，即對資料進行復制。舉例來說，當一個數據庫的副本被破環以後，那麼系統只需要轉換到其他資料副本就能繼續執行下去。另外一個例子，當訪問單一伺服器管理的資料的程序數不斷增加時，系統就需要對伺服器

Hibernate 事務處理和spring中配置事務

原文連結：http://blog.csdn.net/sd0902/article/details/8393700 1.非整合spring事務管理 事務是指由一個或者多個SQL語句組成的工作單元，這個單元中SQL語句只要有一個SQL語句執行失敗，就會撤銷整個工作單元

spring 配置hibernate事務處理

學習Spring+Hibernate，非常強大的框架，為了追新，就直接從最高版本開始學習了，這要冒很大的風險，因為網上可查到的資料大多是針對舊版本的，比如Spring3,Hibernate3。 根據我的測試，記錄如下： 1.Spring4事務必須針對介面，否則報錯。（之前可以不針對介面?）如果沒有事務，則b

原始碼分析 spring事務處理機制

Spring在TransactionDefinition介面中定義這些屬性,以供PlatfromTransactionManager使用, PlatfromTransactionManager是Spring事務管理的核心介面。介面程式碼如下： public interface

Hibernate--事務處理和快取管理

事務處理：    事務是資料庫操作中一個最小的執行單元，它由一組相互依賴的操作行為組成。資料庫事務必須具有ACID特徵，ACID是Atomic（原子性）、Consistency（一致性）、Isolation（隔離性）和Durability（永續性）的英文縮寫。       

分布式系統常見的事務處理機制

分布式計算 返回 系統 zook rollback 個數 自身 重要 數據一致性 為保障系統的可用性、可靠性以及性能，在分布式系統中，往往會設置數據冗余，即對數據進行復制。舉例來說，當一個數據庫的副本被破環以後，那麽系統只需要轉換到其他數據副本就能繼續運行下去。另外一個例子

Hibernate 使用session 進行事務處理

    public void saveLogoPath(String path, List<Terminal> temList)             throws Exception {         Session session = null;   

Hibernate 再接觸 事務隔離機制

nat 機制 原子 ble read 記錄 aci serial png 事務：要麽都要完成，一個不完成就要回滾。 ACID 原子性 一致性 獨立性 持久性 第一類丟失更新 第一類丟失更新 臟讀（讀了另外一個事務沒有提交的數據） 不可重復讀（在同一個事務裏，對數據

Hibernate事務操作及session與本地執行緒繫結

事務相關概念 　　1 什麼是事務 　　　　事務是應用程式中一系列嚴密的操作，所有操作必須成功完成，否則在每個操作中所作的所有更改都會被撤消。也就是事務具有原子性，一個事務中的一系列的操作要麼全部成功，要麼一個都不做。 　　　　事務的結束有兩種，當事務中的所以步驟全部成功執行時，事務提交。如果其中

HIbernate的事務處理和二級快取

一.事務概述 問題1:什麼是事務? 事務就是一件事情,這個事情由多個單元組成,這些單元執行時要麼都成功,要麼都不成功. 問題2:事務特性? (ACID) 1.原子性 2.一致 3.隔離性 4,永續性 問題3:關於不考慮事務的隔離性,會產生的問題?

spring 同時配置hibernate and jdbc 事務

在專案中同時用到了JDBC和hibernate，分別配置了各自的事務，同時配置了不同的tx:annotation-driven。 但是在實際使用中，只有配置在前的tx:annotation-driven起了作用，另外一個tx:annotation-driven不起作用

zookeeper原始碼閱讀分析筆記--客戶端服務端通訊機制以及session超時、過期處理

    這兩天看了一下zookeeper的相關的原始碼，版本基於3.4.5，程式碼結構還是比較清晰的； 這裡重點分析一下zookeeper client和server端之間的通訊以及相關的異常處理機制。   1、客戶端   客戶端幾個主要的類為Zookeeper、Clie

Hibernate——ThreadLocal模式下管理的Session會在事務提交後自動關閉

　　最近對Hibernate的ThreadLocal Session模式有點興趣。於是根據曹曉鋼翻譯的Hibernate Reference做了個小測驗，結果發現了一個小bug。 程式碼很簡單，都是利用Hibernate Reference中現成的程式碼。