spring事务传播机制_spring事务传播行为

最新推荐文章于 2024-07-17 11:58:10 发布
最新推荐文章于 2024-07-17 11:58:10 发布
阅读量124 收藏
点赞数
文章标签： spring事务传播机制 spring事务的传播机制
什么是事务传播

简单来说就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。比如事务方法A()调用事务方法B()时，事务方法B()是继续在A()的事务中运行还是单独新建使用自个的事务B,这就取决于事务方法B()的事务传播行为

//service1@Transactional(propagation = Propagation.REQUIRED)public void B() {}//service2@Transactional(propagation = Propagation.REQUIRED)public void A() {    B()}

A() 和 B()方法都开启了事务，而A()方法调用了B()。

spring提供的七种事务传播行为

  1. REQUIRED：表示当前方法必须运行在事务中，如果当前方法没有运行在事务中，就新建一个事务，如果当前方法已存在于一个事务中，就加入到这个事务中，在该事务中运行
  2. SUPPORTS：表示当前方法是否已经存在于一个事务，如果当前方法已经在一个事务中，就加入该事务，否则就以非事务方法执行，相当于普通方法。
  3. MANDATORY：表示当前方法必须运行在一个事务中，如果没有在一个事务中会抛出异常。IllegalTransactionStateException：No existing transaction found for transaction marked with propagation 'mandatory'
  4. REQUIRES_NEW：表示当前方法必须运行在自己的事务中，如果已经存于一个事务中，则挂起该事务，重新开启一个属于自己的事务。也就是当前方法的事务不受其他事务影响
  5. NOT_SUPPORTED：表示当前方法不在事务中运行，如果已经存在于一个事务中，则将该事务挂起，否则则视为普通非事务方法运行。
  6. NEVER：表示当前方法不在事务中运行，如果已经存在于一个事务中，则抛出一个异常，否则则视为普通非事务方法运行
  7. NESTED：表示当前方法已经运行在一个事务中，则在嵌套在事务内执行，嵌套事务可以单独的提交和回滚，但是如果主事务提交或回滚，会顺带着嵌套事务提交或回滚，嵌套事务出现异常，主事务可以有选择的回滚或不回滚，可以在主事务方法中catch子方法的异常，catch后其他方法就不会受到影响。如果当前没有事务，则执行与REQUIRED类似的操作

以上说法可能并不能很好的理解下面我们通过伪代码演示一下每个行为

一、验证Propagation.REQUIRED

1.子方法添加事务并使用REQUIRED,父方法不添加事务

@Servicepublic class StuServiceImpl implements IStuService {    @Autowired    private StuMapper stuMapper;    @Override    public void saveParent() {        Stu stu = new Stu();        stu.setName("parent");        stu.setAge(19);        stuMapper.insert(stu);    }    @Override    @Transactional(propagation = Propagation.REQUIRED)    public void saveChildren() {        saveChild1();        int a = 1 / 0;        saveChild2();    }    public void saveChild1() {        Stu stu1 = new Stu();        stu1.setName("child-1");        stu1.setAge(11);        stuMapper.insert(stu1);    }    public void saveChild2() {        Stu stu2 = new Stu();        stu2.setName("child-2");        stu2.setAge(22);        stuMapper.insert(stu2);    }    }******************************************************************************@Servicepublic class TestServiceImpl implements ITestService {        //注入上面的service    @Autowired    private IStuService iStuService;    @Override    public void testTrans() {        iStuService.saveParent();        iStuService.saveChildren();    }}.........调用testTrans();

运行结果为：

5f01e66b45d0574ef1407fb65a718c3b.png

我们发现只有parent被插入到数据库中，而两个children则没有，这是因为在saveChildren()方法中发生了 / by zero 异常，所以会进行事务回滚，已经插入的children1被清除。

子方法被父方法调用，父方法没有事务，因而子方法没有运行在事务中，所以子方法新建一个事务并运行

2.子方法不添加事务，父方法添加事务并使用REQUIRED

@Servicepublic class StuServiceImpl implements IStuService {    @Autowired    private StuMapper stuMapper;    @Override    public void saveParent() {        Stu stu = new Stu();        stu.setName("parent");        stu.setAge(19);        stuMapper.insert(stu);    }    @Override    public void saveChildren() {        saveChild1();        int a = 1 / 0;        saveChild2();    }    public void saveChild1() {        Stu stu1 = new Stu();        stu1.setName("child-1");        stu1.setAge(11);        stuMapper.insert(stu1);    }    public void saveChild2() {        Stu stu2 = new Stu();        stu2.setName("child-2");        stu2.setAge(22);        stuMapper.insert(stu2);    }    }********************************************************************************@Servicepublic class TestServiceImpl implements ITestService {        //注入上面的service    @Autowired    private IStuService iStuService;    @Override    @Transactional(propagation = Propagation.REQUIRED)    public void testTrans() {        iStuService.saveParent();        iStuService.saveChildren();    }}.........调用testTrans();

运行结果为：

c2ebca8463bd4ba6507b721835e8b42b.png

我们发现数据库中一条记录也没有被添加，这是因为在子方法saveChildren()方法中发生了 / by zero 异常，子方法异常被父方法感知到，所以会进行全部回滚处理

3.子方法添加事务，父方法添加事务，都使用REQUIRED

@Servicepublic class StuServiceImpl implements IStuService {    @Autowired    private StuMapper stuMapper;    @Override    public void saveParent() {        Stu stu = new Stu();        stu.setName("parent");        stu.setAge(19);        stuMapper.insert(stu);    }    @Override    @Transactional(propagation = Propagation.REQUIRED)    public void saveChildren() {        saveChild1();        int a = 1 / 0;        saveChild2();    }    public void saveChild1() {        Stu stu1 = new Stu();        stu1.setName("child-1");        stu1.setAge(11);        stuMapper.insert(stu1);    }    public void saveChild2() {        Stu stu2 = new Stu();        stu2.setName("child-2");        stu2.setAge(22);        stuMapper.insert(stu2);    }    }********************************************************************************@Servicepublic class TestServiceImpl implements ITestService {        //注入上面的service    @Autowired    private IStuService iStuService;    @Override    @Transactional(propagation = Propagation.REQUIRED)    public void testTrans() {        iStuService.saveParent();        iStuService.saveChildren();    }}.........调用testTrans();

运行结果：

c2ebca8463bd4ba6507b721835e8b42b.png

结果也是一条记录都没有

对于子方法来说，当前已经存在一个父方法的事务，而且子方法被@Transactional(propagation = Propagation.REQUIRED) 修饰，所以子方法会加入到父方法的事务中

二、验证Propagation.SUPPORTS

1.子方法加入@Transactional(propagation = Propagation.SUPPORTS)，父方法为普通方法

@Servicepublic class StuServiceImpl implements IStuService {    @Autowired    private StuMapper stuMapper;    @Override    public void saveParent() {        Stu stu = new Stu();        stu.setName("parent");        stu.setAge(19);        stuMapper.insert(stu);    }    @Override    @Transactional(propagation = Propagation.SUPPORTS)    public void saveChildren() {        saveChild1();        int a = 1 / 0;        saveChild2();    }    public void saveChild1() {        Stu stu1 = new Stu();        stu1.setName("child-1");        stu1.setAge(11);        stuMapper.insert(stu1);    }    public void saveChild2() {        Stu stu2 = new Stu();        stu2.setName("child-2");        stu2.setAge(22);        stuMapper.insert(stu2);    }    }**********************************************************************************************@Servicepublic class TestServiceImpl implements ITestService {        //注入上面的service    @Autowired    private IStuService iStuService;    @Override    public void testTrans() {        iStuService.saveParent();        iStuService.saveChildren();    }}.........调用testTrans();

运行结果：

86705a2e8f42948f6cdc8304d508b45c.png

通过结果我们发现，虽然在子方法上加入@Transactional(propagation = Propagation.SUPPORTS) 但是结果却是跟非事务方法结果一致，下面我们在将父方法添加事务看下结果

@Servicepublic class StuServiceImpl implements IStuService {    @Autowired    private StuMapper stuMapper;    @Override    public void saveParent() {        Stu stu = new Stu();        stu.setName("parent");        stu.setAge(19);        stuMapper.insert(stu);    }    @Override    @Transactional(propagation = Propagation.SUPPORTS)    public void saveChildren() {        saveChild1();        int a = 1 / 0;        saveChild2();    }    public void saveChild1() {        Stu stu1 = new Stu();        stu1.setName("child-1");        stu1.setAge(11);        stuMapper.insert(stu1);    }    public void saveChild2() {        Stu stu2 = new Stu();        stu2.setName("child-2");        stu2.setAge(22);        stuMapper.insert(stu2);    }    }**********************************************************************************************@Servicepublic class TestServiceImpl implements ITestService {        //注入上面的service    @Autowired    private IStuService iStuService;    @Override    @Transactional(propagation = Propagation.REQUIRED)    public void testTrans() {        iStuService.saveParent();        iStuService.saveChildren();    }}.........调用testTrans();

我们在父方法上添加@Transactional(propagation = Propagation.REQUIRED) 子方法上加入 @Transactional(propagation = Propagation.SUPPORTS)

运行结果：

fc149cbc09034773f25c6a894b5c6848.png

也就是说当父方法有事务时，子方法会加入到父方法的事务中，否则就按非事务方法也就是普通方法运行。

三、验证Propagation.MANDATORY

1.子方法添加@Transactional(propagation = Propagation.MANDATORY) ，父方法为普通方法

@Servicepublic class StuServiceImpl implements IStuService {    @Autowired    private StuMapper stuMapper;    @Override    public void saveParent() {        Stu stu = new Stu();        stu.setName("parent");        stu.setAge(19);        stuMapper.insert(stu);    }    @Override    @Transactional(propagation = Propagation.MANDATORY)    public void saveChildren() {        saveChild1();        int a = 1 / 0;        saveChild2();    }    public void saveChild1() {        Stu stu1 = new Stu();        stu1.setName("child-1");        stu1.setAge(11);        stuMapper.insert(stu1);    }    public void saveChild2() {        Stu stu2 = new Stu();        stu2.setName("child-2");        stu2.setAge(22);        stuMapper.insert(stu2);    }    }**********************************************************************************************@Servicepublic class TestServiceImpl implements ITestService {        //注入上面的service    @Autowired    private IStuService iStuService;    @Override    public void testTrans() {        iStuService.saveParent();        iStuService.saveChildren();    }}.........调用testTrans();

运行结果：

504e66bd3b209959a3a0cb3236539b9e.png

子方法直接报错:

org.springframework.transaction.IllegalTransactionStateException: No existing transaction found for transaction marked with propagation 'mandatory'

2.子方法添加@Transactional(propagation = Propagation.MANDATORY) ，父方法添加@Transactional(propagation = Propagation.REQUIRED)

@Servicepublic class StuServiceImpl implements IStuService {    @Autowired    private StuMapper stuMapper;    @Override    public void saveParent() {        Stu stu = new Stu();        stu.setName("parent");        stu.setAge(19);        stuMapper.insert(stu);    }    @Override    @Transactional(propagation = Propagation.MANDATORY)    public void saveChildren() {        saveChild1();        int a = 1 / 0;        saveChild2();    }    public void saveChild1() {        Stu stu1 = new Stu();        stu1.setName("child-1");        stu1.setAge(11);        stuMapper.insert(stu1);    }    public void saveChild2() {        Stu stu2 = new Stu();        stu2.setName("child-2");        stu2.setAge(22);        stuMapper.insert(stu2);    }    }**********************************************************************************************@Servicepublic class TestServiceImpl implements ITestService {        //注入上面的service    @Autowired    private IStuService iStuService;    @Override    @Transactional(propagation = Propagation.REQUIRED)    public void testTrans() {        iStuService.saveParent();        iStuService.saveChildren();    }}.........调用testTrans();

运行结果：

78505aa9bade72d0815700c001d60ee2.png

子方法加入到父方法的事务中，子方法异常，事务整体回滚

四、验证Propagation.REQUIRES_NEW

1. 子方法使用 @Transactional(propagation = Propagation.REQUIRES_NEW) 父方法为普通方法

@Servicepublic class StuServiceImpl implements IStuService {    @Autowired    private StuMapper stuMapper;    @Override    public void saveParent() {        Stu stu = new Stu();        stu.setName("parent");        stu.setAge(19);        stuMapper.insert(stu);    }    @Override    @Transactional(propagation = Propagation.REQUIRES_NEW)    public void saveChildren() {        saveChild1();        int a = 1 / 0;        saveChild2();    }    public void saveChild1() {        Stu stu1 = new Stu();        stu1.setName("child-1");        stu1.setAge(11);        stuMapper.insert(stu1);    }    public void saveChild2() {        Stu stu2 = new Stu();        stu2.setName("child-2");        stu2.setAge(22);        stuMapper.insert(stu2);    }    }**********************************************************************************************@Servicepublic class TestServiceImpl implements ITestService {        //注入上面的service    @Autowired    private IStuService iStuService;    @Override    public void testTrans() {        iStuService.saveParent();        iStuService.saveChildren();    }}.........调用testTrans();

运行结果：

6e562482991679d10e35abc82b7424bd.png

仅在子方法中开启事务，子方法saveChildren()事务回滚

2. 子方法使用 @Transactional(propagation = Propagation.REQUIRES_NEW) 父方法使用 @Transactional(propagation = Propagation.REQUIRED)

@Servicepublic class StuServiceImpl implements IStuService {    @Autowired    private StuMapper stuMapper;    @Override    public void saveParent() {        Stu stu = new Stu();        stu.setName("parent");        stu.setAge(19);        stuMapper.insert(stu);    }    @Override    @Transactional(propagation = Propagation.REQUIRES_NEW)    public void saveChildren() {        saveChild1();        int a = 1 / 0;        saveChild2();    }    public void saveChild1() {        Stu stu1 = new Stu();        stu1.setName("child-1");        stu1.setAge(11);        stuMapper.insert(stu1);    }    public void saveChild2() {        Stu stu2 = new Stu();        stu2.setName("child-2");        stu2.setAge(22);        stuMapper.insert(stu2);    }    }**********************************************************************************************@Servicepublic class TestServiceImpl implements ITestService {        //注入上面的service    @Autowired    private IStuService iStuService;    @Override    @Transactional(propagation = Propagation.REQUIRED)    public void testTrans() {        iStuService.saveParent();        iStuService.saveChildren();    }}.........调用testTrans();

运行结果:

39ecd2e4c133620c2c54158d5d4e6524.png

子方法虽然单独运行一个事务，但是异常被父方法识别到，所以父方法事务进行了回滚

3.下面我们调整一下，将子方法中除0异常转移到父方法中，再看下结果

@Servicepublic class StuServiceImpl implements IStuService {    @Autowired    private StuMapper stuMapper;    @Override    public void saveParent() {        Stu stu = new Stu();        stu.setName("parent");        stu.setAge(19);        stuMapper.insert(stu);    }    @Override    @Transactional(propagation = Propagation.REQUIRES_NEW)    public void saveChildren() {        saveChild1();        //int a = 1 / 0; 将这个异常语句注释掉添加到父方法中        saveChild2();    }    public void saveChild1() {        Stu stu1 = new Stu();        stu1.setName("child-1");        stu1.setAge(11);        stuMapper.insert(stu1);    }    public void saveChild2() {        Stu stu2 = new Stu();        stu2.setName("child-2");        stu2.setAge(22);        stuMapper.insert(stu2);    }    }**********************************************************************************************@Servicepublic class TestServiceImpl implements ITestService {        //注入上面的service    @Autowired    private IStuService iStuService;    @Override    @Transactional(propagation = Propagation.REQUIRED)    public void testTrans() {        iStuService.saveParent();        iStuService.saveChildren();        int a = 1 / 0; //新增一个异常语句    }}.........调用testTrans();

运行结果：

9a227e23aab68267f263dae16eef8b05.png

通过结果我们可以看到，父方法出现异常，但是仅仅回滚了saveParent()方法。而saveChildren()则正常保存到数据库中，没有发生回滚。

也就是说REQUIRES_NEW 是新启动一个事务，它所在的已经存在的那个事务会被挂起。

五、验证Propagation.NOT_SUPPORTED

1.子方法上加入@Transactional(propagation = Propagation.NOT_SUPPORTED)，父方法为普通非事务方法

@Servicepublic class StuServiceImpl implements IStuService {    @Autowired    private StuMapper stuMapper;    @Override    public void saveParent() {        Stu stu = new Stu();        stu.setName("parent");        stu.setAge(19);        stuMapper.insert(stu);    }    @Override    @Transactional(propagation = Propagation.NOT_SUPPORTED)    public void saveChildren() {        saveChild1();        int a = 1 / 0;        saveChild2();    }    public void saveChild1() {        Stu stu1 = new Stu();        stu1.setName("child-1");        stu1.setAge(11);        stuMapper.insert(stu1);    }    public void saveChild2() {        Stu stu2 = new Stu();        stu2.setName("child-2");        stu2.setAge(22);        stuMapper.insert(stu2);    }    }**********************************************************************************************@Servicepublic class TestServiceImpl implements ITestService {        //注入上面的service    @Autowired    private IStuService iStuService;    @Override    public void testTrans() {        iStuService.saveParent();        iStuService.saveChildren();    }}.........调用testTrans();

运行结果：

ddade553518f31e1ad6082ba0643016b.png

通过结果可以看出，该子方法以非事务方式运行

2.子方法上加入@Transactional(propagation = Propagation.NOT_SUPPORTED)，父方法上加入 @Transactional(propagation = Propagation.REQUIRED)

@Servicepublic class StuServiceImpl implements IStuService {    @Autowired    private StuMapper stuMapper;    @Override    public void saveParent() {        Stu stu = new Stu();        stu.setName("parent");        stu.setAge(19);        stuMapper.insert(stu);    }    @Override    @Transactional(propagation = Propagation.NOT_SUPPORTED)    public void saveChildren() {        saveChild1();        int a = 1 / 0;        saveChild2();    }    public void saveChild1() {        Stu stu1 = new Stu();        stu1.setName("child-1");        stu1.setAge(11);        stuMapper.insert(stu1);    }    public void saveChild2() {        Stu stu2 = new Stu();        stu2.setName("child-2");        stu2.setAge(22);        stuMapper.insert(stu2);    }    }**********************************************************************************************@Servicepublic class TestServiceImpl implements ITestService {        //注入上面的service    @Autowired    private IStuService iStuService;    @Override    @Transactional(propagation = Propagation.REQUIRED)    public void testTrans() {        iStuService.saveParent();        iStuService.saveChildren();    }}.........调用testTrans();

运行结果：

b4739347f54f62b0a27d7a5f923c9414.png

从结果我们可以看出，该子方法以非事务方式运行，而该方法的异常被父方法识别到后父方法进行了回滚

weixin_39622643
关注
Spring事务的传播机制
nings666的博客
07-06 494
事务传播行为用来描述由某一个事务传播行为修饰的方法被嵌套进另一个方法的时事务如何传播。代码中methodA()方法嵌套调用了methodB()方法，methodB()的事务传播行为由@Transaction(Propagation=XXX)设置决定。这里需要注意的是methodA()并没有开启事务，某一个事务传播行为修饰的方法并不是必须要在开启事务的外围方法中调用。
Spring事务传播机制总结
一颗学徒
12-29 760
事务传播机制 文章目录事务传播机制概述七种事务传播行为外围方法未开启事务同一类中非同一类中外围方法开启事务同一类中非同一类中REQUIRED,REQUIRES_NEW,NESTED异同总结场景使用 概述 事务传播行为：由一个事务传播行为修饰的方法被嵌套进另一个方法时事务如何传播 spring在TransactionDefintion规定了7中事务传播行为 spring框架特有的事务增强行为 Spring事务 的本质其实就是数据库对事务的支持，没有数据库的事务支持，spring是无法提供事务功能的 真正的数
Spring事务的七种传播机制
最新发布
m0_59605357的博客
07-17 1696
的异常，但是Role信息成功入库了，因为insertUser方法配置了事务，但是insertRole方法配置了NOT_SUPPORTED传播行为，那么insertRole方法会挂起自己的事务，以非事务方式加入到insertUser方法的事务来执行。的异常，但是2条数据都成功入库了。如果A方法存在事务（加了@Transactional注解），B方法配置了NOT_SUPPORTED传播行为，那么B方法会挂起自己的事务，以非事务方式加入到A方法的事务来执行。等B事务结束，才恢复A的事务。
一文搞通Spring事务的七种传播机制（通俗易懂）
黄团团的个人博客
07-29 4328
最近阅读了网上很多关于讲解Spring事务的七种传播机制的文章，很少有通过结合实际代码进行讲解的，对于小白来说干巴巴的文字解释略微抽象，没有一个具体形象化的概念，下面我就通过理论+实践的方式来对Spring事务的每一种传播机制进行剖析，这样大家也容易记得住，毕竟实践才是检验真理的唯一标准！每一个字和每一行代码都是博主纯手打的！
搞懂Spring的事务传播机制
码瘾的空间
04-24 258
搞懂Spring的事务传播机制 事务传播枚举： org.springframework.transaction.annotation.Propagation REQUIRED(0), SUPPORTS(1), MANDATORY(2), REQUIRES_NEW(3), NOT_SUPPORTED(4), NEVER(5), NESTED(6); @Transactional(propagation= Propagation.REQUIRED) 结论：   使用当前的事务，如果当前没有事务，则自己新建一个
Spring 事务机制总结
AAA821的专栏
09-22 642
 转自：https://blog.csdn.net/pingnanlee/article/details/11488695 Spring两种事物处理机制，一是声明式事务，二是编程式事务  1）Spring的声明式事务管理在底层是建立在AOP的基础之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。 声明式事务最大的...
Spring事务传播机制.docx
01-13
Spring 事务传播机制 Spring 事务传播机制是指在 Spring 框架中，事务的传播和嵌套机制。当我们在使用 Spring 所提供的事务功能时，如果是仅仅处理单个的事务，是比较容易把握事务的提交与回滚，不过一旦引入嵌套...
浅谈Spring事务传播行为实战
08-25
浅谈Spring事务传播行为实战 Spring框架提供了事务管理的标准实现，通过注解或者XML文件的方式声明和配置事务。事务管理是指按照给定的事务规则来执行事务的提交或者回滚操作。事务的机制实现很大一部依赖事务日志...
spring 事务传播 demo
06-05
本示例“spring 事务传播 demo”将聚焦于Spring的事务传播行为，这是在多个方法调用中控制事务边界的关键概念。下面我们将详细讨论相关知识点。 首先，事务传播行为是指当一个被@Transactional注解的方法被另一个@...
Spring中事务传播行为的介绍
08-26
Spring 中事务传播行为的介绍 Spring 中事务传播行为是指在分布式事务系统中，事务的边界定义和传播规则。在 Spring 框架中，定义了 7 种不同的传播行为，每种行为都有其特点和应用场景。 1. PROPAGATION_...
Spring事务和事务传播机制
weixin_51062428的博客
07-04 1366
Spring事务和事务的传播机制
7天学完Spring：基础学习结束，关于Spring事务及其传播机制
weixin_53860901的博客
07-28 603
其实昨天就学完了，但是没写博客。说一下感受吧，虽然学的很快，但是真的就一直半解，知其然不知其所以然，以后不要这样学了，很不负责任。下去之后要好好复习巩固了
Spring事务传播机制
憧憬的专栏
05-24 7458
文章目录1. REQUIRED2. SUPPORTS3. MANDATORY4. REQUIRES_NEW5. NOT_SUPPORTED6. NEVER7. NESTED Spring管理的事务是逻辑事务，而且物理事务和逻辑事务最大差别就在于事务传播行为，事务传播行为用于指定在多个事务方法间调用时，事务是如何在这些方法间传播的。 下面以a.save()里调用了b.save()举例，事务方法之间调用时事务如何传播。 @Service public class A { @Autowired privat
Spring的7种事务传播机制
热门推荐
dayuiicghaid的博客
06-13 2万+
什么是事务？ 事务就是用户定义的一系列数据库操作，这些操作可以视为一个完成的逻辑处理工作单元，要么全部执行，要么全部不执行，是不可分割的工作单元。对数据库的增删改查操作传播机制是什么？ 当A调用B的时候，两个事务是怎么运行的？A出现异常，或者B出现异常，A回不回滚，B回不回滚？还是A回滚，B不回滚？这些问题事务 以非事务性方式运行是什么意思？ 非事务的方式运行，其实就是设置为自动提交了，如果一个方法中有多个操作，则每个操作都会在不同事务中完成，不会保证他们的原子性。事务挂起是什么意思？ 在方法A开始运行时，
spring3.0.5的事务传播
decision06的专栏
01-14 509
<br />今天整理下Spring的事务传播特性<br />整理原因：每次看的时候总是能理解，但是过段时间就忘记了，所以记载下，供自己和大家复习<br /><br />事务传播行为类型：<br /><br />REQUIRED ：<br />        如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。 <br /><br />SUPPORTS ：<br />       支持当前事务，如果当前没有事务，就以非事务方式执行。 <br /><br />MANDA
Spring事务传播的7种机制
weixin_43637718的博客
03-04 3223
1、Spring 事务传播的7种机制及简单易懂的类比理解 2、嵌套事务（NESTED）和加入事务（REQUIRED）的区别
Spring事务传播机制解析：TransactionInterceptor的invoke方法
Spring事务传播机制详解 Spring事务是Java EE应用程序中一个非常重要的组件，用于管理数据库事务，以确保数据的一致性和完整性。在Spring框架中，事务是通过AOP（Aspect-Oriented Programming）机制来实现的，这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值