spring service层方法调用同类中的方法 事务不生效？

最新推荐文章于 2025-10-11 20:52:58 发布
原创 最新推荐文章于 2025-10-11 20:52:58 发布 · 1.4w 阅读 · 33 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入探讨了Spring框架中事务管理的机制，特别是在不同场景下（如跨类调用和服务层内部方法调用）事务的有效性。揭示了@Transactional注解在类内部方法调用时为何失效，以及如何通过配置和使用代理调用来解决这一问题。
有这样的一道面试题：在service层调用别的service层的方法，他们的事务能否生效；如果是在同一个类中调用带有@Transactional注解的方法，此时，他们的事务能否生效？
看了许多大神的blog，今天来做一下总结：

先给出大家答案:

  • 不同类之间的方法调用，如类A的方法a()调用类B的方法b()，这种情况事务是正常起作用的。只要方法a()或b()配置了事务，运行中就会开启事务，产生代理。
  • 同一类内方法调用，无论被调用的b()方法是否配置了事务，此事务在被调用时都将不生效。
  1. 首先先说一下Spring事务管理详解：下面的这篇博客介绍的很清楚了，从基本原理、事务的特性、隔离级别以及事务实现的三种方式
    Spring事务管理详解
  2. 知道了事务的一些知识后，下面说一下@Transactional注解的信息（大家着重看一下4 5 6条的解释）
1.在需要事务管理的地方加@Transactional 注解。@Transactional 注解可以被应用于接口定义和接口方法、类定义和类的 public 方法上。

2.@Transactional 注解只能应用到 public 可见度的方法上。 如果你在 protected、private 或者 package-visible 的方法上使用 @Transactional 注解，它也不会报错， 但是这个被注解的方法将不会展示已配置的事务设置。

3.注意仅仅 @Transactional 注解的出现不足于开启事务行为，它仅仅 是一种元数据。必须在配置文件中使用配置元素，才真正开启了事务行为。(spring配置文件中,开启声明式事务)

4.通过 元素的 “proxy-target-class” 属性值来控制是基于接口的还是基于类的代理被创建。如果 “proxy-target-class” 属值被设置为 “true”，那么基于类的代理将起作用（这时需要CGLIB库cglib.jar在CLASSPATH中）。如果 “proxy-target-class” 属值被设置为 “false” 或者这个属性被省略，那么标准的JDK基于接口的代理将起作用。

5.Spring团队建议在具体的类（或类的方法）上使用 @Transactional 注解，而不要使用在类所要实现的任何接口上。在接口上使用 @Transactional 注解，只能当你设置了基于接口的代理时它才生效。因为注解是 不能继承 的，这就意味着如果正在使用基于类的代理时，那么事务的设置将不能被基于类的代理所识别，而且对象也将不会被事务代理所包装。

6.@Transactional的事务开启 ，或者是基于接口的 或者是基于类的代理被创建。所以在同一个类中一个无事务的方法调用另一个有事务的方法，事务是不会起作用的。
  1. 不生效的原因：

       当从类外调用方法a()时，从spring容器获取到的serviceImpl对象实际是包装好的proxy对象，因此调用a()方法的对象是动态代理对象。而在类内部a()调用b()的过程中，实质执行的代码是this.b()，此处this对象是实际的serviceImpl对象而不是本该生成的代理对象，因此直接调用了b()方法。

  1. 解决办法：
  1. 放到不同的类中进行调用
  2. 在spring配置文件中加入配置
    <aop:aspectj-autoproxy/>
    <aop:aspectj-autoproxy proxy-target-class=“true” expose-proxy=“true” />
  3. 将之前使用普通调用的方法,换成使用代理调用
    ((TestService)AopContext.currentProxy()).testTransactional2();
    获取到TestService的代理类，再调用事务方法，强行经过代理类，激活事务切面。
  4. 使用异步操作，另外开启一个线程或者将这个消息写入到队列里面，在其他的地方进行处理

感谢我调用链接的几位大神：

关于加@Transactional注解的方法之间调用，事务是否生效的问题
spring的service类调用自己方法事务无效
Spring事务不起作用 问题汇总

Spring、Springboot中事务传播机制（事物嵌套）
蔡定努
07-24 878
Spring、Springboot中事务传播机制（事物嵌套） 事务传播机制： 事务的传播行为是针对嵌套事务而言。即是针对（需要事务的业务方法）调用（需要事务的业务方法）。以下案例的业务方法在不同的类下: 注意事项 以下案例的业务方法在不同的类下: 在同一个类下面不同的方法就算都有事务，调用的方法事务都是不会生效的。 意思是在A类的a方法调用b方法，a，b方法均有事务，直接调用b方法，事务是不会生效的。 原因是spring事务处理实际是基于动态代理生成类进行事务管理的，而直接调用b方法，调用的实际是当前类的
【BUG】@Transactional注解在同类方法调用中不生效
会者定离，一期一祈
11-26 2160
后台代码 今天做系统开发的时候，遇到了一个BUG：@Transactional注解在同类方法调用中不生效 代码如下： /** * @description: 快递100接口服务类 * @date 2021/11/23 */ @Service public class SysExpressServiceImpl implements ISysExpressService { /** * 处理快递100推送请求并响应 * @param request 快递100的推送请求
Service层事务不能回滚的解决方式
pein_zero的专栏
06-25 5508
1、在service方法里面如果对异常进行了捕获的话，该事务是不会进行回滚的         默认spring事务只在发生未被捕获的 runtimeexcetpion时才回滚。           spring aop  异常捕获原理：被拦截的方法需显式抛出异常，并不能经任何处理，这样aop代理才能捕获到方法的异常，才能进行回滚，默认情况下aop只捕获runtimeexception的异常，但
【Spring事务失效的常见原因】同类内部调用导致 @Transactional 不生效
最新发布
qq_41725967的博客
10-11 191
摘要： Spring中@Transactional事务失效的常见原因是同类内部方法调用导致AOP代理失效。事务基于动态代理实现，若通过this.方法()直接调用，会绕过代理对象，使事务注解失效。解决方案是通过AopContext.currentProxy()获取代理实例调用方法，并配置@EnableAspectJAutoProxy(exposeProxy=true)启用代理暴露功能，确保事务拦截生效。
同一个类中一个方法（无事务）调用另一个方法（有事务）,事务不生效问题
yiyijianxian的博客
09-25 6461
今天同事遇到一事务的问题，pring中同一个service类中方法相互调用事务不生效问题如何解决： 此处的this指向目标对象，调用this.b()不会执行b事务的切面（不会执行事物增强aop），因此b方法的事物不会起作用。 在一个Service内部，事务方法之间的嵌套调用，普通方法和事务方法之间的嵌套调用，都不会开启新的事务。 是因为spring采用动态...
同一个类中，无事务的方法调用有事务的方法问题原因及其解决方法
山羊夫子的博客
05-17 6418
事务
Spring中同一个service中方法相互调用事务不生效问题解决方案
潘超博客
09-27 1万+
问题描述：我们在用Spring框架开发Web项目过程中，经常需要用同一个service中的一个方法调用另一个方法，如果此时调用方没有添加事务注解@Transactional，而在被调用方添加事务注解@Transactional，当被调用方法中出现异常，这时候会发现事务并没有回滚，事务注解@Transactional没有起作用。 分析原因： 我们知道Spring中事务管理是使用AOP代理技术实...
Spring事务处理时自我调用的解决方案及一些实现方式的风险
热门推荐
学习笔记
05-29 1万+
转：http://www.iteye.com/topic/1122740 前些日子一朋友在需要在目标对象中进行自我调用，且需要实施相应的事务定义，且网上的一种通过BeanPostProcessor的解决方案是存在问题的。因此专门写此篇帖子分析why。 1、预备知识 aop概念请参考【http://www.iteye.com/topic/1122401】和【http://jinniansh
SpringAOP同类调用失效（事务失效）
qq_38531706的博客
08-12 1429
项目场景： 同一个 ServiceA 中有B()方法、C()方法，在 ServiceA 中B()调用C()时，事务注解@Transactional不生效 @Service public class ServiceA { public void B(){ //... C(); } @Transactional(rollbackFor = Exception.class) public void C(){ //... } } 原因分析： S
同一个类中，对于@Transactional注解的方法调用，事务传播行为不会生效
pig_ning的博客
04-16 719
同一个类中，对于@Transactional注解的方法调用，事务传播行为不会生效
Spring 事务生效的八大原因
C1476029172的博客
11-28 1046
Spring事务生效的八大原因 这是之前面试被面试官问到的一个问题，没有回答得很好，所以在这里给大家总结一下（我的这次总结可能也会有些欠缺，但是面试够了） 1、数据库引擎不支持事务 我们将 MySQL 为例，其中 MyISAM 引擎是不支持事务操作的，InnoDB 才是支持事务的引擎，一般要支持事务都会使用 InnoDB。 2、没有被 Spring 管理 例如下面代码： // @Service public class OrderServiceImpl implements OrderService {
springboot同一个类里的方法之间调用事务不起作用
qq_37170583的博客
09-06 6126
今天在看项目代码的时候，发现在service层，有方法调用同类中的方法，SonarLint提示有bug。 下图是我自己做测试时写的demo代码： 经过测试发现，当A方法调用同类中带有@Transactional注解的B方法时，被@Transactional注解的B方法的事务是不起作用的。 原因： spring会扫描@Transactional的类和方法，并通过动态代理实现启动事务的代理方法。 这...
Spring项目中Service调用同类方法调用事务失效问题和处理方法
weixin_42202992的博客
12-06 2075
在日常开发中,有时候业务需求的原因,需要在Service层中本类的test()调用本类test2()方法,这时候test2()如果执行中发生异常,test()不会回滚,演示代码如下: 我们会发现上面代码执行完后代码并没有报错,数据库中数据也插入了,并且也执行了test2().分析问题原因:spring事务控制是通过AOP来控制的,AOP又是使用动态代理来实现的,在main()中获取到的userService对象是代理对象,在执行test()是会先进入代理类的test()方法,在代理类test
java类的方法调用service_service层调用同一个类内的方法报空指针
weixin_34539644的博客
02-25 1031
我在service层有做拦截器GlobalServiceInterceptor.java就在我调用内部方法的时候报了空指针报错信息如下java.lang.NullPointerExceptionat com.scbc.service.ActionPlanService.deleteUploadFile(ActionPlanService.java:207)at com.scbc.service....
调用本类方法,使事务生效的调用方式，修复@Transactional调用自身类方法失效问题
zhang19age_的博客
10-27 1148
【代码】调用本类方法,使事务生效的调用方式，修复@Transactional调用自身类方法失效问题。
Spring同一个Service类非事务方法调用事务方法事务失效解决方案
青鸟飞鱼
10-24 343
同一个Service类中非事务方法调用事务方法，事务会失效失效，这里简单解释一下原因：spring采用动态代理机制来实现事务控制，而动态代理最终都是要调用原始对象的，而原始对象在去调用方法时，是不会再触发代理了！可以理解为同一个类中非事务方法调用方法时用的是当前对象去调用，而不是spring生成的代理对象，所以会导致事务失效。原文链接：https://blog.csdn.net/shichen2010/article/details/121792816。
就同一个Service类中，一个方法调用另外一个有事务的方法的思考
qq_42307562的博客
02-24 3650
就同一个Service类中，一个方法调用另外一个有事务的方法的思考 写这篇博客的缘由： 我在link.评论过，有人说我杠，这里就写篇实际操作的博客证明下我的评论 现在库里的数据如下图所示： 现在我在同一个Service中一个事务的方法调用另外一个事务方法： 目的是 将id为1与2 的记录中的name属性值Jack与Rose 分别改为Tom与Jerry 如下图代码所示： package com.wqf.service.flowable.impl; import com.wqf.dao.flowable
Spring service中的方法互相调用,被调用的方法的注解为什么不生效?
rocklee的专栏
03-11 1254
如下代码, 看似没问题,但是却没能成功缓存,为什么呢? @Override public List<OfflineBaseInfo> getAllJobBaseInfo(String station,boolean skipInvalidJob) { List<String> jobs=getOfflineBaseJobs(); List<OfflineBaseInfo> ret=new ArrayList<>(); Arra
同service下调用其他方法，事务失效问题记录
m0_67679339的博客
04-29 263
1 都加事务注解 事务生效 2 被调用的加事务，事务失效 3 第一个方法加事务，第二个不加，事务生效 异常换位置 生效 4. 使用aop第一个加事务 生效 5. 使用aop两个都加事务 生效 6 使用aop调用 第二个加事务 Test2生效 Test不生效
如果事务方法调用事务方法，会生效吗
07-25
<think>我们讨论的是在同一个类中，一个事务方法调用另一个事务方法的情况。根据Spring的事务管理机制，这种内部调用会导致事务失效，原因与之前类似：Spring的事务管理是通过代理实现的，当在同一个类中直接调用时，会绕过代理，因此事务注解不会被代理处理。 但是，如果调用发生在不同类之间，那么事务是正常生效的。所以，问题中的“事务方法调用事务方法”需要区分两种情况： 1. 同一个类中，事务方法A调用事务方法B（内部调用） -> 事务B不会生效（因为绕过了代理） 2. 不同类中，事务方法A调用事务方法B -> 事务B会生效（通过代理调用） 另外，即使是在同一个类中，如果通过代理对象来调用内部的事务方法，那么事务也会生效（如之前提到的自注入或AopContext方式）。 下面我们通过代码示例来说明两种情况： 情况1：同一个类中内部调用事务方法（失效） ```java @Service public class OrderService { public void placeOrder(Order order) { // 直接内部调用，事务不会生效 processPayment(order); } @Transactional public void processPayment(Order order) { // 数据库操作 } } ``` 情况2：不同类中调用事务方法（生效） ```java @Service public class OrderService { @Autowired private PaymentService paymentService; public void placeOrder(Order order) { paymentService.processPayment(order); // 通过代理调用，事务生效 } } @Service public class PaymentService { @Transactional public void processPayment(Order order) { // 数据库操作 } } ``` 那么，如果我们在同一个类中希望内部事务方法调用生效，可以采用之前提到的解决方案，例如自注入： 解决方案：使用自注入（在同一个类中通过代理对象调用） ```java @Service public class OrderService { @Autowired private OrderService self; // 注入自身代理 public void placeOrder(Order order) { // 通过代理对象调用事务方法 self.processPayment(order); } @Transactional public void processPayment(Order order) { // 数据库操作 } } ``` 注意：使用自注入需要确保Spring的代理机制能够处理循环依赖（默认是允许的，但如果有构造器注入则可能失败）。 此外，我们还需要注意事务的传播行为。如果两个事务方法在同一个事务上下文中被调用，那么它们可能会在同一个事务中运行（取决于传播行为的设置）。例如，如果外部方法没有事务，内部方法使用`@Transactional(propagation = Propagation.REQUIRED)`，则内部方法会启动一个新的事务。但是，如果外部方法有事务，则内部方法会加入外部方法的事务（默认传播行为是REQUIRED）。 因此，在讨论事务方法调用事务方法是否生效时，我们不仅要考虑调用方式（是否通过代理），还要考虑传播行为的设置。 总结： 1. 同一个类中直接内部调用事务方法，事务不会生效。 2. 跨类调用事务方法，事务生效。 3. 同一个类中通过代理对象（自注入或AopContext）调用事务方法，事务生效。 下面我们通过一个例子展示传播行为的影响： 假设我们有一个服务类，其中有两个事务方法，并且通过代理对象调用： ```java @Service public class AccountService { @Autowired private AccountService self; // 自注入代理 @Transactional public void transfer(Account from, Account to, double amount) { // 先扣款 self.debit(from, amount); // 再存款 self.credit(to, amount); } @Transactional(propagation = Propagation.REQUIRED) public void debit(Account account, double amount) { // 扣款操作 } @Transactional(propagation = Propagation.REQUIRES_NEW) public void credit(Account account, double amount) { // 存款操作 } } ``` 在这个例子中： - `debit`方法使用默认的REQUIRED传播行为，因此它会加入到`transfer`方法的事务中。 - `credit`方法使用REQUIRES_NEW传播行为，因此无论`transfer`方法是否有事务，它都会启动一个新的事务，并且会挂起`transfer`方法的事务（如果存在）。 注意：由于我们通过`self`代理对象调用，所以`debit`和`credit`方法的事务都会生效。 但是，如果没有使用代理对象（直接内部调用），那么这两个方法的事务都不会生效（因为注解被绕过）。 因此，在编写事务方法时，务必注意调用方式。 最后，我们给出一个使用`TransactionTemplate`编程式事务管理的例子，这样可以在同一个类中灵活控制事务： ```java @Service public class AccountService { @Autowired private TransactionTemplate transactionTemplate; public void transfer(Account from, Account to, double amount) { // 外部事务 transactionTemplate.execute(status -> { debit(from, amount); // 内嵌事务（注意：这里不能直接使用this.credit，因为需要事务控制） transactionTemplate.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) { credit(to, amount); } }); return null; }); } // 注意：这些方法不需要@Transactional注解 private void debit(Account account, double amount) { // 扣款操作 } private void credit(Account account, double amount) { // 存款操作 } } ``` 在编程式事务中，我们可以嵌套多个事务，并且可以精确控制每个事务的边界。 但是，请注意，`TransactionTemplate`的嵌套使用需要理解事务传播机制（默认是PROPAGATION_REQUIRED，所以嵌套事务会加入到当前事务，除非设置传播行为为REQUIRES_NEW）。 所以，为了在同一个类中实现事务方法的嵌套调用，编程式事务是一种可行的方式。 综上所述，事务方法调用事务方法是否生效，取决于调用方式（是否通过代理）以及事务传播行为的设置。 §§相关问题§§: 1. Spring 事务的传播行为有哪些？请详细说明每种行为。 2. 在同一个事务方法中，如何捕获异常但不回滚事务？ 3. 如何配置 Spring 事务的超时时间？ 4. 在分布式事务场景下，Spring 事务管理有哪些局限性？</think>### Spring 事务方法调用事务方法的执行机制 在 Spring 中，当一个事务方法调用另一个事务方法时，事务行为是否生效取决于两个关键因素： 1. **调用方式**（是否通过代理对象） 2. **事务传播行为**（`@Transactional(propagation = ...)` 的设置） #### 核心规则分析 | 调用场景 | 传播行为 | 事务生效 | 说明 | |---------|---------|---------|------| | 同类的内部调用 | 任意 | ❌ 不生效 | 绕过代理机制 | | 跨类调用 | REQUIRED | ✅ 生效 | 加入现有事务 | | 跨类调用 | REQUIRES_NEW | ✅ 生效 | 创建新事务 | | 通过代理调用 | 任意 | ✅ 生效 | 正确经过代理 | --- ### 解决方案及代码示例 #### 方案 1：跨类调用（默认传播行为 - REQUIRED） ```java @Service public class OrderService { @Autowired private PaymentService paymentService; // 注入另一个服务 @Transactional public void placeOrder(Order order) { // 跨类调用事务方法 - 加入当前事务 paymentService.processPayment(order); inventoryService.updateStock(order); } } @Service public class PaymentService { @Transactional // 默认传播行为 REQUIRED public void processPayment(Order order) { // 此方法将加入 placeOrder 的事务 accountService.deduct(order.getAmount()); transactionLogService.log(order); } } ``` **执行流程**： 1. `placeOrder` 启动事务 2. `processPayment` 加入同一事务 3. 所有操作在同一个事务中提交或回滚 --- #### 方案 2：使用 REQUIRES_NEW 传播行为 ```java @Service public class AuditService { @Transactional(propagation = Propagation.REQUIRES_NEW) public void logOperation(String action) { // 此方法总是创建新事务 auditRepository.save(new AuditLog(action)); } } @Service public class UserService { @Autowired private AuditService auditService; @Transactional public void updateUser(User user) { userRepository.save(user); try { // 跨类调用 - 创建独立事务 auditService.logOperation("USER_UPDATE"); } catch (Exception e) { // 审计日志失败不影响主事务 logger.error("Audit failed", e); } } } ``` **关键特性**： - 独立事务提交/回滚 - 外层事务异常不影响内层 - 内层事务异常可选择是否影响外层 --- #### 方案 3：同类方法通过代理调用 ```java @Service public class InventoryService { @Autowired private InventoryService selfProxy; // 自注入代理 public void batchUpdate(List<Item> items) { items.forEach(item -> { // 通过代理调用事务方法 selfProxy.updateSingleItem(item); }); } @Transactional(propagation = Propagation.REQUIRES_NEW) public void updateSingleItem(Item item) { // 每个更新在独立事务中 inventoryRepo.update(item); historyRepo.logUpdate(item); } } ``` **配置要求**： ```java @SpringBootApplication @EnableAspectJAutoProxy(exposeProxy = true) // 关键配置 public class App {} ``` --- ### 事务传播行为详解 Spring 提供 7 种传播行为，最常用的有： 1. **REQUIRED**（默认）： - 存在事务则加入，不存在则新建 ```java @Transactional(propagation = Propagation.REQUIRED) ``` 2. **REQUIRES_NEW**： - 总是创建新事务，挂起当前事务（如果存在） ```java @Transactional(propagation = Propagation.REQUIRES_NEW) ``` 3. **NESTED**： - 在现有事务中创建嵌套事务（保存点） ```java @Transactional(propagation = Propagation.NESTED) ``` 4. **SUPPORTS**： - 存在事务则加入，不存在则以非事务方式运行 ```java @Transactional(propagation = Propagation.SUPPORTS) ``` --- ### 事务嵌套执行示例 ```java @Service public class FinancialService { @Transactional public void transfer(Account from, Account to, double amount) { // 操作1：扣款（主事务） accountService.debit(from, amount); // 操作2：存款（独立事务） try { accountService.credit(to, amount); } catch (Exception e) { // 存款失败不影响扣款 refundService.scheduleRefund(from, amount); } } } @Service public class AccountService { @Transactional(propagation = Propagation.REQUIRED) public void debit(Account account, double amount) { // 加入主事务 } @Transactional(propagation = Propagation.REQUIRES_NEW) public void credit(Account account, double amount) { // 独立事务执行 } } ``` **执行结果**： - 扣款操作回滚 ⇒ 整个事务回滚 - 存款操作失败 ⇒ 仅存款操作回滚，扣款仍有效 - 扣款成功 + 存款成功 ⇒ 全部提交 --- ### 最佳实践建议 1. **事务粒度控制**： - 保持事务方法精简 - 避免超过 3 层嵌套调用 2. **异常处理原则**： ```java @Transactional public void criticalOperation() { try { // 不会导致回滚的异常 nonCriticalService.process(); } catch (NonCriticalException e) { // 标记为不回滚 TransactionAspectSupport.currentTransactionStatus() .setRollbackOnly(false); } } ``` 3. **性能优化**： - 对只读操作使用 `@Transactional(readOnly = true)` - 避免在循环中调用 REQUIRES_NEW 方法
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值