面试中经常要问到的， Spring事务的传递性是如何区分的呢？

最新推荐文章于 2024-07-25 22:43:20 发布
最新推荐文章于 2024-07-25 22:43:20 发布
阅读量353 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37700260/article/details/107148396
版权

1. 概念介绍

本地事务

数据库事务， 默认事务为自动提交， 因此如果一个业务逻辑类中有多次数据库操作将无法保证事务的一致性。

spring事务

对本地事务操作的一次封装， 相当于把使用jdbc代码开启， 提交， 回滚事务进行了封装。

2. spring事务的传递性介绍

事务传播行为， 所谓事务的传播行为是指， 如果在开始当前事务之前， 一个事物上线文已经存在， 此时有若干选项可以指定一个事物性方法的执行行为。在TransactionDefinition定义中包括了如下几个标识传播行为的常量：

TranscationDefinition.PROPAGATION_REQUIRED: 如果当前存在事务， 则加入该事务；如果当前没有事务， 则创建一个新的事务

TranscationDefinition.PROPAGATION_REQUIRES_NEW：创建一个新的事务， 如果当前存在事务， 则把当前事务挂起。

TranscationDefiniton.PROPAGATION_SUPPORTS：如果当前存在事务， 则加入该事务；如果当前没有事务， 则以非事务的方式继续运行。

TransactionDefinition.PROPAGATION_NOT_SUPPORTED: 以非事务方式运行， 如果当前存在事务， 则把当前事务挂起。

TransactionDefinition.PROPAGATION_NEVER: 以非事务方式运行， 如果当前存在事务， 则抛出异常。

TransactionDefinition.PROPAGATIOIN_MANDATORY：如果当前存在事务， 则加入该事务；如果当前没有事务， 则抛出异常。

TransactionDefinition.PROPAGATION_NESTED：如果当前存在事务， 则创建一个事务作为当前事务的嵌套事务来运行， 如果当前没有事务， 则该取值等价TransactionDefinition.PROPAGATION_REQUIRED。

这里需要指出的是， 前面的六种事务传播行为是Spring从EJB中引入的， 他们共享相同的概念。而PROPAGATION_NESTED是Spring所特有的。以PROPAGATION_NESTED启动的事务内嵌于外部事务中（如果存在外部事务的话）， 此时，内嵌事务并不是一个独立的事务，它依赖于外部事务的存在，只有通过外部的事务提交，才能引起内部事务的提交，嵌套的子事务不能单独提交。如果熟悉 JDBC 中的保存点（SavePoint）的概念，那嵌套事务就很容易理解了，其实嵌套的子事务就是保存点的一个应用，一个事务中可以包括多个保存点，每一个嵌套子事务。另外，外部事务的回滚也会导致嵌套子事务的回滚。

3. 示例

原始数据：

idnamecatalogdescription
2namecatalogNull

1. 正常情况

调用方为Conumer,  调用ServiceA的methodA， methodA调用ServiceA的 methodB和ServiceA的methodC。

    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void modifyCommodityInfo(Commodity commodity) {
        updateCommodityCatalog1(commodity);
        updateCommodityCatalog2(commodity);
    }
 
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    private void updateCommodityCatalog1(Commodity commodity) {
        commodity.setCatalog("catalog222222222");
        commodityDao.updateCommodity(commodity);
    }
 
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    private void updateCommodityCatalog2(Commodity commodity) {
        commodity.setName("name222");
        commodityDao.updateCommodity(commodity);
    }

运行结果：

idnamecatalogdescription
2name222catalog222222222Null

说明全部正常执行， 全部成功了。

2. 事务中一个方法抛出异常

    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void modifyCommodityInfo(Commodity commodity) {
        updateCommodityCatalog1(commodity);
        updateCommodityCatalog2(commodity);
    }
 
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    private void updateCommodityCatalog1(Commodity commodity) {
        commodity.setCatalog("catalog222222222");
        commodityDao.updateCommodity(commodity);
    }
 
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    private void updateCommodityCatalog2(Commodity commodity) {
        commodity.setName("name222");
        commodityDao.updateCommodity(commodity);
        throw new RuntimeException("222");
    }

运行结果：

idnamecatalogdescription
2namecatalogNull

结果没有发生变化， 说明整个事务有异常， 全部事务回滚

3. 捕获异常的情况

    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void modifyCommodityInfo(Commodity commodity) {
        updateCommodityCatalog1(commodity);
        try {
            updateCommodityCatalog2(commodity);
        } catch (Exception e) {
            
        }
      
    }
 
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    private void updateCommodityCatalog1(Commodity commodity) {
        commodity.setCatalog("catalog222222222");
        commodityDao.updateCommodity(commodity);
    }
 
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    private void updateCommodityCatalog2(Commodity commodity) {
        commodity.setName("name222");
        commodityDao.updateCommodity(commodity);
        throw new RuntimeException("222");
    }

运行结果：

idnamecatalogdescription
2name222catalog222222222Null

说明程序正常执行， 并捕获到了异常， 但是数据库更新了

4. 跨服务事务

ServiceA的methodA 调用 ServiceA的methodB和ServiceA的methodC和ServiceB的methodD，代码如下：

 @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void modifyCommodityInfo(Commodity commodity) {
        updateCommodityCatalog1(commodity);
        updateCommodityCatalog2(commodity);
        updateCommodityCatalog3(commodity);
    }
 
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    private void updateCommodityCatalog1(Commodity commodity) {
        commodity.setCatalog("catalog222222222");
        commodityDao.updateCommodity(commodity);
    }
 
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    private void updateCommodityCatalog2(Commodity commodity) {
        commodity.setName("name222");
        commodityDao.updateCommodity(commodity);
    }
    
    //另一个Service InnerService的方法
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void updateCommodityCatalog3(Commodity commodity) {
        commodity.setDescription("desc333");
        commodityDao.updateCommodity(commodity);
        throw new RuntimeException("333");
    }

运行结果：

idnamecatalogdescription
2namecatalogNull

假设MethodD抛出异常，则Consumer调用MethodA会发生怎样的情形？    发现Consumer调用MethodA的时候出现了运行时异常,UnexpectedRollbackException: “Transaction rolled back because it has been marked as rollback-only”。这是为什么呢？

网上搜索了下，终于发现了一个合理的解释。当MethodA调用MethodD的时候，且两个方法都为required属性，根据事务传播级别，则methodA和methodD共享一个事务，当methodD抛出了异常，则共享事务回滚，但是被MethodA catch了，而MethodA又没有及时抛出异常，则MethodA正常执行到最后的时候，则会做提交事务的操作，但是事务已经被回滚了，所以才出现了上面的异常。

既然这样，小弟就开始YY了一下，哪些情况会使调用方没有这个异常呢？经过与小伙伴们的思维碰撞，发现有以下几个方法。

  1) MethodA 不加事务，所以执行到最后就不会commit，SUPPORTS和NOT_SUPPORTED都可以实现这种功能。

  2) MethodD设置不共享事务，拥有自己单独的事务。验证发现，REQUIRES_NEW可以实现这种功能。

5. 跨服务事务抛异常

    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void modifyCommodityInfo(Commodity commodity) {
        updateCommodityCatalog1(commodity);
        updateCommodityCatalog2(commodity);
        try {
    commodityInnerService.updateCommodityCatalog3(commodity);
        } catch (Exception e) {
        }
    }
 
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    private void updateCommodityCatalog1(Commodity commodity) {
        commodity.setCatalog("catalog222222222");
        commodityDao.updateCommodity(commodity);
    }
 
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    private void updateCommodityCatalog2(Commodity commodity) {
        commodity.setName("name222");
        commodityDao.updateCommodity(commodity);
    }
    
    //另一个Service InnerService的方法
    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    public void updateCommodityCatalog3(Commodity commodity) {
        commodity.setDescription("desc333");
        commodityDao.updateCommodity(commodity);
        throw new RuntimeException("333");
    }

运行结果：

idnamecatalogdescription
2name222catalog222222222Null

然后又YY了下，既然一个回滚的事务不能提交了，那么这个回滚的事务可以重复回滚吗？

6. 跨事务

ServiceA的methodA 调用 ServiceA的methodB和ServiceA的methodC和ServiceB的methodD和ServiceB的methodE。代码如下：

    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void modifyCommodityInfo(Commodity commodity) {
        updateCommodityCatalog1(commodity);
        updateCommodityCatalog2(commodity);
        try {
    ommodityInnerService.updateCommodityCatalog3(commodity);
        } catch (Exception e) {
        }
         try {
    commodityInnerService.updateCommodityCatalog4(commodity);
        } catch (Exception e) {
        }
    }
 
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    private void updateCommodityCatalog1(Commodity commodity) {
        commodity.setCatalog("catalog222222222");
        commodityDao.updateCommodity(commodity);
    }
 
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    private void updateCommodityCatalog2(Commodity commodity) {
        commodity.setName("name222");
        commodityDao.updateCommodity(commodity);
    }
    
    //另一个Service InnerService的方法
    @Transactional(propagation = Propagation.REQUIRES, rollbackFor = Exception.class)
    public void updateCommodityCatalog3(Commodity commodity) {
        commodity.setDescription("desc333");
        commodityDao.updateCommodity(commodity);
        throw new RuntimeException("333");
    }
    
     //另一个Service InnerService的方法
    @Transactional(propagation = Propagation.REQUIRES, rollbackFor = Exception.class)
    public void updateCommodityCatalog4(Commodity commodity) {
        commodity.setDescription("desc333");
        commodityDao.updateCommodity(commodity);
        throw new RuntimeException("333");
    }

运行结果：

  发现还是只抛出了一个Transaction rolled back because it has been marked as rollback-only

所以猜测一个被共享的事务抛出多个异常的时候只是标记下rollback-only，而在方法结束的时候判断是执行事务还是回滚事务。

  总结：

1） 单个ServiceA 内部调用不存在事务传播，相当于把methodB和methodC的代码嵌套到methodA的代码中，即使定义了也无法生效。

2） 跨Service调用存在事务传播级别，需要考虑共享事务，还是新事务调用，即跨Service的调用是否需要需要回滚本Servcie的代码。
故事凌
关注
Spring面试题1：Spring框架的核心功能是什么？Spring框架的好处是什么？
小小鱼儿小小林的博客
09-22 244
该文章专注于面试，面试只要回答关键点即可，不需要对框架有非常深入的回答，如果你想应付面试，是足够了，抓住关键点。
深入理解 Spring 事务原理及69道Spring面试题和答案
m0_67322837的博客
04-08 816
一、事务的基本原理 Spring事务的本质其实就是数据库对事务的支持，没有数据库的事务支持，spring是无法提供事务功能的。对于纯JDBC操作数据库，想要用到事务，可以按照以下步骤进行： 1.获取连接 Connection con = DriverManager.getConnection() 2.开启事务con.setAutoCommit(true/false); 3.执行CRUD 4.提交事务/回滚事务 con.commit() / con.rollback(); 5.关闭连接 conn.
Spring事务传递性探讨
lkjhoip020的博客
02-20 521
本篇主要讨论下面几点获取【下载地址】  ： 一： Spring 事务的传递性介绍 二： 第三方调用含有事务的Service抛异常方法探讨   一： Spring 事务的传递性介绍     事务传播行为，所谓事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。在TransactionDefinition定义
spring事务的传播性
weixin_45295678的博客
05-02 911
spring事务的传播性 1、事务的传播性 研究的是多个事务存在时的处理策略 1）REQUIRED：如果存在一个事务，则支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。 2）SUPPORTS：如果存在一个事务，支持当前事务，如果当前没有事务，就以非事务方式执行。 3）MANDATORY：如果存在一个事务，支持当前事务，如果当前没有事务，就抛出异常。 4）REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起。 5）NOT_SUPPORTED：以非事务方式执行操作，如果当前存在
12.Spring事务和事务传播机制
最新发布
xinhang10的博客
07-25 927
通过事务操作可以进行回滚操作，有效的降低了我们项目出错的损失。
spring事务传递性
胡润土
10-22 381
Spring事务的传递性
西溪少女的梦
01-20 436
REQUIRED： A调用B，B抛出异常，Acatch住了也会回滚。 REQUIRES_NEW： A调用B，B抛出异常，Acatch住就不会滚，没catch住就回滚。 一般在有关联数据的时候用到事务 ...
【面试】Spring事务面试考点吐血整理（建议珍藏）
m0_60721514的博客
08-29 399
这里获取的属性才是真正用于事务的。在AOP里，Advisor = Pointcut + Advice，Pointcut是切入点，表示要拦截的方法，Advice是增强，表示要加进去的事物功能。整体来说就是，Pointcut拦截住了方法，然后使用这个“源”去方法和类上获取事务属性，如果能获取到，说明此方法需要参与事务，则进行事务增强，反之则不增强。这也证明了以前文章里说过的话，@Transactional注解的作用有两个，一是表明要参与事务，二是表明如何参与事务，这些注解属性就是来规定如何参与的。...
Spring Boot面试都问了什么？快看看这22道面试题！
MCO_TT0的博客
08-09 431
多年来，随着新功能的增加，spring 变得越来越复杂。访问spring官网页面，我们就会看到可以在我们的应用程序中使用的所有 Spring 项目的不同功能。Spring Boot Batch 提供可重用的函数，这些函数在处理大量记录时非常重要，包括日志/跟踪，事务管理，作业处理统计信息，作业重新启动，跳过和资源管理。使用了下面的一些依赖项spring-boot-starter-activemqspring-boot-starter-security这有助于增加更少的依赖关系，并减少版本的冲突。
Java八股文是指程序员在面试过程中经常被问到的具有固定化和格式化答案的问题集合
06-28
这些类型在内存中的存储方式和占用空间通常是面试中的重点考察内容。 #### 二、封装、继承与多态 1. **封装**：是面向对象编程的一个基本原则，通过将数据和方法包装在一个类中，从而隐藏了对象的具体实现细节。...
Spring 事务的传递性介绍-概念
qq_32806781的博客
04-27 502
一： Spring 事务的传递性介绍 事务传播行为，所谓事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。在TransactionDefinition定义中包括了如下几个表示传播行为的常量： TransactionDefinition.PROPAGATION_REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创...
关于事务的传递性
qq_35184946的博客
09-09 570
关于事务的传递性 1、调用方有事务，那么被调用方则有事务； 2、调用方没有事务，被调用方有事务，则还是没有事务； 3、事务控制A调用事务控制B，如果B抛异常，A处理异常，则整个事务会回滚； 4、事务控制方法中，异步方线程是没有事务控制的； ...
浅析Spring事务的传播性
juzhenxing的博客
10-26 535
方法A和方法B的事务传播性都为PROPAGATION_REQUIRED 当方法A调用方法B, 方法B报错, 即使报错被外层捕获, 整体事务也会回滚.报错信息为UnexpectedRollbackException: Transaction rolled back because it has been marked as rollback-only 代码演示 @Override publ...
Spring事务的传递性的使用
张小挑的博客
03-22 1676
关于Spring事务
事务传播性
漫天雪_昆仑巅
02-15 1040
事务传播性说明： 事务传播行为就是多个事务方法相互调用时，事务如何在这些方法间传播。spring支持7种事务传播行为： 1、propagation_requierd：如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是最常见的选择。 2、propagation_supports：支持当前事务，如果没有当前事务，就以非事务方法执行。 3、propagation_mand...
事务的传播性
王如霜
07-16 773
1.Propagation.REQUIRED 方法被调用时自动开启事务，在事务范围内使用则使用同一个事务，否则开启新事务即如果在该Propagation.REQUIRED事务下被调用，则则用Propagation.REQUIRED事务，否则使用自己的新的事务 @Test public void test{ addStudent(); } @Transactional(propagati...
事务传播性是什么？
豪猪的博客
02-21 4729
我们都知道事务的概念，那么事务的传播特性是什么呢？(此处着重介绍传播特性的概念，关于传播特性的相关配置就不介绍了，可以查看spring的官方文档)         在我们用SSH开发项目的时候，我们一般都是将事务设置在Service层 那么当我们调用Service层的一个方法的时候它能够保证我们的这个方法中执行的所有的对数据库的更新操作保持在一个事务中，在事务层里面调用的这些方法要么全部
Spring框架面试详解：依赖注入与事务管理
"Spring面试相关知识点" 在面试中，Spring框架是一个...这些是Spring面试中可能会涉及的关键知识点，涵盖了Spring的核心特性、DI的实现方式以及事务管理等方面。了解和掌握这些内容对于准备Spring相关的面试至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值