Spring同服务内事务隔离：如何让只读方法不继承父事务上下文

云原生阿岚

2026-6-29

Spring事务上下文传播问题

问题场景代码

@Transactional(readOnly = true)
public Optional<SomeEntity> readSomeEntity(String idEntity) {
   return this.someEntityRepository.findById(idEntity);
}

@Transactional
public Optional<SomeEntity> readOrCreateSomeEntity(SomeEntity entity) {
  if (this.someEntityRepository.existsById(entity.getId())) {
    // 如何让此调用通过Spring代理并实际应用@Transactional(readOnly = true)？
    return this.readSomeEntity(entity.getId());
  }
  else {
    return Optional.of(this.someEntityRepository.save(entity));
  }
}

核心疑问

如何确保readOrCreateSomeEntity的非只读事务上下文里，调用readSomeEntity时使用独立的只读事务，不继承前者的上下文？
试过两种方案但有问题：
- 自引用@Autowired MyService self导致循环依赖和实例化错误
- 给readSomeEntity加@Transactional(readOnly = true, propagation = Propagation.REQUIRES_NEW)，但内部调用不经过Spring代理，配置无效
是否只能通过自引用实现需求？我的技术思路有没有问题？
强制该读取方法用独立只读事务是否有必要，是不是过度设计？

解决方案与分析

1. 实现独立只读事务的可行方式

内部调用不触发Spring代理是Spring AOP的机制特性——只有代理对象的外部调用才会触发事务切面逻辑。要绕开这个限制，有两种更稳妥的方式：

方案一：拆分服务类
把只读查询方法单独拆到一个新的服务类（比如SomeEntityQueryService），在原服务类中注入这个新类。跨类调用属于外部调用，会触发Spring代理，此时@Transactional(readOnly = true, propagation = Propagation.REQUIRES_NEW)的配置会生效，完全隔离事务上下文。
示例代码：

// 独立的查询服务类
@Service
public class SomeEntityQueryService {
    @Autowired
    private SomeEntityRepository someEntityRepository;

    @Transactional(readOnly = true, propagation = Propagation.REQUIRES_NEW)
    public Optional<SomeEntity> readSomeEntity(String idEntity) {
        return someEntityRepository.findById(idEntity);
    }
}

// 原业务服务类
@Service
public class SomeEntityService {
    @Autowired
    private SomeEntityRepository someEntityRepository;
    @Autowired
    private SomeEntityQueryService queryService;

    @Transactional
    public Optional<SomeEntity> readOrCreateSomeEntity(SomeEntity entity) {
        if (someEntityRepository.existsById(entity.getId())) {
            return queryService.readSomeEntity(entity.getId());
        } else {
            return Optional.of(someEntityRepository.save(entity));
        }
    }
}

方案二：使用AopContext获取代理对象
开启Spring的暴露代理配置（@EnableAspectJAutoProxy(exposeProxy = true)），内部调用时通过AopContext.currentProxy()获取当前服务的代理对象，再调用目标方法。这种方式不会产生循环依赖，是官方推荐的内部调用触发代理的方案。
示例代码：

@Service
@EnableAspectJAutoProxy(exposeProxy = true) // 开启代理暴露
public class SomeEntityService {
    @Autowired
    private SomeEntityRepository someEntityRepository;

    @Transactional(readOnly = true, propagation = Propagation.REQUIRES_NEW)
    public Optional<SomeEntity> readSomeEntity(String idEntity) {
        return someEntityRepository.findById(idEntity);
    }

    @Transactional
    public Optional<SomeEntity> readOrCreateSomeEntity(SomeEntity entity) {
        if (someEntityRepository.existsById(entity.getId())) {
            // 通过代理对象调用，触发事务切面逻辑
            return ((SomeEntityService) AopContext.currentProxy()).readSomeEntity(entity.getId());
        } else {
            return Optional.of(someEntityRepository.save(entity));
        }
    }
}

2. 关于Spring事务传播的理解

你的思路没有问题：readSomeEntity本身是只读操作，理应使用只读事务。Spring默认的事务传播行为是Propagation.REQUIRED——如果当前存在事务，就加入该事务，所以内部调用时会继承外层的非只读事务上下文，这是设计逻辑，并非Bug。

3. 是否需要强制独立只读事务？

要不要纠结这点，取决于具体业务场景：

如果你的数据库对只读事务有明确优化（比如MySQL的只读事务可以避免加写锁、提升查询性能，或者部分数据库的只读事务有隔离级别优化），且该查询操作调用频繁，那么独立的只读事务能带来实际收益，值得实现。
如果只是普通查询，外层非只读事务不会带来额外开销（比如不会导致不必要的锁竞争），那么强制独立只读事务确实属于过度设计，保持现状即可。

内容的提问来源于stack exchange，提问作者dorian.naa