深入理解Spring事务传播机制-原理与实例说明

最新推荐文章于 2024-03-14 07:30:00 发布
最新推荐文章于 2024-03-14 07:30:00 发布
阅读量242 收藏 1
点赞数
文章标签： spring 数据库 事务 Spring事务 Spring事务传播机制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/trayvontang/article/details/131785624
版权

事务传播机制

简化记忆版本

  1. REQUIRED:有事务加入，没有事务创建，Spring默认
  2. MANDATORY:必须在事务中被调用，没有抛异常
  3. SUPPORTS:有事务加入，没有以非事务运行
  4. NOT_SUPPORTED:不需要事务，有事务则挂起，避免回滚。例如记日志，避免日志信息回滚
  5. REQUIRES_NEW:当前方法创建新事务运行，如果有事务则挂起，主要是为了控制敏感资源事务粒度，避免从时间锁，可以局部回滚
  6. NESTED:如果有事务，加入事务但是记录保存点，如果没有事务创建事务，主要作用局部回滚(通过savepoint实现)，不挂起已有事务
  7. NEVER:该方法不应该在事务中运行，如果存在事务则抛异常

不同传播机制之间的区别

REQUIRED与MANDATORY:REQUIRED没有事务自己创建，MANDATOR没有事务异常。

传播机制区别
REQUIRED与MANDATORY方法没有事务，REQUIRED自己创建；而MANDATOR抛出异常
REQUIRED与REQUIRES_NEW方法在事务中执行，REQUIRED加入该事务；REQUIRES_NEW会挂起已有的事务，创建自己的事务
NESTED与REQUIRES_NEW方法在事务中执行NESTED加入该事务，并记录回滚点；REQUIRES_NEW挂起已有事务，创建新事务
NESTED与REQUIRED都是有事务加入，没有事务创建，但NESTED比REQUIRED多了保存回滚点
NOT_SUPPORTED与NEVER方法在事务中被调用NOT_SUPPORTED会挂起事务，而NEVER会抛出异常
MANDATORY与NEVER两者相反， 没有在事务中MANDATORY抛出异常，而有事务NEVER抛出异常
SUPPORTS与没有传播机制注解感觉没有区别，发现有区别的朋友可以补充一下

当SUPPORTS方法被NEVER、NOT_SUPPORTED、没有@Transactional注解这些方法调用，不会有事务，和不加注解效果一样。
当SUPPORTS方法被REQUIRED、MANDATORY、REQUIRES_NEW、NESTED这些方法调用时，加入事务，和不加注解效果也一样。

所以SUPPORTS应用场景是啥？

问题测试

REQUIRED与MANDATORY

@Service
public class ServiceA
{
    @Transactional(propagation = Propagation.REQUIRED)
    public void methodA(){
        methodB();
    }
    
    @Transactional(propagation = Propagation.MANDATORY)
    public void methodB(){}
}

@Service
public class ServiceC
{
    @Resource
    private ServiceA serviceA;

    public void methodC(){
        // 创建一个事务执行方法A
        serviceA.methodA();
        // methodB是MANDATORY，但是methodC没有事务，所以直接抛出异常
        serviceA.methodB();
    }
}

NESTED回滚测试

@Service
public class ServiceA
{
    @Transactional(propagation = Propagation.NESTED)
    public void methodA(){
        // 数据库操作
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
}

@Service
public class ServiceB
{
    
    @Transactional(propagation = Propagation.NESTED)
    public void methodB(){
        // 数据库操作
    }
}


@Service
public class ServiceC
{
    @Resource
    private ServiceA serviceA;

    @Resource
    private ServiceB serviceB;

    @Transactional
    public void methodC(){
        serviceA.methodA();
        serviceB.methodB();
    }
}

上面的操作哪些会回滚？

答案是：
methodA会回滚
methodB不回滚

因为methodA、methodB是NESTED，记录了回滚点，所以只有methodA被回滚。

NESTED传播测试

做一点小变动，如果把methodA上的@Transactional(propagation = Propagation.NESTED)注解去掉呢？
放在methodC方法上会怎样？

@Service
public class ServiceA
{
    public void methodA(){
        // 数据库操作
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
}

@Service
public class ServiceB
{
    
    @Transactional(propagation = Propagation.NESTED)
    public void methodB(){
        // 数据库操作
    }
}


@Service
public class ServiceC
{
    @Resource
    private ServiceA serviceA;

    @Resource
    private ServiceB serviceB;

    @Transactional(propagation = Propagation.NESTED)
    public void methodC(){
        serviceA.methodA();
        serviceB.methodB();
    }
}

答案是：
methodA会回滚
methodB会回滚

因为methodA没有注解，就相当于使用的是methodC的事务，并且所以回滚点在methodC，
methodB也使用了methodC的事务，也设置了回滚点，但是在methodA中回滚，整个事务都回滚了。

如何只回滚methodB，不回滚methodA呢？

答案是：
将methodA的TransactionAspectSupport.currentTransactionStatus().setRollbackOnly()放在方法放methodB中就可以。
当methodB是NESTED的时候，在其中回滚，因为有回滚点，所以只会回滚methodB中操作，不会影响methodC方法。

REQUIRES_NEW回滚测试

再来一点点小变动：
将methodB的NESTED换为REQUIRES_NEW会怎样？

@Service
public class ServiceA
{
    public void methodA(){
        // 数据库操作
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
}

@Service
public class ServiceB
{
    
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void methodB(){
        // 数据库操作
    }
}


@Service
public class ServiceC
{
    @Resource
    private ServiceA serviceA;

    @Resource
    private ServiceB serviceB;

    @Transactional(propagation = Propagation.NESTED)
    public void methodC(){
        serviceA.methodA();
        serviceB.methodB();
    }
}

答案是：
methodA会回滚
methodB不回滚

把methodB的NESTED换为REQUIRES_NEW就可以，因为REQUIRES_NEW为挂起原有事务，并创建新的事务，
所以methodC的事务不会影响到methodB的事务。

异常对不同传播机制回滚影响测试

再来一点点小变动：

将methodA中的手动回滚TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
换为：throw new RuntimeException(“我要异常”);

会怎样呢？

@Service
public class ServiceA
{
    @Transactional(propagation = Propagation.NESTED)
    public void methodA(){
        // 数据库操作
        throw new RuntimeException("我要异常");
    }
}

@Service
public class ServiceB
{
    
    @Transactional(propagation = Propagation.NESTED)
    public void methodB(){
        // 数据库操作
    }
}


@Service
public class ServiceC
{
    @Resource
    private ServiceA serviceA;

    @Resource
    private ServiceB serviceB;

    @Transactional
    public void methodC(){
        serviceA.methodA();
        serviceB.methodB();
    }
}

答案是：
methodA会回滚
methodB会回滚

如果异常这一次把methodB的传播机制换NESTED为REQUIRES_NEW还能生效吗？

答案是：不能。

很难理解？

的确比较绕，其实很简单，因为异常了，根本就没有执行到methodB，就直接回滚了。

事务内部调用

再来点简单点的问题。

// 调用 1
public class ServiceA
{
    @Transactional
    public void methodA(){
        userMapper.insertSelective(UserTO.builder()
                .username("tim")
                .email("test@gmail.com")
                .build());
        methodB();
    }
    
    public void methodB(){
        eventLogMapper.insertSelective(EventLogTO.builder()
                .type((short) 1)
                .message("创建用户")
                .build());
    }
}

这个事务会生效吗？

答案是：会，很简单，在方法methodA中调用methodB，其实和把methodB的方法体放入methodA方法体中没有什么一样。

在这里插入图片描述

// 调用2
public class ServiceA
{
    public void methodA(){
        methodB();
    }
    
    @Transactional
    public void methodB(){}
}

这个事务会生效吗？

答案是：不能，很多朋友都知道，因为没有走代理，Spring的事务必须通过代理。

如何让它生效呢？

不要直接调用，通过Spring的方式来呗。

@EnableAspectJAutoProxy(exposeProxy = true)
ServiceA serviceA = (ServiceA)AopContext.currentProxy();
serviceA.methodB();

或者：

@Resource
private ApplicationContext applicationContext;
ServiceA serviceA = applicationContext.getBean(this.getClass());
serviceA.methodB();

或者：

@Service
public class ServiceA
{
    @Resource
    private ServiceB serviceB;

    public void methodA(){
        serviceB.methodB();
    }
}

@Service
public class ServiceB
{    
    @Transactional
    public void methodB(){}
}

SQL

CREATE TABLE user (
  id bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  username varchar(30) DEFAULT NULL COMMENT '姓名',
  age smallint(5) unsigned DEFAULT NULL COMMENT '年龄',
  sex tinyint DEFAULT -1 COMMENT '性别(-1-保密,1-男,2-女)',
  email varchar(255) DEFAULT NULL COMMENT '邮箱',
  status tinyint DEFAULT 1 COMMENT '状态(-1-删除,1-正常)' ,
  create_time datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  update_time datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '修改时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='用户表';

CREATE TABLE event_log (
  id bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  message varchar(255) DEFAULT NULL COMMENT '信息',
  type smallint(5) unsigned DEFAULT NULL COMMENT '事件类型',
  create_time datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='事件日志';
trayvontang
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
深入理解Spring事务的传播行为
08-26
Spring事务的传播行为是Spring框架在事务管理中的一项重要特性，它定义了在不同事务上下文中如何执行方法的规则。这些行为由`TransactionDefinition`接口中的7种常量表示，它们分别为： 1. `PROPAGATION_REQUIRED`:...
02-01-10-Spring事务传播原理及数据库事务操作原理1
08-04
在本课程中，我们将深入探讨Spring事务传播原理和数据库事务操作的基本概念，这对于有Spring开发经验的人员来说，是进一步深化事务控制理解的关键。我们还将触及分布式事务的初步知识，帮助开发者更好地掌握基于...
Spring 事务七大传播机制 —— REQUIRED、SUPPORTS、MANDATORY、REQUIRES_NEW、NOT_SUPPORTED、NEVER、NESTED
最新发布
流华追梦的专栏
03-14 2418
首先简单了解一下 Spring 中事务传播行为是什么？听起来很高端，但是真正用起来的时候，稍有不慎，就会让自己陷入困境之中，所以在使用之前，我们必须要十分耐心认真的学习它。从名字理解起来，事务传播行为，既然为传播就肯定发生在两个实体之间，否则单个实体又如何发生行为呢。通俗点讲就是“一个巴掌拍不响”。下面是定义。事务传播行为主要用来描述由某一个事务传播行为修饰的方法被嵌套进另一个方法的事务中，该事务如何传播。这个概述可能不好理解，换句话就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。
Spring事务传播机制详细讲解
qq_39939541的博客
08-01 2100
事务传播机制允许开发者根据实际需求来控制事务的行为。通过合理选择事务传播机制，可以保证事务的一致性和可靠性，提高系统的稳定性和性能。需要注意的是，事务传播机制只对方法级别的事务起作用，对注解方式的事务不适用。在使用注解方式时，可以通过@Transactional注解的propagation属性来指定事务的传播行为。
Spring事务传播机制Propagation.REQUIRES_NEW详解及测试
热门推荐
墨迹程序员
10-30 9万+
REQUIRES_NEW官方文档解释： Create a new transaction, and suspend the current transaction if one exists. 意思是，创建一个新事务，如果当前存在事务，将这个事务挂起。也就是说如果当前存在事务，那么将当前的事务挂起，并开启一个新事务去执行REQUIRES_NEW标志的方法。 先来总结一下结果： 1.标志REQUIR...
spring事务
zhanghe_zht的博客
12-03 956
https://blog.csdn.net/soonfly/article/details/70305683
spring事务传播机制requires_new
wit_cx的博客
08-11 2484
简单案例，保存订单，修改商品数量 就是这两个方法，第一个方法中引用了第二个方法，都用@Transactional注解。debug调用shopping方法。 spring事务实现的源码 在调用方法时会扫描@Transactional，进入方法前会判断是否有注解（在类上也会扫描到，具体扫描方式不是本博客重点） 接着debug这个test方法，会产生proxy的代理 进入proxy（动态代理） 也就是说通过AOP，在进入具体的方法之前，对方法进行了增强，具体增强什么，看下文。 .
Spring的事务机制实例代码
08-28
Spring的事务机制实例代码 Spring的事务机制实例代码主要介绍了Spring的事务机制实例代码，分享了相关...Spring的事务机制实例代码可以帮助开发者更好地理解和应用Spring的事务机制，从而提高开发效率和代码质量。
Spring中的事务管理实例详解
09-04
本篇文章将深入探讨Spring中的事务管理机制，通过实例分析事务的基本概念、特性以及如何在Spring中实现事务管理。 首先，事务是数据库操作的核心概念，它是一个逻辑工作单元，包含了多个数据库操作。事务具有四大...
spring-tx事务管理实例
04-22
本实例将深入探讨Spring事务管理的实现与应用。 首先，Spring事务管理分为编程式事务管理和声明式事务管理两种方式。编程式事务管理是通过调用TransactionTemplate或直接使用PlatformTransactionManager接口来控制...
spring事务REQUIRED REQUIRES_NEW区别
走马行酒醴，驱车布鱼肉
03-15 5448
Spirng中事务的传播性
qq_62698326的博客
02-19 1538
Spring的事务传播
Spring事务REQUIRES_NEW，REQUIRED【开启多线程，事务嵌套】
qq_42196643的博客
12-06 2273
这种事务传播类型新创建的事务和被挂起的事务没有任何关系，他们是两个相互独立的事务，外部事务失败后回滚，不会回滚内部事务的执行结果，内部事务执行失败抛出异常，被外部事务捕获时，外部事务可以不处理内部事务的回滚操作。2.ServiceA使用REQUIRES、ServiceB使用REQUIRES_NEW,同样也是回滚ServiceA的以及ServiceB中有异常的(附图1),需要注意的是：这里回滚A是由于在A中使用了try catch才回滚，如果没有使用try chtch是不会回滚A的（附图2）。
spring事务特性和事务传播
08-15 147
事务特性： 原子性 一致性 隔离性(不同事务相互隔离) 持久性(一旦完成不可逆转) 事务传播七大行为 无事务 required supports 如果当前程序存在事务就加入该事务运行，如果不存在事务则在非事务中运行 mandatory 必须在一个事务中运行，否则就会抛出异常mandatory 这个单词有强制性的意思我们默认用required 而不用mandatory，是因为mandatory不能自动创建事务 required _new 不管事务是不是存在，都会另起一个事务，如果事.
spring事务-说说事物传播机制及其实现原理
青鸟飞鱼
01-02 1522
前言 spring目前已是java开发的一个事实标准，这得益于它的便利、功能齐全、容易上手等特性。在开发过程当中，操作DB是非常常见的操作，而涉及到db，就会涉及到事务。事务在平时的开发过程当中，就算没有注意到，程序正常执行不会有副作用，但如果出现了异常，而又没有处理好事务的话，可能就会出现意想不到的结果。spring在事务方面进行了各种操作的封装，特别是声明式事务的出现，让开发变得更加的舒心。spring对事务进行了扩展，支持定义多种传播属性，这也是本篇要说明的重点。 事务是什么 非严格的讲，一个事务是多
Spring事务（事务的实现、隔离级别、传播机制）
日常学习记录、分享，愿我们都遇见更好的自己，与诸君共勉
01-22 1833
什么是事务？事务的隔离级别又是什么？事务的传播机制又是个什么东东🤔
spring的propogation(传播机制)
ForestCat的专栏
08-24 1251
pring的propagation，表示打算对这些方法怎么使用事务，是用还是不用. propagation有七种配置.  REQUIRED：支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。  SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。  MANDATORY：支持当前事务，如果当前没有事务，就抛出异常。  REQUIRES_NEW：新建事务，如果
事务的7种传播机制和演示
猎人在吃肉
04-11 6981
required 如果当前没有事务，就创建一个新事务，如果当前存在事务，就加入该事务，该设置是最常用的设置。 requires_new 创建新事务，无论当前存不存在事务，都创建新事务。 nested 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与 propagation_required 类似的操作。 supports 支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就以非事务执行。 not_supported 以非事务方式执行操作，如果
Spring 7种事务的传播机制
qq_15490613的博客
11-23 275
7种事务的传播机制（可通过spring配置或注解来设置） REQUIRED（默认）：支持使用当前事务，如果当前事务不存在，创建一个新事务。 SUPPORTS：支持使用当前事务，如果当前事务不存在，则不使用事务。 MANDATORY：中文翻译为强制，支持使用当前事务，如果当前事务不存在，则抛出Exception。 REQUIRES_NEW：创建一个新事务，如果当前事务存在，把当前事务挂起。 NOT_SUPPORTED：无事务执行，如果当前事务存在，把当前事务挂起。 NEVER：无事务执行，如果当前有事务则抛出
Spring事务管理详解与实例
总结，Spring事务管理是其核心功能之一，通过深入理解和灵活运用，可以有效地保障分布式系统的数据完整性。无论是编程式事务管理还是声明式事务管理，都提供了强大且易用的工具，使得开发者能够专注于业务逻辑，而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值