spring事务的传播方式

已于 2022-10-28 12:23:04 修改
阅读量3.8k 收藏 9
点赞数 1
分类专栏： spring 文章标签： spring 事务传播
于 2019-06-21 15:24:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LiuRenyou/article/details/93197263
版权

文章目录

文章简介：

在写spring几个有趣的小甜点中的事务失效的时候被事务传播机制卡住了，觉得有必要学习整理一下事务的传播。
事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。
例如：methodA事务方法调用methodB事务方法时，methodB是继续在调用者methodA的事务中运行呢，还是为自己开启一个新事务运行，这就是由methodB的事务传播行为决定的。

REQUIRED(默认是这个)：

这个方法必须运行在事务中，如果事务存在，则会运行在当前事务中，否则会新开一个事务。
什么意思？从字面意思根本看不懂，举例最实在了。
controller

	@RequestMapping("tran")
    public void hello(){
        Order order = new Order();
        order.setName("order1");
        userService.createOrder(order);
    }

service

	@Override
    @Transactional
    public void createOrder(Order order) {
        orderMapper.save(order);
        try {
            UserService proxy= (UserService)AopContext.currentProxy();
            proxy.sendMsg();
        }catch (Exception e){
            System.out.println("rollback");
        }
    }
    @Override
    @Transactional(propagation= Propagation.REQUIRED)
    public void sendMsg(){
        msgMapper.save(new Msg("你已经下单了"));
        //调用短信网关
        throw new RuntimeException();//运行时异常，编译时上层可以不捕捉
    }

createOrder外层事务加了@Transactional，调用sendMsg，sendMsg事务传播方式为REQUIRED，如果createOrder外层事务存在，则sendMsg会运行createOrder事务中，这也就是为什么在sendMsg里面抛运行时异常会.UnexpectedRollbackException: Transaction rolled back because it has been marked as rollback-only。解决方法在spring几个有趣的小甜点事务失效部分有详细解说。

上面是外层createOrder加了 @Transactional的情况，如果外层事务不加这个注解，那么内层事务sendMsg会自己开一个事务。此时的结果应该是订单表add进去了，短信表被回滚。

SUPPORTS：

这个方法不需要事务，但是如果存在事务，就在事务中运行。
createOrder没有事务，所以sendMsg也没有事务，最终的结果就是两张表都add进去了。

	@Override
    public void createOrder(Order order) {
        orderMapper.save(order);
        try {
            UserService proxy= (UserService)AopContext.currentProxy();
            proxy.sendMsg();
        }catch (Exception e){
            System.out.println("rollback");
        }
    }
    @Override
    @Transactional(propagation= Propagation.SUPPORTS)
    public void sendMsg(){
        msgMapper.save(new Msg("你已经下单了"));
        //调用短信网关
        throw new RuntimeException();//运行时异常，编译时上层可以不捕捉
    }

如果给createOrder加事务注解，那么两个方法就都有事务了，而且是在同一个事务中运行，不出意外又是UnexpectedRollbackException: Transaction rolled back because it has been marked as rollback-only

MANDATORY：

该方法必须在事务中运行，如果没有事务，抛异常IllegalTransactionStateException

	@Override
	@Transactional
    public void createOrder(Order order) {
        orderMapper.save(order);
        try {
            UserService proxy= (UserService)AopContext.currentProxy();
            proxy.sendMsg();
        }catch (Exception e){
            System.out.println("rollback");
        }
    }
    @Override
    @Transactional(propagation= Propagation.MANDATORY)
    public void sendMsg(){
        msgMapper.save(new Msg("你已经下单了"));
        //调用短信网关
        throw new RuntimeException();//运行时异常，编译时上层可以不捕捉
    }

两个方法都有事务了，而且是在同一个事务中运行，不出意外又是UnexpectedRollbackException: Transaction rolled back because it has been marked as rollback-only
如果把createOrder改成这样

 @Override
public void createOrder(Order order) {
        orderMapper.save(order);
        try {
            UserService proxy= (UserService)AopContext.currentProxy();
            proxy.sendMsg();
        }catch (Exception e){
            System.out.println("rollback");
            e.printStackTrace();//打印异常看看
        }
    }

会抛出IllegalTransactionStateException: No existing transaction found for transaction marked with propagation ‘mandatory’

REQUIRES_NEW：

该方法必须运行在新事务中

	@Override
    @Transactional
    public void createOrder(Order order) {
        orderMapper.save(order);
        try {
            UserService proxy= (UserService)AopContext.currentProxy();
            proxy.sendMsg();
        }catch (Exception e){
            System.out.println("rollback");
            e.printStackTrace();
        }
    }
    @Override
    @Transactional(propagation= Propagation.REQUIRES_NEW)
    public void sendMsg(){
        msgMapper.save(new Msg("你已经下单了"));
        //调用短信网关
        throw new RuntimeException();//运行时异常，编译时上层可以不捕捉
    }

很明显无论createOrder加不加事务，sendMsg都是有自己的事务的，所以执行结果是order表add进去，msg回滚。非常符合业务需求。

NOT_SUPPORTED：

该方法不应该运行在事务中，如果当前存在事务，事务会被挂起。

	@Override
    @Transactional
    public void createOrder(Order order) {
        orderMapper.save(order);
        try {
            UserService proxy= (UserService)AopContext.currentProxy();
            proxy.sendMsg();
        }catch (Exception e){
            System.out.println("rollback");
            e.printStackTrace();
        }
    }

    @Override
    @Transactional(propagation= Propagation.NOT_SUPPORTED)
    public void sendMsg(){
        msgMapper.save(new Msg("你已经下单了"));
        //调用短信网关
        throw new RuntimeException();//运行时异常，编译时上层可以不捕捉
    }

createOrder不加事务时没什么好说的，createOrder加事务时，这个事务会被挂起，所以相当于没加事务，所以两张表都加进去了。

NEVER

该方法不能运行在事务中，如果存在事务，抛异常，这个最简单，不说了。

NESTED

如果当前存在事务，则该方法会在嵌套事务中运行，该嵌套事务可以独立于当前事务进行提交回滚操作。
如果当前不存在事务，会新开一个事务

	@Override
    @Transactional
    public void createOrder(Order order) {
        orderMapper.save(order);
        try {
            UserService proxy= (UserService)AopContext.currentProxy();
            proxy.sendMsg();
        }catch (Exception e){
            System.out.println("rollback");
            e.printStackTrace();
        }
    }
    @Override
    @Transactional(propagation= Propagation.NESTED)
    public void sendMsg(){
        msgMapper.save(new Msg("你已经下单了"));
        //调用短信网关
        throw new RuntimeException();//运行时异常，编译时上层可以不捕捉
    }

此时内层事务sendMsg会独立于外层事务进行事务的提交回滚，所以最终结果时order表add进去，msg被回滚。非常符合业务需求。

增强理解

例1，NOT_SUPPORTED

	@Override
    @Transactional
    public void testTran()   {
        orderService.saveOrder();//保存订单
        productService.saveProduct();//保存商品
    }
		
	@Override
    public void saveOrder(){
        Order order = new Order();
        order.setOrderSn(2L);
        order.setProductId(1);
        order.setUserId(1);
        order.setBuyNum(1);
        orderMapper.save(order);
    }
    
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    @Override
    public void saveProduct(){
        Product product = new Product();
        product.setPrice(1);
        product.setName("2121");
        productMapper.insert(product);
        int i = 1/0;
    }

读者可以先判断下最终order和product表最终的数据状态？

执行流程如下：
在这里插入图片描述结论：订单表回滚，商品表不回滚，not_supported会挂起事务，在执行完后会恢复事务

例2，REQUIRED_NEW

	@Override
    @Transactional
    public void testTran()   {
        orderService.saveOrder();//保存订单
        productService.saveProduct();//保存商品
        int i = 1/0;
    }
		
	@Override
    public void saveOrder(){
        Order order = new Order();
        order.setOrderSn(2L);
        order.setProductId(1);
        order.setUserId(1);
        order.setBuyNum(1);
        orderMapper.save(order);
    }
    
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    @Override
    public void saveProduct(){
        Product product = new Product();
        product.setPrice(1);
        product.setName("2121");
        productMapper.insert(product);
    }

结果：product不回滚，order回滚，因为saveProduct是一个新开事务，所以没有异常直接就提交了

例3，REQUIRED

REQUIRED作用是需要事务，没有就新开一个事务。

	@Override
    @Transactional
    public void testTran()   {
        orderService.saveOrder();//保存订单
        try{
        	productService.saveProduct();//保存商品
        }catch(Exception e){
        
        }
    }
		
	@Override
    public void saveOrder(){
        Order order = new Order();
        order.setOrderSn(2L);
        order.setProductId(1);
        order.setUserId(1);
        order.setBuyNum(1);
        orderMapper.save(order);
    }
    
    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void saveProduct(){
        Product product = new Product();
        product.setPrice(1);
        product.setName("2121");
        productMapper.insert(product);
        int i = 1/0;
    }

结果是两个表都回滚，这个就有点奇怪，因为自始至终就只有一个testTran开启的事务，saveProduct也只是延用了testTran开启的事务，就算saveProduct抛了异常，但是testTran捕捉了，其实不应该回滚的吧？但是源代码不是这么处理的。
在这里插入图片描述
在这里插入图片描述

酒醉梦醒
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring事务传播行为问题解决
08-25
主要介绍了Spring事务传播行为问题解决,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring的事务传播机制(通俗易懂)
Samdom的博客
06-05 1万+
概述 Spring的传播机制有7种，在枚举Propagation中有定义。 1.REQUIRED PROPAGATION_REQUIRED：如果当前没有事务，就创建一个新事务，如果当前存在事务，就加入该事务，该设置是最常用的默认设置。 @Transactional(propagation= Propagation.REQUIRED) public void methodA(){ methodB(); // do something } @Transactional(propagation= P
Spring 事务（详解）
最新发布
qq_45559559的博客
03-24 2490
将⼀组操作封装成⼀个执⾏单元，要么全部成功要么全部失败。
事务的7种传播行为
glenshappy的专栏
10-14 3934
另一方面, PROPAGATION_NESTED 开始一个 “嵌套的” 事务, 它是已经存在事务的一个真正的子事务. 潜套事务开始执行时, 它将取得一个 savepoint. 如果这个嵌套事务失败, 我们将回滚到此 savepoint. 潜套事务是外部事务的一部分, 只有外部事务结束后它才会被提交。两个事务不是一个真正的嵌套事务。举例说明：有两个事务方法，一个是方法A，一个是方法B，方法A中调用了方法B，那方法B是开启一个事务运行还是在方法A中的事务中运行，是由方法B的事务传播行为控制的。
【Spring学习34】Spring事务(4)：事务属性之7种传播行为
程序老兵的博客
04-20 1万+
事务传播行为什么叫事务传播行为？听起来挺高端的，其实很简单。 即然是传播，那么至少有两个东西，才可以发生传播。单体不存在传播这个行为。事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。 例如：methodA事务方法调用methodB事务方法时，methodB是继续在调用者methodA的事务中运行呢，还是为自己开启一个
事务的7种传播机制和演示
猎人在吃肉
04-11 6489
required 如果当前没有事务，就创建一个新事务，如果当前存在事务，就加入该事务，该设置是最常用的设置。 requires_new 创建新事务，无论当前存不存在事务，都创建新事务。 nested 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与 propagation_required 类似的操作。 supports 支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就以非事务执行。 not_supported 以非事务方式执行操作，如果
事务
kk屯学的博客
12-04 285
/** * 事务传播 - Propagation * REQUIRED: 使用当前的事务，如果当前没有事务，则自己新建一个事务，子方法是必须运行在一个事务中的； * 如果当前存在事务，则加入这个事务，成为一个整体。 * 举例：领导没饭吃，我有钱，我会自己买了自己吃；领导有的吃，会分给你一起吃。 * SUPP...
【Spring】Spring的7种事务传播机制讲解，以及49种组合方式介绍
zxy2361380031的博客
03-09 3811
Spring的7种事务传播机制讲解，以及49种组合方式介绍
事务的七种传播方式
__盛某人的博客
12-30 41
所谓事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。 当事务存在嵌套关系时，子事务与父事务的关系以及回滚的影响范围(传播-回滚的传播) 示例定义： T1{ O(A); T2{ O(B); O(C); }; O(D); }; 各种传播性的关系 PROPAGATION_REQU...
详解事务的7种传播行为
热门推荐
卓越无关环境，保持空杯心态——靡不有初，鲜克有终
04-11 5万+
什么是Spring事务的传播行为？事务传播行为的七种类型有哪些？将异常try-catch捕获，事务是否还会回滚？
Spring事务传播行为详解
m0_62903983的博客
07-07 918
Spring在TransactionDefinition接口中规定了7种类型的事务传播行为。事务传播行为是Spring框架独有的事务增强特性，他不属于的事务实际提供方数据库行为。这是Spring为我们提供的强大的工具箱，使用事务传播行可以为我们的开发工作提供许多便利。但是人们对他的误解也颇多，你一定也听过“service方法事务最好不要嵌套”的传言。要想正确的使用工具首先需要了解工具。本文对七种事务传播行为做详细介绍，内容主要代码示例的方式呈现。......
spring 事务传播 demo
06-05
spring 事务传播 demo
浅谈Spring事务传播行为实战
08-25
主要介绍了浅谈Spring事务传播行为实战，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
spring事务几种传播方式
07-31
本文介绍spring事务传播的几种方式
Spring事务传播机制.docx
01-13
spring传播机制个人学习
Spring中事务传播行为的介绍
08-26
今天小编就为大家分享一篇关于Spring中事务传播行为的介绍，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
Spring事务传播
三冬暖
07-08 719
事务传播行为是为了解决业务层方法之间互相调用的事务问题，当一个事务方法被另一个事务方法调用时，事务该以何种状态存在？例如新方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行，等等，这些规则就涉及到事务的传播性。大白话就是，多个业务相互调用，业务如果开启了业务，业务会变成什么样？（新建一个业务还是共用同一个业务）
Spring的7种事务传播方式
一只猿的自我修养
12-30 2544
Spring事务传播行为体现在某个service方法调用另一个service方法，事务该如何进行下去。 Spring支持7中事务传播方式...
一文看懂Spring事务传播机制
a20100997的博客
03-15 822
所谓事务的“传播”指的是多个包含事务的方法互相调用时，事务是如何传播的。本文首先介绍Spring中的七种事务传播方式，然后针对每一种传播方式举例进行讲解，看完就能完全理解Spring的事务传播机制。
spring事务传播方式
09-07
Spring事务传播方式是指在一个service方法调用另一个service方法时，事务如何进行传播。Spring的默认事务传播方式是PROPAGATION_REQUIRED。这意味着如果当前存在一个事务（比如其他有事务的service方法调用此方法）...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值