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. 　
*

这个接口有一个默认的实现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对象被保存到当前线程中。

而这个方法会在事务拦截器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()<TRANSACTIONDEFINITION.TIMEOUT_DEFAULT){ 　
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声明式事务管理源码之事务开始的示例分析”这篇文章就分享到这里了，希望以上内容可以对大家有一定的帮助，让大家可以学到更多知识，如果觉得文章不错，可以把它分享出去让更多的人看到吧！