2. 程式人生 > >Spring @Transactional 宣告式事務管理 getCurrentSession

Spring @Transactional 宣告式事務管理 getCurrentSession

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

在Spring @Transactional宣告式事務管理的配置中,hibernate.current_session_context_class=thread…

這一句是不能加的…加了就會出錯，具體錯誤為：

org.hibernate.HibernateException: save is not valid without active transaction
at org.hibernate.context.ThreadLocalSessionContext$TransactionProtectionWrapper.invoke(ThreadLocalSessionContext.java:341)
at com.sun.proxy.$Proxy12.save(Unknown Source)
at cn.javass.h4.hello.UserDao.save(UserDao.java:18)

..那為什麼不能加呢?

那是因為在Spring宣告式事務管理中, current Session是繫結到SpringSessionContext中的,而不是ThreadLocalSessionContext中的

先結合Hibernate4.0說說:

從Hibernate3.1開 始，SessionFactory.getCurrentSession()的後臺實現是可拔插的。因此，我們引入了新的擴充套件介面 (org.hibernate.context.spi.CurrentSessionContext)和

新的配置引數(hibernate.current_session_context_class)，以便對什麼是“當前session”的範圍和上下文(scope and context)的定義進行拔插。

它定義 了單一的方法，currentSession()，特定的實現用它來負責跟蹤當前的上下文session, SessionFactory.getCurrentSession()通過呼叫sessionContext.currentSession()方法獲得當前session。

這個介面僅有一個方法:

SessioncurrentSession()

Retrieve thecurrent session according to the scoping defined by this implementation.

currentSession()表示 根據當前CurrentSessionContext的實現及定義返回”當前的Session”

這個介面…Hibernate中有3個類實現了這個介面

All Known Implementing Classes:

1: org.hibernate.context.internal.ThreadLocalSessionContext - 當前session通過當前執行的執行緒來跟蹤和界定。

2: org.hibernate.context.internal.JTASessionContext- 當前session根據JTA來跟蹤和界定。這和以前的僅支援JTA的方法是完全一樣的。

3: org.hibernate.context.internal.ManagedSessionContext..

Spring為事務管理,也實現了此介面:

這幾種實現都提供了“每資料庫事務對應一個session”的程式設計模型，也稱作每次請求一個session。Hibernate session的起始和終結由資料庫事務的生存來控制。

hibernate.current_session_context_class 配置引數定義了應該採用哪個org.hibernate.context.spi.CurrentSessionContext實現。

一般而言，此引數的值指明瞭要使用的實 現類的全名，但那兩個內建的實現可以使用簡寫，即"jta"和"thread"。

hibernate.current_session_context_class=thread

實質是:

hibernate.current_session_context_class= org.hibernate.context.internal.ThreadLocalSessionContext

同理:

hibernate.current_session_context_class=jta

實質是:

hibernate.current_session_context_class= org.hibernate.context.internal.JTASessionContext

而在Spring @Transactional宣告式事務管理,”currentSession”的定義為: 當前被 Spring事務管理器 管理的Session,此時應配置:

spring 整合hibernate管理事務後，由Spring的TransactionManager管理事務後, currentSession是繫結到SpringSessionContext的，而不是thread。

此時hibernate.current_session_context_class應該是SpringSessionContext，而它又會在使用LocalSessionFactoryBean時自動的設定。

所以就不需要你去設定current_session_context_class

-   -       - --         -

下面我們來分析一下SessionFactoryImpl, org.hibernate.context.spi.CurrentSessionContext

org.hibernate.context.internal.ThreadLocalSessionContext

這些類的原始碼

1: 分析sessionFactory.getCurrentSession() 我們跟進去

來到SessionFactoryImpl.getCurrentSession()方法:

  1. publicfinalclass SessionFactoryImpl  
  2.       implements SessionFactoryImplementor {  
  3.   . . .  
  4.   privatefinaltransient CurrentSessionContext currentSessionContext;  
  5.   . . .  
  6.   public Session getCurrentSession() throws HibernateException {  
  7.       if ( currentSessionContext == null ) {  
  8.          thrownew HibernateException( "No CurrentSessionContext configured!" );  
  9.       }  
  10.       return currentSessionContext.currentSession();  
  11.   }  
  12. . . .  
  13. }  


SessionFactoryImpl 的currentSessionContext屬性的實際型別就是

由hibernate.current_session_context_class決定的…

2:首先設定: hibernate.current_session_context_class= org.hibernate.context.internal.ThreadLocalSessionContext

   到這一句,currentSessionContext.currentSession()跟進去

  1. publicclass ThreadLocalSessionContext implements CurrentSessionContext {  
  2.     . . .  
  3.    privatestaticfinal ThreadLocal<Map> context = newThreadLocal<Map>();  
  4.    . . .  
  5.    //開啟一個”事務提交後自動關閉”的Session
  6.    protected Session buildOrObtainSession() {  
  7.        return factory.withOptions()  
  8.             .autoClose( isAutoCloseEnabled() )  
  9.             .connectionReleaseMode( getConnectionReleaseMode() )  
  10.             .flushBeforeCompletion( isAutoFlushEnabled() )  
  11.             .openSession();  
  12.     }  
  13.     publicfinal Session currentSession() throws HibernateException {  
  14.       //從執行緒區域性量context中嘗試取出已經繫結到執行緒的Session
  15.       Session current = existingSession( factory );  
  16.       //如果沒有繫結到執行緒的Session
  17.       if (current == null) {  
  18.          //開啟一個”事務提交後自動關閉”的Session
  19.          current = buildOrObtainSession();  
  20.             current.getTransaction().registerSynchronization(buildCleanupSynch() );  
  21.          // wrap the session in thetransaction-protection proxy
  22.          if ( needsWrapping( current ) ) {  
  23.             current = wrap( current );  
  24.          }  
  25.          //將得到的Session繫結到執行緒中:即以<SessionFactory,Session>鍵值對方式設定到執行緒區域性量context
  26.          doBind( current, factory );  
  27.       }  
  28.       return current;  
  29.    }  
  30. . . .  
  31. }  


現在對於hibernate.current_session_context_class= thread時的getCurrentSession()就很清楚了:

1:嘗試取出繫結到執行緒的Session

2:如果沒有,則開啟一個”事務提交後自動關閉”的Session,並將此Session加入到ThreadLocal的Map中.

3:返回Session

  1. Public UserService  
  2. {  
  3.    @Transactional
  4.    publicvoid addUser(User user) throws Exception  
  5.    {  
  6.       Session session = sessionFactory.getCurrentSession();  
  7.       session.save(user);  
  8.    }  
  9. }  


因為加入了@Transactional,執行addUser()方法時,Spring的TransactionManager會自動 Open Sesion, 自動 開啟事務,並且 將此Sesion繫結到SpringSessionContext(實際上是TransactionSynchronizationManager的ThreadLocal的Map)中..

然後到SessionFactoryImpl.getCurrentSesssion()的currentSessionContext.currentSession()這一句,跟進去

  1. publicclass SpringSessionContext implements CurrentSessionContext {  
  2.    privatefinal SessionFactoryImplementor sessionFactory;  
  3.    -  - - - - -  
  4.    public Session currentSession() throws HibernateException {  
  5.     //關鍵就是這一句,Spring實際上會去TransactionSynchronizationManager裡查詢”currentSession”
  6.     Object value = TransactionSynchronizationManager.getResource(this.sessionFactory);  
  7.       if (value instanceof Session) {  
  8.          return (Session) value;  
  9.       }  
  10.       elseif (value instanceof SessionHolder) {  
  11.          SessionHolder sessionHolder = (SessionHolder) value;  
  12.          Session session = sessionHolder.getSession();  
  13.          if (TransactionSynchronizationManager.isSynchronizationActive()&&  
  14.                 !sessionHolder.isSynchronizedWithTransaction()) {  
  15.             TransactionSynchronizationManager.registerSynchronization(  
  16.                    new SpringSessionSynchronization(sessionHolder, this.sessionFactory));  
  17.             sessionHolder.setSynchronizedWithTransaction(true);  
  18.             FlushMode flushMode = session.getFlushMode();  
  19.             if (FlushMode.isManualFlushMode(flushMode)&&  
  20.                    !TransactionSynchronizationManager.isCurrentTransactionReadOnly()){  
  21.                 session.setFlushMode(FlushMode.AUTO);  
  22.                 sessionHolder.setPreviousFlushMode(flushMode);  
  23.             }  
  24.          }  
  25.          return session;  
  26.       }  
  27.       elseif (this.jtaSessionContext != null) {  
  28.          Session session = this.jtaSessionContext.currentSession();  
  29.          if (TransactionSynchronizationManager.isSynchronizationActive()){  
  30.             TransactionSynchronizationManager.registerSynchronization(newSpringFlushSynchronization(session));  
  31.          }  
  32.          return session;  
  33.       }  
  34.       else {  
  35.          thrownew HibernateException("No Session found for current thread");  
  36.       }  
  37.    }  
  38. }  

Object value =TransactionSynchronizationManager.getResource(this.sessionFactory); 關鍵是這一句,跟進去:

  1. publicabstractclass TransactionSynchronizationManager {  
  2.  . . .  
  3.  privatestaticfinal ThreadLocal<Map<Object, Object>> resources;  
  4.  publicstatic Object getResource(Object key) {  
  5.       Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);  
  6.       //在ThreadLocal的屬性resources裡查詢Session, resources裡以<SessionFactory,SessionHolder>或 <SessionFactory,Session>的鍵值對存放到ThreadLocal的Map中
  7.       Object value = doGetResource(actualKey);  
  8.       if (value != null && logger.isTraceEnabled()) {  
  9.          logger.trace("Retrievedvalue [" + value + "] for key [" + actualKey + "] bound to thread [" +  
  10.                 Thread.currentThread().getName() + "]");  
  11.       }  
  12.       return value;  
  13.    }  
  14.  . ..  
  15. }  

根據以上程式碼，我們可以發現，如果我們通過@Transactional註解配置事務，那麼SpringSessionContext中就不會存在當前的session, Object value = TransactionSynchronizationManager.getResource(this.sessionFactory);    

這個值會是null，這個時候Spring 就會返回"No Session found for current thread"。所以對於SpringSessionContext 來說， @Transactional註解（或者通過tx標籤攔截器等其他方式配置的事務應該也起了同樣的作用，未驗證）很關鍵, getCurrentSession()在SpringSessionContext的情況下（預設情況）必須配置事務才有效。 

現在對於hibernate.current_session_context_class= org.springframework.orm.hibernate4.SpringSessionContext時的getCurrentSession()就很清楚了:

1: @Transactional宣告的方法執行時,Spring的TransactionManager會自動Open Sesion,自動開啟事務,並且將此Sesion繫結到SpringSessionContext(實際上是TransactionSynchronizationManager的ThreadLocal的Map)中..

2:SessionFactory.getCurrentSession()方法執行時,呼叫SpringSessionContext.currentSession()從TransactionSynchronizationManager的上下文中查詢 當前的Session

3:找到後返回當前的Session,找不到,則返回HibernateException("No Sessionfound for current thread")

PS: 從中,我們也知道了,執行SessionFactoryImpl.openSession()時,只是簡單地new 一個SessionBuilder,然後呼叫SessionBuilder.openSession(),得到的Session是不會繫結到任何 org.hibernate.context.spi.CurrentSessionContext 在上下文中的.

////////////////////////////////////////////////////////////////--------------------------------------------------------------------------------------------------------------------------------------- 

總結: hibernate.current_session_context_class=thread(org.hibernate.context.internal.ThreadLocalSessionContext)

與      hibernate.current_session_context_class=org.springframework.orm.hibernate4.SpringSessionContext 時的SessionFactory.getCurrentSession()的不同之處在於: 

 前者在ThreadLocalSessionContext裡的執行緒區域性的Map中查詢Session,

      最終,你會發覺,無論是ThreadLocalSessionContext 或 SpringSessionContext 查詢的"currentSession",都是以類似鍵值對<SessionFactory,Session>的形式存放到ThreadLocal的Map中,也就是說這兩者的上下文都是一個ThreadLocal的Map...查詢時以SessionFactory為鍵來查詢對應的Session,所以在同一執行緒中,一個SessionFactory只能有一個currentSession


相關推薦

Spring @Transactional 宣告式事務管理 getCurrentSession

在Spring @Transactional宣告式事務管理的配置中,hibernate.current_session_context_class=thread… 這一句是不能加的…加了就會出錯..那為什麼不能加呢? 那是因為在Spring事務管理中,current S

Spring @Transactional 宣告式事務管理 getCurrentSession

在Spring @Transactional宣告式事務管理的配置中,hibernate.current_session_context_class=thread… 這一句是不能加的…加了就會出錯，具體錯誤為： org.hibernate.HibernateExce

Java程式設計師從笨鳥到菜鳥之（八十）細談Spring（九）spring+hibernate宣告式事務管理詳解

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

使用註解實現Spring的宣告式事務管理

使用註解實現Spring的宣告式事務管理，更加簡單！ 步驟：          1） 必須引入Aop相關的jar檔案          2） b

xml方式實現spring的宣告式事務管理及對jdbc操作的支援

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"     xmlns:xsi="http://www.w3.org/2001/XMLSchema-

淺談spring事務管理的2種方式：程式設計式事務管理和宣告式事務管理；以及@Transactional(rollbackFor=Exception.class)註解用法

事務的概念，以及特性： 百度百科介紹： ->資料庫事務(Database Transaction) ，是指作為單個邏輯工作單元執行的一系列操作，要麼完全地執行，要麼完全地不執行。 事務處理可以確保除非事務性單元內的所有操作都成功完成，否則不會永久更新面向資料的資源。通過

spring事物配置，宣告式事務管理和基於@Transactional註解的使用

spring支援程式設計式事務管理和宣告式事務管理兩種方式。         程式設計式事務管理使用TransactionTemplate或者直接使用底層的PlatformTransactionManager。對於程式設計式事務管理，spring推薦使用Transactio

深入解讀Spring Framework事務管理（第四彈：基於@Transactional註解的宣告式事務管理）

基於註解的宣告式事務，主要使用的是@Transactional註解，下面我們來具體看一下。 使用@Transactional註解實現事務的例子 // 這個service我們要將他事務化 @Transactional public class Defa

第十二講：12，spring宣告式事務管理-註解式

1，複製專案spring404 ，改名spring404-3。修改BankServiceImpl類，添加註解，package com.cruise.service.impl;import org.springframework.transaction.annotation.Tra

第十一講：11.spring宣告式事務管理-xml方式

1，複製專案spring404 ，改名spring404-2，修改BankServiceImpl類，刪除宣告式事務的程式碼。宣告式事務管理的方式缺點是，事務程式碼嚴重嵌入邏輯程式碼中 package com.cruise.service.impl; import org.springframewor

spring宣告式事務管理方式( 基於tx和aop名字空間的xml配置[email&#

轉自：https://www.cnblogs.com/niceyoo/p/8732891.html 1. 宣告式事務管理分類 宣告式事務管理也有兩種常用的方式， 一種是基於tx和aop名字空間的xml配置檔案，另一種就是基於@Transactional註解。 顯然基於註解的方式更簡單

9.spring：事務管理（下）:宣告式事務管理

宣告式事務管理  sprin的宣告式事務是管理AOP技術實現的事務管理，其本質是是對方法前後進行攔截，然後 在目標方法開始之前建立或者加入一個事務，在執行完成目標方法之後根據執行情況提交或者回滾事務。   宣告式事務管理優點：不需要通過程式設計的方式管理事務，因而不需要在業務邏輯程

spring事務管理之四：宣告式事務管理：使用事務註解的方式

事務註解的方式，相對xml的方式來說，有優點，無需配置需要事務的業務方法的切點和事務屬性。但是也有缺點，就是需要在每個需要事務的業務方法上加上一個註解@Transaction，否則事務不會生效。 這裡沿用之前spring事務管理的程式碼： pom.xml依賴部分： <depen

spring事務管理之三：宣告式事務管理：使用xml配置檔案的方式

這種方式是開發中常見的一種方式：利用aop的思想，將需要事務管理的業務方法通過xml配置的方式，將事務管理加在該類的相關方法上。這種方法的優點是，一次xml配置，後期不用關心業務類增加或者減少，通過xml中配置的匹配資訊，會去找業務類所在的包和方法，然後加上事務。 重點是配置<tx:a

spring事務管理之二：宣告式事務管理：使用代理方式

spring宣告式事務管理，分為三種方式,分別是： 1、使用代理類TransactionProxyFactoryBean的方式 2、使用aspectj+xml配置的方式 3、使用事務註解的方式 其中後面兩種是比較常用的，使用xml和註解的方式。 這裡介紹使用代理類Transa

Spring宣告式事務管理、事務的傳播行為xml配置

 1. <tx:method name="insert*" propagation="REQUIRED" />中name的值是ServiceImpl中各個要加入事物管理的方法的方法名。 <!-- 事務管理： Spring宣告式事務管理 。

全面分析 Spring 的程式設計式事務管理及宣告式事務管理

Spring 事務屬性分析 事務管理對於企業應用而言至關重要。它保證了使用者的每一次操作都是可靠的，即便出現了異常的訪問情況，也不至於破壞後臺資料的完整性。就像銀行的自助取款機，通常都能正常為客戶服務，但是也難免遇到操作過程中機器突然出故障的情況，此時，事務就必須確保出

spring宣告式事務管理：基於註解的方式

1）在spring.xml中配置事務管理器DataSourceTransactionManager，<bean id="txManager" class="org.springframework.

全面分析 Spring 的程式設計式事務管理及宣告式事務管理(1)

也許你會奇怪，為什麼介面只提供了獲取屬性的方法，而沒有提供相關設定屬性的方法。其實道理很簡單，事務屬性的設定完全是程式設計師控制的，因此程式設計師可以自定義任何設定屬性的方法，而且儲存屬性的欄位也沒有任何要求。唯一的要求的是，Spring 進行事務操作的時候，通過呼叫以上介面提供的方法必須能夠返回事務相關的

Spring宣告式事務管理及事務巢狀

一>  事務配置 Spring動態代理的一個重要特徵是，它是針對介面的，所以我們的dao要通過動態代理來讓spring接管事務，就必須在dao前面抽象出一個介面，當然如果沒有這樣的介面，那麼spring會使用CGLIB來解決問題。     一般地，使用Spri