学习东西要知行合一，如果只是知道理论而没实践过，那么掌握的也不会特别扎实，估计过几天就会忘记，接下来我们一起实践来学习Spring事务的传播属性。

传播属性

required(没有则新建，默认)、require new(总是新建)、support、not supported（不支持不以事务运行）、never（不支持，抛异常）、mandatory(没有抛异常)、nested(嵌套)

传播属性定义的是当一个事务方法碰到另一个事务方法时的处理行为，一共有七种行为，定义如下

传播性 值 描述
PROPAGATION_REQUIRED 0 支持当前事务，如果没有就新建事务
PROPAGATION_SUPPORTS 1 支持当前事务，如果没有就不以事务的方式运行
PROPAGATION_MANDATORY 2 支持当前事务，如果当前没事务就抛异常
PROPAGATION_REQUIRES_NEW 3 无论当前是否有事务，都会新起一个事务
PROPAGATION_NOT_SUPPORTED 4 不支持事务，如果当前存在事务，就将此事务挂起不以事务方式运行
PROPAGATION_NEVER 5 不支持事务，如果有事务就抛异常
PROPAGATION_NESTED 6 如果当前存在事务，在当前事务中再新起一个事务

其实只看概念的话已经很直截了当了说明了每个传播性的作用，此时我们再用具体的例子演示一下每个传播性属性下的行为。

此次演示我们使用的是H2数据库，这个数据库是作用在内存里面的，所以对于我们演示事务效果来说正好，无需我们在进行其他的配置了，我们新建一个表。将下面语句放在schema.sql文件里面即可，SpringBoot程序在启动的时候就会自动为我们在内存里面建立这样的一个表。

  1. CREATE TABLE FOO (ID INT IDENTITY, BAR VARCHAR(64));

演示之前我们会定义两个类FooService和BarService。我们使用BarService里面的方法进行调用FooService中的方法。

环境准备

在进行事务演示之前，其实可以分为以下几种情况，根据排列组合，我们可以得出以下八种情况

  • 调用者：有无事务
  • 调用者：是否有异常
  • 被调用者：有无事务(这个是通过传播属性进行控制的)所以并不在排列组合中
  • 被调用者：是否有异常 | 调用者是否有事务 | 调用者是否有异常 | 被调用者是否有异常 | | —- | —- | —- | | 有 | 有 | 有 | | 有 | 有 | 无 | | 有 | 无 | 有 | | 有 | 无 | 无 | | 无 | 有 | 有 | | 无 | 有 | 无 | | 无 | 无 | 有 | | 无 | 无 | 无 |

异常类

其中的RollbackException是我们自己定义的一个异常类

  1. @Service
  2. public class BarServiceImpl implements BarService{
  3.     @Autowired
  4.     private FooService fooService;
  6.      // PROPAGATION_REQUIRED演示 无事务
  7.     @Override
  8.     public void testRequiredNoTransactional() throws RollbackException {
  9.         fooService.testRequiredTransactional();
  10.     }
  11. }

调用者

在BarService中定义两个方法，一个是带着事务的，一个是不带事务的

  1. // 有事务
  2. @Override
  3. @Transactional(rollbackFor = Exception.class)
  4. public void hasTransactional() throws RollbackException {
  6. }
  8. // 无事务
  9. @Override
  10. public void noTransactional() throws RollbackException {
  12. }

接下来我们就根据俄上面定义的八种情况进行事务传播属性的学习。

PROPAGATION_REQUIRED

在此传播属性下，被调用方是否新建事务取决去调用者是否带着事务。

想要了解这个传播属性的特性，其实我们演示上面八种情况的两个例子就够了

调用者是否有事务 调用者是否有异常 被调用者是否有异常
无 无 有
有 有 无
  • 第一种情况我们在被调用者抛出异常的情况下，如果查询不到插入的数据，那么就说明被调用者在调用者没有事务的情况下自己新建了事务。
  • 第二种情况我们在调用者抛出异常的情况下，如果查询不到插入的数据，那么就说明被调用者在调用者有事务的情况下就加入当前事务了。

我们先来看一下被调用者的类的方法例子。

  1. @Service
  2. public class FooServiceImpl implements FooService {
  3.     @Autowired
  4.     private JdbcTemplate jdbcTemplate;
  6.     // REQUIRED传播属性-被调用者有异常抛出
  7.     @Override
  8.     @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
  9.     public void testRequiredHasException() throws RollbackException {
  10.         jdbcTemplate.execute("INSERT INTO FOO (BAR) VALUES ("+Global.REQUIRED_HAS_EXCEPTION+")");
  11.         throw new RollbackException();
  12.     }
  14.     // REQUIRED传播属性-被调用者无异常抛出
  15.     @Override
  16.     @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
  17.     public void testRequiredNoException() throws RollbackException {
  18.         jdbcTemplate.execute("INSERT INTO FOO (BAR) VALUES ("+Global.REQUIRED_NO_EXCEPTION+")");
  19.     }
  20. }

接下来我们看一下调用者方法的例子

  1. @Service
  2. public class BarServiceImpl implements BarService{
  3.     @Autowired
  4.     private FooService fooService;
  6.     // 有事务
  7.     @Override
  8.     @Transactional(rollbackFor = Exception.class)
  9.     public void hasTransactional() throws RollbackException {
  10.         // 调用者有事务,抛异常  被调用者无异常
  11.         fooService.testRequiredNoException();
  12.         throw new RollbackException();
  13.     }
  15.     // 无事务
  16.     @Override
  17.     public void noTransactional() throws RollbackException {
  18.         // 调用者无事务,不抛异常  被调用者有异常
  19.         fooService.testRequiredHasException();
  20.     }
  21. }

此时我们在程序调用时进行查询

  1. String noException = Global.REQUIRED_NO_EXCEPTION;
  2. String hasException = Global.REQUIRED_HAS_EXCEPTION;
  4. try {
  5.     barService.noTransactional();
  6. }catch (Exception e){
  7.     log.info("第一种情况 {}",
  8.             jdbcTemplate
  9.                     .queryForObject("SELECT COUNT(*) FROM FOO WHERE BAR='"+hasException+"'", Long.class));
  10. }
  12. try {
  13.     barService.hasTransactional();
  14. }catch (Exception e){
  15.     log.info("第二种情况 {}",
  16.             jdbcTemplate
  17.                     .queryForObject("SELECT COUNT(*) FROM FOO WHERE BAR='"+noException+"'", Long.class));
  18. }

查看打印出来的日志

  1. 2019-10-16 13:02:04.142  INFO 11869 --- [           main] c.e.t.t.TransactionApplication           : 第一种情况 0
  2. 2019-10-16 13:02:04.143  INFO 11869 --- [           main] c.e.t.t.TransactionApplication           : 第二种情况 0

我们看到我们都没有查到相应的数据，说明数据都回滚了。此时我们应该就理解了那句话支持当前事务，如果没有就新建事务。

PROPAGATION_SUPPORTS

被调用者是否有事务，完全依赖于调用者，调用者有事务则有事务，调用者没事务则没事务。

接下来我们还是用上面的两个例子进行演示

调用者是否有事务 调用者是否有异常 被调用者是否有异常
无 无 有
有 有 无
  • 第一种情况：被调用者抛出异常的情况下，如果仍能查询到数据，说明事务没有回滚，说明被调用者没有事务
  • 第二种情况：调用者抛出异常情况下，如果查不到数据，说明两个方法在一个事务中

接下来仍然是例子演示

被调用者，只是将@Transactional注解中的propagation属性更换为了Propagation.SUPPORTS

  1. // SUPPORTS传播属性-被调用者有异常抛出
  2. @Override
  3. @Transactional(rollbackFor = Exception.class,propagation = Propagation.SUPPORTS)
  4. public void testSupportsHasException() throws RollbackException {
  5.     jdbcTemplate.execute("INSERT INTO FOO (BAR) VALUES ('"+Global.SUPPORTS_HAS_EXCEPTION+"')");
  6.     throw new RollbackException();
  7. }
  9. // SUPPORTS传播属性-被调用者无异常抛出
  10. @Override
  11. @Transactional(rollbackFor = Exception.class,propagation = Propagation.SUPPORTS)
  12. public void testSupportsNoException() throws RollbackException {
  13.     jdbcTemplate.execute("INSERT INTO FOO (BAR) VALUES ('"+Global.SUPPORTS_NO_EXCEPTION+"')");
  14. }

调用者和上面的例子调用一样，我们直接查看执行效果

  1. 2019-10-16 13:50:27.738  INFO 12174 --- [           main] c.e.t.t.TransactionApplication           : 第一种情况 1
  2. 2019-10-16 13:50:27.741  INFO 12174 --- [           main] c.e.t.t.TransactionApplication           : 第二种情况 0

我们看到了在第一种情况下查到了数据，说明在第一种情况下被调用者是没有事务的。此时我们应该就理解了这句话
支持当前事务，如果没有就不以事务的方式运行。

PROPAGATION_MANDATORY

依然是这两个例子进行演示

调用者是否有事务 调用者是否有异常 被调用者是否有异常
无 无 有
有 有 无
  • 第一种情况：因为调用者没有事务，所以此传播属性下应该是抛异常的
  • 第二种情况：被调用者的事务和调用者事务是同样的

接下来是被调用者的代码例子

  1. // MANDATORY传播属性-被调用者有异常抛出
  2. @Override
  3. @Transactional(rollbackFor = Exception.class,propagation = Propagation.MANDATORY)
  4. public void testMandatoryHasException() throws RollbackException {
  5.     jdbcTemplate.execute("INSERT INTO FOO (BAR) VALUES ('"+Global.SUPPORTS_HAS_EXCEPTION+"')");
  6.     throw new RollbackException();
  7. }
  9. // MANDATORY传播属性-被调用者无异常抛出
  10. @Override
  11. @Transactional(rollbackFor = Exception.class,propagation = Propagation.MANDATORY)
  12. public void testMandatoryNoException() throws RollbackException {
  13.     jdbcTemplate.execute("INSERT INTO FOO (BAR) VALUES ('"+Global.SUPPORTS_NO_EXCEPTION+"')");
  14. }

调用者和上面的例子调用一样，我们直接查看执行效果

  1. 2019-10-16 13:58:39.178 ERROR 12317 --- [           main] c.e.t.t.TransactionApplication           : org.springframework.transaction.IllegalTransactionStateException: No existing transaction found for transaction marked with propagation 'mandatory'
  2. 2019-10-16 13:58:39.276  INFO 12317 --- [           main] c.e.t.t.TransactionApplication           : 第一种情况 0
  3. 2019-10-16 13:58:39.281  INFO 12317 --- [           main] c.e.t.t.TransactionApplication           : 第二种情况 0

我们发现和我们推测一样，说明被调用者是不会自己新建事务的，此时我们应该就理解了这句话支持当前事务，如果当前没事务就抛异常。

PROPAGATION_REQUIRES_NEW

此传播属性下，无论调用者是否有事务，被调用者都会新建一个事务

调用者是否有事务 调用者是否有异常 被调用者是否有异常
无 无 有
有 有 无
  • 第一种情况：调用者无事务，被调用者会新建事务，所以查不到数据
  • 第二种情况：调用者有事务，被调用者会新建一个事务，所以调用者抛异常影响不到被调用者，所以能查到数据

接下来我们演示代码。

被调用者

  1. // REQUIRES_NEW传播属性-被调用者有异常抛出
  2. @Override
  3. @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
  4. public void testRequiresNewHasException() throws RollbackException {
  5.     jdbcTemplate.execute("INSERT INTO FOO (BAR) VALUES ('"+Global.REQUIRES_NEW_HAS_EXCEPTION+"')");
  6.     throw new RollbackException();
  7. }
  9. // REQUIRES_NEW传播属性-被调用者无异常抛出
  10. @Override
  11. @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
  12. public void testRequiresNewNoException() throws RollbackException {
  13.     jdbcTemplate.execute("INSERT INTO FOO (BAR) VALUES ('"+Global.REQUIRES_NEW_NO_EXCEPTION+"')");
  14. }

调用者的例子和上面的相同，我们直接来看执行情况

  1. 2019-10-16 16:29:20.296  INFO 15553 --- [           main] c.e.t.t.TransactionApplication           : 第一种情况 0
  2. 2019-10-16 16:29:20.298  INFO 15553 --- [           main] c.e.t.t.TransactionApplication           : 第二种情况 1

我们发现和我们的推论是一样的，说明调用者的事务和被调用者的事务完全无关。此时我们应该就理解这句话了无论当前是否有事务，都会新起一个事务。

PROPAGATION_NOT_SUPPORTED

无论调用者是否有事务，被调用者都不以事务的方法运行

同样是这两个例子

调用者是否有事务 调用者是否有异常 被调用者是否有异常
无 无 有
有 有 无
  • 第一种情况：被调用者都不会有事务，那么在抛异常之后就能查到相应的数据
  • 第二种情况：在调用者有事务的情况下，被调用者也会在无事务环境下运行，所以我们依然能查到数据

接下来验证我们的猜测

  1. // NOT_SUPPORTED传播属性-被调用者有异常抛出
  2. @Override
  3. @Transactional(rollbackFor = Exception.class,propagation = Propagation.NOT_SUPPORTED)
  4. public void testNotSupportHasException() throws RollbackException {
  5.     jdbcTemplate.execute("INSERT INTO FOO (BAR) VALUES ('"+Global.NOT_SUPPORTS_HAS_EXCEPTION+"')");
  6.     throw new RollbackException();
  7. }
  9. // NOT_SUPPORTED传播属性-被调用者无异常抛出
  10. @Override
  11. @Transactional(rollbackFor = Exception.class,propagation = Propagation.NOT_SUPPORTED)
  12. public void testNotSupportNoException() throws RollbackException {
  13.     jdbcTemplate.execute("INSERT INTO FOO (BAR) VALUES ('"+Global.NOT_SUPPORTS_NO_EXCEPTION+"')");
  14. }

然后查看执行结果

  1. 2019-10-16 16:38:35.065  INFO 15739 --- [           main] c.e.t.t.TransactionApplication           : 第一种情况 1
  2. 2019-10-16 16:38:35.067  INFO 15739 --- [           main] c.e.t.t.TransactionApplication           : 第二种情况 1

我们可以看到在最后两种情况都查到了数据，根据演示效果应该可以理解这句话了，不支持事务，如果当前存在事务，就将此事务挂起不以事务方式运行。

PROPAGATION_NEVER

调用者有事务，被调用者就会抛出异常

调用者是否有事务 调用者是否有异常 被调用者是否有异常
无 无 有
有 有 无

这个就不演示，相信大家看到这里应该都会明白在第一种情况下我们是能够查到数据的。在第二种情况下由于调用者带着事务，所以会抛异常。

PROPAGATION_NESTED

此传播属性下，被调用者的事务是调用者的事务的子集。

我们重点说一下NESTED的传播属性的特性

调用者是否有事务 说明
有 被调用者会新起一个事务，此事务和调用者事务是一个嵌套的关系
无 被调用者会自己新起一个事务

关于什么是嵌套事务的关系，我们用下面三个例子能够进行演示。

调用者是否有事务 调用者是否有异常 被调用者是否有异常
无 无 有
有 有 无
有 无 有
  • 第一种情况：如果查不到数据，则说明在调用者无事务情况下，被调用者会新起一个事务
  • 第二种情况：如果查不到数据，说明外层事务能够影响内层事务
  • 第三种情况：如果查到数据，说明内层事务不影响外层事务

接下来我们编写具体的代码

  1. // NESTED传播属性-回滚事务
  2. @Override
  3. @Transactional(rollbackFor = Exception.class,propagation = Propagation.NESTED)
  4. public void testNestedHasException() throws RollbackException {
  5.     jdbcTemplate.execute("INSERT INTO FOO (BAR) VALUES ('"+Global.NESTED_HAS_EXCEPTION+"')");
  6.    // TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
  7.     throw new RollbackException();
  8. }
  10. // NESTED传播属性-不回滚事务
  11. @Override
  12. @Transactional(rollbackFor = Exception.class,propagation = Propagation.NESTED)
  13. public void testNestedNoException() throws RollbackException {
  14.     jdbcTemplate.execute("INSERT INTO FOO (BAR) VALUES ('"+Global.NESTED_NO_EXCEPTION+"')");
  15. }

然后接下来的调用者也会有点区别

  1. @Override
  2. @Transactional()
  3. public void hasTransactionalNoException() throws RollbackException {
  4.     // NESTED传播属性 - 调用者有事务,不抛异常  被调用者有异常
  5.     jdbcTemplate.execute("INSERT INTO FOO (BAR) VALUES ('"+Global.NESTED_HAS_EXCEPTION_TWO+"')");
  6.     fooService.testNestedHasException();
  7. }

然后执行效果

  1. 2019-10-16 18:01:06.387  INFO 17172 --- [           main] c.e.t.t.TransactionApplication           : 第一种情况 0
  2. 2019-10-16 18:01:06.389  INFO 17172 --- [           main] c.e.t.t.TransactionApplication           : 第二种情况 0
  3. 2019-10-16 18:01:06.390  INFO 17172 --- [           main] c.e.t.t.TransactionApplication           : 第三种情况 1

可以看出来嵌套事务的本质就是外层会影响内层，内层不影响外层。而REQUIRES_NEW则是互不影响。

总结

到现在我们已经全部分析完了七种传播属性，从写这篇文章开始到结束其中也碰到过一些坑，有些是不自己实践一遍是根本不知道的，所以我还是建议读者看完这篇文章以后自己进行实践，演示各种情况，只有这样才能够烂熟于心。

本文代码地址