SpringBoot之Transactional事务传播行为

已于 2022-03-13 22:51:16 修改
阅读量2k 收藏 22
点赞数 1
分类专栏： spring boot 文章标签： spring boot
于 2022-03-11 15:55:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43654581/article/details/123290521
版权

环境准备

sql语句

CREATE TABLE `account` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(32) NOT NULL COMMENT '账户名',
  `money` double(11,2) NOT NULL COMMENT '金额',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='账号表';

初始数据
在这里插入图片描述
配置文件

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb?useUnicode=true&characterEncoding=utf8&useSSL=false&allowMultiQueries=true&zeroDateTimeBehavior=convertToNull&serverTimezone=Asia/Shanghai
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver

mybatis-plus:
  mapper-locations: classpath*:/mapper/*Mapper.xml
  type-aliases-package: com.yzm.transactional.entity
  configuration:
    map-underscore-to-camel-case: true
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

启用事务管理

@Configuration
@MapperScan("com.yzm.transactional.mapper")
@EnableTransactionManagement
public class MybatisPlusConfig {
}

目录结构
在这里插入图片描述
以下示例中，A称为外方法，B称为内方法
AB方法不能在同一个Service中，这跟spring的事务实现机制有关
比如A方法在AccountService类中，B方法在BccountService类中

Propagation.REQUIRED

示例 11 正常转账

    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void methodA1() {
        Account xwang = getById(1);
        xwang.setMoney(xwang.getMoney() - 200);
        updateById(xwang);

        bccountService.methodB12();
        System.out.println("转账成功！");
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void methodB12() {
        Account xming = getById(2);
        xming.setMoney(xming.getMoney() + 200);
        updateById(xming);

        int i = 1 / 0;
    }

SQL执行流程
在这里插入图片描述
在这里插入图片描述
事务正常提交，金额改变。

示例 12 外方法异常

    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void methodA1() {
        Account xwang = getById(1);
        xwang.setMoney(xwang.getMoney() - 200);
        updateById(xwang);

        bccountService.methodB12();
        System.out.println("转账成功！");
        int i = 1 / 0;
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void methodB12() {
        Account xming = getById(2);
        xming.setMoney(xming.getMoney() + 200);
        updateById(xming);
    }

在这里插入图片描述
在这里插入图片描述
外方法有异常，未显示事务提交，且金额不变，说明事务回滚了

示例 13 内方法异常

    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void methodA1() {
        Account xwang = getById(1);
        xwang.setMoney(xwang.getMoney() - 200);
        updateById(xwang);

        bccountService.methodB12();
        System.out.println("转账成功！");
//        int i = 1 / 0;
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void methodB12() {
        Account xming = getById(2);
        xming.setMoney(xming.getMoney() + 200);
        updateById(xming);

        int i = 1 / 0;
    }

在这里插入图片描述
在这里插入图片描述
内方法有异常，未显示事务提交，且金额不变，说明事务回滚了

从上面三个示例可以看出：
REQUIRED修饰的内外方法是在同一个事务中的，只要其中一个方法抛出异常，整个事务就会回滚。

示例 14 内方法不加 @Transactional 注解，并有异常

    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void methodA1() {
        Account xwang = getById(1);
        xwang.setMoney(xwang.getMoney() - 200);
        updateById(xwang);

        bccountService.methodB12();
        System.out.println("转账成功！");
//        int i = 1 / 0;
    }

    @Override
//    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void methodB12() {
        Account xming = getById(2);
        xming.setMoney(xming.getMoney() + 200);
        updateById(xming);

        int i = 1 / 0;
    }

结果跟 @示例 13 是一样的
内方法没有注解，但能被外方法的事务包裹，使得内外方法始终在同一事务中。

示例 15 外方法不加 @Transactional 注解，并内方法有异常

    @Override
//    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void methodA1() {
        Account xwang = getById(1);
        xwang.setMoney(xwang.getMoney() - 200);
        updateById(xwang);

        bccountService.methodB12();
        System.out.println("转账成功！");
//        int i = 1 / 0;
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void methodB12() {
        Account xming = getById(2);
        xming.setMoney(xming.getMoney() + 200);
        updateById(xming);

        int i = 1 / 0;
    }

在这里插入图片描述
在这里插入图片描述
外方法以非事务方式运行的，小王钱少了200
内方法有异常，小明钱没变，说明事务回滚了

示例 16 平级内方法

    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void methodA1() {
        Account xwang = getById(1);
        xwang.setMoney(xwang.getMoney() - 200);
        updateById(xwang);

        bccountService.methodB12();
        bccountService.methodB13();
        System.out.println("转账成功！");
//        int i = 1 / 0;
    }

    @Override
//    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void methodB12() {
        Account xming = getById(2);
        xming.setMoney(xming.getMoney() + 100);
        updateById(xming);

//        int i = 1 / 0;
    }

    @Override
//    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void methodB13() {
        Account xming = getById(2);
        xming.setMoney(xming.getMoney() + 100);
        updateById(xming);

        int i = 1 / 0;
    }

在这里插入图片描述
在这里插入图片描述
内方法B13有异常，金额不变，说明3个方法都在同一事物中，有异常导致整个事务回滚

如果是嵌套内方法也是一样的，都在同一事务中。
总结：

默认，最常用的；
支持事务，当前存在事务则加入，不存在就创建事务；
最外层方法必须加事务注解，里层方法可加可不加(不加注解的里层方法会被外层事务包裹)；
外层方法和里层包裹的方法始终在同一事务中，只要任意一个方法抛出异常(未捕获)，整个事务就会回滚。

Propagation.SUPPORTS

恢复成初始数据
在这里插入图片描述

示例 21 外方法REQUIRED、内方法SUPPORTS并有异常

    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void methodA2() {
        Account xwang = getById(1);
        xwang.setMoney(xwang.getMoney() - 200);
        updateById(xwang);

        bccountService.methodB22();
        System.out.println("转账成功！");
//        int i = 1 / 0;
    }

    @Override
    @Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
    public void methodB22() {
        Account xming = getById(2);
        xming.setMoney(xming.getMoney() + 200);
        updateById(xming);

        int i = 1 / 0;
    }

在这里插入图片描述
外方法创建事务，内方法(支持事务)加入该事务，使得内外方法处于同一事务中，内方法抛出异常，导致整个事务回滚，金额不变。

示例 22 外方法不加 @Transactional 注解，内方法SUPPORTS

    @Override
//    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void methodA2() {
        Account xwang = getById(1);
        xwang.setMoney(xwang.getMoney() - 200);
        updateById(xwang);

        bccountService.methodB22();
        System.out.println("转账成功！");
//        int i = 1 / 0;
    }

    @Override
    @Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
    public void methodB22() {
        Account xming = getById(2);
        xming.setMoney(xming.getMoney() + 200);
        updateById(xming);

        int i = 1 / 0;
    }

在这里插入图片描述
在这里插入图片描述
外方法以非事务方式运行，小王钱少了200
内方法有异常，未显示事务提交，小明钱多了200，说明内方法没有事务，也是以非事务方式运行

示例 23 内外都是SUPPORTS，内方法有异常

    @Override
    @Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
    public void methodA2() {
        Account xwang = getById(1);
        xwang.setMoney(xwang.getMoney() - 200);
        updateById(xwang);

        bccountService.methodB22();
        System.out.println("转账成功！");
//        int i = 1 / 0;
    }

    @Override
    @Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
    public void methodB22() {
        Account xming = getById(2);
        xming.setMoney(xming.getMoney() + 200);
        updateById(xming);

        int i = 1 / 0;
    }

在这里插入图片描述
在这里插入图片描述
内方法有异常，未显示事务提交，但是金额都变了，说明是以非事务方式运行

示例 24 外方法SUPPORTS，内方法REQUIRED，内外都有异常

    @Override
    @Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
    public void methodA2() {
        Account xwang = getById(1);
        xwang.setMoney(xwang.getMoney() - 200);
        updateById(xwang);

        bccountService.methodB22();
        System.out.println("转账成功！");
        int i = 1 / 0;
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void methodB22() {
        Account xming = getById(2);
        xming.setMoney(xming.getMoney() + 200);
        updateById(xming);

        int i = 1 / 0;
    }

在这里插入图片描述
在这里插入图片描述
外方法有异常，小王钱少了200，说明没有事务，以非事务方式运行
内方法有异常，小明钱没变，说明内方法自己创建了一个事务，同时也证实了外方法没有事务，不然内方法一定会加入到外方法的事务中
总结：

少见少用；
支持当前事务，有事务就加入事务，没有事务就以非事务方式运行；
单独调用或最外层方法是SUPPORTS，都是以非事务方式运行，有异常不回滚。

Propagation.MANDATORY

恢复初始数据
在这里插入图片描述

示例 31 外方法REQUIRED、内方法MANDATORY

    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void methodA3() {
        Account xwang = getById(1);
        xwang.setMoney(xwang.getMoney() - 200);
        updateById(xwang);

        bccountService.methodB32();
        System.out.println("转账成功！");
//        int i = 1 / 0;
    }

    @Override
    @Transactional(propagation = Propagation.MANDATORY, rollbackFor = Exception.class)
    public void methodB32() {
        Account xming = getById(2);
        xming.setMoney(xming.getMoney() + 200);
        updateById(xming);

        int i = 1 / 0;
    }

跟 示例 21 一样
外方法创建事务，内方法(支持事务)加入外方法事务，同一事务，事务回滚，金额不变。

示例 32 外方法不加 @Transactional 注解，内方法MANDATORY

    @Override
//    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void methodA3() {
        Account xwang = getById(1);
        xwang.setMoney(xwang.getMoney() - 200);
        updateById(xwang);

        bccountService.methodB32();
        System.out.println("转账成功！");
//        int i = 1 / 0;
    }

    @Override
    @Transactional(propagation = Propagation.MANDATORY, rollbackFor = Exception.class)
    public void methodB32() {
        Account xming = getById(2);
        xming.setMoney(xming.getMoney() + 200);
        updateById(xming);

        int i = 1 / 0;
    }

在这里插入图片描述
在这里插入图片描述
外层以非事务方式运行，小王钱少了
内方法直接报错

示例 33 内外都是MANDATORY(或者内方法是REQUIRED)

在这里插入图片描述
都是直接报错

总结：

少见少用；
支持当前事务，有事务则加入事务，没有事务就会抛出异常，显示错误信息。
单独调用或者最外层方法是MANDATORY，就直接报错

Propagation.REQUIRES_NEW

恢复初始数据
在这里插入图片描述

示例 41 外方法REQUIRED、内方法REQUIRES_NEW，外方法有异常

    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void methodA4() {
        Account xwang = getById(1);
        xwang.setMoney(xwang.getMoney() - 200);
        updateById(xwang);

        bccountService.methodB42();
        System.out.println("转账成功！");
        int i = 1 / 0;
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    public void methodB42() {
        Account xming = getById(2);
        xming.setMoney(xming.getMoney() + 200);
        updateById(xming);

//        int i = 1 / 0;
    }

在这里插入图片描述
在这里插入图片描述
小王钱不变小明钱多了200
外方法创建外事务，内方法创建内事务，外方法有异常，只会回滚外事务，内事务正常提交。

示例 42 外方法REQUIRED、内方法REQUIRES_NEW，内方法有异常

    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void methodA4() {
        Account xwang = getById(1);
        xwang.setMoney(xwang.getMoney() - 200);
        updateById(xwang);

        bccountService.methodB42();
        System.out.println("转账成功！");
//        int i = 1 / 0;
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    public void methodB42() {
        Account xming = getById(2);
        xming.setMoney(xming.getMoney() + 200);
        updateById(xming);

        int i = 1 / 0;
    }

在这里插入图片描述
在这里插入图片描述
金额都不变
外方法创建外事务，无异常；
内方法创建内事务，有异常导致内事务回滚，同时也让外事务回滚

示例 43 外方法REQUIRES_NEW、内方法REQUIRED，外方法有异常

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    public void methodA4() {
        Account xwang = getById(1);
        xwang.setMoney(xwang.getMoney() - 200);
        updateById(xwang);

        bccountService.methodB42();
        System.out.println("转账成功！");
        int i = 1 / 0;
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void methodB42() {
        Account xming = getById(2);
        xming.setMoney(xming.getMoney() + 200);
        updateById(xming);

//        int i = 1 / 0;
    }

在这里插入图片描述
在这里插入图片描述
金额都不变
外方法创建事务后，内方法就不再创建事务而是加入到外方法的事务中，同一事务，外异常，就回滚

改成内异常也是整个事务回滚。

示例 44 外内方法都是REQUIRES_NEW，外方法有异常

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    public void methodA4() {
        Account xwang = getById(1);
        xwang.setMoney(xwang.getMoney() - 200);
        updateById(xwang);

        bccountService.methodB42();
        System.out.println("转账成功！");
        int i = 1 / 0;
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    public void methodB42() {
        Account xming = getById(2);
        xming.setMoney(xming.getMoney() + 200);
        updateById(xming);

//        int i = 1 / 0;
    }

在这里插入图片描述
在这里插入图片描述
小王钱不变，小明钱凭空多了200
跟 示例 41 是一样的，内外方法都有自己的事务，外方法有异常外事务回滚，内事务不影响

示例 45 外内方法都是REQUIRES_NEW，内方法有异常

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    public void methodA4() {
        Account xwang = getById(1);
        xwang.setMoney(xwang.getMoney() - 200);
        updateById(xwang);

        bccountService.methodB42();
        System.out.println("转账成功！");
//        int i = 1 / 0;
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    public void methodB42() {
        Account xming = getById(2);
        xming.setMoney(xming.getMoney() + 200);
        updateById(xming);

        int i = 1 / 0;
    }

在这里插入图片描述
在这里插入图片描述
金额都不变
跟 示例 42 是一样的，内外方法都有自己的事务，内方法有异常导致内事务回滚，外事务也跟着回滚

示例 46 平级内方法

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    public void methodA4() {
        Account xwang = getById(1);
        xwang.setMoney(xwang.getMoney() - 200);
        updateById(xwang);

        bccountService.methodB42();
        bccountService.methodB43();
        System.out.println("转账成功！");
//        int i = 1 / 0;
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    public void methodB42() {
        Account xming = getById(2);
        xming.setMoney(xming.getMoney() + 100);
        updateById(xming);

//        int i = 1 / 0;
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    public void methodB43() {
        Account xming = getById(2);
        xming.setMoney(xming.getMoney() + 100);
        updateById(xming);

        int i = 1 / 0;
    }

在这里插入图片描述
在这里插入图片描述
小王钱不变，小明两次收钱，只有一次成功收到钱加了100
A外事务，B1、B2内事务(平级关系)；
B2异常回滚，能影响A外事务回滚，但不影响B1事务提交

示例 47 嵌套内方法

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    public void methodA4() {
        Account xwang = getById(1);
        xwang.setMoney(xwang.getMoney() - 200);
        updateById(xwang);

        bccountService.methodB42();
        System.out.println("转账成功！");
//        int i = 1 / 0;
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    public void methodB42() {
        Account xming = getById(2);
        xming.setMoney(xming.getMoney() + 100);
        updateById(xming);

        cccountService.methodC44();
        int i = 1 / 0;
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    public void methodC44() {
        Account xming = getById(3);
        xming.setMoney(xming.getMoney() + 100);
        updateById(xming);

//        int i = 1 / 0;
    }

A(祖父级) 包含 B(父级) 包含 C(子级)，父级B异常
注意：C的SQL内容不能对小明进行修改，跟B的SQL内容对冲，会报错"Lock wait timeout exceeded; try restarting transaction"，新增小马用户。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
小王钱不变，小明钱也没变，小马钱多了100
父级B异常，自身事务回滚，子级C事务不被B影响正常提交，祖父级A事务被B影响也回滚

如果是子级C异常，那么3个事务都回滚
总结：

常见常用；
无论当前有没有事务，都始终自己创建新事务；
平级或嵌套事务时，异常事务回滚，父级和父级以上的外层事务也跟着回滚，但平级跟子级事务不影响正常提交。

Propagation.NOT_SUPPORTED

在这里插入图片描述

示例 51 外方法REQUIRED、内方法NOT_SUPPORTED，都有异常

    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void methodA5() {
        Account xwang = getById(1);
        xwang.setMoney(xwang.getMoney() - 200);
        updateById(xwang);

        bccountService.methodB52();
        System.out.println("转账成功！");
        int i = 1 / 0;
    }

    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, rollbackFor = Exception.class)
    public void methodB52() {
        Account xming = getById(2);
        xming.setMoney(xming.getMoney() + 200);
        updateById(xming);

        int i = 1 / 0;
    }

在这里插入图片描述
在这里插入图片描述
小王钱不变，小明钱多了200
外方法有异常，能回滚，有事务；内方法有异常，不能回滚，说明没有事务
总结：

少见少用；
不支持当前事务，无论有没有事务，都是以非事务方式运行

Propagation.NEVER

示例 61 外方法REQUIRED、内方法NEVER

    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void methodA6() {
        Account xwang = getById(1);
        xwang.setMoney(xwang.getMoney() - 200);
        updateById(xwang);

        bccountService.methodB62();
        System.out.println("转账成功！");
    }

    @Override
    @Transactional(propagation = Propagation.NEVER, rollbackFor = Exception.class)
    public void methodB62() {
        Account xming = getById(2);
        xming.setMoney(xming.getMoney() + 200);
        updateById(xming);
    }

在这里插入图片描述
外方法有事务，内方法被NEVER修饰，直接报错
总结：

少见少用；
不支持事务，只要有事务就报错，始终以非事务方式运行

Propagation.NESTED

在这里插入图片描述

示例 71 外方法REQUIRED、内方法NESTED，外方法异常

    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void methodA7() {
        Account xwang = getById(1);
        xwang.setMoney(xwang.getMoney() - 200);
        updateById(xwang);

        bccountService.methodB72();
        System.out.println("转账成功！");

        int i = 1 / 0;
    }

    @Override
    @Transactional(propagation = Propagation.NESTED, rollbackFor = Exception.class)
    public void methodB72() {
        Account xming = getById(2);
        xming.setMoney(xming.getMoney() + 200);
        updateById(xming);

//        int i = 1 / 0;
    }

在这里插入图片描述
在这里插入图片描述
金额不变
外方法创建外事务，内方法不是加入到外事务中，而是在外事务里面再创建一个子事务，嵌套在外事务里；
此时外事务异常回滚，嵌套子事务也跟着回滚。

示例 72 外方法REQUIRED、内方法NESTED，内方法异常

    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void methodA7() {
        Account xwang = getById(1);
        xwang.setMoney(xwang.getMoney() - 200);
        updateById(xwang);

        bccountService.methodB72();
        System.out.println("转账成功！");

//        int i = 1 / 0;
    }

    @Override
    @Transactional(propagation = Propagation.NESTED, rollbackFor = Exception.class)
    public void methodB72() {
        Account xming = getById(2);
        xming.setMoney(xming.getMoney() + 200);
        updateById(xming);

        int i = 1 / 0;
    }

在这里插入图片描述
在这里插入图片描述
金额不变
外方法创建外事务，内方法创建外事务的嵌套子事务，子事务有异常回滚了，也会导致外事务回滚
总结：

常见常用；
当前存在事务，则在该事务里面创建一个嵌套子事务运行；
当前没有事务，NESTED就等同于REQUIRED属性。

比较REQUIRED、REQUIRES_NEW和NESTED属性

定义serviceA.methodA()以PROPAGATION_REQUIRED修饰；
定义serviceB.methodB()以表格中三种方式修饰；
methodA中调用methodB

异常状态PROPAGATION_REQUIREDPROPAGATION_REQUIRES_NEWPROPAGATION_NESTED
事务同一事务两个独立事务B事务嵌套在A事务中
A正常B正常AB一起提交B先提交，A再提交AB一起提交
A异常B正常AB一起回滚B先提交，A再回滚AB一起回滚
A正常B异常AB一起回滚B先回滚；A再回滚AB一起回滚
A异常B异常AB一起回滚B先回滚，A再回滚AB一起回滚
yzm4399
关注
  • 1
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
SpringBoot之@Transactional事务实现的原理
weixin_44601714的博客
10-27 1461
Spring实现事务的方式分为编程式和声明式，其中声明式是最为常见的，声明式事务的实现又分为XML配置文件、@Transactional注解两种实现方式，SpringBoot因为取消了XML配置文件的书写，所以SpringBoot中的事务主要是使用@Transactional注解来实现的，下面从源码角度分析其原理 已知@Transactional事务实现的原理是基于AOP来实现的，在之前的博客中详...
SpringBoot中事务@Transactional的使用
妖怪的博客
11-27 1249
Spring框架提供了便捷的事务管理。不会对业务调用造成任何干扰。不需要手动开启,提交事务，只需要在类或者方法上进行少量的注解就可以自动完成这些操作。本篇主要介绍了@Transactional注解的使用
springboot-transaction事务
01-25
springboot中事务的使用demo,用jpa链接的Mysql数据库.
SpringBoot事物Transaction
我的博客
06-04 293
默认配置下，spring只有在抛出的异常为运行时unchecked异常时才回滚该事务，也就是抛出的异常为RuntimeException的子类(Errors也会导致事务回滚)，而抛出checked异常则不会导致事务回滚。所谓事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。指示spring事务管理器回滚一个事务的推荐方法是在当前事务的上下文内抛出异常。spring事务管理器会捕捉任何未处理的异常，然后依据规则决定是否回滚抛出异常的事务。
注解@Transactional的传播行为类型有哪些？
最新发布
良月柒
05-29 562
事务传播行为（Transaction Propagation Behavior）决定了当一个事务方法调用另一个事务方法时，事务应该如何传播。简单来说，它定义了一个事务在嵌套方法调用中的传播方式。在Spring中，注解提供了强大的事务管理功能，事务传播行为是其重要组成部分。不同的传播行为决定了方法调用时事务的边界如何传播，选择合适的传播行为可以确保事务的一致性和数据的完整性。
SpringBoot @Transactional事务详解
Tongyao
03-30 3324
当Java中一个方法内有多次对数据库的增删改查等操作，并且这些操作之间有一些关联关系，如果方法执行一半出问题报错，后面的操作将不会执行，造成数据异常，但是使用了事务以后可以如果中途执行失败，可以回退到方法执行之前，保证数据不出问题。事务要么全部都被执行，要么就全都不被执行，如果有子事务提交失败，那么其他子事务对数据库的操作将被回滚，数据库回到事务提交前的状态；注解，默认会回滚所有事务，前提下，一定要主动抛出异常，否则事务是不会生效的。下面是异常类和子类关系图，@Transactional，不加任何参数时，
Spring boot 事务(Transaction)
Yang_JK_accrDays的博客
06-10 926
Spring boot 事务(Transaction)问题学习 事务的理解： 事务的四个特性：原子性 【要么全部执行，要么全部不执行】、一致性【事务完成时，必须是所有相关数据保持一致(原子性保证数据库出现了问题之后还是会继续执行保证在了 一致性，隔离性 通过限制可能会出现的覆盖等问题来保证一致性)】、隔离性【一个事务的执行不能被其他事务干扰】、持久性【事务一旦提交，那么就是永久性的存储】 一致性是事务最终的目的，其他三个性质都是为了一致性而存在的。 java支持的事务类型： jdbc事务 ：分为手动和
springboot之@Transactional详解
jiaxiaoyan321的博客
09-08 3940
springboot @Transactional注解是如何起作用？
SpringBoot-Mybatis处理事务
08-15
对于复杂的事务场景，Spring的`PlatformTransactionManager`接口和`@Transactional`的`propagation`属性可以用来控制事务传播行为，如REQUIRED、REQUIRES_NEW等。 总的来说，SpringBoot结合Mybatis处理事务主要是...
springboot整合spring事务
09-12
这时可以调整事务传播行为或考虑是否需要分开处理。 8. **事务嵌套**：Spring支持事务嵌套，当一个事务方法被另一个事务方法调用时，Spring会创建一个子事务，子事务的提交或回滚不影响父事务。 9. **事务隔离级别...
springboot-jpa atomikos 分布式事务管理
10-08
4. 在需要处理事务的Service层，使用`@Transactional`注解，并设置相应的事务属性，如传播行为、隔离级别等。 5. 对于MyBatis和Hibernate，需要配置它们使用Atomikos提供的JTA支持，以确保在同一个事务中操作多个...
详解SpringBoot的事务管理
08-30
同时，`@Transactional`注解还可以配置不同的事务属性，如传播行为、隔离级别等，以满足不同场景的需求。 总的来说，Spring Boot的事务管理是其强大功能的一部分，它通过自动配置和声明式事务处理，为开发者提供了...
Spring Boot 中的事务传播行为是什么，原理，如何使用
程序员徐师兄的博客
06-27 1525
在本文中，我们介绍了 Spring Boot 中的事务传播行为。它决定了事务在协作中的传递方式，包括 REQUIRED、SUPPORTS、MANDATORY、REQUIRES_NEW、NOT_SUPPORTED、NEVER 和 NESTED 等几种方式。我们还介绍了事务传播行为的原理和如何在 Spring Boot 中使用它。使用事务传播行为可以帮助我们更加灵活地控制事务的行为，避免出现数据不一致的情况。
【Spring Boot系列】- Spring Boot事务应用详解
记录总结工作过往
10-26 2572
事务交给spring管理，那么你肯定要创建一个或者多个事务管理者，有这些管理者来管理具体的事务，比如启动事务、提交事务、回滚事务，这些都是管理者来负责的。spring中使用PlatformTransactionManager这个接口来表示事务管理者。PlatformTransactionManager多个实现类，用来应对不同的环境如果你用jpa来操作db，那么需要用这个管理器来帮你控制事务。
SpringBoot 开启事务的两种常用方式
热门推荐
weixin_44340643的博客
01-12 1万+
spring boot 使用事务
在Springboot中如何配置全局的transaction事务
大树叶 技术专栏
03-20 2589
在我们的spring boot工程中，基本是要处理mysql等数据库的数据的，而springboot实现事务只需要 public 方法在头上加上@Transactional注解就可以了，@Transactional 默认只捕获RuntimeException.class，对Exception异常得需要 @Transactional(rollbackFor = {Exception.class}) 捕获回滚。但是当项目特别大的时候，对所有的service 都加上事务 ，显得非常麻烦。可以通过aop 方式实现.
Spring Boot 事务和事务传播机制
YeZh1Yong 的博客
08-23 1854
详细解析Spring Boot中的事务和事务传播机制
一看就理解_Spring事务的7种传播行为
wushijuewu
09-30 985
事务传播行为 什么叫事务传播行为？听起来挺高端的，其实很简单。 即然是传播，那么至少有两个东西，才可以发生传播。单体不存在传播这个行为。 事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。 例如：methodA事务方法调用methodB事务方法时，methodB是继续在调用者methodA的事务中运行呢，还是为自己开启一个新事务运行，这就是由methodB的事务传播行为决定的。 Spring定义了七种传播行为： 现在来
【Spring Boot】事务和事务传播机制
吞吞吐吐大魔王的博客
08-07 2927
将一组操作封装成一个执行单元，要么全部成功，要么全部失败。当执行某个操作，例如支付操作时（分为先将钱从个人账户扣除和将他人账户新增两个操作），如果这两个操作不能同时成功或者失败，那么就会出现财产问题。而使用事务就能够很好的解决这个问题。通过上文我们了解到，在需要的方法上添加 @Transactional 注解，就能自动开启事务。接下来将会具体了解下 @Transactional 的使用细节。Spring 事务传播机制定义了多个包含了事务的方法在相互调用时，事务是如何在这些方法之间进行传递的。...
springboot Transactional事务传播方式
05-15
Spring Boot中使用@Transactional注解来进行事务管理，事务传播方式是指在多个事务方法之间调用时，事务应该如何传播。Spring Boot支持多种事务传播方式，具体如下： 1. REQUIRED：默认值，如果当前没有事务，则新建一个事务；如果当前有事务，则加入到当前事务中。 2. SUPPORTS：如果当前有事务，则加入到当前事务中；如果当前没有事务，则以非事务方式运行。 3. MANDATORY：如果当前有事务，则加入到当前事务中；如果当前没有事务，则抛出异常。 4. REQUIRES_NEW：新建一个独立的事务，并挂起当前事务；如果当前有事务，则挂起当前事务。 5. NOT_SUPPORTED：以非事务方式运行；如果当前有事务，则挂起当前事务。 6. NEVER：以非事务方式运行；如果当前有事务，则抛出异常。 7. NESTED：如果当前有事务，则在嵌套事务中执行；如果当前没有事务，则新建一个事务。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值