Spring中的@Transactional注解

小伙伴们对数据库编程感兴趣吗？是否正在学习相关知识点？如果是，那么本文《Spring中的@Transactional注解》，就很适合你，本篇文章讲解的知识点主要包括MySQL、Java、事务。在之后的文章中也会多多分享相关知识点，希望对大家的知识积累有所帮助！

什么是事务

数据库的事务是一种机制、一个操作序列，包含了数据库操作命令。事务把所有的命令做为一个整体一起向系统提交或撤销操作请求，即这一组命令要么成功，要么失败。

事务的4个特性（ACID）：

1. 原子性

事务是一个完整的操作。事务内的各元素是不可分割的。事务中的元素必须作为一个整体提交或回滚。如果事务中的任何元素失败，整个事务将失败。

2. 一致性

在事务开始前，数据必须处于一致状态；在事务结束后，数据的状态也必须保持一致。通过事务对数据所做的修改不能损坏数据。

3. 隔离性

事务的执行不受其他事务的干扰，事务执行的中间结果对其他事务必须是透明的。

4. 持久性

对于提交的事务，系统必须保证事务对数据库的改变不被丢失，即使数据库发生故障。

如何实现事务

在目前的业务开发过程中，都是以Spring框架为主。Spring支持两种方式的事务管理

    @Autowired
    private PlatformTransactionManager transactionManager;

    @Override
    public Map saveResource(MultipartFile file) {

        TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());
        try {
            // 相关业务
            
            // 手动提交
            transactionManager.commit(status);
        } catch (Exception e) {
            log.error("Exception:{}", ExceptionUtil.stacktraceToString(e));
            // 发生异常时进行回滚
            transactionManager.rollback(status);
        }
    }

声明式事务

所谓声明式事务，就是使用

    @Transactional
    @Override
    public Map saveResource(MultipartFile file) {
            // 相关业务
    }

protected Object invokeWithinTransaction(Method method, @Nullable Class> targetClass,final InvocationCallback invocation) throws Throwable {
        ...
        PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
        // 切点
        final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

        if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
            // Standard transaction demarcation with getTransaction and commit/rollback calls.
            // 创建事务
            TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);

            // 环绕切点执行业务逻辑
            Object retVal;
            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);
            }

            if (vavrPresent && VavrDelegate.isVavrTry(retVal)) {
                // Set rollback-only in case of Vavr failure matching our rollback rules...
                TransactionStatus status = txInfo.getTransactionStatus();
                if (status != null && txAttr != null) {
                    retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
                }
            }
            // 正常执行，提交事务
            commitTransactionAfterReturning(txInfo);
            return retVal;
        }
        ...
}

    protected void completeTransactionAfterThrowing(@Nullable TransactionInfo txInfo, Throwable ex) {
        // 判断事务状态不为空的情况下
        if (txInfo != null && txInfo.getTransactionStatus() != null) {
        // 输出debug日志
            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 {
                // We don't roll back on this exception.
                // Will still roll back if TransactionStatus.isRollbackOnly() is true.
                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;
                }
            }
        }
    }

// 结束执行，且没有抛出异常，就执行提交
protected void commitTransactionAfterReturning(@Nullable TransactionInfo txInfo) {
        if (txInfo != null && txInfo.getTransactionStatus() != null) {
            if (logger.isTraceEnabled()) {
                logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() + "]");
            }
            txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
        }
    }

常用属性配置

propagation

配置事务的传播特性，默认为：required

        Resource resource = new Resource();
        resource.setCreateUser("admin");
        try {
            resourceMapper.insertUseGeneratedKeys(resource);
        } catch (Exception e) {
            // 在日志中输出堆栈信息，并抛出异常
            log.error("Exception:{}", ExceptionUtil.stacktraceToString(e));
            throw new RuntimeException("系统错误");
        }

innodb