Spring事务失效场景-CSDN博客

本文链接：https://blog.csdn.net/2301_76740633/article/details/148099086

在 Spring 应用中，事务失效是一个常见但容易被忽视的问题。以下是10 种典型的事务失效场景及其原因分析，并提供解决方案：

一、代理机制导致的失效

1. 同类方法内部调用

@Service
public class UserService {
    
    public void updateUser(User user) {
        // 内部调用带事务的方法
        this.createUser(user); // 事务失效！
    }

    @Transactional
    public void createUser(User user) {
        // 数据库操作
    }
}

原因：
Spring 事务基于 AOP 代理实现，this.createUser()调用的是目标对象方法，而非代理对象方法，导致事务拦截器未生效。

解决方案：

通过ApplicationContext获取代理对象：

@Autowired
private ApplicationContext context;

public void updateUser(User user) {
    UserService proxy = context.getBean(UserService.class);
    proxy.createUser(user); // 事务生效
}

使用@Autowired注入自身：

@Autowired
private UserService self;

public void updateUser(User user) {
    self.createUser(user); // 事务生效
}

二、异常处理不当

2. 捕获异常但未抛出

@Transactional
public void transferMoney() {
    try {
        // 业务逻辑
        int result = 1 / 0; // 抛出 ArithmeticException
    } catch (Exception e) {
        // 未手动抛出异常或标记回滚
        log.error("转账失败", e);
    }
}

原因：
@Transactional默认只对RuntimeException 和 Error回滚，捕获异常后未重新抛出或标记TransactionStatus.setRollbackOnly()，事务会正常提交。

解决方案：

手动抛出异常：throw new RuntimeException("转账失败", e)

或设置回滚标记：

@Autowired
private TransactionStatus transactionStatus;

public void transferMoney() {
    try {
        // ...
    } catch (Exception e) {
        transactionStatus.setRollbackOnly(); // 标记回滚
    }
}

3. 自定义检查异常未配置回滚

@Transactional
public void createOrder() throws BusinessException {
    // 业务逻辑
    if (库存不足) {
        throw new BusinessException("库存不足"); // 自定义检查异常
    }
}

原因：
自定义检查异常（Checked Exception）若未通过@Transactional(rollbackFor = Exception.class)指定，事务不会回滚。

解决方案：
显式指定回滚异常类型：

@Transactional(rollbackFor = Exception.class)
public void createOrder() throws BusinessException {
    // ...
}

三、传播行为配置错误

4. REQUIRES_NEW 导致外层事务失效

@Service
public class OrderService {
    
    @Autowired
    private PaymentService paymentService;

    @Transactional
    public void createOrder() {
        // 创建订单
        paymentService.processPayment(); // 内层事务为REQUIRES_NEW
        int result = 1 / 0; // 外层事务回滚，但内层已提交
    }
}

@Service
public class PaymentService {
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void processPayment() {
        // 支付处理（独立事务）
    }
}

原因：
REQUIRES_NEW会创建新事务，挂起外层事务。若内层事务成功提交，即使外层事务回滚，内层操作也不会回滚。

解决方案：
根据业务需求选择传播行为，如改为REQUIRED使内外层事务为同一事务。

5. NOT_SUPPORTED 导致事务丢失

@Service
public class UserService {
    
    @Transactional
    public void updateUser() {
        // 外层有事务
        this.queryUser(); // 内层以非事务方式执行
    }

    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public void queryUser() {
        // 查询操作（无事务）
    }
}

原因：
NOT_SUPPORTED强制方法在非事务环境执行，若外层存在事务，会被挂起。

四、事务配置问题

6. 未启用事务管理

@Configuration
public class AppConfig {
    // 缺少 @EnableTransactionManagement 注解
}

原因：
未在配置类上添加@EnableTransactionManagement，Spring 不会创建事务代理。

解决方案：
添加注解：

@Configuration
@EnableTransactionManagement
public class AppConfig {
    // ...
}

7. 错误的事务管理器配置

@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource) {
    return new DataSourceTransactionManager(dataSource); // 仅支持JDBC
}

// 实际使用JPA操作数据库
@PersistenceContext
private EntityManager entityManager;

原因：
使用DataSourceTransactionManager管理 JPA 事务，导致事务不生效。

解决方案：
使用正确的事务管理器：

@Bean
public PlatformTransactionManager transactionManager(EntityManagerFactory emf) {
    return new JpaTransactionManager(emf); // JPA专用事务管理器
}

五、访问权限问题

8. 非 public 方法上的事务注解

@Service
public class UserService {
    
    @Transactional
    private void saveUser(User user) { // private方法
        // 数据库操作
    }
}

原因：
Spring AOP 代理默认只对public方法生效，非public方法的事务注解会被忽略。

解决方案：
将方法改为public访问权限。

六、数据源与连接问题

9. 多数据源未配置正确的事务管理器

@Service
public class MultiDataSourceService {
    
    @Autowired
    private JdbcTemplate primaryJdbcTemplate;
    
    @Autowired
    private JdbcTemplate secondaryJdbcTemplate;

    @Transactional
    public void transferData() {
        // 操作主数据源
        primaryJdbcTemplate.update("INSERT INTO ...");
        
        // 操作从数据源
        secondaryJdbcTemplate.update("INSERT INTO ..."); // 可能使用不同事务管理器
    }
}

原因：
多数据源场景下，未显式指定事务管理器，导致部分操作不在事务内。

解决方案：
使用@Transactional(value = "secondaryTransactionManager")指定具体事务管理器。

10. 手动管理连接导致事务失效

@Transactional
public void manualConnection() {
    Connection conn = dataSource.getConnection();
    try {
        // 手动执行SQL，未使用Spring管理的连接
        Statement stmt = conn.createStatement();
        stmt.executeUpdate("INSERT INTO ...");
    } finally {
        conn.close();
    }
}

原因：
手动获取的数据库连接未参与 Spring 事务管理，操作独立于事务之外。

解决方案：
通过 Spring 提供的模板类（如JdbcTemplate）或 ORM 框架（如 JPA）操作数据库。

七、总结与预防措施

理解代理机制：避免同类方法内部调用，通过代理对象调用事务方法。
明确异常处理策略：
- 使用rollbackFor指定需回滚的异常类型。
- 避免在事务方法中捕获异常不处理。
谨慎选择传播行为：根据业务逻辑选择合适的传播行为（如REQUIRED、REQUIRES_NEW）。
检查事务配置：
- 确保启用@EnableTransactionManagement。
- 使用匹配的事务管理器（如 JPA 对应JpaTransactionManager）。
遵循规范：
- 事务方法必须是public。
- 避免手动管理数据库连接。