Spring事务传播行为详解

小鱼儿 2021-09-25 12:46 285阅读 0赞

前言：

Spring在TransactionDefinition接口中规定了7种类型的事务传播行为。事务传播行为是Spring框架独有的事务增强特性，他不属于的事务实际提供方数据库行为。这是Spring为我们提供的强大的工具箱，使用事务传播行可以为我们的开发工作提供许多便利。但是人们对他的误解也颇多，你一定也听过“service方法事务最好不要嵌套”的传言。要想正确的使用工具首先需要了解工具。本文对七种事务传播行为做详细介绍。

基础概念：

1. 什么是事务传播行为？

事务传播行为用来描述由某一个事务传播行为修饰的方法被嵌套进另一个方法的时事务如何传播。

用伪代码说明：

public void methodA()\{ methodB(); //doSomething \} @Transaction(Propagation=XXX) public void methodB()\{ //doSomething \}

代码中methodA()方法嵌套调用了methodB()方法，methodB()的事务传播行为由@Transaction(Propagation=XXX)设置决定。这里需要注意的是methodA()并没有开启事务，某一个事务传播行为修饰的方法并不是必须要在开启事务的外围方法中调用。

2. Spring中七种事务传播行为

<table> 
 <tbody> 
 <tr> 
 <td> 事务传播行为类型 </td> 
 <td> 说明 </td> 
 </tr> 
 <tr> 
 <td> PROPAGATION_REQUIRED </td> 
 <td> 如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。 </td> 
 </tr> 
 <tr> 
 <td> PROPAGATION_SUPPORTS </td> 
 <td> 支持当前事务，如果当前没有事务，就以非事务方式执行。 </td> 
 </tr> 
 <tr> 
 <td> PROPAGATION_MANDATORY </td> 
 <td> 使用当前的事务，如果当前没有事务，就抛出异常。 </td> 
 </tr> 
 <tr> 
 <td> PROPAGATION_REQUIRES_NEW </td> 
 <td> 新建事务，如果当前存在事务，把当前事务挂起。 </td> 
 </tr> 
 <tr> 
 <td> PROPAGATION_NOT_SUPPORTED </td> 
 <td> 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。 </td> 
 </tr> 
 <tr> 
 <td> PROPAGATION_NEVER </td> 
 <td> 以非事务方式执行，如果当前存在事务，则抛出异常。 </td> 
 </tr> 
 <tr> 
 <td> PROPAGATION_NESTED </td> 
 <td> 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。 </td> 
 </tr> 
 </tbody> 
</table>

代码验证

首先我们在数据库中创建两张表：

user1

CREATE TABLE \`user1\` ( \`id\` INTEGER UNSIGNED NOT NULL AUTO\_INCREMENT, \`name\` VARCHAR(45) NOT NULL DEFAULT '', PRIMARY KEY(\`id\`) ) ENGINE = InnoDB;

user2

CREATE TABLE \`user2\` ( \`id\` INTEGER UNSIGNED NOT NULL AUTO\_INCREMENT, \`name\` VARCHAR(45) NOT NULL DEFAULT '', PRIMARY KEY(\`id\`) ) ENGINE = InnoDB;

然后编写相应的Bean和DAO层代码，最后验证的代码由service来实现。分情况列举：

1、PROPAGATION\_REQUIRED

我们为User1Service和User2Service相应方法加上Propagation.REQUIRED属性。

@Service public class User1ServiceImpl implements User1Service \{ @Autowired private User1Mapper user1Mapper; @Override @Transactional(propagation = Propagation.REQUIRED) public void addRequired(User1 user) \{ user1Mapper.insert(user); \} \}

@Service public class User2ServiceImpl implements User2Service \{ @Autowired private User2Mapper user2Mapper; @Override @Transactional(propagation = Propagation.REQUIRED) public void addRequired(User2 user) \{ user2Mapper.insert(user); \} @Override @Transactional(propagation = Propagation.REQUIRED) public void addRequiredException(User2 user) \{ user2Mapper.insert(user); throw new RuntimeException(); \} \}

1.1 场景一

此场景外围方法没有开启事务。

@Service public class UserServiceImplTest implements UserServiceTest \{ @Autowired private User1Service user1Service; @Autowired private User2Service user2Service; // 方法1 @Override public void notransaction\_exception\_required\_required() \{ User1 user1=new User1(); user1.setName("张三"); user1Service.addRequired(user1); User2 user2=new User2(); user2.setName("李四"); user2Service.addRequired(user2); throw new RuntimeException(); \} // 方法2 @Override public void notransaction\_required\_required\_exception() \{ User1 user1=new User1(); user1.setName("张三"); user1Service.addRequired(user1); User2 user2=new User2(); user2.setName("李四"); user2Service.addRequiredException(user2); \} \}

分别执行验证方法，结果：

<table> 
 <tbody> 
 <tr> 
 <td> 验证方法序号 </td> 
 <td> 数据库结果 </td> 
 <td> 结果分析 </td> 
 </tr> 
 <tr> 
 <td> 1 </td> 
 <td> “张三”、“李四”均插入。 </td> 
 <td> 外围方法未开启事务，插入“张三”、“李四”方法在自己的事务中独立运行，外围方法异常不影响内部插入“张三”、“李四”方法独立的事务。 </td> 
 </tr> 
 <tr> 
 <td> 2 </td> 
 <td> “张三”插入，“李四”未插入。 </td> 
 <td> 外围方法没有事务，插入“张三”、“李四”方法都在自己的事务中独立运行,所以插入“李四”方法抛出异常只会回滚插入“李四”方法，插入“张三”方法不受影响。 </td> 
 </tr> 
 </tbody> 
</table>

结论：通过这两个方法我们证明了在外围方法未开启事务的情况下Propagation.REQUIRED修饰的内部方法会新开启自己的事务，且开启的事务相互独立，互不干扰。

1.2 场景二

外围方法开启事务，这个是使用率比较高的场景。

public class UserServiceImplTest implements UserServiceTest \{ @Autowired private User1Service user1Service; @Autowired private User2Service user2Service; //method1 @Override @Transactional(propagation = Propagation.REQUIRED) public void notransaction\_exception\_required\_required() \{ User1 user1=new User1(); user1.setName("张三"); user1Service.addRequired(user1); User2 user2=new User2(); user2.setName("李四"); user2Service.addRequired(user2); throw new RuntimeException(); \} //method2 @Override @Transactional(propagation = Propagation.REQUIRED) public void notransaction\_required\_required\_exception() \{ User1 user1=new User1(); user1.setName("张三"); user1Service.addRequired(user1); User2 user2=new User2(); user2.setName("李四"); user2Service.addRequiredException(user2); \} //method3 @Override @Transactional public void transaction\_required\_required\_exception\_try() \{ User1 user1=new User1(); user1.setName("张三"); user1Service.addRequired(user1); User2 user2=new User2(); user2.setName("李四"); try \{ user2Service.addRequiredException(user2); \} catch (Exception e) \{ System.out.println("方法回滚"); \} \} \}

分别执行验证方法，结果：

<table> 
 <tbody> 
 <tr> 
 <td> 验证方法序号 </td> 
 <td> 数据库结果 </td> 
 <td> 结果分析 </td> 
 </tr> 
 <tr> 
 <td> 1 </td> 
 <td> “张三”、“李四”均未插入。 </td> 
 <td> 外围方法开启事务，内部方法加入外围方法事务，外围方法回滚，内部方法也要回滚。 </td> 
 </tr> 
 <tr> 
 <td> 2 </td> 
 <td> “张三”、“李四”均未插入。 </td> 
 <td> 外围方法开启事务，内部方法加入外围方法事务，内部方法抛出异常回滚，外围方法感知异常致使整体事务回滚。 </td> 
 </tr> 
 <tr> 
 <td> 3 </td> 
 <td> “张三”、“李四”均未插入。 </td> 
 <td> 外围方法开启事务，内部方法加入外围方法事务，内部方法抛出异常回滚，即使方法被catch不被外围方法感知，整个事务依然回滚。 </td> 
 </tr> 
 </tbody> 
</table>

结论：以上试验结果我们证明在外围方法开启事务的情况下Propagation.REQUIRED修饰的内部方法会加入到外围方法的事务中，所有Propagation.REQUIRED修饰的内部方法和外围方法均属于同一事务，只要一个方法回滚，整个事务均回滚。

2.PROPAGATION\_REQUIRES\_NEW

我们为User1Service和User2Service相应方法加上Propagation.REQUIRES\_NEW属性。

User1Service方法：

@Service public class User1ServiceImpl implements User1Service \{ //省略其他... @Override @Transactional(propagation = Propagation.REQUIRES\_NEW) public void addRequiresNew(User1 user)\{ user1Mapper.insert(user); \} @Override @Transactional(propagation = Propagation.REQUIRED) public void addRequired(User1 user)\{ user1Mapper.insert(user); \} \}

User2Service方法：

@Service public class User2ServiceImpl implements User2Service \{ //省略其他... @Override @Transactional(propagation = Propagation.REQUIRES\_NEW) public void addRequiresNew(User2 user)\{ user2Mapper.insert(user); \} @Override @Transactional(propagation = Propagation.REQUIRES\_NEW) public void addRequiresNewException(User2 user)\{ user2Mapper.insert(user); throw new RuntimeException(); \} \}

2.1 场景一

外围方法没有开启事务。

验证方法1：

@Override public void notransaction\_exception\_requiresNew\_requiresNew()\{ User1 user1=new User1(); user1.setName("张三"); user1Service.addRequiresNew(user1); User2 user2=new User2(); user2.setName("李四"); user2Service.addRequiresNew(user2); throw new RuntimeException(); \}

验证方法2：

@Override public void notransaction\_requiresNew\_requiresNew\_exception()\{ User1 user1=new User1(); user1.setName("张三"); user1Service.addRequiresNew(user1); User2 user2=new User2(); user2.setName("李四"); user2Service.addRequiresNewException(user2); \}

分别执行验证方法，结果：

<table> 
 <tbody> 
 <tr> 
 <td> 验证方法序号 </td> 
 <td> 数据库结果 </td> 
 <td> 结果分析 </td> 
 </tr> 
 <tr> 
 <td> 1 </td> 
 <td> “张三”插入，“李四”插入。 </td> 
 <td> 外围方法没有事务，插入“张三”、“李四”方法都在自己的事务中独立运行,外围方法抛出异常回滚不会影响内部方法。 </td> 
 </tr> 
 <tr> 
 <td> 2 </td> 
 <td> “张三”插入，“李四”未插入 </td> 
 <td> 外围方法没有开启事务，插入“张三”方法和插入“李四”方法分别开启自己的事务，插入“李四”方法抛出异常回滚，其他事务不受影响。 </td> 
 </tr> 
 </tbody> 
</table>

结论：通过这两个方法我们证明了在外围方法未开启事务的情况下Propagation.REQUIRES\_NEW修饰的内部方法会新开启自己的事务，且开启的事务相互独立，互不干扰。

2.2 场景二

外围方法开启事务。

验证方法1：

@Override @Transactional(propagation = Propagation.REQUIRED) public void transaction\_exception\_required\_requiresNew\_requiresNew()\{ User1 user1=new User1(); user1.setName("张三"); user1Service.addRequired(user1); User2 user2=new User2(); user2.setName("李四"); user2Service.addRequiresNew(user2); User2 user3=new User2(); user3.setName("王五"); user2Service.addRequiresNew(user3); throw new RuntimeException(); \}

验证方法2：

@Override @Transactional(propagation = Propagation.REQUIRED) public void transaction\_required\_requiresNew\_requiresNew\_exception()\{ User1 user1=new User1(); user1.setName("张三"); user1Service.addRequired(user1); User2 user2=new User2(); user2.setName("李四"); user2Service.addRequiresNew(user2); User2 user3=new User2(); user3.setName("王五"); user2Service.addRequiresNewException(user3); \}

验证方法3：

@Override @Transactional(propagation = Propagation.REQUIRED) public void transaction\_required\_requiresNew\_requiresNew\_exception\_try()\{ User1 user1=new User1(); user1.setName("张三"); user1Service.addRequired(user1); User2 user2=new User2(); user2.setName("李四"); user2Service.addRequiresNew(user2); User2 user3=new User2(); user3.setName("王五"); try \{ user2Service.addRequiresNewException(user3); \} catch (Exception e) \{ System.out.println("回滚"); \} \}

分别执行验证方法，结果：

<table> 
 <tbody> 
 <tr> 
 <td> 验证方法序号 </td> 
 <td> 数据库结果 </td> 
 <td> 结果分析 </td> 
 </tr> 
 <tr> 
 <td> 1 </td> 
 <td> “张三”未插入，“李四”插入，“王五”插入。 </td> 
 <td> 外围方法开启事务，插入“张三”方法和外围方法一个事务，插入“李四”方法、插入“王五”方法分别在独立的新建事务中，外围方法抛出异常只回滚和外围方法同一事务的方法，故插入“张三”的方法回滚。 </td> 
 </tr> 
 <tr> 
 <td> 2 </td> 
 <td> “张三”未插入，“李四”插入，“王五”未插入。 </td> 
 <td> 外围方法开启事务，插入“张三”方法和外围方法一个事务，插入“李四”方法、插入“王五”方法分别在独立的新建事务中。插入“王五”方法抛出异常，首先插入 “王五”方法的事务被回滚，异常继续抛出被外围方法感知，外围方法事务亦被回滚，故插入“张三”方法也被回滚。 </td> 
 </tr> 
 <tr> 
 <td> 3 </td> 
 <td> “张三”插入，“李四”插入，“王五”未插入。 </td> 
 <td> 外围方法开启事务，插入“张三”方法和外围方法一个事务，插入“李四”方法、插入“王五”方法分别在独立的新建事务中。插入“王五”方法抛出异常，首先插入“王五”方法的事务被回滚，异常被catch不会被外围方法感知，外围方法事务不回滚，故插入“张三”方法插入成功。 </td> 
 </tr> 
 </tbody> 
</table>

结论：在外围方法开启事务的情况下Propagation.REQUIRES\_NEW修饰的内部方法依然会单独开启独立事务，且与外部方法事务也独立，内部方法之间、内部方法和外部方法事务均相互独立，互不干扰。

3.PROPAGATION\_NESTED

我们为User1Service和User2Service相应方法加上Propagation.NESTED属性。

User1Service方法：

@Service public class User1ServiceImpl implements User1Service \{ //省略其他... @Override @Transactional(propagation = Propagation.NESTED) public void addNested(User1 user)\{ user1Mapper.insert(user); \} \}

User2Service方法：

@Service public class User2ServiceImpl implements User2Service \{ //省略其他... @Override @Transactional(propagation = Propagation.NESTED) public void addNested(User2 user)\{ user2Mapper.insert(user); \} @Override @Transactional(propagation = Propagation.NESTED) public void addNestedException(User2 user)\{ user2Mapper.insert(user); throw new RuntimeException(); \} \}

3.1 场景一

此场景外围方法没有开启事务。

验证方法1：

@Override public void notransaction\_exception\_nested\_nested()\{ User1 user1=new User1(); user1.setName("张三"); user1Service.addNested(user1); User2 user2=new User2(); user2.setName("李四"); user2Service.addNested(user2); throw new RuntimeException(); \}

验证方法2：

@Override public void notransaction\_nested\_nested\_exception()\{ User1 user1=new User1(); user1.setName("张三"); user1Service.addNested(user1); User2 user2=new User2(); user2.setName("李四"); user2Service.addNestedException(user2); \}

分别执行验证方法，结果：

结论：通过这两个方法我们证明了在外围方法未开启事务的情况下Propagation.NESTED和Propagation.REQUIRED作用相同，修饰的内部方法都会新开启自己的事务，且开启的事务相互独立，互不干扰。

3.2 场景二

外围方法开启事务。

验证方法1：

@Transactional @Override public void transaction\_exception\_nested\_nested()\{ User1 user1=new User1(); user1.setName("张三"); user1Service.addNested(user1); User2 user2=new User2(); user2.setName("李四"); user2Service.addNested(user2); throw new RuntimeException(); \}

验证方法2：

@Transactional @Override public void transaction\_nested\_nested\_exception()\{ User1 user1=new User1(); user1.setName("张三"); user1Service.addNested(user1); User2 user2=new User2(); user2.setName("李四"); user2Service.addNestedException(user2); \}

验证方法3：

@Transactional @Override public void transaction\_nested\_nested\_exception\_try()\{ User1 user1=new User1(); user1.setName("张三"); user1Service.addNested(user1); User2 user2=new User2(); user2.setName("李四"); try \{ user2Service.addNestedException(user2); \} catch (Exception e) \{ System.out.println("方法回滚"); \} \}

分别执行验证方法，结果：

<table> 
 <tbody> 
 <tr> 
 <td> 验证方法序号 </td> 
 <td> 数据库结果 </td> 
 <td> 结果分析 </td> 
 </tr> 
 <tr> 
 <td> 1 </td> 
 <td> “张三”、“李四”均未插入。 </td> 
 <td> 外围方法开启事务，内部事务为外围事务的子事务，外围方法回滚，内部方法也要回滚。 </td> 
 </tr> 
 <tr> 
 <td> 2 </td> 
 <td> “张三”、“李四”均未插入。 </td> 
 <td> 外围方法开启事务，内部事务为外围事务的子事务，内部方法抛出异常回滚，且外围方法感知异常致使整体事务回滚。 </td> 
 </tr> 
 <tr> 
 <td> 3 </td> 
 <td> “张三”插入、“李四”未插入。 </td> 
 <td> 外围方法开启事务，内部事务为外围事务的子事务，插入“李四”内部方法抛出异常，可以单独对子事务回滚。 </td> 
 </tr> 
 </tbody> 
</table>

结论：以上试验结果我们证明在外围方法开启事务的情况下Propagation.NESTED修饰的内部方法属于外部事务的子事务，外围主事务回滚，子事务一定回滚，而内部子事务可以单独回滚而不影响外围主事务和其他子事务

4. REQUIRED,REQUIRES\_NEW,NESTED异同

由“1.2 场景二”和“3.2 场景二”对比，我们可知：

NESTED和REQUIRED修饰的内部方法都属于外围方法事务，如果外围方法抛出异常，这两种方法的事务都会被回滚。但是REQUIRED是加入外围方法事务，所以和外围事务同属于一个事务，一旦REQUIRED事务抛出异常被回滚，外围方法事务也将被回滚。而NESTED是外围方法的子事务，有单独的保存点，所以NESTED方法抛出异常被回滚，不会影响到外围方法的事务。

由“2.2 场景二”和“3.2 场景二”对比，我们可知：

NESTED和REQUIRES\_NEW都可以做到内部方法事务回滚而不影响外围方法事务。但是因为NESTED是嵌套事务，所以外围方法回滚之后，作为外围方法事务的子事务也会被回滚。而REQUIRES\_NEW是通过开启新的事务实现的，内部事务和外围事务是两个事务，外围事务回滚不会影响内部事务。

5. PROPAGATION\_SUPPORTS

我们为User1Service和User2Service相应方法加上Propagation.SUPPOERTS属性。

User1Service方法：

@Service public class User1ServiceImpl implements User1Service \{ //省略其他... @Override @Transactional(propagation = Propagation.SUPPOERTS) public void addSupport(User1 user)\{ user1Mapper.insert(user); \} \}

User2Service方法：

@Service public class User2ServiceImpl implements User2Service \{ //省略其他... @Override @Transactional(propagation = Propagation.SUPPOERTS) public void addSupport(User2 user)\{ user2Mapper.insert(user); \} @Override @Transactional(propagation = Propagation.SUPPOERTS) public void addSupportException(User2 user)\{ user2Mapper.insert(user); throw new RuntimeException(); \} \}

5.1 场景一

此场景外围方法没有开启事务。

验证方法1：

@Override public void notransaction\_exception\_nested\_nested()\{ User1 user1=new User1(); user1.setName("张三"); user1Service.addSupport(user1); User2 user2=new User2(); user2.setName("李四"); user2Service.addSupport(user2); throw new RuntimeException(); \}

验证方法2：

@Override public void notransaction\_nested\_nested\_exception()\{ User1 user1=new User1(); user1.setName("张三"); user1Service.addSupport(user1); User2 user2=new User2(); user2.setName("李四"); user2Service.addSupportException(user2); \}

分别执行验证方法，结果：

<table> 
 <tbody> 
 <tr> 
 <td> 验证方法序号 </td> 
 <td> 数据库结果 </td> 
 <td> 结果分析 </td> 
 </tr> 
 <tr> 
 <td> 1 </td> 
 <td> “张三”、“李四”均插入。 </td> 
 <td> 外围方法未开启事务，插入“张三”、“李四”方法以非事务方法独立运行。外围方法异常不会影响到其他方法运行 </td> 
 </tr> 
 <tr> 
 <td> 2 </td> 
 <td> “张三”、“李四”均插入。 </td> 
 <td> 外围方法没有事务，插入“张三”、“李四”方法以非事务独立运行,插入“李四”方法抛出异常对已运行数据不受影响。 </td> 
 </tr> 
 </tbody> 
</table>

结论：通过这两个方法我们证明了在外围方法未开启事务的情况下Propagation.SUPPOERTS，修饰的内部方法都会以非事务方法运行。

5.2 场景二

外围方法开启事务。

验证方法1：

验证方法2：

验证方法3：

分别执行验证方法，结果：

结论：以上试验结果我们证明在外围方法开启事务的情况下Propagation.SUPPOERTS修饰的内部方法会加入到外围方法的事务中，所有Propagation.SUPPOERTS修饰的内部方法和外围方法均属于同一事务，只要一个方法回滚，整个事务均回滚。

6、PROPAGATION\_MANDATORY

我们为User1Service相应方法加上Propagation.MANDATORY属性。

6.1、外围方法没有开启事务

方法直接抛出异常，如下：