前言

事务指逻辑上的一组操作，组成这组操作的每个操作，如果成功则全部成功，如果失败则全部失败。
在IT行业的信息系统说，操作具体是指一段方法或函数的执行。
而界定信息系统操作的成功与否，是与信息的是否正常更新有关。
对信息化技术而言，要保证信息正常更新就一定要满足ACID四大特征：

原子性（Atomicity）
一致性（Consistency）
隔离性（Isolation）
持久性（Durability）
而因为其事务的持久化特征,事务往往由具有持久化功能的中间件来完成，最典型的中间件就是关系型数据库。
而在系统中，我们主要是关心如何来做事务管理，所谓的事务管理即：
事务控制的范围与边界。
事务传播级别的控制。
事务的提交与回滚。
下面我们通过Spring申明式事务管理为例，来看一下Spring是如何去对事务进行管理的，及Spring内部是如何实现的。

Spring申明式事务管理配置

下面我们以关系型数据库Mysql为例，来说明Spring对申明式事务管理。

导入相关依赖

Spring基础组件（IOC,DI,ASPECT):

        
            org.springframework
            spring-context
        
        
        
            org.springframework
            spring-aspects

数据源

数据库驱动

        
        
            mysql
            mysql-connector-java
            5.1.44

spring-jdbc(该组件会引入所依赖的spring-tx组件包）

        
            org.springframework
            spring-jdbc

配置数据库及事务管理

创建一个配置类，使用注解@EnableTransactionManagement开启事务管理

@EnableTransactionManagement
@Configuration
public class TransactionConfig {

在配置类中创建数据源

    @Bean
    public DataSource dataSource() throws Exception{
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser("");
        dataSource.setPassword("");
        dataSource.setDriverClass("com.mysql.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
        return dataSource;
    }

创建对数据源的事务管理器

    @Bean
    public PlatformTransactionManager transactionManager() throws Exception{
        return new DataSourceTransactionManager(dataSource());
    }

在业务中应用事务

对指定方法应用事务管理

    @Transactional
    public void insertUser(){

对指定接口所有方法应用事务管理

@Service
@Transactional
public class UserService {

并且可以通过@Transactional注解属性，对事务进行控制:

propagation 控制传播级别
isolation 隔离级别
rollbackFor 回滚机制

源码分析Spring申明式事务管理实现方法

EnableTransactionManagement

通过@EnableTransactionManagement注解引入选择器TransactionManagementConfigurationSelector；

@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement {

选择器TransactionManagementConfigurationSelector根据事务管理模式引入AutoProxyRegistrar和ProxyTransactionManagementConfiguration两个类；

    protected String[] selectImports(AdviceMode adviceMode) {
        switch (adviceMode) {
            case PROXY:
                return new String[] {AutoProxyRegistrar.class.getName(), ProxyTransactionManagementConfiguration.class.getName()};

AutoProxyRegistrar

其中AutoProxyRegistrar注册一个InfrastructureAdvisorAutoProxyCreator类；

    public static BeanDefinition registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {
        return registerOrEscalateApcAsRequired(InfrastructureAdvisorAutoProxyCreator.class, registry, source);
    }

InfrastructureAdvisorAutoProxyCreator利用后置处理器机制在对象创建以后，包装对象，返回一个代理对象（增强器），代理对象执行方法利用拦截器链进行调用；

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
        implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {

ProxyTransactionManagementConfiguration

配置类ProxyTransactionManagementConfiguration给容器中注册事务增强器BeanFactoryTransactionAttributeSourceAdvisor

    @Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor() {
        BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
        advisor.setTransactionAttributeSource(transactionAttributeSource());
        advisor.setAdvice(transactionInterceptor());
        advisor.setOrder(this.enableTx.getNumber("order"));
        return advisor;
    }

事务增强器需要TransactionAttributeSource类实例解析事务注解，

    @Bean
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public TransactionAttributeSource transactionAttributeSource() {
        return new AnnotationTransactionAttributeSource();
    }

以及TransactionInterceptor类：

    @Bean
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public TransactionInterceptor transactionInterceptor() {
        TransactionInterceptor interceptor = new TransactionInterceptor();
        interceptor.setTransactionAttributeSource(transactionAttributeSource());
        if (this.txManager != null) {
            interceptor.setTransactionManager(this.txManager);
        }
        return interceptor;
    }

事务拦截器TransactionInterceptor的实例是一个方法拦截器：

public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor, Serializable {

拦截器方法在目标方法执行的时候执行拦截器链：

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

        // 先获取事务相关的属性
        final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(method, targetClass);
               //再获取PlatformTransactionManager，如果事先没有添加指定任何transactionmanger,最终会从容器中按照类型获取一个PlatformTransactionManager；
        final PlatformTransactionManager tm = determineTransactionManager(txAttr);
        final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

        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 {
                // 执行目标方法
                retVal = invocation.proceedWithInvocation();
            }
            catch (Throwable ex) {
                //如果异常，获取到事务管理器，利用事务管理回滚操作；
                completeTransactionAfterThrowing(txInfo, ex);
                throw ex;
            }
            finally {
                                //如果正常，利用事务管理器，提交事务
                cleanupTransactionInfo(txInfo);
            }
            commitTransactionAfterReturning(txInfo);
            return retVal;
        }

Spring-申明式事务管理

前言