知识大全 Spring声明式事务管理源码解读之事务开始

Posted 2022-07-18 知

篇首语：读书是学习，摘抄是整理，写作是创造。本文由小常识网(cha138.com)小编为大家整理，主要介绍了知识大全 Spring声明式事务管理源码解读之事务开始相关的知识，希望对你有一定的参考价值。

Spring声明式事务管理源码解读之事务开始 以下文字资料是由(全榜网网www.cha138.com)小编为大家搜集整理后发布的内容，让我们赶快一起来看一下吧！

　　在spring的声明式事务管理中它是如何判定一个及标记一个方法是否应该是处在事务体之中呢

　　首先要理解的是spring是如何来标记一个方法是否应该处在事务体之中的有这样一个接口TransactionDefinition 其中定义了很多常量它还有一个子接口TransactionAttribute 其中只有一个方法rollback

　　TransactionDefinition中有很多常量定义它们分别属于两种类型传播途径和隔离级别

　　代码

　　 /** 　*Supportacurrenttransaction createanewoneifnoneexists 　*AnalogoustoEJBtransactionattributeofthesamename 　*

　　Thisistypicallythedefaultsettingofatransactiondefinition 　*/　intPROPAGATION_REQUIRED= ;

　　当然其中也定义了隔离级别

　　/**

　　代码

　　 *Aconstantindicatingthatdirtyreadsareprevented;non repeatablereads 　*andphantomreadscanoccur Thislevelonlyprohibitsatransaction 　*fromreadingarowwithunmittedchangesinit 　*@seejava sql Connection#TRANSACTION_READ_MITTED 　*/ 　intISOLATION_READ_MITTED　=Connection TRANSACTION_READ_MITTED;

　　同时还有两个对应的方法来得到这样的传播途径和隔离级别

　　代码

　　/** 　*Returnthepropagationbehavior 　*MustreturnoneofthePROPAGATIONconstants 　*@see#PROPAGATION_REQUIRED 　*@see springframework transaction support TransactionSynchronizationManager#isActualTransactionActive() 　*/　intgetPropagationBehavior(); 　/** 　*Returntheisolationlevel 　*MustreturnoneoftheISOLATIONconstants 　*

　　OnlymakessenseinbinationwithPROPAGATION_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()); 　　 //Thetransactionmanagerwillflaganerrorifaninpatibletxalreadyexists 　 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:maybe null 　//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方法了假设我们是使用hibernate 其他类似看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)这里（这是一个抽象方法，子类必须实现这个方法，

　　具体依赖于抽象，这个是对方法模板模式的一个概括。tW.WingWIT.），前面讲到我们假设是使用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."+ 　"ItisremendedtouseasingleHibernateTransactionManagerforalltransactions"+ 　"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()) 　//WeneedAUTOorMITforanon-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放到线程中，以供在mit时使用　//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()); 　　

cha138/Article/program/Java/ky/201311/28216