@Transactional 事务注解坑之为什么自调用（同一个类中方法互相调用）事务不生效？

原创已于 2025-10-29 15:36:48 修改 · 451 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#java #spring boot

于 2025-10-29 15:35:43 首次发布

为什么自调用（同一个类中方法互相调用）事务不生效？

一、前言

这个问题是Spring AOP的一个经典陷阱！这里我用一个具体的例子来彻底解释清楚。

二、解释

核心原理：Spring AOP是通过"代理对象"工作的

正常情况（事务生效）：

@Service
public class UserService {
    
    @Transactional
    public void createUser(User user) {
        // 数据库操作
        userMapper.insert(user);
    }
}

@Controller
public class UserController {
    @Autowired
    private UserService userService; // 这里注入的是Spring的代理对象！
    
    public void someMethod() {
        userService.createUser(new User()); // ✅ 事务生效
    }
}

实际发生的过程：

Spring创建了一个UserService的代理对象（比如叫UserServiceProxy）
UserController中注入的是UserServiceProxy，不是原始的UserService
当你调用userService.createUser()时，实际上调用的是：

// 伪代码：代理对象的工作流程
class UserServiceProxy extends UserService {
    public void createUser(User user) {
        // 1. 开启事务
        startTransaction();
        
        // 2. 调用原始对象的真实方法
        super.createUser(user);
        
        // 3. 提交事务
        commitTransaction();
    }
}

问题场景：自调用（同一个类内部方法调用）

@Service
public class UserService {
    
    public void processUser(User user) {
        // 一些业务逻辑...
        this.createUser(user); // ❌ 问题在这里！
    }
    
    @Transactional
    public void createUser(User user) {
        userMapper.insert(user);
        logMapper.insertLog(user); // 希望这两个操作在同一个事务中
    }
}

为什么事务不生效？

实际的对象关系：

UserServiceProxy (代理对象，有事务能力)
↓ 继承/实现
UserService (原始对象，没有事务能力)

调用流程分析：

// 1. 外部调用代理对象的方法（事务正常）
userServiceProxy.processUser(user);

// 2. 在processUser方法内部，this指向的是原始对象！
public void processUser(User user) {
    // 这里的this是UserService（原始对象），不是UserServiceProxy！
    this.createUser(user); // 直接调用，绕过了代理
}

// 3. 相当于直接调用原始方法，没有事务包装
public void createUser(User user) {
    userMapper.insert(user); // 没有事务保护！
    logMapper.insertLog(user);
}

三、解决方案

方案1：注入自身代理（推荐）

@Service
public class UserService {
    
    @Autowired
    private UserService self; // 注入Spring代理后的自己
    
    public void processUser(User user) {
        // 通过代理对象调用，事务生效 ✅
        self.createUser(user);
    }
    
    @Transactional
    public void createUser(User user) {
        userMapper.insert(user);
        logMapper.insertLog(user);
    }
}

方案2：将事务方法拆分到另一个Service

@Service
public class UserService {
    @Autowired
    private TransactionalService transactionalService;
    
    public void processUser(User user) {
        transactionalService.createUser(user); // ✅ 事务生效
    }
}

@Service
public class TransactionalService {
    @Transactional
    public void createUser(User user) {
        userMapper.insert(user);
        logMapper.insertLog(user);
    }
}

方案3：使用AspectJ代替Spring AOP

// 在配置中启用AspectJ
@EnableAspectJAutoProxy(proxyTargetClass = true)
// 或者使用编译时/加载时织入

四、总结

核心原因：自调用时，this指向的是原始对象而不是Spring的代理对象，因此绕过了AOP的拦截机制。

记住这个黄金法则：在Spring管理的Bean中，如果要让AOP特性（事务、缓存、日志等）生效，必须通过Spring容器获取的代理对象来调用方法，而不是直接通过this调用。