Spring聲明式事務管理源碼解讀之事務開始

作者：ahuaxuan 2009-02-11 11:14:31

事務是所有企業應用系統的核心，之前人們使用EJB的時候，容器事務管理(CMT)，是SLSB最令人稱道的地方，據說很多人使用EJB，使用SLSB就是為了CMT，但是spring出現之后，格局就變了，因為程序員又多了一種選擇，就是聲明式事務管理，聲明式事務管理是基于AOP的，及AOP是它的底層特性，本文的目的就是為了和大家探討一下spring的聲明式事務管理，從源代碼來分析它的背后的思想。

相關文章：Spring聲明式事務管理源碼解讀之事務提交

在spring的聲明式事務管理中，它是如何判定一個及標記一個方法是否應該是處在事務體之中呢。

首先要理解的是spring是如何來標記一個方法是否應該處在事務體之中的。有這樣一個接口TransactionDefinition，其中定義了很多常量，它還有一個子接口TransactionAttribute，其中只有一個方法rollback。

TransactionDefinition中有很多常量定義，它們分別屬于兩種類型，傳播途徑和隔離級別

代碼：

/** 　　　*Supportacurrenttransaction,createanewoneifnoneexists. 　　　*AnalogoustoEJBtransactionattributeofthesamename. 　　　*

Thisistypicallythedefaultsettingofatransactiondefinition. 　　　*/　　　intPROPAGATION_REQUIRED=0;

當然其中也定義了隔離級別

/**

代碼

*Aconstantindicatingthatdirtyreadsareprevented;non-repeatablereads 　
*andphantomreadscanoccur.Thislevelonlyprohibitsatransaction 　
*fromreadingarowwithuncommittedchangesinit. 　
*@seejava.sql.Connection#TRANSACTION_READ_COMMITTED 　
*/ 　
intISOLATION_READ_COMMITTED　=Connection.TRANSACTION_READ_COMMITTED;

同時還有兩個對應的方法來得到這樣的傳播途徑和隔離級別

代碼

/** 　
　　*Returnthepropagationbehavior. 　
　　*MustreturnoneofthePROPAGATIONconstants. 　
　　*@see#PROPAGATION_REQUIRED 　
　　*@seeorg.springframework.transaction.support.TransactionSynchronization
Manager#isActualTransactionActive() 　
　　*/　
　　intgetPropagationBehavior(); 　
　　/** 　
　　*Returntheisolationlevel. 　
　　*MustreturnoneoftheISOLATIONconstants. 　
　　*

OnlymakessenseincombinationwithPROPAGATION_REQUIREDor 　
　　*PROPAGATION_REQUIRES_NEW. 　
　　*

Notethatatransactionmanagerthatdoesnotsupportcustom 　
　　*isolationlevelswillthrowanexceptionwhengivenanyotherlevel 　
　　*thanISOLATION_DEFAULT. 　
　　*@see#ISOLATION_DEFAULT 　
　　*/　
　　intgetIsolationLevel();　　

這個接口有一個默認的實現DefaultTransactionDefinition。然后它還有子類，比如說
DefaultTransactionAttribute。Spring在判斷一個方法是否需要事務體的時候其實是創建一個TransactionAttribute實現的實例.

有了上面的簡單介紹就可以進入真正判斷是否需要事務的地方了。這個方法在TransactionAspectSupport類里，

代碼

/** 　
　　*Createatransactionifnecessary. 　
　　*@parammethodmethodabouttoexecute 　
　　*@paramtargetClassclassthemethodison 　
　　*@returnaTransactionInfoobject,whetherornotatransactionwascreated. 　
　　*ThehasTransaction()methodonTransactionInfocanbeusedtotellifthere 　
　　*wasatransactioncreated. 　
　　*/　
　　protectedTransactionInfocreateTransactionIfNecessary(Methodmethod,ClasstargetClass){ 　
　　　　//Ifthetransactionattributeisnull,themethodisnon-transactional. 　
　　　　finalTransactionAttributesourceAttr= 　
　　　　　　　　this.transactionAttributeSource.getTransactionAttribute(method,targetClass);//就是在這里判斷了這個方法的事務屬性 　
　　　　TransactionAttributetxAttr=sourceAttr; 　
　　　　//Ifnonamespecified,applymethodidentificationastransactionname. 　
　　　　if(txAttr!=null&&txAttr.getName()==null){ 　
　　　　　　finalStringname=methodIdentification(method); 　
　　　　　　txAttr=newDelegatingTransactionAttribute(sourceAttr){ 　
　　　　　　　　publicStringgetName(){ 　
　　　　　　　　　　returnname; 　
　　　　　　　　} 　
　　　　　　}; 　
　　　　} 　
　　　　TransactionInfotxInfo=newTransactionInfo(txAttr,method); 　
//TransactionInfo是TransactionAspectSupport的一個內部類，它的主要功能是記錄方法和對應的事務屬性 　
　　　　if(txAttr!=null){ 　
　　　　　　//Weneedatransactionforthismethod 　
　　　　　　if(logger.isDebugEnabled()){ 　
　　　　　　　　logger.debug("Gettingtransactionfor"+txInfo.joinpointIdentification()); 　
　　　　　　} 　
　　　　　　//Thetransactionmanagerwillflaganerrorifanincompatibletxalreadyexists 　
　　　　　　txInfo.newTransactionStatus(this.transactionManager.getTransaction(txAttr));//這個方法要仔細的看 　
　　　　} 　
　　　　else{ 　
　　　　　　//TheTransactionInfo.hasTransaction()methodwillreturn 　
　　　　　　//false.Wecreateditonlytopreservetheintegrityof 　
　　　　　　//theThreadLocalstackmaintainedinthisclass. 　
　　　　　　if(logger.isDebugEnabled()) 　
　　　　　　　　logger.debug("Don'tneedtocreatetransactionfor["+methodIdentification(method)+ 　
　　　　　　　　　　　　"]:thismethodisn'ttransactional"); 　
　　　　} 　
　　　　//WealwaysbindtheTransactionInfotothethread,evenifwedidn'tcreate 　
　　　　//anewtransactionhere.ThisguaranteesthattheTransactionInfostack 　
　　　　//willbemanagedcorrectlyevenifnotransactionwascreatedbythisaspect. 　
　　　　txInfo.bindToThread(); 　
　　　　returntxInfo; 　
　　}

TransactionInfo是TransactionAspectSupport的一個內部類，它的主要功能是記錄方法和對應的事務屬性，在上面這個方法的***，這個TransactionInfo對象被保存到當前線程中。

#p#

而這個方法會在事務攔截器TransactionInterceptor中被調用，TransactionInterceptor實際上是TransactionAspectSupport的子類，看看其中的invoke方法：

代碼

//Workoutthetargetclass:maybenull. 　
　　　　//TheTransactionAttributeSourceshouldbepassedthetargetclass 　
　　　　//aswellasthemethod,whichmaybefromaninterface 　
　　　　ClasstargetClass=(invocation.getThis()!=null)?invocation.getThis().getClass():null; 　
　　　　　
　　　　//Createtransactionifnecessary. 　
　　　　TransactionInfotxInfo=createTransactionIfNecessary(invocation.getMethod(),targetClass); 　
　　　　ObjectretVal=null; 　
　　　　try{ 　
　　　　　　//Thisisanaroundadvice. 　
　　　　　　//Invokethenextinterceptorinthechain. 　
　　　　　　//Thiswillnormallyresultinatargetobjectbeinginvoked. 　
　　　　　　retVal=invocation.proceed(); 　
　　　　} 　
　　　　catch(Throwableex){ 　
　　　　　　//targetinvocationexception 　
　　　　　　doCloseTransactionAfterThrowing(txInfo,ex); 　
　　　　　　throwex; 　
　　　　} 　
　　　　finally{ 　
　　　　　　doFinally(txInfo); 　
　　　　} 　
　　　　doCommitTransactionAfterReturning(txInfo);//在這里執行方法結束之后需要的操作　
　　　　returnretVal;　

這個方法就如同一般的interceptor需要實現的方法一樣。只不過在這個方法里判斷被反射的方法是否需要事務。

接著我們重點再回頭看一下createTransactionIfNecessary方法里的這一句：

txInfo.newTransactionStatus(this.transactionManager.getTransaction(txAttr));

接著我們就應該去看看這個getTransaction方法了，假設我們是使用hibernate3，其他類似。看getTransaction之前我們來看一下這兩類和一個接口

接口PlatformTransactionManager

抽象類public abstract class AbstractPlatformTransactionManager implements PlatformTransactionManager

類public class HibernateTransactionManager extends AbstractPlatformTransactionManager，很明顯，這里有一個方法模板模式。

那我們看一下AbstractPlatformTransactionManager中的getTransaction方法：

代碼

publicfinalTransactionStatusgetTransaction(TransactionDefinitiondefinition)throwsTransactionException{ 　
　　　　Objecttransaction=doGetTransaction();//抽象方法，也需要子類實現,這個方法同樣很重要　
　　　　//Cachedebugflagtoavoidrepeatedchecks. 　
　　　　booleandebugEnabled=logger.isDebugEnabled(); 　
　　　　if(debugEnabled){ 　
　　　　　　logger.debug("Usingtransactionobject["+transaction+"]"); 　
　　　　} 　
　　　　if(definition==null){ 　
　　　　　　//Usedefaultsifnotransactiondefinitiongiven. 　
　　　　　　definition=newDefaultTransactionDefinition(); 　
　　　　} 　
　　　　if(isExistingTransaction(transaction)){ 　
　　　　　　//Existingtransactionfound->checkpropagationbehaviortofindouthowtobehave. 　
　　　　　　returnhandleExistingTransaction(definition,transaction,debugEnabled); 　
　　　　} 　
　　　　//Checkdefinitionsettingsfornewtransaction. 　
　　　　if(definition.getTimeout()　　　　　　thrownewInvalidTimeoutException("Invalidtransactiontimeout",definition.getTimeout()); 　
　　　　} 　
　　　　//Noexistingtransactionfound->checkpropagationbehaviortofindouthowtobehave. 　
　　　　if(definition.getPropagationBehavior()==TransactionDefinition.PROPAGATION_MANDATORY){ 　
　　　　　　thrownewIllegalTransactionStateException( 　
　　　　　　　　　　"Transactionpropagation'mandatory'butnoexistingtransactionfound"); 　
　　　　} 　
　　　　elseif(definition.getPropagationBehavior()==TransactionDefinition.PROPAGATION_REQUIRED|| 　
　　　　　　　　definition.getPropagationBehavior()==TransactionDefinition.PROPAGATION_REQUIRES_NEW|| 　
　　　　　　definition.getPropagationBehavior()==TransactionDefinition.PROPAGATION_NESTED){ 　
　　　　　　if(debugEnabled){ 　
　　　　　　　　logger.debug("Creatingnewtransactionwithname["+definition.getName()+"]"); 　
　　　　　　} 　
　　　　　　doBegin(transaction,definition); 　
　　　　　　booleannewSynchronization=(this.transactionSynchronization!=SYNCHRONIZATION_NEVER); 　
　　　　　　returnnewTransactionStatus(definition,transaction,true,newSynchronization,debugEnabled,null); 　
　　　　} 　
　　　　else{ 　
　　　　　　//Create"empty"transaction:noactualtransaction,butpotentiallysynchronization. 　
　　　　　　booleannewSynchronization=(this.transactionSynchronization==SYNCHRONIZATION_ALWAYS); 　
　　　　　　returnnewTransactionStatus(definition,null,false,newSynchronization,debugEnabled,null); 　
　　　　} 　
　　}　

上面的代碼很多地方都有解釋，所以很好理解，這段代碼的關鍵部分在doBegin(transaction,definition)這里（這是一個抽象方法，子類必須實現這個方法，

具體依賴于抽象，這個是對方法模板模式的一個概括。），前面講到我們假設是使用hibernate，那么就看看HibernateTransactionManager這個類吧，doBegin里的參數1，transaction其實是HibernateTransactionObject的一個實例，這個實例里主要存放的就是sessionholder，sessionholder里存放的就是開始事務的session和transaction對象,如果之前沒有sessionholder存放到線程中，那么這個HibernateTransactionObject的實例的屬性其實是空的，這一點可以在doBegin方法的實現中看出來

代碼

protectedvoiddoBegin(Objecttransaction,TransactionDefinitiondefinition){ 　
　　　　if(getDataSource()!=null&&TransactionSynchronizationManager.hasResource(getDataSource())){ 　
　　　　　　thrownewIllegalTransactionStateException( 　
　　　　　　　　　　"Pre-boundJDBCConnectionfound-HibernateTransactionManagerdoesnotsupport"+ 　
　　　　　　　　　　"runningwithinDataSourceTransactionManageriftoldtomanagetheDataSourceitself."+ 　
　　　　　　　　　　"ItisrecommendedtouseasingleHibernateTransactionManagerforalltransactions"+ 　
　　　　　　　　　　"onasingleDataSource,nomatterwhetherHibernateorJDBCaccess."); 　
　　　　} 　
　　　　Sessionsession=null; 　
　　　　try{ 　
　　　　　　HibernateTransactionObjecttxObject=(HibernateTransactionObject)transaction; 　
　　　　　　if(txObject.getSessionHolder()==null){ 　
　　　　　　　　InterceptorentityInterceptor=getEntityInterceptor(); 　
　　　　　　　　SessionnewSession=(entityInterceptor!=null? 　
　　　　　　　　　　　　getSessionFactory().openSession(entityInterceptor):getSessionFactory().openSession()); 　
　　　　　　　　if(logger.isDebugEnabled()){ 　
　　　　　　　　　　logger.debug("OpenednewSession["+newSession+"]forHibernatetransaction"); 　
　　　　　　　　} 　
　　　　　　　　txObject.setSessionHolder(newSessionHolder(newSession),true);}//

我們看到，如果傳進來的transaction中并沒有存放sessionholder，那么就新建一個session，放到新的sessionholder中，再放到HibernateTransactionObject的實例中去,順便說一下，這個變量的名字取得真是差，雖然是Juergen Hoeller寫的，也要批一下，搞得別人會以為是Transaction的實例

代碼

txObject.getSessionHolder().setSynchronizedWithTransaction(true); 　
　　　　　　session=txObject.getSessionHolder().getSession(); 　
　　　　　　Connectioncon=session.connection(); 　
　　　　　　IntegerpreviousIsolationLevel=DataSourceUtils.prepareConnectionForTransaction(con,definition); 　
　　　　　　txObject.setPreviousIsolationLevel(previousIsolationLevel); 　
　　　　　　if(definition.isReadOnly()&&txObject.isNewSessionHolder()){ 　
　　　　　　　　//JustsettoNEVERincaseofanewSessionforthistransaction. 　
　　　　　　　　session.setFlushMode(FlushMode.NEVER); 　
　　　　　　}//如果是只讀事務，并且sessionholder是新建的，那么就設置hibernate的flushmode為never 　
　　　　　　if(!definition.isReadOnly()&&!txObject.isNewSessionHolder()){ 　
　　　　　　　　//WeneedAUTOorCOMMITforanon-read-onlytransaction. 　
　　　　　　　　FlushModeflushMode=session.getFlushMode(); 　
　　　　　　　　if(FlushMode.NEVER.equals(flushMode)){ 　
　　　　　　　　　　session.setFlushMode(FlushMode.AUTO); 　
//如果session的flushmode是nerver，就設置為auto，因為如果事務定義成非readonly，那么這個session一定是可以flush的　
　　　　　　　　　　txObject.getSessionHolder().setPreviousFlushMode(flushMode); 　
　　　　　　　　} 　
　　　　　　} 　
　　　　　　//AddtheHibernatetransactiontothesessionholder. 　
　　　　　　txObject.getSessionHolder().setTransaction(session.beginTransaction())；//開始一個事務，并把這個事務對象放到sessionholder中，隨后這個sessionholder會通過threadlocal放到線程中，以供在commit時使用　
　　　　　　//Registertransactiontimeout. 　
　　　　　　if(definition.getTimeout()!=TransactionDefinition.TIMEOUT_DEFAULT){ 　
　　　　　　　　txObject.getSessionHolder().setTimeoutInSeconds(definition.getTimeout());//設置超時時間,如果其超時時間為-1，則不進行設置，如果不是-1，那么超時時間是這樣設置的newDate(System.currentTimeMillis()+millis*1000);既程序員在配置文件中指定的其實是秒數　
　　　　　　} 　
　　　　　　//RegistertheHibernateSession'sJDBCConnectionfortheDataSource,ifset. 　
　　　　　　if(getDataSource()!=null){ 　
　　　　　　　　ConnectionHolderconHolder=newConnectionHolder(con); 　
　　　　　　　　if(definition.getTimeout()!=TransactionDefinition.TIMEOUT_DEFAULT){ 　
　　　　　　　　　　conHolder.setTimeoutInSeconds(definition.getTimeout()); 　
　　　　　　　　} 　
　　　　　　　　if(logger.isDebugEnabled()){ 　
　　　　　　　　　　logger.debug("ExposingHibernatetransactionasJDBCtransaction["+con+"]"); 　
　　　　　　　　} 　
　　　　　　　　TransactionSynchronizationManager.bindResource(getDataSource(),conHolder); 　
　　　　　　　　txObject.setConnectionHolder(conHolder); 　
　　　　　　} 　
　　　　　　//Bindthesessionholdertothethread. 　
　　　　　　if(txObject.isNewSessionHolder()){ 　
　　　　　　　　TransactionSynchronizationManager.bindResource(getSessionFactory(),txObject.getSessionHolder());//如果是新的sessionholder則綁定到線程。這樣在進入方法棧中的下一個方法時就能得到整個sessionholder了，connectionholder亦是如此　
　　　　　　} 　
　　　　} 　
catch(Exceptionex){ 　
　　　　　　SessionFactoryUtils.releaseSession(session,getSessionFactory());//如果拋出異常就釋放這個session,這個操作還會在后面出現　
　　　　　　thrownewCannotCreateTransactionException("CouldnotopenHibernateSessionfortransaction",ex); 　
　　　　} 　
　　}

通過以上對代碼的注釋可以知道，如果給service設置聲明式事務管理，假設事務傳播途徑為required，然后一個service調用另一個service時，他們其實是共用一個session，原則是沒有就創建，有就不創建，并返回之前已創建的session和transaction。也就是說spring通過threadlocal把session和對應的transaction放到線程之中，保證了在整個方法棧的任何一個地方都能得到同一個session和transaction。

所以如果你的方法在事務體之內，那么你只要通過hibernatesupportdao或者hibernatetemplate來得到session的話，那這個session一定是開始事務的那個session，這個得到session的主要方法在SessionFactoryUtils里，我們來看一下

（這里還有一個小細節，public abstract class SessionFactoryUtils ，Juergen Hoeller在寫工具類的時候為了不能讓其有實例使用的是abstract，而我們一般的做法是final類加private的構造方法，看上去不怎么雅觀,看看源代碼還是能學習到不少寫代碼的技巧的）

在SessionFactoryUtils的doGetSession里寫到，如果當前線程有綁定session，則返回這個session，如果沒有綁定session，則看是否允許創建（既allowCreate這個參數是true還是false，這個參數將會在很多地方設計到，比如說hibernatetemplate和hibernatedaosupport里都有），如果不允許創建就拋出一個原始的hibernateException，舉個例子，如果你沒有給某個service方法配置聲明式事務管理，而卻要在這個service所調用的dao里得到當前得session，這樣就會報這個錯了：

代碼

if(method.getName().equals("getCurrentSession")){ 　
　　　　　　　　//HandlegetCurrentSessionmethod:returntransactionalSession,ifany. 　
　　　　　　　　try{ 　
　　　　　　　　　　returnSessionFactoryUtils.doGetSession((SessionFactory)proxy,false); 　
//***一個參數是false，說明這個方法不能返回一個新的session，沒有就拋異常 　
　　　　　　　　} 　
　　　　　　　　catch(IllegalStateExceptionex){ 　
　　　　　　　　　　thrownewHibernateException(ex.getMessage()); 　
　　　　　　　　} 　
　　　　　　}

【編輯推薦】

Spring聲明式事務管理源碼解讀之事務提交
Spring中XML配置的12個技巧
Spring MVC框架的高級配置
如何在Java Web應用中獲取Spring的ApplicationContext

責任編輯：楊鵬飛來源： javaeye

事務管理事務開始 Spring Java

成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看

Spring聲明式事務管理源碼解讀之事務開始