2020-12-30

你了解Spring事务传播行为吗？多个方法之间调用事务如何传播？

前言:

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

基础概念:

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

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

用伪代码说明：

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

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

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

定义非常简单，也很好理解，下面我们就进入代码测试部分，验证我们的理解是否正确。

代码验证:

文中代码以传统三层结构中两层呈现，即Service和Dao层，由Spring负责依赖注入和注解式事务管理，DAO层由Mybatis实现，你也可以使用任何喜欢的方式，

例如，Hibernate,JPA,JDBCTemplate等。数据库使用的是MySQL数据库，你也可以使用任何支持事务的数据库，并不会影响验证结果。

User1Service方法：

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

User2Service方法：

@Servicepublic class User2ServiceImpl implements User2Service {  @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 场景一
此场景外围方法没有开启事务。

验证方法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); }

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

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

1.2 场景二

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

验证方法1:

 @Override @Transactional(propagation = Propagation.REQUIRED) public void transaction_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 @Transactional(propagation = Propagation.REQUIRED) public void transaction_required_required_exception(){  User1 user1=new User1();  user1.setName("张三");  user1Service.addRequired(user1);    User2 user2=new User2();  user2.setName("李四");  user2Service.addRequiredException(user2); }

验证方法3：

 @Transactional @Override 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("方法回滚");  } }

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

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

2.PROPAGATION_REQUIRES_NEW

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

User1Service方法：

@Servicepublic 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方法：

@Servicepublic 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); }

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

结论：通过这两个方法我们证明了在外围方法未开启事务的情况下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("回滚");  } }

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

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

3.PROPAGATION_NESTED

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

User1Service方法：

@Servicepublic class User1ServiceImpl implements User1Service {  @Override @Transactional(propagation = Propagation.NESTED) public void addNested(User1 user){  user1Mapper.insert(user); }}

User2Service方法：

@Servicepublic 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("方法回滚");  } }

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

结论：以上试验结果我们证明在外围方法开启事务的情况下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是通过开启新的事务实现的，内部事务和外围事务是两个事务，外围事务回滚不会影响内部事务。

结论

通过上面的介绍，相信大家对Spring事务传播行为有了更加深入的理解，希望大家日常开发工作有所帮助。

写在最后

欢迎大家关注我的公众号【风平浪静如码】，海量Java相关文章，学习资料都会在里面更新，整理的资料也会放在里面。

觉得写的还不错的就点个赞，加个关注呗！点关注，不迷路，持续更新！！！









原文转载：http://www.shaoqun.com/a/504499.html

跨境电商：https://www.ikjzd.com/

3suisses：https://www.ikjzd.com/w/412

拍怕：https://www.ikjzd.com/w/2205


前言:Spring在TransactionDefinition接口中规定了7种类型的事务传播行为。事务传播行为是Spring框架独有的事务增强特性，他不属于的事务实际提供方数据库行为。这是Spring为我们提供的强大的工具箱，使用事务传播行可以为我们的开发工作提供许多便利。但是人们对他的误解也颇多，你一定也听过"service方法事务最好不要嵌套"的传言。要想正确的使用工具首先需要了解工具。本文对
巴克莱银行：巴克莱银行
沃尔玛：沃尔玛
Shopee 11.11爆单背后：我亲历的东南亚电商风云 ：Shopee 11.11爆单背后：我亲历的东南亚电商风云
宠物用品选品：Wish1000+亿级宠物用品市场的选品技巧：宠物用品选品：Wish1000+亿级宠物用品市场的选品技巧
江西乐安县流坑古村周边有什么好玩的景点？：江西乐安县流坑古村周边有什么好玩的景点？
Posted by at

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)