spring 事务

　　在Spring的事务处理模块中，可以看到的类层次结构如下

　　从图6-1中可以看到，Spring事务处理模块是通过AOP功能来实现声明式事务处理的，比如事务属性的

配置和读取，事务对象的抽象等。因此，在Spring事务处理中，可以通过设计一个

TransactionProxyFactoryBean来使用AOP功能，通过这个TransactionProxyFactoryBean可以生成Proxy代理

对象，在这个代理对象中，通过TransactionInterceptor来完成对代理方法的拦截，正是这些AOP的拦截功能

，将事务处理的功能编织进来。在Spring事务处理中，在实现声明式事务处理时，这是AOP和IoC模块集成的

部分。对于具体的事务处理实现，比如事务的生成、提交、回滚、挂起等，由于不同的底层数据库有不同的

支持方式，因此，在Spring的事务处理中，对主要的事务实现做了一个抽象和适配。适配的具体事务处理器

包含：对DataSource数据源的事务处理支持，对Hibernate数据源的事务处理支持，对JDO数据源的事务处理

支持，对JPA和JTA等数据源的事务处理支持等。这一系列的事务处理支持，都是通过设计PlatformTransactio

-nManager、AbstractPlatformTransactionManager以及一系列具体事务处理器来实现的，而PlatfromTransac

-tionManager又在TransactionInterceptor被包含，通过这样一个接口实现设计，就把这一系列的事务处理的

实现与前面提到的TransactionProxyFactoryBean结合起来，从而形成了一个Spring声明式事务处理的设计

体系

配置demo

<bean id="baseProxyFactory" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
          abstract="true">
        <property name="transactionManager"><ref local="mockMan"/></property>
        <property name="transactionAttributes">
            <props>
                <prop key="s*">PROPAGATION_MANDATORY</prop>
                <prop key="setAg*">  PROPAGATION_REQUIRED  ,  readOnly  </prop>
                <prop key="set*">PROPAGATION_SUPPORTS</prop>
            </props>
        </property>
    </bean>

    <bean id="proxyFactory2DynamicProxy" parent="baseProxyFactory">
        <property name="target"><ref local="target"/></property>
    </bean>

    <!--
        Same as proxyFactory2DynamicProxy but forces the use of CGLIB.
    -->
    <bean id="proxyFactory2Cglib" parent="baseProxyFactory">
        <property name="proxyTargetClass"><value>true</value></property>
        <property name="target"><ref local="target"/></property>
    </bean>

    <bean id="proxyFactory2Lazy" parent="baseProxyFactory">
        <property name="target">
            <bean class="org.springframework.aop.target.LazyInitTargetSource">
                <property name="targetBeanName"><idref local="target"/></property>        
            </bean>
        </property>
    </bean>

    <bean id="proxyFactory3" parent="baseProxyFactory">
        <property name="target"><ref local="target"/></property>
        <property name="proxyTargetClass"><value>true</value></property>
        <property name="pointcut">
            <ref local="txnInvocationCounterPointcut"/>
        </property>
        <property name="preInterceptors">
            <list>
                <ref local="preInvocationCounterInterceptor"/>
            </list>
        </property>
        <property name="postInterceptors">
            <list>
                <ref local="postInvocationCounterInterceptor"/>
            </list>
        </property>
    </bean>

声明式事务处理的实现大致可以分为以下几个部分

　　1）读取和处理在IoC容器中配置的事务处理属性，并转化为Spring事务处理需要的内部数据结构。具体

来说，这里涉及的类是TransactionAttributeSourceAdvisor，从名字可以看出，它是一个AOP通知器，Spring

使用这个通知器来完成对事务处理属性值的处理。处理的结果是，在IoC容器中配置的事务处理属性信息，会

被读入并转化成TransactionAttribute表示的数据对象，这个数据对象是Spring对事务处理属性值的数据抽象，

对这些属性的处理是和TransactionProxyFactoryBean拦截下来的事务方法的处理结合起来的。

　　2）Spring事务处理模块实现统一的事务处理过程。这个通用的事务处理过程包含处理事务配置属性，

以及与线程绑定完成事务处理的过程，Spring通过TransactionInfo和TransactionStatus这两个数据对象，在

事务处理过程中记录和传递相关执行场景。

　　3）底层的事务处理实现。对于底层的事务操作，Spring委托给具体的事务处理器来完成，这些具体的事

务处理器，就是在IoC容器中配置声明式事务处理时，配置的PlatformTransactionManager的具体实现，比如

DataSourceTransactionManager和HibernateTransactionManager等。

实现分析

在TransactionProxyFactoryBean中，在IoC容器进行注入的时候，会创建TransactionInterceptor对象，而这

个对象会创建一个TransactionAttributePointcut，为读取TransactionAtturbute做准备。在容器初始化的过程

中，由于实现了InitializingBean接口，因此AbstractSingletonProxyFactoryBean会实现afterPropertiesSet()

方法，正是在这个方法实例化了一个ProxyFactory，建立起Spring AOP的应用，在这里，会为这个Proxy

-Factory设置通知、目标对象，并最终返回Proxy代理对象。在Proxy代理对象建立起来以后，在调用其代理

方法的时候，会调用相应的TransactionInteceptor拦截器，在这个调用过程中，会根据TransactionAttribute

配置是事务属性进行配置，从而为事务处理做好准备。

 　　从TransactionProxyFactoryBean代码

/*
 * Copyright 2002-2014 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.transaction.interceptor;

import java.util.Properties;

import org.springframework.aop.Pointcut;
import org.springframework.aop.framework.AbstractSingletonProxyFactoryBean;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.transaction.PlatformTransactionManager;

/**
 * Proxy factory bean for simplified declarative transaction handling.
 * This is a convenient alternative to a standard AOP
 * {@link org.springframework.aop.framework.ProxyFactoryBean}
 * with a separate {@link TransactionInterceptor} definition.
 *
 * <p><strong>HISTORICAL NOTE:</strong> This class was originally designed to cover the
 * typical case of declarative transaction demarcation: namely, wrapping a singleton
 * target object with a transactional proxy, proxying all the interfaces that the target
 * implements. However, in Spring versions 2.0 and beyond, the functionality provided here
 * is superseded by the more convenient {@code tx:} XML namespace. See the <a
 * href="http://bit.ly/qUwvwz">declarative transaction management</a> section of the
 * Spring reference documentation to understand the modern options for managing
 * transactions in Spring applications. For these reasons, <strong>users should favor of
 * the {@code tx:} XML namespace as well as
 * the @{@link org.springframework.transaction.annotation.Transactional Transactional}
 * and @{@link org.springframework.transaction.annotation.EnableTransactionManagement
 * EnableTransactionManagement} annotations.</strong>
 *
 * <p>There are three main properties that need to be specified:
 * <ul>
 * <li>"transactionManager": the {@link PlatformTransactionManager} implementation to use
 * (for example, a {@link org.springframework.transaction.jta.JtaTransactionManager} instance)
 * <li>"target": the target object that a transactional proxy should be created for
 * <li>"transactionAttributes": the transaction attributes (for example, propagation
 * behavior and "readOnly" flag) per target method name (or method name pattern)
 * </ul>
 *
 * <p>If the "transactionManager" property is not set explicitly and this {@link FactoryBean}
 * is running in a {@link ListableBeanFactory}, a single matching bean of type
 * {@link PlatformTransactionManager} will be fetched from the {@link BeanFactory}.
 *
 * <p>In contrast to {@link TransactionInterceptor}, the transaction attributes are
 * specified as properties, with method names as keys and transaction attribute
 * descriptors as values. Method names are always applied to the target class.
 *
 * <p>Internally, a {@link TransactionInterceptor} instance is used, but the user of this
 * class does not have to care. Optionally, a method pointcut can be specified
 * to cause conditional invocation of the underlying {@link TransactionInterceptor}.
 *
 * <p>The "preInterceptors" and "postInterceptors" properties can be set to add
 * additional interceptors to the mix, like
 * {@link org.springframework.aop.interceptor.PerformanceMonitorInterceptor}.
 *
 * <p><b>HINT:</b> This class is often used with parent / child bean definitions.
 * Typically, you will define the transaction manager and default transaction
 * attributes (for method name patterns) in an abstract parent bean definition,
 * deriving concrete child bean definitions for specific target objects.
 * This reduces the per-bean definition effort to a minimum.
 *
 * <pre code="class">
 * {@code
 * <bean id="baseTransactionProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
 *     abstract="true">
 *   <property name="transactionManager" ref="transactionManager"/>
 *   <property name="transactionAttributes">
 *     <props>
 *       <prop key="insert*">PROPAGATION_REQUIRED</prop>
 *       <prop key="update*">PROPAGATION_REQUIRED</prop>
 *       <prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
 *     </props>
 *   </property>
 * </bean>
 *
 * <bean id="myProxy" parent="baseTransactionProxy">
 *   <property name="target" ref="myTarget"/>
 * </bean>
 *
 * <bean id="yourProxy" parent="baseTransactionProxy">
 *   <property name="target" ref="yourTarget"/>
 * </bean>}</pre>
 *
 * @author Juergen Hoeller
 * @author Dmitriy Kopylenko
 * @author Rod Johnson
 * @author Chris Beams
 * @since 21.08.2003
 * @see #setTransactionManager
 * @see #setTarget
 * @see #setTransactionAttributes
 * @see TransactionInterceptor
 * @see org.springframework.aop.framework.ProxyFactoryBean
 */
@SuppressWarnings("serial")
public class TransactionProxyFactoryBean extends AbstractSingletonProxyFactoryBean
        implements BeanFactoryAware {

    private final TransactionInterceptor transactionInterceptor = new TransactionInterceptor();

    private Pointcut pointcut;


    /**
     * Set the transaction manager. This will perform actual
     * transaction management: This class is just a way of invoking it.
     * @see TransactionInterceptor#setTransactionManager
     */
    public void setTransactionManager(PlatformTransactionManager transactionManager) {
        this.transactionInterceptor.setTransactionManager(transactionManager);
    }

    /**
     * Set properties with method names as keys and transaction attribute
     * descriptors (parsed via TransactionAttributeEditor) as values:
     * e.g. key = "myMethod", value = "PROPAGATION_REQUIRED,readOnly".
     * <p>Note: Method names are always applied to the target class,
     * no matter if defined in an interface or the class itself.
     * <p>Internally, a NameMatchTransactionAttributeSource will be
     * created from the given properties.
     * @see #setTransactionAttributeSource
     * @see TransactionInterceptor#setTransactionAttributes
     * @see TransactionAttributeEditor
     * @see NameMatchTransactionAttributeSource
     */
    public void setTransactionAttributes(Properties transactionAttributes) {
        this.transactionInterceptor.setTransactionAttributes(transactionAttributes);
    }

    /**
     * Set the transaction attribute source which is used to find transaction
     * attributes. If specifying a String property value, a PropertyEditor
     * will create a MethodMapTransactionAttributeSource from the value.
     * @see #setTransactionAttributes
     * @see TransactionInterceptor#setTransactionAttributeSource
     * @see TransactionAttributeSourceEditor
     * @see MethodMapTransactionAttributeSource
     * @see NameMatchTransactionAttributeSource
     * @see org.springframework.transaction.annotation.AnnotationTransactionAttributeSource
     */
    public void setTransactionAttributeSource(TransactionAttributeSource transactionAttributeSource) {
        this.transactionInterceptor.setTransactionAttributeSource(transactionAttributeSource);
    }

    /**
     * Set a pointcut, i.e a bean that can cause conditional invocation
     * of the TransactionInterceptor depending on method and attributes passed.
     * Note: Additional interceptors are always invoked.
     * @see #setPreInterceptors
     * @see #setPostInterceptors
     */
    public void setPointcut(Pointcut pointcut) {
        this.pointcut = pointcut;
    }

    /**
     * This callback is optional: If running in a BeanFactory and no transaction
     * manager has been set explicitly, a single matching bean of type
     * {@link PlatformTransactionManager} will be fetched from the BeanFactory.
     * @see org.springframework.beans.factory.BeanFactory#getBean(Class)
     * @see org.springframework.transaction.PlatformTransactionManager
     */
    public void setBeanFactory(BeanFactory beanFactory) {
        this.transactionInterceptor.setBeanFactory(beanFactory);
    }


    /**
     * Creates an advisor for this FactoryBean's TransactionInterceptor.
     */
    @Override
    protected Object createMainInterceptor() {
        this.transactionInterceptor.afterPropertiesSet();
        if (this.pointcut != null) {
            return new DefaultPointcutAdvisor(this.pointcut, this.transactionInterceptor);
        }
        else {
            // Rely on default pointcut.
            return new TransactionAttributeSourceAdvisor(this.transactionInterceptor);
        }
    }

}

　　以上代码完成了AOP配置，对于用户来说，一个值得关心的问题是，Spring的TransactionInterceptor

配置是在什么时候被启动并成为Advisor通知器的一部分的呢？从对createMainInterceptor方法的调用分析

这个createMainInterceptor方法在IoC容器完成Bean的依赖注入时，通过initializeBean方法被调用

TransactionInterceptor中invoke方法

public Object invoke(final MethodInvocation invocation) throws Throwable {
        // Work out the target class: may be {@code 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 ? AopUtils.getTargetClass(invocation.getThis()) : null);

        // Adapt to TransactionAspectSupport's invokeWithinTransaction...
        return invokeWithinTransaction(invocation.getMethod(), targetClass, new InvocationCallback() {
            public Object proceedWithInvocation() throws Throwable {
                return invocation.proceed();
            }
        });
    }


protected Object invokeWithinTransaction(Method method, Class targetClass, final InvocationCallback invocation)
            throws Throwable {

        // If the transaction attribute is null, the method is non-transactional.
        final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(method, targetClass);
        final PlatformTransactionManager tm = determineTransactionManager(txAttr);
        final String joinpointIdentification = methodIdentification(method, targetClass);

        if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
            // Standard transaction demarcation with getTransaction and commit/rollback calls.
            TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
            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.proceedWithInvocation();
            }
            catch (Throwable ex) {
                // target invocation exception
                completeTransactionAfterThrowing(txInfo, ex);
                throw ex;
            }
            finally {
                cleanupTransactionInfo(txInfo);
            }
            commitTransactionAfterReturning(txInfo);
            return retVal;
        }

        else {
            // It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
            try {
                Object result = ((CallbackPreferringPlatformTransactionManager) tm).execute(txAttr,
                        new TransactionCallback<Object>() {
                            public Object doInTransaction(TransactionStatus status) {
                                TransactionInfo txInfo = prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
                                try {
                                    return invocation.proceedWithInvocation();
                                }
                                catch (Throwable ex) {
                                    if (txAttr.rollbackOn(ex)) {
                                        // A RuntimeException: will lead to a rollback.
                                        if (ex instanceof RuntimeException) {
                                            throw (RuntimeException) ex;
                                        }
                                        else {
                                            throw new ThrowableHolderException(ex);
                                        }
                                    }
                                    else {
                                        // A normal return value: will lead to a commit.
                                        return new ThrowableHolder(ex);
                                    }
                                }
                                finally {
                                    cleanupTransactionInfo(txInfo);
                                }
                            }
                        });

                // Check result: It might indicate a Throwable to rethrow.
                if (result instanceof ThrowableHolder) {
                    throw ((ThrowableHolder) result).getThrowable();
                }
                else {
                    return result;
                }
            }
            catch (ThrowableHolderException ex) {
                throw ex.getCause();
            }
        }
    }