关于spring:Spring-声明式事务应该怎么学

35次阅读

共计 11062 个字符，预计需要花费 28 分钟才能阅读完成。

大家好呀，我是课代表。
关注我的公众号：Java 课代表，原创干货首发地儿，等你来呦。

1、引言

Spring 的申明式事务极大中央便了日常的事务相干代码编写，它的设计如此奇妙，以至于在应用中简直感觉不到它的存在，只须要优雅地加一个 @Transactional 注解，所有就都牵强附会地实现了！

毫不夸大地讲，Spring 的申明式事务切实是太好用了，以至于大多数人都遗记了编程式事务应该怎么写。

不过，越是你认为理所应当的事件，如果出了问题，就越难排查。不晓得你和身边的小伙伴有没有遇到过 @Transactional 生效的场景，这不然而日常开发中常踩的坑，也是面试中的高频问题。

其实这些生效场景不必死记硬背，如果搞明确了它的工作原理，再联合源码，须要用到的时候 Debug 一下就能本人剖析进去。毕竟，源码才是最好的说明书。

还是那句话，授人以鱼不如授人以渔，课代表就算总结 100 种生效场景，也不肯定能笼罩到你可能踩到的坑。所以本文中，课代表将联合几个常见生效状况，从源码层面解释其生效起因。认真读完本文，置信你会对申明式事务有更粗浅的意识。

文中所有代码已上传至课代表的 github，为了不便疾速部署并运行，示例代码采纳了内存数据库H2，不须要额定部署数据库环境。

2、回顾手写事务

数据库层面的事务，有 ACID 四个个性，他们独特保障了数据库中数据的准确性。事务的原理并不是本文的重点，咱们只须要晓得样例中用的 H2 数据库齐全实现了对事务的反对（read committed）。

编写 Java 代码时，咱们应用 JDBC 接口与数据库交互，实现事务的相干指令，伪代码如下：

// 获取用于和数据库交互的连贯
Connection conn = DriverManager.getConnection();
try {
    // 敞开主动提交:
    conn.setAutoCommit(false);
    // 执行多条 SQL 语句:
    insert(); 
    update(); 
    delete();
    // 提交事务:
    conn.commit();} catch (SQLException e) {
    // 如果出现异常，回滚事务:
    conn.rollback();} finally {
    // 开释资源
    conn.close();}

这是典型的编程式事务代码流程：开始前先敞开主动提交，因为默认状况下，主动提交是开启的，每条语句都会开启新事务，执行结束后主动提交。

敞开事务的主动提交，是为了让多个 SQL 语句在同一个事务中。代码失常运行，就提交事务，出现异常，就整体回滚，以此保障多条 SQL 语句的整体性。

除了事务提交，数据库还反对保留点的概念，在一个物理事务中，能够设置多个保留点，不便回滚到指定保留点（其相似玩单机游戏时的存档，你能够在角色挂掉后随时回到上次的存档）设置和回滚到保留点的代码如下：

// 设置保留点    
Savepoint savepoint = connection.setSavepoint();
// 回滚到指定的保留点
connection.rollback(savepoint);
// 回滚到保留点后按需提交 / 回滚后面的事务
conn.commit();//conn.rollback();

Spring 申明式事务所做的工作，就是围绕着 提交 / 回滚 事务，设置 / 回滚到保留点 这两对命令进行的。为了让咱们尽可能地少写代码，Spring 定义了几种流传属性将事务做了进一步的形象。留神哦，Spring 的事务流传(Propagation) 只是 Spring 定义的一层形象而已，和数据库没啥关系，不要和数据库的事务隔离级别混同。

3、Spring 的事务流传（Transaction Propagation）

察看传统事务代码：

    conn.setAutoCommit(false);
    // 执行多条 SQL 语句:
    insert(); 
    update(); 
    delete();
    // 提交事务:
    conn.commit();

这段代码表白的是三个 SQL 语句在同一个事务里。

他们可能是同一个类中的不同办法，也可能是不同类中的不同办法。如何来表白诸如事务办法退出别的事务、新建本人的事务、嵌套事务等等概念呢？这就要靠 Spring 的事务流传机制了。

事务流传（Transaction Propagation）就是字面意思：事务的流传 / 传递 形式。

在 Spring 源码的 TransactionDefinition 接口中，定义了 7 种流传属性，官网对其中的 3 个做了阐明，咱们只有搞懂了这 3 个，剩下的 4 个就是触类旁通的事了。

1)PROPAGATION_REQUIRED

字面意思：流传 - 必须

PROPAGATION_REQUIRED是其 默认 流传属性，强制开启事务，如果之前的办法曾经开启了事务，则退出前一个事务，二者在物理上属于同一个事务。

一图胜千言，下图示意它俩物理上是在同一个事务内：

上图翻译成伪代码是这样的：

try {conn.setAutoCommit(false);
    transactionalMethod1(); 
    transactionalMethod2();
    conn.commit();} catch (SQLException e) {conn.rollback();
} finally {conn.close();
}

既然在同一个物理事务中，那如果 transactionalMethod2() 产生了异样，导致须要回滚，那么请问 transactionalMethod1() 是否也要回滚呢？

得益于下面的图解和伪代码，咱们能够很容易地得出答案，transactionalMethod1()必定回滚了。

这里抛一个问题：

事务办法外面的异样被 try catch 吃了，事务还能回滚吗？

先别着急出论断，看上面两段代码示例。

示例一：不会回滚的状况（事务生效）

察看上面的代码，methodThrowsException()什么也没干，就抛了个异样，调用方将其抛出的异样try catch 住了，该场景下是不会触发回滚的

@Transactional(rollbackFor = Exception.class)
public void tryCatchRollBackFail(String name) {jdbcTemplate.execute("INSERT INTO USER (NAME) VALUES ('" + name + "')");
    try {methodThrowsException();
    } catch (RollBackException e) {//do nothing}
}

public void methodThrowsException() throws RollBackException {throw new RollBackException(ROLL_BACK_MESSAGE);
}

示例二：会回滚的状况（事务失效）

再看这个例子，同样是 try catch 了异样，后果却截然相同

@Transactional(rollbackFor = Throwable.class)
public void tryCatchRollBackSuccess(String name, String anotherName) {jdbcTemplate.execute("INSERT INTO USER (NAME) VALUES ('" + name + "')");
    try {
        // 带事务，抛异样回滚
        userService.insertWithTxThrowException(anotherName);
    } catch (RollBackException e) {// do nothing}
}

@Transactional(rollbackFor = Throwable.class)
public void insertWithTxThrowException(String name) throws RollBackException {jdbcTemplate.execute("INSERT INTO USER (NAME) VALUES ('" + name + "')");
    throw new RollBackException(ROLL_BACK_MESSAGE);
}

本例中，两个办法的事务都没有设置 propagation 属性，默认都是 PROPAGATION_REQUIRED。即前者开启事务，后者退出后面开启的事务，二者同属于一个物理事务。insertWithTxThrowException() 办法抛出异样，将事务标记为回滚。既然大家是在一条船上，那么后者打翻了船，前者必定也不能幸免。

所以 tryCatchRollBackSuccess() 所执行的 SQL 也必将回滚，执行此用例能够查看后果

拜访 http://localhost:8080/h2-cons…，连贯信息如下：

点击 Connect 进入控制台即可查看表中数据：

USER 表的确没有插入数据，证实了咱们的论断，并且能够看到日志报错：

Transaction rolled back because it has been marked as rollback-only事务曾经回滚，因为它被标记为必须回滚。

也就是前面办法触发的事务回滚，让后面办法的插入也回滚了。

看到这里，你应该能把默认的流传类型 PROPAGATION_REQUIRED 了解透彻了，本例中是因两个办法在同一个物理事务下，相互影响从而回滚。

你可能会问，那我如果想让前后两个开启了事务的办法互不影响该怎么办呢？

这就要用到上面要说的流传类型了。

2)、PROPAGATION_REQUIRES_NEW

字面意思：流传 - 必须 - 新的

PROPAGATION_REQUIRES_NEW与 PROPAGATION_REQUIRED 不同的是，其总是开启独立的事务，不会参加到已存在的事务中，这就保障了两个事务的状态互相独立，互不影响，不会因为一方的回滚而烦扰到另一方。

一图胜千言，下图示意他俩物理上不在同一个事务内：

上图翻译成伪代码是这样的：

//Transaction1
try {conn.setAutoCommit(false);
    transactionalMethod1(); 
    conn.commit();} catch (SQLException e) {conn.rollback();
} finally {conn.close();
}
//Transaction2
try {conn.setAutoCommit(false); 
    transactionalMethod2();
    conn.commit();} catch (SQLException e) {conn.rollback();
} finally {conn.close();
}

TransactionalMethod1 开启新事务，当他调用同样须要事务的 TransactionalMethod2 时，因为后者的流传属性设置了PROPAGATION_REQUIRES_NEW，所以挂起后面的事务（至于如何挂起，前面咱们会从源码中窥见），并开启一个物理上独立于前者的新事务，这样二者的事务回滚就不会互相烦扰了。

还是后面的例子，只须要把 insertWithTxThrowException() 办法的事务流传属性设置为 Propagation.REQUIRES_NEW 就能够互不影响了：

@Transactional(rollbackFor = Throwable.class)
public void tryCatchRollBackSuccess(String name, String anotherName) {jdbcTemplate.execute("INSERT INTO USER (NAME) VALUES ('" + name + "')");
    try {
        // 带事务，抛异样回滚
        userService.insertWithTxThrowException(anotherName);
    } catch (RollBackException e) {// do nothing}
}

@Transactional(rollbackFor = Throwable.class, propagation = Propagation.REQUIRES_NEW)
public void insertWithTxThrowException(String name) throws RollBackException {jdbcTemplate.execute("INSERT INTO USER (NAME) VALUES ('" + name + "')");
    throw new RollBackException(ROLL_BACK_MESSAGE);
}

PROPAGATION_REQUIRED和 Propagation.REQUIRES_NEW 曾经足以应答大部分利用场景了，这也是开发中罕用的事务流传类型。前者要求基于同一个物理事务，要回滚一起回滚，后者是大家应用独立事务互不干涉。还有一个场景就是：内部办法和外部办法共享一个事务，然而内部事务的回滚不影响内部事务，内部事务的回滚能够影响内部事务。这就是嵌套这种流传类型的应用场景。

3)、PROPAGATION_NESTED

字面意思：流传 - 嵌套

PROPAGATION_NESTED能够在一个已存在的物理事务上设置多个供回滚应用的保留点。这种局部回滚能够让内部事务在其本人的作用域内回滚，与此同时，内部事务能够在某些操作回滚后继续执行。其底层实现就是数据库的savepoint。

这种流传机制比后面两种都要灵便，看上面的代码：

@Transactional(rollbackFor = Throwable.class)
public void invokeNestedTx(String name,String otherName) {jdbcTemplate.execute("INSERT INTO USER (NAME) VALUES ('" + name + "')");
    try {userService.insertWithTxNested(otherName);
    } catch (RollBackException e) {// do nothing}
    // 如果这里抛出异样，将导致两个办法都回滚
    // throw new RollBackException(ROLL_BACK_MESSAGE);
}

@Transactional(rollbackFor = Throwable.class,propagation = Propagation.NESTED)
public void insertWithTxNested(String name) throws RollBackException {jdbcTemplate.execute("INSERT INTO USER (NAME) VALUES ('" + name + "')");
    throw new RollBackException(ROLL_BACK_MESSAGE);
}

内部事务办法 invokeNestedTx() 开启事务，内部事务办法 insertWithTxNested 标记为嵌套事务，内部事务的回滚通过保留点实现，不会影响内部事务。而内部办法的回滚，则会连带外部办法一块回滚。

小结：本大节介绍了 3 种常见的 Spring 申明式事务流传属性，联合样例代码，置信你也对其有所理解了，接下来咱们从源码层面看一看，Spring 是如何帮咱们简化事务样板代码，解放生产力的。

4、源码窥探

在浏览源码前，先剖析一个问题：我要给一个办法增加事务，须要做哪些工作呢？

就算咱们本人手写，也至多得须要这么四步：

  • 开启事务
  • 执行办法
  • 遇到异样就回滚事务
  • 失常执行后提交事务

这不就是典型的 AOP 嘛~

没错，Spring 就是通过 AOP，将咱们的事务办法加强，从而实现了事务的相干操作。上面给出几个要害类及其要害办法的源码走读。

既然是 AOP 那必定要给事务写一个切面来做这个事，这个类就是 TransactionAspectSupport ，从命名能够看出，这就是“事务切面反对类”，他的次要工作就是实现事务的执行流程，其次要实现办法为invokeWithinTransaction：

protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
      final InvocationCallback invocation) throws Throwable {
    
    // 省略代码...
    // Standard transaction demarcation with getTransaction and commit/rollback calls.
    // 1、开启事务
    TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
       try {
        // This is an around advice: Invoke the next interceptor in the chain.
        // This will normally result in a target object being invoked.
        //2、执行办法
        retVal = invocation.proceedWithInvocation();}
    catch (Throwable ex) {
        // target invocation exception
        // 3、捕捉异样时的解决
        completeTransactionAfterThrowing(txInfo, ex);
        throw ex;
    }
    finally {cleanupTransactionInfo(txInfo);
    }

    if (retVal != null && 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);
        }
    }
    //4、执行胜利，提交事务
    commitTransactionAfterReturning(txInfo);
    return retVal;
    // 省略代码...

联合课代表减少的这四步正文，置信你很容易就能看明确。

搞懂了事务的次要流程，它的流传机制又是怎么实现的呢？这就要看 AbstractPlatformTransactionManager 这个类了，从命名就能看出，它负责事务管理，其中的 handleExistingTransaction 办法实现了事务流传逻辑，这里挑 PROPAGATION_REQUIRES_NEW 的实现跟一下代码：

private TransactionStatus handleExistingTransaction(TransactionDefinition definition, Object transaction, boolean debugEnabled)
            throws TransactionException {
        // 省略代码...
        if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {if (debugEnabled) {
                logger.debug("Suspending current transaction, creating new transaction with name [" +
                        definition.getName() + "]");
            }
            // 事务挂起
            SuspendedResourcesHolder suspendedResources = suspend(transaction);
            try {return startTransaction(definition, transaction, debugEnabled, suspendedResources);
            }
            catch (RuntimeException | Error beginEx) {resumeAfterBeginException(transaction, suspendedResources, beginEx);
                throw beginEx;
            }
        }
        // 省略代码...
    }

前文咱们晓得 PROPAGATION_REQUIRES_NEW 会将前一个事务挂起，并开启独立的新事务，而数据库是不反对事务的挂起的，Spring 是如何实现这一个性的呢？

通过源码能够看到，这里调用了返回值为 SuspendedResourcesHolder 的suspend(transaction)办法，它的理论逻辑由其外部的 doSuspend(transaction) 形象办法实现。这里咱们应用的是 JDBC 连贯数据库，天然要抉择 DataSourceTransactionManager 这个子类去查看其实现，代码如下：

protected Object doSuspend(Object transaction) {DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
        txObject.setConnectionHolder(null);
        return TransactionSynchronizationManager.unbindResource(obtainDataSource());
    }

这里是把已有事务的 connection 解除，并返回该挂起资源。在接下来开启事务时，会将该挂起资源一并传入，这样当内层事务执行实现后，能够继续执行外层被挂起的事务。

那么，什么时候来继续执行被挂起的事务呢？

事务的流程，尽管是由 TransactionAspectSupport 实现的，然而真正的提交，回滚，是由 AbstractPlatformTransactionManager 来实现，在其 processCommit(DefaultTransactionStatus status) 办法最初的 finally 块中，执行了cleanupAfterCompletion(status):

private void cleanupAfterCompletion(DefaultTransactionStatus status) {status.setCompleted();
        if (status.isNewSynchronization()) {TransactionSynchronizationManager.clear();
        }
        if (status.isNewTransaction()) {doCleanupAfterCompletion(status.getTransaction());
        }
         // 有挂起事务则获取挂起的资源，继续执行
        if (status.getSuspendedResources() != null) {if (status.isDebug()) {logger.debug("Resuming suspended transaction after completion of inner transaction");
            }
            Object transaction = (status.hasTransaction() ? status.getTransaction() : null);
           
            resume(transaction, (SuspendedResourcesHolder) status.getSuspendedResources());
        }
    }

这里判断有挂起的资源将会复原执行，至此实现挂起和复原事务的逻辑。

对于其余事务流传属性的实现，感兴趣的同学应用课代表的样例工程，打断点本人去跟一下源码。限于篇幅，这里只给出了大略解决流程，源码里有大量细节，须要同学们本人去体验，有了上文介绍的主逻辑框架根底，跟踪源码查看其余实现应该不怎么吃力了。

5、常见生效场景

很多人（包含课代表自己）一开始应用申明式事务，都会感觉这玩意儿真坑，应用起来那么多条条框框，一不小心就不失效了。为什么会有这种感觉呢？

爬了屡次坑之后，课代表总结了两条教训：

  1. 没看官网文档
  2. 不会读源码

上面简略列举几个生效场景：

1）非 public 办法不失效

官网有阐明：

Method visibility and @Transactional

When you use transactional proxies with Spring’s standard configuration, you should apply the @Transactional annotation only to methods with public visibility.

2）Spring 不反对 redis 集群中的事务

redis事务开启命令是multi，然而 Spring Data Redis 不反对 redis 集群中的 multi 命令，如果应用了申明式事务，将会报错：MULTI is currently not supported in cluster mode.

3）多数据源状况下须要为每个数据源配置 TransactionManager，并指定transactionManager 参数

第四局部源码窥探中曾经看到理论执行事务操作的是 AbstractPlatformTransactionManager，其为TransactionManager 的实现类，每个事务的 connection 连贯都受其治理，如果没有配置，无奈实现事务操作。单数据源的状况下失常运行，是因为 SpringBoot 的 DataSourceTransactionManagerAutoConfiguration 为咱们主动配置了。

4）rollbackFor 设置谬误

默认状况下只回滚非受检异样（也就是，java.lang.RuntimeException的子类）和java.lang.Error，如果明确晓得抛异样就要回滚，倡议设置为@Transactional(rollbackFor = Throwable.class)

5）AOP 不失效问题

其余诸如 MyISAM 不反对，es 不反对等等就不一一列举了。

如果感兴趣，以上这些在源码中都能找到解答。

6、结束语

对于 Spring 的申明式事务，如果想用好，还真得多 Debug 几遍源码，因为 Spring 的源码细节过于丰盛，切实不适宜全副贴到文章里，倡议本人去跟一下源码。相熟之后就不怕再遇到生效状况了。

以下材料证实我不是在胡扯

1、文中测试用例代码：https://github.com/zhengxl556…

2、Spring 官网事务文档：https://docs.spring.io/spring…

3、Oracle 官网 JDBC 文档：https://docs.oracle.com/javas…

4、Spring Data Redis 源码：https://github.com/spring-pro…

往期原创干货

应用 Spring Validation 优雅地校验参数
下载的附件名总乱码？你该去读一下 RFC 文档了！
单例模式，关键字级别详解

原创码字不易，欢送点赞关注和分享。
我在公众号：Java 课代表，等你呦。

正文完
spring
发表至： spring
2021-09-07
 0
关于spring:利用tox打造自动自动化测试框架
关于spring:SpringBean的几个问题以及原理
关于spring:SpringConfiguration注解简析
关于spring:一spring-aop注解失效