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

这个是我昨天在解决问题是看源码得一点体验，可能说得比较大概，希望大家多多讨 论，把本贴得质量提高上去，因为spring实现的事务管理这部分我相信还是有点复杂的。 一个人未必能想得十分清楚

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

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

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

代码

/**<br />* Support a current transaction, create a new one if none exists.<br />* Analogous to EJB transaction attribute of the same name.<br />* <p>This is typically the default setting of a transaction definition.<br />*/<br />int PROPAGATION_REQUIRED = 0;

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

/** * A constant indicating that dirty reads are prevented; non-repeatable reads* and phantom reads can occur. This level only prohibits a transaction* from reading a row with uncommitted changes in it.* @see java.sql.Connection#TRANSACTION_READ_COMMITTED*/int ISOLATION_READ_COMMITTED = Connection.TRANSACTION_READ_COMMITTED;

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

/*** Return the propagation behavior.* Must return one of the PROPAGATION constants.* @see #PROPAGATION_REQUIRED* @see org.springframework.transaction.support.TransactionSynchronizationManager#isAc tualTransactionActive()*/int getPropagationBehavior(); /*** Return the isolation level.* Must return one of the ISOLATION constants.*

Note that a transaction manager that does not support custom* isolation levels will throw an exception when given any other level* than ISOLATION_DEFAULT.* @see #ISOLATION_DEFAULT*/int getIsolationLevel();

这个接口有一个默认的实现DefaultTransactionDefinition。然后它还有子类，比如 说

DefaultTransactionAttribute。Spring在判断一个方法是否需要事务体的时候其实是 创建一个TransactionAttribute实现的实例.

有了上面的简单介绍就可以进入真正判断是否需要事务的地方了。这个方法在 TransactionAspectSupport类里，

/*** Create a transaction if necessary.* @param method method about to execute* @param targetClass class the method is on* @return a TransactionInfo object, whether or not a transaction was created.* The hasTransaction() method on TransactionInfo can be used to tell if there* was a transaction created.*/protected TransactionInfo createTransactionIfNecessary(Method method, Class targetClass) {// If the transaction attribute is null, the method is non-transactional.final TransactionAttribute sourceAttr =this.transactionAttributeSource.getTransactionAttribute(method, targetClass);//就是在这里判断了这个方法的事务属性TransactionAttribute txAttr = sourceAttr; // If no name specified, apply method identification as transaction name.if (txAttr != null && txAttr.getName() == null) {final String name = methodIdentification(method);txAttr = new DelegatingTransactionAttribute(sourceAttr) {public String getName() {return name;}};}TransactionInfo txInfo = new TransactionInfo(txAttr, method);//TransactionInfo是TransactionAspectSupport的一个内部类，它的主要功能是记录 方法和对应的事务属性if (txAttr != null) {// We need a transaction for this methodif (logger.isDebugEnabled()) {logger.debug("Getting transaction for " + txInfo.joinpointIdentification());}// The transaction manager will flag an error if an incompatible tx already existstxInfo.newTransactionStatus(this.transactionManager.getTransaction (txAttr));//这个方法要仔细的看}else {// The TransactionInfo.hasTransaction() method will return// false. We created it only to preserve the integrity of// the ThreadLocal stack maintained in this class.if (logger.isDebugEnabled())logger.debug("Don't need to create transaction for [" + methodIdentification(method) +"]: this method isn't transactional");}// We always bind the TransactionInfo to the thread, even if we didn't create// a new transaction here. This guarantees that the TransactionInfo stack// will be managed correctly even if no transaction was created by this aspect.txInfo.bindToThread();return txInfo;}

TransactionInfo是TransactionAspectSupport的一个内部类，它的主要功能是记录方 法和对应的事务属性，在上面这个方法的最后，这个TransactionInfo对象被保存到当前 线程中。

而这个方法会在事务拦截器TransactionIntercepTor中被调用， TransactionIntercepTor实际上是TransactionAspectSupport的子类，看看其中的invoke 方法：

// Work out the target class: may be null.// The TransactionAttributeSource should be passed the target class// as well as the method, which may be from an interfaceClass targetClass = (invocation.getThis() != null) ? invocation.getThis ().getClass() : null;// Create transaction if necessary.TransactionInfo txInfo = createTransactionIfNecessary(invocation.getMethod(), targetClass); Object retVal = null;try {// This is an around advice.// Invoke the next intercepTor in the chain.// This will normally result in a target object being invoked.retVal = invocation.proceed();}catch (Throwable ex) {// target invocation exceptiondoCloseTransactionAfterThrowing(txInfo, ex);throw ex;}finally {doFinally(txInfo);}doCommitTransactionAfterReturning(txInfo);//在这里执行方法结束之后需要的操作 return retVal;

这个方法就如同一般的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方法：

public final TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException {Object transaction = doGetTransaction();//抽象方法，也需要子类实现,这个方法同 样很重要 // Cache debug flag to avoid repeated checks.boolean debugEnabled = logger.isDebugEnabled();if (debugEnabled) {logger.debug("Using transaction object [" + transaction + "] ");}if (definition == null) {// Use defaults if no transaction definition given.definition = new DefaultTransactionDefinition();}if (isExistingTransaction(transaction)) {// Existing transaction found -> check propagation behavior. to find out how to behave.return handleExistingTransaction(definition, transaction, debugEnabled);}// Check definition settings for new transaction.if (definition.getTimeout() check propagation behavior. to find out how to behave.if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATorY) {throw new IllegalTransactionStateException("Transaction propagation 'mandaTory' but no existing transaction found");}else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {if (debugEnabled) {logger.debug("Creating new transaction with name [" + definition.getName() + "]");}doBegin(transaction, definition);boolean newSynchronization = (this.transactionSynchronization != SYNCHRONIZATION_NEVER);return newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, null);}else {// Create "empty" transaction: no actual transaction, but potentially synchronization.boolean newSynchronization = (this.transactionSynchronization == SYNCHRONIZATION_ALWAYS);return newTransactionStatus(definition, null, false, newSynchronization, debugEnabled, null);}}

上面的代码很多地方都有解释，所以很好理解，这段代码的关键部分在doBegin (transaction,definition)这里（这是一个抽象方法，子类必须实现这个方法，

具体依赖于抽象，这个是对方法模板模式的一个概括。），前面讲到我们假设是使用 hibernate，那么就看看HibernateTransactionManager这个类吧，doBegin里的参数1， transaction其实是HibernateTransactionObject的一个实例，这个实例里主要存放的就 是sessionholder，sessionholder里存放的就是开始事务的session和transaction对象, 如果之前没有sessionholder存放到线程中，那么这个HibernateTransactionObject的实 例的属性其实是空的，这一点可以在doBegin方法的实现中看出来

protected void doBegin(Object transaction, TransactionDefinition definition) {if (getDataSource() != null && TransactionSynchronizationManager.hasResource(getDataSource())) {throw new IllegalTransactionStateException("Pre-bound JDBC Connection found - HibernateTransactionManager does not support " +"running within DataSourceTransactionManager if told to manage the DataSource itself. " +"It is recommended to use a single HibernateTransactionManager for all transactions " +"on a single DataSource, no matter whether Hibernate or JDBC Access.");} Session session = null;try {HibernateTransactionObject txObject = (HibernateTransactionObject) transaction;if (txObject.getSessionHolder() == null) {IntercepTor entityIntercepTor = getEntityIntercepTor();Session newSession = (entityIntercepTor != null ?getSessionFacTory().openSession(entityIntercepTor) : getSessionFacTory ().openSession());if (logger.isDebugEnabled()) {logger.debug("Opened new Session [" + newSession + "] for Hibernate transaction");}txObject.setSessionHolder(new SessionHolder(newSession), true);

}//我们看到，如果传进来的transaction中并没有存放sessionholder，那么就新建一 个session，放到新的sessionholder中，再放到HibernateTransactionObject的实例中去 ,顺便说一下，这个变量的名字取得真是差，虽然是Juergen Hoeller写的，也要批一下， 搞得别人会以为是Transaction的实例

txObject.getSessionHolder().setSynchronizedWithTransaction(true);session = txObject.getSessionHolder().getSession(); Connection con = session.connection();Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);txObject.setPreviousIsolationLevel(previousIsolationLevel);if (definition.isReadOnly() && txObject.isNewSessionHolder()) {// Just set to NEVER in case of a new Session for this transaction.session.setFlushMode(FlushMode.NEVER);}//如果是只读事务，并且sessionholder是新建的，那么就设置hibernate的flushmode 为neverif (!definition.isReadOnly() && ! txObject.isNewSessionHolder()) {// We need AUTO or COMMIT for a non-read-only transaction.FlushMode flushMode = session.getFlushMode();if (FlushMode.NEVER.equals(flushMode)) {session.setFlushMode(FlushMode.AUTO);//如果session的flushmode是nerver，就设置为auto，因为如果事务定义成非readonly ，那么这个session一定是可以flush的txObject.getSessionHolder().setPreviousFlushMode(flushMode);}}// Add the Hibernate transaction to the session holder.txObject.getSessionHolder().setTransaction(session.beginTransaction())；//开 始一个事务，并把这个事务对象放到sessionholder中，随后这个sessionholder会通过 threadlocal放到线程中，以供在commit时使用// Register transaction timeout.if (definition.getTimeout() != TransactionDefinition.TIMEOUT_DEFAULT) {txObject.getSessionHolder().setTimeoutInSeconds(definition.getTimeout());// 设置超时时间,如果其超时时间为-1，则不进行设置，如果不是-1，那么超时时间是这样 设置的new Date(System.currentTimeMillis() + millis*1000);既程序员在配置文件中 指定的其实是秒数}// Register the Hibernate Session's JDBC Connection for the DataSource, if set.if (getDataSource() != null) {ConnectionHolder conHolder = new ConnectionHolder(con);if (definition.getTimeout() != TransactionDefinition.TIMEOUT_DEFAULT) {conHolder.setTimeoutInSeconds(definition.getTimeout());}if (logger.isDebugEnabled()) {logger.debug("Exposing Hibernate transaction as JDBC transaction [" + con + "]");}TransactionSynchronizationManager.bindResource(getDataSource(), conHolder);txObject.setConnectionHolder(conHolder);}// Bind the session holder to the thread.if (txObject.isNewSessionHolder()) {TransactionSynchronizationManager.bindResource(getSessionFacTory(), txObject.getSessionHolder());//如果是新的sessionholder则绑定到线程。这样在进入 方法栈中的下一个方法时就能得到整个sessionholder了，connectionholder亦是如此 }}catch (Exception ex) {SessionFacToryUtils.releaseSession(session, getSessionFacTory());//如果抛出 异常就释放这个session,这个操作还会在后面出现throw new CannotCreateTransactionException("Could not open Hibernate Session for transaction", 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的构造方法，看上去不怎么雅观,看看源代码还是能学习到不少写代码 的技巧的,这里还有一个插曲，上次feiing还说java为什么不能弄成final和abstract同时 存在呢，这样就可以确保既不会有实例产生，也不能继承了，呵呵）

在SessionFacToryUtils的doGetSession里写到，如果当前线程有绑定session，则返 回这个session，如果没有绑定session，则看是否允许创建（既allowCreate这个参数是 true还是false，这个参数将会在很多地方设计到，比如说hibernatetemplate和 hibernatedaosupport里都有），如果不允许创建就抛出一个原始的hibernateException ，举个例子，如果你没有给某个service方法配置声明式事务管理，而却要在这个service 所调用的dao里得到当前得session，这样就会抛这个错了：

if (method.getName().equals("getCurrentSession")) {// Handle getCurrentSession method: return transactional Session, if any.try {return SessionFacToryUtils.doGetSession((SessionFacTory) proxy, false);//最后一个参数是false，说明这个方法不能返回一个新的session，没有就抛异常}catch (IllegalStateException ex) {throw new HibernateException(ex.getMessage());}}

到这里事务开始部分基本就结束了

按正常流程，那么接下来就是方法结束commit的问题了。Commit放到下一篇文章里说 吧

在前进的路上，主动搬开别人脚下的绊脚石，有时往往也是为自己铺路。