Spring声明式事务管理源码解读(2)

tombaby

接着我们重点再回头看一下createTransactionIfNecessary方法里的这一句：
txInfo.newTransactionStatus(this.transactionManager.getTransaction(txAttr));
接着我们就应该去看看这个getTransaction方法了，假设我们是使用hibernate3，其他类似。看getTransaction之前我们来看一下这两类和一个接口：
接口PlatformTransactionManager
抽象类public abstract class AbstractPlatformTransactionManager implements PlatformTransactionManager
类public class HibernateTransactionManager extends AbstractPlatformTransactionManager，很明显，这里有一个方法模板模式。
那我们看一下AbstractPlatformTransactionManager中得getTransaction方法：

代码
1.       public final TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException {   
2.               Object transaction = doGetTransaction();//抽象方法，也需要子类实现,这个方法同样很重要   
3.         
4.               // Cache debug flag to avoid repeated checks.   
5.               boolean debugEnabled = logger.isDebugEnabled();   
6.               if (debugEnabled) {   
7.                   logger.debug("Using transaction object [" + transaction + "]");   
8.               }   
9.         
10.            if (definition == null) {   
11.                // Use defaults if no transaction definition given.   
12.                definition = new DefaultTransactionDefinition();   
13.            }   
14.      
15.            if (isExistingTransaction(transaction)) {   
16.                // Existing transaction found -> check propagation behavior to find out how to behave.   
17.                return handleExistingTransaction(definition, transaction, debugEnabled);   
18.            }   
19.      
20.            // Check definition settings for new transaction.   
21.            if (definition.getTimeout()
22.                throw new InvalidTimeoutException("Invalid transaction timeout", definition.getTimeout());   
23.            }   
24.      
25.            // No existing transaction found -> check propagation behavior to find out how to behave.   
26.            if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {   
27.                throw new IllegalTransactionStateException(   
28.                        "Transaction propagation 'mandatory' but no existing transaction found");   
29.            }   
30.            else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||   
31.                    definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||   
32.                definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {   
33.                if (debugEnabled) {   
34.                    logger.debug("Creating new transaction with name [" + definition.getName() + "]");   
35.                }   
36.                doBegin(transaction, definition);   
37.                boolean newSynchronization = (this.transactionSynchronization != SYNCHRONIZATION_NEVER);   
38.                return newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, null);   
39.            }   
40.            else {   
41.                // Create "empty" transaction: no actual transaction, but potentially synchronization.   
42.                boolean newSynchronization = (this.transactionSynchronization == SYNCHRONIZATION_ALWAYS);   
43.                return newTransactionStatus(definition, null, false, newSynchronization, debugEnabled, null);   
44.            }   
45.    }  

上面的代码很多地方都有解释，所以很好理解，这段代码的关键部分在doBegin(transaction,definition)这里（这是一个抽象方法，子类必须实现这个方法，具体依赖于抽象，这个是对方法模板模式的一个概括。），前面讲到我们假设是使用hibernate，那么就看看HibernateTransactionManager这个类吧，doBegin里的参数1，transaction其实是HibernateTransactionObject的一个实例，这个实例里主要存放的就是sessionholder，sessionholder里存放的就是开始事务的session和transaction对象,如果之前没有sessionholder存放到线程中，那么这个HibernateTransactionObject的实例的属性其实是空的，这一点可以在doBegin方法的实现中看出来

代码
1.       protected void doBegin(Object transaction, TransactionDefinition definition) {   
2.               if (getDataSource() != null && TransactionSynchronizationManager.hasResource(getDataSource())) {   
3.                   throw new IllegalTransactionStateException(   
4.                           "Pre-bound JDBC Connection found - HibernateTransactionManager does not support " +   
5.                           "running within DataSourceTransactionManager if told to manage the DataSource itself. " +   
6.                           "It is recommended to use a single HibernateTransactionManager for all transactions " +   
7.                           "on a single DataSource, no matter whether Hibernate or JDBC access.");   
8.               }   
9.         
10.            Session session = null;   
11.      
12.            try {   
13.                HibernateTransactionObject txObject = (HibernateTransactionObject) transaction;   
14.                if (txObject.getSessionHolder() == null) {   
15.                    Interceptor entityInterceptor = getEntityInterceptor();   
16.                    Session newSession = (entityInterceptor != null ?   
17.                            getSessionFactory().openSession(entityInterceptor) : getSessionFactory().openSession());   
18.                    if (logger.isDebugEnabled()) {   
19.                        logger.debug("Opened new Session [" + newSession + "] for Hibernate transaction");   
20.                    }   
21.             txObject.setSessionHolder(new SessionHolder(newSession), true);  
22.           }//我们看到，如果传进来的transaction中并没有存放sessionholder，那么就新建一个session，放到新的sessionholder中，再放到HibernateTransactionObject的实例中去,顺便说一下，这个变量的名字取得真是差，虽然是Juergen Hoeller写的，也要批一下，搞得别人会以为是Transaction的实例
23.           txObject.getSessionHolder().setSynchronizedWithTransaction(true);   
24.                session = txObject.getSessionHolder().getSession();   
25.      
26.                Connection con = session.connection();   
27.                Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);   
28.                txObject.setPreviousIsolationLevel(previousIsolationLevel);   
29.      
30.                if (definition.isReadOnly() && txObject.isNewSessionHolder()) {   
31.                    // Just set to NEVER in case of a new Session for this transaction.   
32.                    session.setFlushMode(FlushMode.NEVER);   
33.                }//如果是只读事务，并且sessionholder是新建的，那么就设置hibernate的flushmode为never   
34.      
35.                if (!definition.isReadOnly() && !txObject.isNewSessionHolder()) {   
36.                    // We need AUTO or COMMIT for a non-read-only transaction.   
37.                    FlushMode flushMode = session.getFlushMode();   
38.                    if (FlushMode.NEVER.equals(flushMode)) {   
39.                        session.setFlushMode(FlushMode.AUTO);   //如果session的flushmode是nerver，就设置为auto，因为如果事务定义成非readonly，那么这个session一定是可以flush的   
40.                        txObject.getSessionHolder().setPreviousFlushMode(flushMode);   
41.                    }   
42.                }   
43.      
44.                // Add the Hibernate transaction to the session holder.   
45.                txObject.getSessionHolder().setTransaction(session.beginTransaction())；//开始一个事务，并把这个事务对象放到sessionholder中，随后这个sessionholder会通过threadlocal放到线程中，以供在commit时使用   
46.      
47.                // Register transaction timeout.   
48.                if (definition.getTimeout() != TransactionDefinition.TIMEOUT_DEFAULT) {   
49.                    txObject.getSessionHolder().setTimeoutInSeconds(definition.getTimeout());//设置超时时间,如果其超时时间为-1，则不进行设置，如果不是-1，那么超时时间是这样设置的new Date(System.currentTimeMillis() + millis*1000);既程序员在配置文件中指定的其实是秒数   
50.                }   
51.      
52.                // Register the Hibernate Session's JDBC Connection for the DataSource, if set.   
53.                if (getDataSource() != null) {   
54.                    ConnectionHolder conHolder = new ConnectionHolder(con);   
55.                    if (definition.getTimeout() != TransactionDefinition.TIMEOUT_DEFAULT) {   
56.                        conHolder.setTimeoutInSeconds(definition.getTimeout());   
57.                    }   
58.                    if (logger.isDebugEnabled()) {   
59.                        logger.debug("Exposing Hibernate transaction as JDBC transaction [" + con + "]");   
60.                    }   
61.                    TransactionSynchronizationManager.bindResource(getDataSource(), conHolder);   
62.                    txObject.setConnectionHolder(conHolder);   
63.                }   
64.      
65.                // Bind the session holder to the thread.   
66.                if (txObject.isNewSessionHolder()) {   
67.                    TransactionSynchronizationManager.bindResource(getSessionFactory(), txObject.getSessionHolder());//如果是新的sessionholder则绑定到线程。这样在进入方法栈中的下一个方法时就能得到整个sessionholder了，connectionholder亦是如此   
68.                }   
69.            }  catch (Exception ex) {   
70.                SessionFactoryUtils.releaseSession(session, getSessionFactory());//如果抛出异常就释放这个session,这个操作还会在后面出现   
71.                throw new CannotCreateTransactionException("Could not open Hibernate Session for transaction", ex);   
72.            }   
73.    }  

通过以上对代码的注释可以知道，如果给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，这样就会抛这个错了：

代码
1.            if (method.getName().equals("getCurrentSession")) {   
2.                       // Handle getCurrentSession method: return transactional Session, if any.   
3.                       try {   
4.                           return SessionFactoryUtils.doGetSession((SessionFactory) proxy, false);   
5.                //最后一个参数是false，说明这个方法不能返回一个新的session，没有就抛异常   
6.                       } catch (IllegalStateException ex) {   
7.                           throw new HibernateException(ex.getMessage());   
8.                       }   
9.                   }  

到这里事务开始部分基本就结束了。
按正常流程，那么接下来就是方法结束commit的问题了。Commit放到下一篇文章里说吧，我会把大家正确得观点不断得加到贴中，使本贴得质量不断提高，共同进步吧，使劲的拍吧。俺写文章得水平是不行的，希望大家也多提提写文章技巧方面的意见。




本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u/12821/showart_467101.html