Spring声明式事务管理源码解读之事务开始

开发 后端
事务是所有企业应用系统的核心,之前人们使用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());  
        }  
      }  

【编辑推荐】

  1. Spring声明式事务管理源码解读之事务提交
  2. Spring中XML配置的12个技巧
  3. Spring MVC框架的高级配置
  4. 如何在Java Web应用中获取Spring的ApplicationContext
责任编辑:杨鹏飞 来源: javaeye
相关推荐

2009-02-11 13:08:29

事务提交事务管理Spring

2024-11-13 19:03:14

2009-06-22 09:01:57

Spring声明式事务

2023-10-08 08:28:10

Spring事务管理

2009-06-17 14:57:11

Spring事务管理

2009-06-30 16:57:42

Spring事务管理

2023-03-27 10:40:09

2009-06-08 17:56:00

SpringJDBC事务

2014-08-25 09:12:47

Spring事务管理

2023-05-06 07:29:49

Spring事务传播

2021-09-06 13:42:14

Spring声明式事务

2010-03-29 13:34:15

ibmdwSpring

2009-09-25 12:59:53

Hibernate事务

2010-03-23 08:46:40

Spring

2009-06-17 14:43:47

Spring框架Spring事务管理

2009-06-03 10:20:11

Hibernate事务管理配置

2009-09-23 17:48:00

Hibernate事务

2009-09-29 09:44:52

Hibernate事务

2023-04-28 08:21:36

SpringBoot声明式事务编程式事务

2020-10-19 11:05:17

SpringTransaction事务
点赞
收藏

51CTO技术栈公众号