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

/***作者：张荣华(ahuaxuan) *2007-06-16 *转载请注明出处及作者*/

出自：http://www.iteye.com/topic/87426

简介：事务是所有企业应用系统的核心，之前人们使用ejb的时候，容器事务管理(CMT)，是slsb最令人称道的地方，据说很多人使用ejb，使用slsb就是为了cmt，但是spring出现之后，格局就变了，因为程序员又多了一种选择，就是声明式事务管理，声明式事务管理是基于AOP的，及AOP是它的底层特性，本文的目的就是为了和大家探讨一下spring的声明式事务管理，从源代码来分析它的背后的思想。

这个是我昨天在解决问题是看源码得一点体验，可能说得比较大概，希望大家多多讨论，把本贴得质量提高上去，因为spring实现的事务管理这部分我相信还是有点复杂的。一个人未必能想得十分清楚，在spring的声明式事务管理中，它是如何判定一个及标记一个方法是否应该是处在事务体之中呢。

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

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

代码

1.       /**  

2.        * Support a current transaction; create a new one if none exists.  

3.        * Analogous to EJB transaction attribute of the same name.  

4.        * <p>This is typically the default setting of a transaction definition.  

5.        */  

6.       int PROPAGATION_REQUIRED = 0;  

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

代码

1.       /**  

2.        * A constant indicating that dirty reads are prevented; non-repeatable reads   

3.        * And phantom reads can occur. This level only prohibits a transaction   

4.        * From reading a row with uncommitted changes in it.   

5.        * @see java.sql.Connection#TRANSACTION_READ_COMMITTED   

6.        */   

7.       int ISOLATION_READ_COMMITTED   = Connection.TRANSACTION_READ_COMMITTED;  

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

代码

1.       /**

2.        * Return the propagation behavior.  

3.        * Must return one of the PROPAGATION constants.  

4.        * @see #PROPAGATION_REQUIRED  

5.        * @see org.springframework.transaction.support.TransactionSynchronizationManager#isActualTransactionActive()  

6.        */  

7.       int getPropagationBehavior();   

8.         

9.       /**  

10.     * Return the isolation level.  

11.     * Must return one of the ISOLATION constants.  

12.     * <p>Only makes sense in combination with PROPAGATION_REQUIRED or  

13.     * PROPAGATION_REQUIRES_NEW.  

14.     * <p>Note that a transaction manager that does not support custom  

15.     * isolation levels will throw an exception when given any other level  

16.     * than ISOLATION_DEFAULT.  

17.     * @see #ISOLATION_DEFAULT  

18.     */  

19.    int getIsolationLevel();  

这个接口有一个默认的实现DefaultTransactionDefinition。然后它还有子类，比如说 DefaultTransactionAttribute。Spring在判断一个方法是否需要事务体的时候其实是创建一个TransactionAttribute实现的实例.

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

代码

1.       /**  

2.            * Create a transaction if necessary.  

3.            * @param method method about to execute  

4.            * @param targetClass class the method is on  

5.            * @return a TransactionInfo object, whether or not a transaction was created.  

6.            * The hasTransaction() method on TransactionInfo can be used to tell if there  

7.            * was a transaction created.  

8.            */  

9.           protected TransactionInfo createTransactionIfNecessary(Method method, Class targetClass) {   

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

11.            final TransactionAttribute sourceAttr =   

12.                    this.transactionAttributeSource.getTransactionAttribute(method, targetClass);//就是在这里判断了这个方法的事务属性   

13.            TransactionAttribute txAttr = sourceAttr;   

14.      

15.            // If no name specified, apply method identification as transaction name.   

16.            if (txAttr != null && txAttr.getName() == null) {   

17.                final String name = methodIdentification(method);   

18.                txAttr = new DelegatingTransactionAttribute(sourceAttr) {   

19.                    public String getName() {   

20.                        return name;   

21.                    }   

22.                };   

23.            }   

24.      

25.            TransactionInfo txInfo = new TransactionInfo(txAttr, method);   //TransactionInfo是TransactionAspectSupport的一个内部类，它的主要功能是记录方法和对应的事务属性   

26.            if (txAttr != null) {   

27.                // We need a transaction for this method   

28.                if (logger.isDebugEnabled()) {   

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

30.                }   

31.      

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

33.                txInfo.newTransactionStatus(this.transactionManager.getTransaction(txAttr));//这个方法要仔细的看   

34.            }   

35.            else {   

36.                // The TransactionInfo.hasTransaction() method will return   

37.                // false. We created it only to preserve the integrity of   

38.                // the ThreadLocal stack maintained in this class.   

39.                if (logger.isDebugEnabled())   

40.                    logger.debug("Don't need to create transaction for [" + methodIdentification(method) +   

41.                            "]: this method isn't transactional");   

42.            }   

43.      

44.            // We always bind the TransactionInfo to the thread, even if we didn't create   

45.            // a new transaction here. This guarantees that the TransactionInfo stack   

46.            // will be managed correctly even if no transaction was created by this aspect.   

47.            txInfo.bindToThread();   

48.            return txInfo;   

49.    }  

 

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

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

 

代码

      public Object invoke(MethodInvocation invocation) throws Throwable {  

1.       // Work out the target class: may be <code>null</code>.   

2.       // The TransactionAttributeSource should be passed the target class   

3.       // as well as the method, which may be from an interface   

4.               Class targetClass = (invocation.getThis() != null) ? invocation.getThis().getClass() : null;   

5.                  

6.               // Create transaction if necessary.   

7.               TransactionInfo txInfo = createTransactionIfNecessary(invocation.getMethod(), targetClass);   

8.         

9.               Object retVal = null;   

10.            try {   

11.                // This is an around advice.   

12.                // Invoke the next interceptor in the chain.   

13.                // This will normally result in a target object being invoked.   

14.                retVal = invocation.proceed();   

15.            }   

16.            catch (Throwable ex) {   

17.                // target invocation exception   

18.                doCloseTransactionAfterThrowing(txInfo, ex);   

19.                throw ex;   

20.            }   

21.            finally {   

22.                doFinally(txInfo);   

23.            }   

24.            doCommitTransactionAfterReturning(txInfo);//在这里执行方法结束之后需要的操作   

25.            return retVal;  

这个方法就如同一般的interceptor需要实现的方法一样。只不过在这个方法里判断被反射的方法是否需要事务。