作为Java开发者，Spring事务管理是我们日常开发中不可或缺的一部分。然而，事务失效问题却像幽灵一样困扰着无数开发者。本文将揭示12种最常见的事务失效场景，并给出经过实战验证的解决方案，这些都是我15年开发经验中踩过的坑，现在一次性打包送给你！

1. 方法用final修饰

场景：当你的事务方法被final修饰时，Spring无法通过CGLIB生成代理类，导致事务失效。

解决方案：

• 移除final修饰符
• 改用接口+JDK动态代理方式（需确保所有事务方法都在接口中声明）

// 错误示例
public final void transferMoney() {...}

// 正确示例
public void transferMoney() {...}

2. 方法内部调用

场景：在同一个类中，一个非事务方法调用另一个事务方法，事务不会生效。

解决方案：

• 将事务方法拆分到另一个类中
• 通过ApplicationContext获取代理对象调用
• 使用AopContext.currentProxy()获取当前代理对象

// 错误示例
public void outerMethod() {
    innerMethod(); // 事务失效
}

@Transactional
public void innerMethod() {...}

// 正确示例
@Service
public class ServiceA {
    @Autowired
    private ServiceB serviceB;
    
    public void outerMethod() {
        serviceB.innerMethod(); // 事务生效
    }
}

@Service
public class ServiceB {
    @Transactional
    public void innerMethod() {...}
}

3. 未被Spring管理

场景：使用new关键字创建的对象，没有被Spring容器管理，导致事务注解无效。

解决方案：

• 确保类被@Component、@Service等注解标记
• 通过@Autowired注入使用，而不是new创建

// 错误示例
public void process() {
    UserService service = new UserService(); // 事务失效
    service.saveUser();
}

// 正确示例
@Autowired
private UserService userService;

public void process() {
    userService.saveUser(); // 事务生效
}

4. 多线程调用

场景：在方法内开启新线程执行数据库操作，事务不会跨线程传播。

解决方案：

• 避免在多线程中执行事务操作
• 如果必须使用，在主线程中完成所有事务操作
• 考虑使用异步事务（需要特殊处理）

// 错误示例
@Transactional
public void multiThreadProcess() {
    new Thread(() -> {
        // 这里的事务不会生效
        userDao.update();
    }).start();
}

// 正确示例
@Transactional
public void singleThreadProcess() {
    userDao.update(); // 在主线程中执行
}

5. 表不支持事务

场景：使用MyISAM等不支持事务的存储引擎。

解决方案：

• 将表引擎改为InnoDB
• 检查数据库是否支持事务

-- 修改表引擎
ALTER TABLE your_table ENGINE=InnoDB;

6. 错误的传播特性

场景：使用了不恰当的事务传播属性，如REQUIRES_NEW、NESTED等导致意外行为。

解决方案：

• 理解每种传播特性的含义
• 默认使用PROPAGATION_REQUIRED
• 在明确需要时才使用其他传播特性

// 通常情况下使用默认即可
@Transactional(propagation = Propagation.REQUIRED)
public void defaultPropagation() {...}

7. 自己吞了异常

场景：在方法内捕获了异常但没有重新抛出，Spring无法感知异常导致不会回滚。

解决方案：

• 让异常抛出到事务切面
• 如需捕获处理，手动设置回滚

// 错误示例
@Transactional
public void process() {
    try {
        // 业务代码
    } catch (Exception e) {
        // 吞掉异常，事务不会回滚
        log.error("error", e);
    }
}

// 正确示例
@Transactional
public void process() {
    try {
        // 业务代码
    } catch (Exception e) {
        log.error("error", e);
        throw e; // 重新抛出
    }
}

// 或者手动回滚
@Transactional
public void process() {
    try {
        // 业务代码
    } catch (Exception e) {
        log.error("error", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
}

8. 手动抛了别的异常

场景：抛出的异常不是RuntimeException或Error，且未在@Transactional中配置rollbackFor。

解决方案：

• 抛出RuntimeException
• 或在@Transactional中指定rollbackFor

// 错误示例
@Transactional
public void process() throws IOException {
    // 业务代码
    throw new IOException(); // 不会触发回滚
}

// 正确示例
@Transactional(rollbackFor = Exception.class)
public void process() throws IOException {
    // 业务代码
    throw new IOException(); // 会触发回滚
}

9. 自定义了回滚异常

场景：@Transactional中noRollbackFor配置错误，导致应该回滚的异常被排除。

解决方案：

• 仔细检查noRollbackFor配置
• 只在明确知道不需要回滚的异常时才配置

// 谨慎使用noRollbackFor
@Transactional(noRollbackFor = {NullPointerException.class})
public void process() {
    // 只有NullPointerException不会触发回滚
    // 其他RuntimeException仍会触发回滚
}

10. 嵌套事务回滚多了

场景：嵌套事务中内层事务回滚过多，导致外层事务也被回滚。

解决方案：

• 理解嵌套事务行为
• 使用PROPAGATION_NESTED时注意保存点机制
• 必要时拆分事务

@Transactional
public void outer() {
    try {
        innerService.inner();
    } catch (Exception e) {
        // 处理异常但不抛出
    }
    // 其他操作
}

@Service
public class InnerService {
    @Transactional(propagation = Propagation.NESTED)
    public void inner() {
        // 操作数据库
    }
}

11. 事务方法不是public

场景：Spring要求事务方法必须是public的，否则事务不会生效。

解决方案：

• 将事务方法改为public
• 避免在private/protected方法上使用@Transactional

// 错误示例
@Transactional
private void process() {...} // 事务失效

// 正确示例
@Transactional
public void process() {...} // 事务生效

12. 异常被自定义切面捕获

场景：自定义的AOP切面捕获了异常，导致事务切面无法感知异常。

解决方案：

• 在自定义切面中重新抛出异常
• 调整切面执行顺序，确保事务切面在内层

@Aspect
@Component
public class CustomAspect {
    @Around("execution(* com.example..*.*(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        try {
            return joinPoint.proceed();
        } catch (Exception e) {
            // 记录日志
            log.error("error", e);
            throw e; // 关键：重新抛出异常
        }
    }
}

总结

Spring事务失效问题看似复杂，实则有其规律可循。本文总结的12种场景涵盖了90%以上的事务失效情况。记住这些陷阱和解决方案，你将能快速定位和解决大部分事务问题。

最后分享一个排查事务失效的快速检查清单：

1. 方法是否为public
2. 异常是否被正确处理
3. 是否使用了正确的传播特性
4. 方法是否被正确代理
5. 数据库表是否支持事务

掌握这些知识，你就能在Spring事务管理中游刃有余，避免踩坑！如果觉得有用，欢迎分享给更多开发者。