spring事务原理

事务有原子性、一致性、隔离性、持久性的特点，在开发中我们将一组不可分割的操作放在事务中，要么一起成功，要么一起失败，例如最简单的转账，我们看一下spring是如何实现事务管理的。

spring事务的关键对象

spring的事务实现中有几个关键对象，我们先来认识一下:

PlatformTransactionManager

事务管理器接口只有三个方法：

1588492786428.jpg

getTransaction：获取当前激活的事务或者创建一个事务
commit：提交当前事务
rollback：回滚当前事务

PlatformTransactionManager有很多具体的实现：

DataSourceTransactionManager，使用JDBC与ibatis进行持久化
JtaTransactionManager：使用分布式事务
JpaTransactionManager：使用jpa
HibernateTransactionManager：使用hibernate

TransactionDefiition

TransactionDefiition是事务属性的定义，其中包含事务的隔离级别、事务传播类型、事务过期时间、事务是否可读等事务信息。

image

spring的隔离级别和数据库的是对应的，只是多了一个ISOLATION_DEFAULT类型，表示使用mysql默认隔离级别。

spring的事务传播类型如下：

常量名称	常量解释
PROPAGATION_REQUIRED	支持当前事务，如果当前没有事务，就新建一个事务
PROPAGATION_REQUIRES_NEW	新建事务，如果当前存在事务，把当前事务挂起。新建的事务将和被挂起的事务没有任何关系，是两个独立的事务，外层事务失败回滚之后，不能回滚内层事务执行的结果，内层事务失败抛出异常，外层事务捕获，也可以不处理回滚操作
PROPAGATION_SUPPORTS	支持当前事务，如果当前没有事务，就以非事务方式执行
PROPAGATION_MANDATORY	使用当前事务，如果当前没有事务，就抛出异常
PROPAGATION_NOT_SUPPORTED	以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
PROPAGATION_NEVER	以非事务方式执行，如果当前存在事务，则抛出异常。
PROPAGATION_NESTED	如果当前存在事务，则运行在一个嵌套的事务中。如果没有事务，则按REQUIRED属性执行。它使用了一个单独的事务，这个事务拥有多个可以回滚的保存点。内部事务的回滚不会对外部事务造成影响。它只对DataSourceTransactionManager事务管理器起效

事务的具体实现

我们用一个简单的例子看一下spring的事务是如何实现的

新建一个账户表，包含几个基本字段，金额、姓名等

CREATE TABLE `account` (
  `ID` int(11) NOT NULL AUTO_INCREMENT,
  `count` int(11) NOT NULL DEFAULT '0',
  `name` varchar(400) DEFAULT NULL COMMENT '姓名',
  `update` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`ID`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

新建一个springboot工程，引入jdbc与mysql的依赖

新建一个service，在用一个controller调用此service的转账方法

@Service
public class AccountService {

    private JdbcTemplate jdbctemplate;

    public AccountService(DataSource dataSource){
        jdbctemplate = new JdbcTemplate(dataSource);
    }

    @Transactional
    public int update(int count,int fromId,int toId){
        int update = jdbctemplate.update("update account set count = count-? where id=?", count, fromId);
//        int i = 0 / 0;
        jdbctemplate.update("update account set count = count+? where id=?", count, toId);
        return update;
    }

}

为了探究spring是如何实现事务的，我们通过tcpdump抓mysql的包来看执行的语句

 //楼主是mac环境
 sudo tcpdump -i lo0  -s 0 -l -w -  port 3306 | strings

我们执行用户1给用户2转账5元，看到抓包结果为

image

可以看到，在第一个语句执行前设置为手动提交，在所有语句执行完后执行commit，最后再设置成自动提交。

如果中间执行失败呢，我们将 int i = 0 / 0;这行的注释打开，制造一个RuntimeException，看看执行结果

image

事务被执行回滚了。

分析事务代码

spring中可以用aop注入TransactionInterceptor，或者像前面的例子一样，在需要事务管理的方法上加上注解@Transactional，spring在此方法执行时会执行个方法的interceptor集合，事务的interceptor是org.springframework.transaction.interceptor.TransactionInterceptor，它继承自TransactionAspectSupport，事务的具体实现在TransactionAspectSupport中。

image

TransactionInterceptor在执行时会调用方法invoke

@Override
    @Nullable
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
        return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
    }

在invokeWithinTransaction中会调用createTransactionIfNecessary方法

protected TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm,
            @Nullable TransactionAttribute txAttr, final String joinpointIdentification) {

        // 设置事务名称
        if (txAttr != null && txAttr.getName() == null) {
            txAttr = new DelegatingTransactionAttribute(txAttr) {
                @Override
                public String getName() {
                    return joinpointIdentification;
                }
            };
        }

        TransactionStatus status = null;
        if (txAttr != null) {
            if (tm != null) {
        //获取事务状态
                status = tm.getTransaction(txAttr);
            }
            else {
                if (logger.isDebugEnabled()) {
                    logger.debug("Skipping transactional joinpoint [" + joinpointIdentification +
                            "] because no transaction manager has been configured");
                }
            }
        }
    //填充事务信息
        return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
    }

tm.getTransaction(txAttr);这里会使用具体持久化方式对应的那个TransactionManager，楼主使用的Jdbc，实现是DataSourceTransactionManager，getTransaction方法调用的是父类中的方法

org.springframework.transaction.support.AbstractPlatformTransactionManager#getTransaction

@Override
    public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition)
            throws TransactionException {

        //如果TransactionDefinition为空则使用默认配置
        TransactionDefinition def = (definition != null ? definition : TransactionDefinition.withDefaults());

        Object transaction = doGetTransaction();
        boolean debugEnabled = logger.isDebugEnabled();

        if (isExistingTransaction(transaction)) {
            //如果有存在的事务，则处理存在的事物
            return handleExistingTransaction(def, transaction, debugEnabled);
        }

        // 判断事务是否超时
        if (def.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
            throw new InvalidTimeoutException("Invalid transaction timeout", def.getTimeout());
        }

        // 使用PROPAGATION_MANDATORY这个级别，没有可用的事务则抛异常
        if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
            throw new IllegalTransactionStateException(
                    "No existing transaction found for transaction marked with propagation 'mandatory'");
        }
        else if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
                def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
                def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
            SuspendedResourcesHolder suspendedResources = suspend(null);
            if (debugEnabled) {
                logger.debug("Creating new transaction with name [" + def.getName() + "]: " + def);
            }
            try {
        //根据隔离级别开始事务
                return startTransaction(def, transaction, debugEnabled, suspendedResources);
            }
            catch (RuntimeException | Error ex) {
                resume(null, suspendedResources);
                throw ex;
            }
        }
        else {
            // Create "empty" transaction: no actual transaction, but potentially synchronization.
            if (def.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {
                logger.warn("Custom isolation level specified but no actual transaction initiated; " +
                        "isolation level will effectively be ignored: " + def);
            }
            boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
            return prepareTransactionStatus(def, null, true, newSynchronization, debugEnabled, null);
        }
    }

startTransaction会调用DataSourceTransactionManager的doBegin方法设置当前连接为手动提交事务

@Override
    protected void doBegin(Object transaction, TransactionDefinition definition) {
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
        Connection con = null;

        try {
      //获取数据库连接
            if (!txObject.hasConnectionHolder() ||
                    txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
                Connection newCon = obtainDataSource().getConnection();
                if (logger.isDebugEnabled()) {
                    logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
                }
                txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
            }

            txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
            con = txObject.getConnectionHolder().getConnection();

            Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
            txObject.setPreviousIsolationLevel(previousIsolationLevel);
            txObject.setReadOnly(definition.isReadOnly());

            //如果连接是自动提交，则设置成手动
            if (con.getAutoCommit()) {
                txObject.setMustRestoreAutoCommit(true);
                if (logger.isDebugEnabled()) {
                    logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
                }
        //这里会和数据库通信
                con.setAutoCommit(false);
            }

            prepareTransactionalConnection(con, definition);
            txObject.getConnectionHolder().setTransactionActive(true);

            int timeout = determineTimeout(definition);
            if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
                txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
            }

            // Bind the connection holder to the thread.
            if (txObject.isNewConnectionHolder()) {
                TransactionSynchronizationManager.bindResource(obtainDataSource(), txObject.getConnectionHolder());
            }
        }

        catch (Throwable ex) {
            if (txObject.isNewConnectionHolder()) {
                DataSourceUtils.releaseConnection(con, obtainDataSource());
                txObject.setConnectionHolder(null, false);
            }
            throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);
        }
    }

再看回org.springframework.transaction.interceptor.TransactionAspectSupport#invokeWithinTransaction方法，这里显示了aop如何处理事务

if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
        
            //获取事务
            TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);

            Object retVal;
            try {
                //触发后面的拦截器和方法本身
                retVal = invocation.proceedWithInvocation();
            }
            catch (Throwable ex) {
                // 捕获异常处理回滚
                completeTransactionAfterThrowing(txInfo, ex);
                throw ex;
            }
            finally {
        //重置threadLocal中事务状态
                cleanupTransactionInfo(txInfo);
            }
            //省略
            ...
            return retVal;
        }

再看一下completeTransactionAfterThrowing方法，如果是需要回滚的异常则执行回滚，否则执行提交

protected void completeTransactionAfterThrowing(@Nullable TransactionInfo txInfo, Throwable ex) {
        if (txInfo != null && txInfo.getTransactionStatus() != null) {
            if (logger.isTraceEnabled()) {
                logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() +
                        "] after exception: " + ex);
            }
            //需要回滚的异常
            if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) {
                try {
                    //执行回滚
                    txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());
                }
                catch (TransactionSystemException ex2) {
                    logger.error("Application exception overridden by rollback exception", ex);
                    ex2.initApplicationException(ex);
                    throw ex2;
                }
                catch (RuntimeException | Error ex2) {
                    logger.error("Application exception overridden by rollback exception", ex);
                    throw ex2;
                }
            }
            else {
                try {
                    //提交
                    txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
                }
                catch (TransactionSystemException ex2) {
                    logger.error("Application exception overridden by commit exception", ex);
                    ex2.initApplicationException(ex);
                    throw ex2;
                }
                catch (RuntimeException | Error ex2) {
                    logger.error("Application exception overridden by commit exception", ex);
                    throw ex2;
                }
            }
        }
    }

总结

spring中的事务实现从原理上说比较简单，通过aop在方法执行前后增加数据库事务的操作。
1、在方法开始时判断是否开启新事务，需要开启事务则设置事务手动提交 set autocommit=0;
2、在方法执行完成后手动提交事务 commit;
3、在方法抛出指定异常后调用rollback回滚事务
spring事务管理有很多细节的处理，如传播方式的实现，感兴趣的同学自己去看看源码喽~