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

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

Java代码

intPROPAGATION_REQUIRED =0;

int PROPAGATION_REQUIRED = 0;

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

intISOLATION_READ_COMMITTED = Connection.TRANSACTION_READ_COMMITTED;

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

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

Java代码

intgetPropagationBehavior();

intgetIsolationLevel();

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

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

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

Java代码

protectedTransactionInfo createTransactionIfNecessary(Method method, Class targetClass) {

// If the transaction attribute is null, the method is non-transactional.

finalTransactionAttribute 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) {

finalString name = methodIdentification(method);

txAttr =newDelegatingTransactionAttribute(sourceAttr) {

publicString getName() {

returnname;

}

};

}

TransactionInfo txInfo =newTransactionInfo(txAttr, method);

//TransactionInfo是TransactionAspectSupport的一个内部类，它的主要功能是记录方法和对应的事务属性

if(txAttr !=null) {

// We need a transaction for this method

if(logger.isDebugEnabled()) {

logger.debug("Getting transaction for "+ txInfo.joinpointIdentification());

}

// The transaction manager will flag an error if an incompatible tx already exists

txInfo.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();

returntxInfo;

}

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

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

Java代码

// 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 interface

Class 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 exception

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方法：

Java代码

publicfinalTransactionStatus getTransaction(TransactionDefinition definition)throwsTransactionException {

Object transaction = doGetTransaction();//抽象方法，也需要子类实现,这个方法同样很重要

// Cache debug flag to avoid repeated checks.

booleandebugEnabled = logger.isDebugEnabled();

if(debugEnabled) {

logger.debug("Using transaction object ["+ transaction +"]");

}

if(definition ==null) {

// Use defaults if no transaction definition given.

definition =newDefaultTransactionDefinition();

}

if(isExistingTransaction(transaction)) {

// Existing transaction found -> check propagation behavior to find out how to behave.

returnhandleExistingTransaction(definition, transaction, debugEnabled);

}

// Check definition settings for new transaction.

if(definition.getTimeout()

thrownewInvalidTimeoutException("Invalid transaction timeout", definition.getTimeout());

}

// No existing transaction found -> check propagation behavior to find out how to behave.

if(definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {

thrownewIllegalTransactionStateException(

"Transaction propagation 'mandatory' but no existing transaction found");

}

elseif(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);

booleannewSynchronization = (this.transactionSynchronization != SYNCHRONIZATION_NEVER);

returnnewTransactionStatus(definition, transaction,true, newSynchronization, debugEnabled,null);

}

else{

// Create "empty" transaction: no actual transaction, but potentially synchronization.

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方法的实现中看出来

Java代码

protectedvoiddoBegin(Object transaction, TransactionDefinition definition) {

if(getDataSource() !=null&& TransactionSynchronizationManager.hasResource(getDataSource())) {

thrownewIllegalTransactionStateException(

"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(newSessionHolder(newSession),true);

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

Java代码

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为never

if(!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 =newConnectionHolder(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,这个操作还会在后面出现

thrownewCannotCreateTransactionException("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，这样就会抛这个错了：

Java代码

if(method.getName().equals("getCurrentSession")) {

// Handle getCurrentSession method: return transactional Session, if any.

try{

returnSessionFactoryUtils.doGetSession((SessionFactory) proxy,false);

//最后一个参数是false，说明这个方法不能返回一个新的session，没有就抛异常

}

catch(IllegalStateException ex) {

thrownewHibernateException(ex.getMessage());

}

}