你了解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方法:
@Service public class User1ServiceImpl implements User1Service { @Override @Transactional(propagation = Propagation.REQUIRED) public void addRequired(User1 user){ user1Mapper.insert(user); } }
User2Service方法:
@Service public 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方法:
@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); }
分别执行验证方法,结果:
结论:通过这两个方法我们证明了在外围方法未开启事务的情况下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方法:
@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_nes 8000 ted_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相关文章,学习资料都会在里面更新,整理的资料也会放在里面。
觉得写的还不错的就点个赞,加个关注呗!点关注,不迷路,持续更新!!!
- 2.2.1 传播行为 当事务方法被另一个事务方法调用时,必须指定事务应该如何传播。例如:方法可能继续在现有事务中运行,也可能开启一个新事务,并在自己的事务中运行。
- Spring事务传播特性的浅析——事务方法嵌套调用
- Spring事务传播特性的浅析——事务方法嵌套调用的迷茫
- Spring事务传播特性的浅析——事务方法嵌套调用的迷茫
- Spring事务传播特性的浅析——事务方法嵌套调用的迷茫
- Spring事务传播特性的浅析——事务方法嵌套调用的迷茫
- Spring事务传播特性的浅析——事务方法嵌套调用的迷茫
- Spring事务的传播行为和隔离级别
- Spring五个事务隔离级别和七个事务传播行为
- Spring事务的传播行为和隔离级别
- SpringAop 事务传播行为
- Spring事务的传播行为和隔离级别
- Spring事务传播行为种类
- spring事务传播行为种类
- spring 事务传播行为
- 切面(aop)控制反转和依赖注入(IOC,DI)和spring的事务隔离和传播行为
- [转帖]Spring事务,传播行为类型PROPAGATION_REQUIRED
- Spring中的事务传播行为
- Spring事务的传播行为和隔离级别
- Spring事务的传播行为和隔离级别