在spring的声明式事务管理中它是如何判定一个及标记一个方法是否应该是处在事务体之中呢
首先要理解的是spring是如何来标记一个方法是否应该处在事务体之中的有这样一个接口TransactionDefinition其中定义了很多常量它还有一个子接口TransactionAttribute其中只有一个方法rollback
TransactionDefinition中有很多常量定义它们分别属于两种类型传播途径和隔离级别
代码
/**
*Supportacurrenttransactioncreateanewoneifnoneexists
*AnalogoustoEJBtransactionattributeofthesamename
*
Thisistypicallythedefaultsettingofatransactiondefinition
*/
intPROPAGATION_REQUIRED=;
当然其中也定义了隔离级别
/**
代码
*Aconstantindicatingthatdirtyreadsareprevented;nonrepeatablereads
*andphantomreadscanoccurThislevelonlyprohibitsatransaction
*fromreadingarowwithuncommittedchangesinit
*@seejavasqlConnection#TRANSACTION_READ_COMMITTED
*/
intISOLATION_READ_COMMITTED=ConnectionTRANSACTION_READ_COMMITTED;
同时还有两个对应的方法来得到这样的传播途径和隔离级别
代码
/**
*Returnthepropagationbehavior
*MustreturnoneofthePROPAGATIONconstants
*@see#PROPAGATION_REQUIRED
*@seeorgspringframeworktransactionsupportTransactionSynchronization
Manager#isActualTransactionActive()
*/
intgetPropagationBehavior();
/**
*Returntheisolationlevel
*MustreturnoneoftheISOLATIONconstants
*
OnlymakessenseincombinationwithPROPAGATION_REQUIREDor
*PROPAGATION_REQUIRES_NEW
*
Notethatatransactionmanagerthatdoesnotsupportcustom
*isolationlevelswillthrowanexceptionwhengivenanyotherlevel
*thanISOLATION_DEFAULT
*@see#ISOLATION_DEFAULT
*/
intgetIsolationLevel();
这个接口有一个默认的实现DefaultTransactionDefinition然后它还有子类比如说
DefaultTransactionAttributeSpring在判断一个方法是否需要事务体的时候其实是创建一个TransactionAttribute实现的实例
有了上面的简单介绍就可以进入真正判断是否需要事务的地方了这个方法在TransactionAspectSupport类里
代码
/** *Createatransactionifnecessary *@parammethodmethodabouttoexecute *@paramtargetClassclassthemethodison *@returnaTransactionInfoobjectwhetherornotatransactionwascreated *ThehasTransaction()methodonTransactionInfocanbeusedtotellifthere *wasatransactioncreated */protectedTransactionInfocreateTransactionIfNecessary(MethodmethodClasstargetClass){ //Ifthetransactionattributeisnullthemethodisnontransactional finalTransactionAttributesourceAttr= thistransactionAttributeSourcegetTransactionAttribute(methodtargetClass);//就是在这里判断了这个方法的事务属性 TransactionAttributetxAttr=sourceAttr; //Ifnonamespecifiedapplymethodidentificationastransactionname if(txAttr!=null&&txAttrgetName()==null){ finalStringname=methodIdentification(method); txAttr=newDelegatingTransactionAttribute(sourceAttr){ publicStringgetName(){ returnname; } }; } TransactionInfotxInfo=newTransactionInfo(txAttrmethod); //TransactionInfo是TransactionAspectSupport的一个内部类它的主要功能是记录方法和对应的事务属性 if(txAttr!=null){ //Weneedatransactionforthismethod if(loggerisDebugEnabled()){ loggerdebug(Gettingtransactionfor+txInfojoinpointIdentification()); } //Thetransactionmanagerwillflaganerrorifanincompatibletxalreadyexists txInfonewTransactionStatus(thistransactionManagergetTransaction(txAttr));//这个方法要仔细的看 } else{ //TheTransactionInfohasTransaction()methodwillreturn //falseWecreateditonlytopreservetheintegrityof //theThreadLocalstackmaintainedinthisclass if(loggerisDebugEnabled()) loggerdebug(Dontneedtocreatetransactionfor[+methodIdentification(method)+ ]:thismethodisnttransactional); } //WealwaysbindtheTransactionInfotothethreadevenifwedidntcreate //anewtransactionhereThisguaranteesthattheTransactionInfostack //willbemanagedcorrectlyevenifnotransactionwascreatedbythisaspect txInfobindToThread(); returntxInfo; }
TransactionInfo是TransactionAspectSupport的一个内部类它的主要功能是记录方法和对应的事务属性在上面这个方法的最后这个TransactionInfo对象被保存到当前线程中
而这个方法会在事务拦截器TransactionInterceptor中被调用TransactionInterceptor实际上是TransactionAspectSupport的子类看看其中的invoke方法
代码
//Workoutthetargetclass:maybenull
//TheTransactionAttributeSourceshouldbepassedthetargetclass
//aswellasthemethodwhichmaybefromaninterface
ClasstargetClass=(invocationgetThis()!=null)?invocationgetThis()getClass():null;
//Createtransactionifnecessary
TransactionInfotxInfo=createTransactionIfNecessary(invocationgetMethod()targetClass);
ObjectretVal=null;
try{
//Thisisanaroundadvice
//Invokethenextinterceptorinthechain
//Thiswillnormallyresultinatargetobjectbeinginvoked
retVal=invocationproceed();
}
catch(Throwableex){
//targetinvocationexception
doCloseTransactionAfterThrowing(txInfoex);
throwex;
}
finally{
doFinally(txInfo);
}
doCommitTransactionAfterReturning(txInfo);//在这里执行方法结束之后需要的操作
returnretVal;
这个方法就如同一般的interceptor需要实现的方法一样只不过在这个方法里判断被反射的方法是否需要事务
接着我们重点再回头看一下createTransactionIfNecessary方法里的这一句
txInfonewTransactionStatus(thistransactionManagergetTransaction(txAttr));
接着我们就应该去看看这个getTransaction方法了假设我们是使用hibernate其他类似看getTransaction之前我们来看一下这两类和一个接口
接口PlatformTransactionManager
抽象类public abstract class AbstractPlatformTransactionManager implements PlatformTransactionManager
类public class HibernateTransactionManager extends AbstractPlatformTransactionManager很明显这里有一个方法模板模式
那我们看一下AbstractPlatformTransactionManager中的getTransaction方法
代码
publicfinalTransactionStatusgetTransaction(TransactionDefinitiondefinition)throwsTransactionException{
Objecttransaction=doGetTransaction();//抽象方法也需要子类实现这个方法同样很重要
//Cachedebugflagtoavoidrepeatedchecks
booleandebugEnabled=loggerisDebugEnabled();
if(debugEnabled){
loggerdebug(Usingtransactionobject[+transaction+]);
}
if(definition==null){
//Usedefaultsifnotransactiondefinitiongiven
definition=newDefaultTransactionDefinition();
}
if(isExistingTransaction(transaction)){
//Existingtransactionfound>checkpropagationbehaviortofindouthowtobehave
returnhandleExistingTransaction(definitiontransactiondebugEnabled);
}
//Checkdefinitionsettingsfornewtransaction
if(definitiongetTimeout()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)这里（这是一个抽象方法，子类必须实现这个方法，
具体依赖于抽象，这个是对方法模板模式的一个概括。Tw.WiNGWIt.cOm），前面讲到我们假设是使用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=nnection();
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());
}
}
