关于Spring注解式事务的误区

最新推荐文章于 2022-03-09 17:19:58 发布
最新推荐文章于 2022-03-09 17:19:58 发布
阅读量97 收藏
点赞数
分类专栏： 工作经验
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43014839/article/details/119459617
版权 
   Spring可以使用注解进行事务管理，但很多时候，会出现事务不起作用，无法实现我们想要的效果。在众多博客和资料中搜集，@Transactional失效的常见场景主要如下：
   1：@Transactional必须要写在public修饰符修饰的方法；private protected等修饰符的方法无法起作用；
   2：@Transactional的调用发起方不能是同一类；
   3：@Transactional通常不要去手动捕获异常，一旦捕获，则极有可能无法触发回滚操作。

    另外，还有事务传播配置、事务异常回滚配置等都会产生影响。在此不做详细说明。

    为了更进一步验证方法调用过程中的事务回滚情况。简单编写了几个示例。其结果如下：

情况一：
同类调用：

	一：入口方法不写@Transactional。被调用方法写。异常出现在被调用方法。结论：插入和更新都会成功，不会回滚。例子如下：
		
		public void testSW() {
			insertBatch(buildInsertPrimary());
			updateBatch(buildUpdatePrimary());
		}

		@Transactional
		public void insertBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.insertBatch(primaryReports);
		}

		@Transactional
		public void updateBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.updateBatch(primaryReports);
			int a = 10/0;
		}


     二：入口方法不写@Transactional。被调用方法写。异常出现在入口方法。结论：插入和更新都会成功，不会回滚。例子如下：

		public void testSW() {
			insertBatch(buildInsertPrimary());
			updateBatch(buildUpdatePrimary());
			int a = 10/0;
		}

		@Transactional
		public void insertBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.insertBatch(primaryReports);
		}

		@Transactional
		public void updateBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.updateBatch(primaryReports);
		}

     三：入口方法写@Transactional。被调用方法也写。异常出现在被调用方法。结论：插入和更新都不会成功，例子如下：
		@Transactional
		public void testSW() {
			insertBatch(buildInsertPrimary());
			updateBatch(buildUpdatePrimary());
		}
		@Transactional
		public void insertBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.insertBatch(primaryReports);
		}

		@Transactional
		public void updateBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.updateBatch(primaryReports);
			int a = 10/0;
		}

      四：入口方法写@Transactional。被调用方法也写。异常出现在入口方法。结论：插入和更新都不会成功，例子如下：
		@Transactional
		public void testSW() {
			insertBatch(buildInsertPrimary());
			updateBatch(buildUpdatePrimary());
                   int a = 10/0;
		}
		@Transactional
		public void insertBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.insertBatch(primaryReports);
		}

		@Transactional
		public void updateBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.updateBatch(primaryReports);
			
		}
		
    五：入口方法写@Transactional。被调用方法也写。异常出现在被调用方法。入口方法进行try catch捕获异常。结论：插入和更新都会成功，不会回滚，例子如下：
		@Transactional
		public void testSW() {
			try {
			    insertBatch(buildInsertPrimary());
			    updateBatch(buildUpdatePrimary());
                   }catch(Exception e) {
                        System.out.println("捕获异常"); 
                  }
			
                   
		}
		@Transactional
		public void insertBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.insertBatch(primaryReports);
		}

		@Transactional
		public void updateBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.updateBatch(primaryReports);
			int a = 10/0;
			
		}
		
     六：入口方法写@Transactional。被调用方法也写。异常出现在入口方法。入口方法进行try catch捕获异常。结论：插入和更新都会成功，不会回滚，例子如下：
		@Transactional
		public void testSW() {
			try {
			    insertBatch(buildInsertPrimary());
			    updateBatch(buildUpdatePrimary());
                        int a = 10/0;
                   }catch(Exception e) {
                        System.out.println("捕获异常"); 
                  }
			
                   
		}
		@Transactional
		public void insertBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.insertBatch(primaryReports);
		}

		@Transactional
		public void updateBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.updateBatch(primaryReports);
		}

情况二：
异类调用：

	七：入口方法不写@Transactional。被调用方法写。异常出现在被调用方法。结论：插入可以成功，更新不会成功。例子如下：
		public void testSW() {
			primaryReportService.insertBatch(buildInsertPrimary());
			primaryReportService.updateBatch(buildUpdatePrimary());
		}
		@Transactional
		public void insertBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.insertBatch(primaryReports);
		}

		@Transactional
		public void updateBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.updateBatch(primaryReports);
			int a = 10/0;
			
		}
	
	八：入口方法不写@Transactional。插入方法写，更新方法不写。异常出现在被调用方法。结论：插入和更新都会成功。例子如下：
		public void testSW() {
			primaryReportService.insertBatch(buildInsertPrimary());
			primaryReportService.updateBatch(buildUpdatePrimary());
		}
		@Transactional
		public void insertBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.insertBatch(primaryReports);
		}
		public void updateBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.updateBatch(primaryReports);
			int a = 10/0;
			
		}

	九：入口方法不写@Transactional。被调用方法写。异常出现在入口方法。结论：插入和更新都会成功。例子如下：
		public void testSW() {
			primaryReportService.insertBatch(buildInsertPrimary());
			primaryReportService.updateBatch(buildUpdatePrimary());
			int a = 10/0;
		}
		@Transactional
		public void insertBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.insertBatch(primaryReports);
		}

		@Transactional
		public void updateBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.updateBatch(primaryReports);
		}

	十：入口方法不写@Transactional。被调用方法写。异常出现在入口方法，且捕获住异常。结论：插入和更新都会成功。例子如下：
		public void testSW() {
			try {
				primaryReportService.insertBatch(buildInsertPrimary());
				primaryReportService.updateBatch(buildUpdatePrimary());
				int a = 10/0;
                   }catch(Exception e) {
                        System.out.println("捕获异常");
                   }
		}
		@Transactional
		public void insertBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.insertBatch(primaryReports);
		}

		@Transactional
		public void updateBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.updateBatch(primaryReports);
		}

	十一：入口方法不写@Transactional。被调用方法写。异常出现在被调用方法，且捕获住异常。结论：插入成功，更新不成功。例子如下：
		public void testSW() {
			try {
				primaryReportService.insertBatch(buildInsertPrimary());
				primaryReportService.updateBatch(buildUpdatePrimary());
				
                   }catch(Exception e) {
                        System.out.println("捕获异常");
                   }
		}
		@Transactional
		public void insertBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.insertBatch(primaryReports);
		}

		@Transactional
		public void updateBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.updateBatch(primaryReports);
			int a = 10/0;
		}

	十二：入口方法不写@Transactional。插入方法写，更新方法不写。异常出现在被调用方法，且捕获住异常。结论：插入和更新成功。例子如下：
		public void testSW() {
			try {
				primaryReportService.insertBatch(buildInsertPrimary());
				primaryReportService.updateBatch(buildUpdatePrimary());
				
                   }catch(Exception e) {
                        System.out.println("捕获异常");
                   }
		}
		@Transactional
		public void insertBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.insertBatch(primaryReports);
		}
		public void updateBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.updateBatch(primaryReports);
			int a = 10/0;
		}

	十三：都写上@Transactional 异常出现在被调用方法或者入口方法，结论：插入和更新不成功，例子如下：
		@Transactional
            public void testSW() {
			primaryReportService.insertBatch(buildInsertPrimary());
			primaryReportService.updateBatch(buildUpdatePrimary());
				
                 
		}
		@Transactional
		public void insertBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.insertBatch(primaryReports);
		}
            @Transactional
		public void updateBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.updateBatch(primaryReports);
			int a = 10/0;
		}

	十四：都写上@Transactional 异常出现在被调用方法，且捕获住异常，结论：插入和更新不成功，且报错信息为：Transaction rolled back because it has been marked as rollback-only 例子如下：
		@Transactional
            public void testSW() {
                   try {
				primaryReportService.insertBatch(buildInsertPrimary());
				primaryReportService.updateBatch(buildUpdatePrimary());
                   }catch(Exception e) {
                   		System.out.println("捕获异常");
                   }
			
				
                 
		}
		@Transactional
		public void insertBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.insertBatch(primaryReports);
		}
            @Transactional
		public void updateBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.updateBatch(primaryReports);
			int a = 10/0;
		}

	十五：都写上@Transactional 异常出现在入口方法，且捕获住异常，结论：新增和更新都成功 例子如下：
		@Transactional
            public void testSW() {
                   try {
				primaryReportService.insertBatch(buildInsertPrimary());
				primaryReportService.updateBatch(buildUpdatePrimary());
				int a = 10/0;
                   }catch(Exception e) {
                   		System.out.println("捕获异常");
                   }
			
				
                 
		}
		@Transactional
		public void insertBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.insertBatch(primaryReports);
		}
            @Transactional
		public void updateBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.updateBatch(primaryReports);
			
		}

     十六：入口方法写上@Transactional 异常出现在被调用方法上或者在入口方法上。结论：新增和更新都不成功。例子如下：
		@Transactional
            public void testSW() {
			primaryReportService.insertBatch(buildInsertPrimary());
			primaryReportService.updateBatch(buildUpdatePrimary());
                 
		}
		
		public void insertBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.insertBatch(primaryReports);
		}
           
		public void updateBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.updateBatch(primaryReports);
                   int i=10/0;
			
		}

	十七：入口方法写上@Transactional 异常出现在被调用方法上或者在入口方法上，且捕获异常。结论：新增和更新都成功。例子如下：
		@Transactional
            public void testSW() {
                   try {
				primaryReportService.insertBatch(buildInsertPrimary());
			       primaryReportService.updateBatch(buildUpdatePrimary());
                   }catch(Exception e) {
                   		System.out.println("捕获异常");
                   }
			
		}
		
		public void insertBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.insertBatch(primaryReports);
		}
           
		public void updateBatch(List<PrimaryReport> primaryReports) {
			primaryReportMapper.updateBatch(primaryReports);
                   int i=10/0;
			
		}
qq_43014839
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
在用注解来做Spring声明式事务管理时遇到的问题
huchaun的博客
07-10 140
用spring来做声明式事务管理有两种方式，可以使用注解，也可以使用xml配置文件。先来说说步骤。 首先，不论哪种方式，都需要先在Spring配置文件中创建一个事务管理器。（Mybatis使用DataSourceTransactionManager，） <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <pr
Spring注解事务失效原因以及解决方法
chordimp的博客
04-06 960
原因 在于spring 声明示事物使用动态代理实现，而当调用同一个类的方法时，是会不会走代理逻辑的，自然事物的配置也会失效。 比如Spring调用同一个类下的其他方法时用的是this.xxx()，所以不会走代理，导致事务失效 解决方法 在spring xml中配置 暴露proxy 对象，然后在代码中用AopContext.currentProxy() 就可以获当前代理对象 xml配置文件...
Spring官方都推荐使用的注解Transactional事务，为啥我不建议使用 转载的，我觉得写的太好了就转载一下（不是我写的）
zy103118的博客
01-04 133
原文地址：Spring官方都推荐使用的@Transactional事务，为啥我不建议使用！_方志朋的博客-CSDN博客 事务管理在系统开发中是不可缺少的一部分，Spring提供了很好事务管理机制，主要分为编程式事务和声明式事务两种。 关于事务的基础知识，如什么是事务，数据库事务以及Spring事务的ACID、隔离级别、传播机制、行为等，就不在这篇文章中详细介绍了。默认大家都有一定的了解。 本文，作者会先简单介绍下什么是声明式事务和编程式事务，再说一下为什么我不建议使用声明式事务。 编程式事务 基于
【Java】Spring注解踩坑记
u010394846的博客
08-13 188
一、写在前面 记录工作中遇到的Spring注解有关的问题。 二、@Scheduled 1、Spring使用@scheduled定时执行任务的时候是在一个单线程中，如果有多个任务，其中一个任务执行时间过长，则有可能会导致其他后续任务被阻塞直到该任务执行完成，也就是会造成一些任务无法定时执行的错觉 2、修改服务器时间时会导致定时任务不执行情况的发生，解决的办法是当修改服务器时间后，将服务进行重启就可以避免此现象的发生。根本原因，jvm启动之后会记录系统时间，然后jvm根据CPU ticks自己来算时间，
Spring框架注解式事务的缺陷
三人行必有我师,手写三行必有所悟
07-06 1245
事务基于连接(Connection)是基本的，由于Spring框架里，类实例的创建都是框架完成，参与事务的方法之间没有连接的传递，因此要保证事务的执行，就只能采用其它的方法，Spring框架采用的是将一个线程中执行的标有事务注解的数据库操作采用一个连接来达成事务处理的目的，优点是简单，不用程序员操心。但实际上这种事务处理方式有非常大的局限性： 1）如果一个线程中有多个不同的事务很难处理； 2）...
Spring注解 TX声明式事务实现过程解析
08-19
Spring 注解 TX 声明式事务实现过程解析 本文将详细介绍 Spring 注解 TX 声明式事务实现过程，通过示例代码和详细的分析，向读者展示如何使用 Spring 注解实现声明式事务。首先，让我们从环境搭建开始。 环境搭建 ...
Spring注解开发,事务控制
最新发布
01-15
Spring事务管理是其核心功能之一，它提供了一种在多层架构中维护数据一致性的机制。事务控制涉及到ACID（原子性、一致性、隔离性和持久性）属性，确保了数据库操作的完整性和可靠性。在Spring中，事务管理有两种方式...
spring注解式事务
06-05
"spring注解式事务" Spring框架提供了基于注解的方式来管理事务，使用@Transactional注解来标记需要事务管理的方法。该注解可以被应用于public方法上，对于非public方法，如果标记了@Transactional也不会报错，但...
Spring实战之使用注解实现声明式事务操作示例
08-25
Spring实战之使用注解实现声明式事务操作示例 在本文中，我们将详细介绍如何使用 Spring 框架来实现声明式事务操作，通过对配置文件和接口实现的分析，来描述如何使用注解来实现事务操作。 事务管理 在 Spring ...
spring boot注解事务+多线程
01-25
本示例将深入探讨如何使用注解来实现事务控制以及如何在Spring Boot中运用多线程。 首先，让我们关注"注解事务"。在Spring框架中，我们主要依赖`@Transactional`注解来声明事务边界。当一个方法被这个注解标记时，...
java加事务与不加事务的区别_【Java】Spring Transactional ReadOnly 和 不加Transactional的区别...
weixin_30066779的博客
03-02 5025
在网络上搜了下，答案如下两个。说下我的理解，其实不管你写不写transaction，事务是肯定有的。只是默认单条sql一个事务，如果我们在Service层的方法上加Transaction注解，那么事务的范围就会扩大，包含在service方法执行的所有sql。Mysql默认的隔离级别是可以防止不可重复读的，所以，加上Transactional，里面如果涉及多次查询一条记录，中间即使被其它事务修改，这...
一个简单接口打开事务和不开事务性能差别，@Transactional注解事务带来的性能损耗
u013958151的博客
10-16 2275
打开事务的后台日志（打上@Transactional注解） 2020-10-15 22:40:40.324 DEBUG 5544 --- [nio-8080-exec-3] o.s.web.servlet.DispatcherServlet : POST "/praise", parameters={} 2020-10-15 22:40:40.325 DEBUG 5544 --- [nio-8080-exec-3] s.w.s.m.m.a.RequestMappingHandlerMapp
关于springboot中的事务注解
chen_19971103的博客
01-18 6838
主要关于在开发中遇到的springboot项目不回滚情况的原因和分析
【Spring】配置事务 注解方式与非注解方式
分享记录开发中的问题，欢迎一起探讨！
07-05 1095
Spring的事务配置非注解方式 <!--通知--> <tx:advice id="txAdvice" transaction-manager="txTransactionManager"> <tx:attributes> <tx:method name="query*" propagation="SUPPO...
SpringBoot中使用Transaction注解遇到的坑
专注JAVA、算法、数据库等干货分享，同时维护【IT技术资源免费分享】圈子
11-17 3241
一:场景 开发一个多批次入库的功能,功能中涉及到多个表间的操作,对数据库表的操作要么同时成功,要么同时失败,不然就会存在脏数据,所以使用到了事务这个知识点()。 划重点:重要的都使用红色标出来了,大家如果不想看我废话,直接跳到红色字体即可0...0 二:Spring中使用的使用方式 1、使用传统的手动开始，手动提交事务即:beginTransaction()、commit()、ro...
配置事务注解出现错误以及总结
weixin_44110100的博客
01-03 273
说一下做什么出现的问题： 在学习spirng框架的时候，我们去配置注解，然后进行事务的管理。首先是要创建对象：事务管理器。然后在我们的业务方法中进行使用。 在未修改前，我在spirng.xml中，通过aop的形式写了这个bean 但是这是错误的。 错误的原因是：你的事务管理对象放在bean标签内，所以出现了错误，如果此时修改陈如下的情况，错误就可以去进行避免了。 顺便提及：其实写事务，还是比较死板的： spring使用事务的步骤如下： 使用@Transactional的步骤： 1.声明事务管理器对象 .
Spring注解事务失效原因
morrison1的博客
03-09 3000
整理了一下Spring事务失效的原因，希望帮到有缘人。 原因一：没有开启事务管理 原因二：标注了@Transactional的方法里面的异常被捕获了 原因三：标注了@Transactional的方法发生了非Error 或者 非RuntimeException 原因四：标注了@Transactional的方法的事务传播类型propagation配置成了NOTSUPPORT 原因五：标注了@Transactional的方法的事务传播类型propagation配置成了NEVER 原因六：标注了@Transact
没有加注解的后果
stujike123456的博客
02-07 165
没有加注解的后果 发生了异常： java.lang.IllegalStateException: Ambiguous mapping. Cannot map 'categoryController' method 原因是没有加注解，系统就找不到这个方法。 posted @ 2018-...
关于同一个service方法中事务的问题
weixin_30436101的博客
04-09 1017
上午有个朋友问我,他在一个service方法中对两张表进行了插入操作.那么它们之间是否会有影响,一个出了异常会不会影响到另一个.对此,我做了以下测试. 图中的transactionalTest方法中有两个插入操作,第一个insertVm方法是可以正常执行的,第二个insertTask方法是会抛异常的. 我执行了两遍,第一个方法正常往数据库中插入了数据,第二个insert方法没有往数据库插入...
spring声明式事务配置方法.docx
04-16
Spring 声明式事务配置是指在 Spring 框架中通过配置文件或注解的方式来管理事务的提交和回滚。这种配置方法可以使得事务管理变得更加灵活和可靠。 TransactionProxyFactoryBean 方式是 Spring 中的一种声明式事务...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值