详解事务的7种传播行为

末蓝、 2022-11-18 01:46 297阅读 0赞

### 文章目录 ###

*  一、什么是Spring事务的传播行为？
 *  二、事务传播行为的七种类型
 *  三、Propagation.REQUIRED（默认）
 *  四、将异常try-catch捕获，事务是否还会回滚？（这个总结很重要）
 *  五、Propagation.SUPPORTS
 *  六、Propagation.MANDATORY
 *  七、Propagation.REQUIRES\_NEW
 *  八、Propagation.NOT\_SUPPORTED
 *  九、Propagation.NEVER
 *  十、Propagation.NESTED

# 一、什么是Spring事务的传播行为？ #

事务传播行为是指多个拥有事务的方法在嵌套调用时的事务控制方式  
比如XML中配置：`XML:<tx:method name="..." propagation="REQUIRED"/>`  
注解配置：`@Transactional(propagation=Propagation.REQUIRED)`

# 二、事务传播行为的七种类型 #

![20210411170246163.png][]

# 三、Propagation.REQUIRED（默认） #

如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。

![20210411171729808.png][]

例子如下，后续各种情况将此例子展开讲解。

......
    	// ===========测试类
        @Transactional(propagation = Propagation.REQUIRED)
        public void testPropagationTrans() {
        
        	saveParent();
            saveChildren();
        }
        ......
    
    
        // ===========service实现类
        public void saveParent() {
        
            Stu stu = new Stu();
            stu.setName("parent");
            stu.setAge(19);
            stuMapper.insert(stu); // 数据库插入一条parent记录
        }
        // @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); // 数据库插入一条child-1记录
        }
        public void saveChild2() {
        
            Stu stu2 = new Stu();
            stu2.setName("child-2");
            stu2.setAge(22);
            stuMapper.insert(stu2); // 数据库插入一条child-2记录
        }

结果是除以0错误`java.lang.ArithmeticException: / by zero`

**这个例子中，有一个子方法`saveParent()`是没写事务注解的，用于对照比较有事务的子方法`saveChildren()`**

**情况一：**  
父方法`testPropagationTrans()`开启事务，子方法`saveChildren()`没有开启事务。

子方法`saveChildren()`和`saveParent()`同处在父方法的事务中，`saveChildren()`除以0异常导致事务中对数据库的操作都回滚。所以没有记录插入。

![在这里插入图片描述][20210411172649926.png]  
**情况二：**  
父方法`testPropagationTrans()`**不**开启事务，只有`saveChildren()`开启事务

......
    	// ==========测试类
    	// @Transactional(propagation = Propagation.REQUIRED)
        public void testPropagationTrans() {
        
        	saveParent();
            saveChildren();
        }
        ......
        
    	// ===========service实现类
        public void saveParent() {
        
            Stu stu = new Stu();
            stu.setName("parent");
            stu.setAge(19);
            stuMapper.insert(stu); // 数据库插入一条parent记录
        }
        @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); // 数据库插入一条child-1记录
        }
        public void saveChild2() {
        
            Stu stu2 = new Stu();
            stu2.setName("child-2");
            stu2.setAge(22);
            stuMapper.insert(stu2); // 数据库插入一条child-2记录
        }

![在这里插入图片描述][20210411173634840.png]  
只有`saveChildren()`开启事务，`saveChildren()`发生异常就回滚该方法里面的数据库操作，所以数据库插入一条`parent`记录还是可以成功的。

**情况三：**  
父方法`testPropagationTrans()`和子方法`saveChildren()`均开启事务。这里不拉出多余代码，文字解释+结果图即可。  
![在这里插入图片描述][20210411174415195.png]  
`saveChildren()`发生异常，开始回滚，异常继续往上抛，父方法`testPropagationTrans()`也知道发生了异常，父方法里面所有数据库操作都回滚，所以`saveParent()`数据库插入的`parent`记录也回滚，最后数据库没有数据插入。  
  
  
疑问：异常继续往上抛父方法才知道发生了异常，导致方法里所有数据库操作回滚，那么我把这个异常`try-catch`，是不是就只有`saveChildren()`回滚呢？那可不一定，跟着我继续来看。

# 四、将异常try-catch捕获，事务是否还会回滚？（这个总结很重要） #

> 所有的讲解都是围绕开头第一段代码，依然是情况一二三，只不过此时多了`try-catch`

......
        public void testPropagationTrans() {
        
        	saveParent();
        	try {
        
                saveChildren();
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    ......

**情况一：**  
父方法`testPropagationTrans()`开启事务，子方法`saveChildren()`没有开启事务。  
![在这里插入图片描述][20210411175801170.png]  
`saveChildren()`产生的异常被捕获，没有继续上抛，父方法开启的事务不会回滚，故插入2条数据。

**情况二：**  
父方法`testPropagationTrans()`**不**开启事务，只有`saveChildren()`开启事务.  
![在这里插入图片描述][20210411180017806.png]  
`saveChildren()`发生异常，回滚数据，`parent`记录插入不受影响。

**情况三：**  
父方法`testPropagationTrans()`和子方法`saveChildren()`均开启事务。  
![在这里插入图片描述][20210411180351615.png]  
结果发现即使`saveChildren()`产生的异常被`try-catch`，父事务也回滚。

综上：  
**1.父方法和子方法都开启事务，子事务回滚，父事务一定回滚（子事务没将父事务挂起的情况下），不管异常是否被`try-catch`捕获。  
2.子方法没开启事务发生异常，父方法开启事务，这个异常被`try-catch`后，父方法不会回滚。如果没被`try-catch`，那么异常会从子事务抛到父事务导致父事务回滚。  
3.子方法开启了事务，父方法不开启事务，不管是否`try-catch`子方法中的异常，父方法都不会回滚。没开事务就不涉及回滚的概念。**

# 五、Propagation.SUPPORTS #

如果当前有事务，则使用事务，如果当前没有事务，就以非事务方式执行

**情况一：**  
父方法`testPropagationTrans()`**不**开启事务，子方法`saveChildren()`事务传播类型改为`Propagation.SUPPORTS`  
![在这里插入图片描述][20210411182412860.png]  
外层父方法没有事务，子方法`saveChildren()`也就以非事务方式执行，这里不会回滚，所以有2条数据。

**情况二：**  
父方法`testPropagationTrans()`开启事务，传播类型为`Propagation.REQUIRED`，子方法`saveChildren()`事务传播类型改为`Propagation.SUPPORTS`  
![在这里插入图片描述][20210411182859856.png]  
子方法`saveChildren()`当前父方法开启了事务，故使用事务，`saveChildren()`发生异常回滚，这里子事务没将父事务挂起，子事务回滚，父事务一定回滚，正好验证了前面说过的结论，所以这里没有记录。

# 六、Propagation.MANDATORY #

支持当前的事务，如果当前没有事务，就抛出异常。  
**情况一：**  
父方法`testPropagationTrans()`**不**开启事务，子方法`saveChildren()`事务传播类型改为`Propagation.MANDATORY`  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTE1ODk5_size_16_color_FFFFFF_t_70]  
此时`saveChildren()`直接抛出异常，和之前的除以0异常不同， `No existing transaction found for transaction marked with propagation 'mandatory'`，外层没有事务，就会抛异常。  
![在这里插入图片描述][20210411184130829.png]  
异常导致`saveChildren()`方法没执行，没有`child-1`记录插入，但是数据库会插入`parent`记录，因为父方法没开启事务，不影响`saveParent()`的执行。

**情况二：**  
父方法`testPropagationTrans()`开启事务，传播类型为`Propagation.REQUIRED`，子方法`saveChildren()`事务传播类型改为`Propagation.MANDATORY`  
![在这里插入图片描述][20210411184338477.png]  
子方法`saveChildren()`支持父事务，故使用事务，`saveChildren()`发生异常回滚，这里子事务没将父事务挂起，子事务回滚，父事务一定回滚，正好验证了前面说过的结论，所以这里没有记录。

# 七、Propagation.REQUIRES\_NEW #

新建事务，如果当前存在事务，把当前事务挂起。

![20210411184941881.png][]

这里说得多一些，所以代码整个给出来

......
    	// ==========测试类
        @Transactional(propagation = Propagation.REQUIRED)
        public void testPropagationTrans() {
        
        	saveParent();
            saveChildren();
        }
        ......
    
    	// ===========service实现类
    
        public void saveParent() {
        
            Stu stu = new Stu();
            stu.setName("parent");
            stu.setAge(19);
            stuMapper.insert(stu); // 数据库插入一条parent记录
        }
        @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); // 数据库插入一条child-1记录
        }
        public void saveChild2() {
        
            Stu stu2 = new Stu();
            stu2.setName("child-2");
            stu2.setAge(22);
            stuMapper.insert(stu2); // 数据库插入一条child-2记录
        }

![在这里插入图片描述][20210411190333510.png]

有人会疑问了，**saveChildren()** 都新建事务将原事务挂起了，为什么子事务回滚父事务也会回滚？**原来的事务都挂起了，子事务回滚和父事务回滚没有必然联系了。** 其实这里原因是因为异常抛给了父事务，导致回滚。我们可以将`saveChildren()`用`try-catch`包裹，就会发现，`testPropagationTrans()`所在的事务并没有回滚，因为`parent`记录插入成功了。  
![在这里插入图片描述][202104111910276.png]  
为了不混淆，我们将异常提出来

......
    	// ==========测试类
        @Transactional(propagation = Propagation.REQUIRED)
        public void testPropagationTrans() {
        
        	saveParent();
            saveChildren();
            int a = 1 / 0;  // =======将saveChildren的异常提到外面=============
        }
        ......
    
    	// ===========service实现类
        public void saveParent() {
        
            Stu stu = new Stu();
            stu.setName("parent");
            stu.setAge(19);
            stuMapper.insert(stu); // 数据库插入一条parent记录
        }
        @Transactional(propagation = Propagation.REQUIRES_NEW)
        public void saveChildren() {
        
            saveChild1();
            saveChild2();
        }
    
        public void saveChild1() {
        
            Stu stu1 = new Stu();
            stu1.setName("child-1");
            stu1.setAge(11);
            stuMapper.insert(stu1); // 数据库插入一条child-1记录
        }
        public void saveChild2() {
        
            Stu stu2 = new Stu();
            stu2.setName("child-2");
            stu2.setAge(22);
            stuMapper.insert(stu2); // 数据库插入一条child-2记录
        }

![在这里插入图片描述][20210411191519136.png]  
两条`child`记录插入成功，而`parent`记录没插入，说明子事务执行完就`commit`了，父事务所有相关数据库的操作全部回滚，`parent`记录的插入被撤销，但这也影响不了已经`commit`的子事务。

举个形象的例子，小区的人都用小区网，我觉得小区网太慢了，自己拉了一根光纤，某天因施工小区网断掉了，大家都受到影响，但是我自己的网不受影响。

# 八、Propagation.NOT\_SUPPORTED #

以非事务方式执行操作，如果当前存在事务，就把当前事务挂起

......
    	// ==========测试类
        @Transactional(propagation = Propagation.REQUIRED)
        public void testPropagationTrans() {
        
        	saveParent();
            saveChildren();
        }
        ......
    
    	// ===========service实现类
        public void saveParent() {
        
            Stu stu = new Stu();
            stu.setName("parent");
            stu.setAge(19);
            stuMapper.insert(stu); // 数据库插入一条parent记录
        }
        @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); // 数据库插入一条child-1记录
        }
        public void saveChild2() {
        
            Stu stu2 = new Stu();
            stu2.setName("child-2");
            stu2.setAge(22);
            stuMapper.insert(stu2); // 数据库插入一条child-2记录
        }

![在这里插入图片描述][20210411193452893.png]  
结果是`child-1`记录插入成功，`parent`没有插入成功。原因是`saveChildren()`以非事务方式执行，并将父事务挂起，执行之后发生异常，但是`child-1`插入成功，异常抛到父事务后数据库操作全部回滚，所以`parent`没有插入成功。

这种情况主要用在查询操作，比如在类上开启了事务，类里面的所有方法都开启了事务，插入删除更新是需要的，但是查询就没必要了，所以可以用这个`Propagation.NOT_SUPPORTED`将查询方法以非事务的方式执行。

# 九、Propagation.NEVER #

以非事务方式执行，如果当前存在事务，则抛出异常。与`Propagation.MANDATORY`正好相反。

......
    	// ==========测试类
        @Transactional(propagation = Propagation.REQUIRED)
        public void testPropagationTrans() {
        
        	saveParent();
            saveChildren();
        }
        ......
    
    
    	// ===========service实现类
        public void saveParent() {
        
            Stu stu = new Stu();
            stu.setName("parent");
            stu.setAge(19);
            stuMapper.insert(stu); // 数据库插入一条parent记录
        }
        @Transactional(propagation = Propagation.NEVER)
        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); // 数据库插入一条child-1记录
        }
        public void saveChild2() {
        
            Stu stu2 = new Stu();
            stu2.setName("child-2");
            stu2.setAge(22);
            stuMapper.insert(stu2); // 数据库插入一条child-2记录
        }

结果异常`Existing transaction found for transaction marked with propagation 'never'`  
![在这里插入图片描述][20210411195657973.png]  
![在这里插入图片描述][20210411195725788.png]  
数据库也没有记录，因为`parent`记录插入后，收到`saveChildren()`的异常导致父事务回滚，而`saveChildren()`因为注解检查到异常，内容就没执行。如果去掉`testPropagationTrans()`事务，那么执行如下，方法都是以非事务方式执行。  
![在这里插入图片描述][20210411200030969.png]

# 十、Propagation.NESTED #

如果当前有事务，则开启子事务（嵌套事务），嵌套事务是独立提交或者回滚，如果当前没有事务，就新建事务运行。

运行结果和原因与`Propagation.REQUIRED`一模一样。几乎没区别，这种情况用得少。

欢迎一键三连~  
  
有问题请留言，大家一起探讨学习  
  
\----------------------Talk is cheap, show me the code-----------------------

[20210411170246163.png]: /images/20221022/c09145c66159455f95ef4edcea9f9578.png
[20210411171729808.png]: /images/20221022/b4ffe80d388949ce898c1710945ad092.png
[20210411172649926.png]: /images/20221022/acad99927a1b45458340d45b78773491.png
[20210411173634840.png]: /images/20221022/04b23cdb699640dfbb6bf1a823af8623.png
[20210411174415195.png]: /images/20221022/06d29a394b35466db77030599d97dd90.png
[20210411175801170.png]: /images/20221022/6c61be242f5843eaa6040655277a8c13.png
[20210411180017806.png]: /images/20221022/466d467ebb7447bfafbc852c04241e11.png
[20210411180351615.png]: /images/20221022/1c5f8617c2f94f4693f8bc1cbfbe5869.png
[20210411182412860.png]: /images/20221022/fc753805a86a44bab06e4b7391a7beca.png
[20210411182859856.png]: /images/20221022/c178a92574904479ab211861a2bd22d9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTE1ODk5_size_16_color_FFFFFF_t_70]: /images/20221022/369db236b13945d1adc6af84120f10ca.png
[20210411184130829.png]: /images/20221022/6dd23231e8f14c018d56be26700d16c4.png
[20210411184338477.png]: /images/20221022/adec9a0b89df456fad4d98052f4f504a.png
[20210411184941881.png]: /images/20221022/fe5cb6c3d3a94862bcccd96feb5edcd9.png
[20210411190333510.png]: /images/20221022/279b7f747c1049d9aad310d11cdaa2e1.png
[202104111910276.png]: /images/20221022/580abc3267b44343adea7ed1f574142b.png
[20210411191519136.png]: /images/20221022/24e581ee9bc34e71bdecc28fa0430d76.png
[20210411193452893.png]: /images/20221022/ab569ffbade8477a9c60c08ebcd3b09d.png
[20210411195657973.png]: /images/20221022/a2da80f274454a0cb0c5ba6d89107dca.png
[20210411195725788.png]: /images/20221022/7048b1883c6c42219dddc27871075753.png
[20210411200030969.png]: /images/20221022/75c5add5ac62407499479f4e3efe4da1.png