Spring事务失效：原因分析与最佳实践

在使用Spring事务时，你是否曾遇到明明添加了@Transactional注解，事务却不生效的情况？本文将深入分析Spring事务失效的常见原因，并提供相应的解决方案，帮助你正确使用Spring事务。

Spring事务基础回顾

在深入分析事务失效原因前，我们先简要回顾Spring事务的基本概念和使用方式，这有助于更好地理解后续内容。Spring事务管理主要有两种方式：编程式事务和声明式事务。其中，声明式事务通过@Transactional注解实现，是我们最常用的方式。

1
2
3
4
5
6
7
8
9
10
11
@Service  
public class UserService {  
	@Autowired  
	private UserMapper userMapper;  

	@Transactional  
	publicvoidcreateUser(User user) {  
      	userMapper.insert(user);  
		// 其他操作...  
	}  
}

Spring事务的核心原理是AOP（面向切面编程），它通过动态代理在目标方法执行前后进行拦截，实现事务的开启、提交或回滚。

Spring事务失效的常见原因

方法访问权限问题

@Transactional注解只能应用于public方法上。如果将其应用于protected、private或package-visible方法，事务将不会生效。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 错误示例
@Service
public class UserService {
    @Transactional
    private void createUser(User user) { // 私有方法，事务不生效
        userMapper.insert(user);
    }
}

// 正确示例
@Service
public class UserService {
    @Transactional
    public void createUser(User user) { // 公共方法，事务生效
        userMapper.insert(user);
    }
}

方法内部调用

当一个类的非事务方法内部调用同类的事务方法时，事务会失效。这是因为Spring事务基于代理实现，而内部方法调用不经过代理。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// 错误示例
@Service
public class UserService {
    public void createUserAndLog(User user) {
        createUser(user); // 内部调用，事务不生效
        logOperation("创建用户");
    }
  
    @Transactional
    public void createUser(User user) {
        userMapper.insert(user);
    }
}

// 正确示例
@Service
public class UserService {
    @Autowired
    private UserService self; // 注入自身代理对象
  
    public void createUserAndLog(User user) {
        self.createUser(user); // 通过代理调用，事务生效
        logOperation("创建用户");
    }
  
    @Transactional
    public void createUser(User user) {
        userMapper.insert(user);
    }
}

异常被捕获但未重新抛出

Spring事务只有在检测到未捕获的异常时才会回滚。如果在事务方法中捕获了异常但未重新抛出，事务不会回滚。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// 错误示例
@Service
public class UserService {
    @Transactional
    public void createUser(User user) {
        try {
            userMapper.insert(user);
            int a = 1 / 0; // 抛出异常
        } catch (Exception e) {
            log.error("创建用户失败", e); // 异常被捕获但未重新抛出，事务不回滚
        }
    }
}

// 正确示例
@Service
public class UserService {
    @Transactional
    public void createUser(User user) {
        try {
            userMapper.insert(user);
            int a = 1 / 0; // 抛出异常
        } catch (Exception e) {
            log.error("创建用户失败", e);
            throw e; // 重新抛出异常，事务回滚
        }
    }
}

异常类型不匹配

默认情况下，Spring事务只在遇到运行时异常(RuntimeException)或Error时才会回滚。对于受检异常(Checked Exception)，事务不会回滚。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 错误示例
@Service
public class UserService {
    @Transactional
    public void createUser(User user) throws IOException {
        userMapper.insert(user);
        throw new IOException("IO异常"); // 受检异常，事务不回滚
    }
}

// 正确示例
@Service
public class UserService {
    @Transactional(rollbackFor = Exception.class) // 指定回滚的异常类型
    public void createUser(User user) throws IOException {
        userMapper.insert(user);
        throw new IOException("IO异常"); // 现在事务会回滚
    }
}

事务传播行为设置不当

不正确的事务传播行为设置可能导致事务失效。例如，使用PROPAGATION_NEVER或PROPAGATION_NOT_SUPPORTED时，会阻止事务的创建或挂起已有事务。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 示例
@Service
public class UserService {
    @Transactional(propagation = Propagation.REQUIRED)
    public void createUser(User user) {
        userMapper.insert(user);
        logService.log("创建用户");
    }
}

@Service
public class LogService {
    @Transactional(propagation = Propagation.NOT_SUPPORTED) // 挂起当前事务
    public void log(String message) {
        logMapper.insert(new Log(message));
    }
}

数据库引擎不支持事务

如果使用的数据库引擎不支持事务（如MySQL的MyISAM引擎），即使配置了Spring事务，也不会生效。

1
2
3
// 解决方案：修改为支持事务的引擎，如InnoDB
// 在MySQL中执行：
// ALTER TABLE user ENGINE=InnoDB;

未被Spring管理

如果类没有被Spring容器管理（即没有使用@Component、@Service等注解或XML配置），@Transactional注解不会生效。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 错误示例
public class UserService { // 未被Spring管理
    @Transactional
    public void createUser(User user) {
        userMapper.insert(user);
    }
}

// 正确示例
@Service // 被Spring管理
public class UserService {
    @Transactional
    public void createUser(User user) {
        userMapper.insert(user);
    }
}

事务管理器配置错误

如果没有正确配置事务管理器或配置了多个事务管理器但未指定使用哪一个，事务可能不会生效。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 正确配置示例
@Configuration
@EnableTransactionManagement
public class TransactionConfig {
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}

// 多事务管理器时指定使用哪一个
@Service
public class UserService {
    @Transactional(transactionManager = "primaryTransactionManager")
    public void createUser(User user) {
        userMapper.insert(user);
    }
}

使用final修饰的类或方法

Spring事务基于动态代理实现，而final修饰的类无法被继承，final修饰的方法无法被重写，因此无法生成代理对象，导致事务失效。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// 错误示例
@Service
public final class UserService { // final类无法被代理
    @Transactional
    public void createUser(User user) {
        userMapper.insert(user);
    }
}

// 或者
@Service
public class UserService {
    @Transactional
    public final void createUser(User user) { // final方法无法被代理
        userMapper.insert(user);
    }
}

// 正确示例
@Service
public class UserService { // 非final类
    @Transactional
    public void createUser(User user) { // 非final方法
        userMapper.insert(user);
    }
}

使用错误的事务注解

使用了错误的事务注解，例如使用了Jakarta EE的javax.transaction.Transactional而非Spring的org.springframework.transaction.annotation.Transactional。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 错误示例
@Service
public class UserService {
    @javax.transaction.Transactional // 错误的注解
    public void createUser(User user) {
        userMapper.insert(user);
    }
}

// 正确示例
@Service
public class UserService {
    @org.springframework.transaction.annotation.Transactional // 正确的注解
    public void createUser(User user) {
        userMapper.insert(user);
    }
}

事务超时

如果事务执行时间超过了设定的超时时间，事务会被自动回滚。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 示例
@Service
public class UserService {
    @Transactional(timeout = 5) // 设置超时时间为5秒
    public void longRunningOperation() {
        // 执行耗时操作，如果超过5秒，事务会被回滚
        try {
            Thread.sleep(6000); // 休眠6秒，超过超时时间
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        userMapper.insert(new User());
    }
}

嵌套事务配置错误

在嵌套事务场景下，如果内部事务和外部事务的传播行为配置不当，可能导致内部事务失效或外部事务被挂起。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 示例
@Service
public class OrderService {
    @Autowired
    private PaymentService paymentService;
  
    @Transactional
    public void createOrder(Order order) {
        orderMapper.insert(order);
        // 如果paymentService的方法使用了PROPAGATION_REQUIRES_NEW
        // 则会挂起当前事务，创建新的事务
        paymentService.processPayment(order.getPayment());
    }
}

@Service
public class PaymentService {
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void processPayment(Payment payment) {
        paymentMapper.insert(payment);
        // 如果这里抛出异常，只会回滚支付事务，不会回滚订单事务
    }
}

使用了不同的数据源

如果在同一个事务中使用了不同的数据源，而没有配置分布式事务管理器，会导致事务在某些数据源上失效。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 示例
@Service
public class UserService {
    @Autowired
    private JdbcTemplate primaryJdbcTemplate; // 使用主数据源
  
    @Autowired
    private JdbcTemplate secondaryJdbcTemplate; // 使用从数据源
  
    @Transactional // 默认只对主数据源生效
    public void createUserWithLog(User user) {
        // 主数据源操作
        primaryJdbcTemplate.update("INSERT INTO users VALUES (?, ?)", 
                                  user.getId(), user.getName());
      
        // 从数据源操作，不在同一事务中
        secondaryJdbcTemplate.update("INSERT INTO logs VALUES (?, ?)", 
                                    UUID.randomUUID().toString(), "Created user: " + user.getId());
    }
}

事务管理器类型不匹配

使用了与实际数据访问技术不匹配的事务管理器，例如在使用JPA的项目中配置了JDBC的事务管理器。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 错误示例 - 使用JPA但配置了JDBC事务管理器
@Configuration
@EnableTransactionManagement
public class TransactionConfig {
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource); // JDBC事务管理器
    }
}

// 正确示例 - 使用JPA并配置JPA事务管理器
@Configuration
@EnableTransactionManagement
public class TransactionConfig {
    @Bean
    public PlatformTransactionManager transactionManager(EntityManagerFactory emf) {
        return new JpaTransactionManager(emf); // JPA事务管理器
    }
}

使用了编程式事务但未提交

在使用编程式事务时，忘记调用commit()方法提交事务。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
// 错误示例
@Service
public class UserService {
    @Autowired
    private PlatformTransactionManager transactionManager;
  
    public void createUser(User user) {
        TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());
        try {
            userMapper.insert(user);
            // 忘记提交事务
            // transactionManager.commit(status);
        } catch (Exception e) {
            transactionManager.rollback(status);
            throw e;
        }
    }
}

// 正确示例
@Service
public class UserService {
    @Autowired
    private PlatformTransactionManager transactionManager;
  
    public void createUser(User user) {
        TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());
        try {
            userMapper.insert(user);
            transactionManager.commit(status); // 记得提交事务
        } catch (Exception e) {
            transactionManager.rollback(status);
            throw e;
        }
    }
}

Spring事务失效的检测方法

如何判断Spring事务是否生效？以下是几种常用的检测方法：

查看事务日志

通过配置日志级别，查看Spring事务相关的日志信息。

1
2
3
4
# 在application.properties中配置
logging.level.org.springframework.transaction=DEBUG
logging.level.org.springframework.orm.jpa=DEBUG
logging.level.org.springframework.jdbc.core=TRACE

使用断点调试

在事务方法的关键位置设置断点，查看事务是否正常开启和提交。

数据库监控

通过数据库监控工具查看事务的执行情况，如MySQL的information_schema.innodb_trx表。

1
SELECT * FROM information_schema.innodb_trx;

Spring事务的最佳实践

为避免事务失效，以下是一些最佳实践建议：

正确使用@Transactional注解

1
2
3
4
5
6
7
8
9
10
11
12
@Service
public class UserService {
    @Transactional(
        rollbackFor = Exception.class, // 所有异常都回滚
        timeout = 30, // 超时时间（秒）
        isolation = Isolation.READ_COMMITTED, // 隔离级别
        propagation = Propagation.REQUIRED // 传播行为
    )
    public void createUser(User user) {
        userMapper.insert(user);
    }
}

避免在同一个类中内部调用事务方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Service
public class UserService {
    @Autowired
    private UserService self; // 注入自身代理对象
  
    public void businessOperation(User user) {
        // 通过代理对象调用事务方法
        self.createUser(user);
    }
  
    @Transactional
    public void createUser(User user) {
        userMapper.insert(user);
    }
}

合理处理异常

1
2
3
4
5
6
7
8
9
10
@Transactional
public void createUser(User user) {
    try {
        userMapper.insert(user);
        // 其他操作...
    } catch (Exception e) {
        log.error("创建用户失败", e);
        throw new RuntimeException("创建用户失败", e); // 确保异常被抛出
    }
}

使用编程式事务处理复杂场景

对于特别复杂的事务场景，可以考虑使用编程式事务。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Service
public class UserService {
    @Autowired
    private PlatformTransactionManager transactionManager;
  
    public void complexOperation() {
        TransactionDefinition definition = new DefaultTransactionDefinition();
        TransactionStatus status = transactionManager.getTransaction(definition);
      
        try {
            // 业务操作...
            transactionManager.commit(status);
        } catch (Exception e) {
            transactionManager.rollback(status);
            throw e;
        }
    }
}

合理设置事务的隔离级别和传播行为

1
2
3
4
5
6
7
8
9
10
11
// 根据业务需求设置合适的隔离级别
@Transactional(isolation = Isolation.READ_COMMITTED)
public void readOperation() {
    // 读操作...
}

// 根据业务需求设置合适的传播行为
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void independentOperation() {
    // 需要在独立事务中执行的操作...
}

Spring事务失效案例分析

案例1：自调用问题

1
2
3
4
5
6
7
8
9
10
11
12
13
@Service
public class OrderService {
    public void createOrder(Order order) {
        // 前置处理...
        saveOrder(order); // 内部调用，事务不生效
    }
  
    @Transactional
    public void saveOrder(Order order) {
        orderMapper.insert(order);
        // 可能抛出异常...
    }
}

问题分析：
内部方法调用不经过Spring代理，导致@Transactional注解失效。

解决方案：

  1. 将两个方法拆分到不同的类中

  2. 注入自身代理对象，通过代理对象调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Service
public class OrderService {
    @Autowired
    private OrderService self;
  
    public void createOrder(Order order) {
        // 前置处理...
        self.saveOrder(order); // 通过代理调用，事务生效
    }
  
    @Transactional
    public void saveOrder(Order order) {
        orderMapper.insert(order);
        // 可能抛出异常...
    }
}

案例2：异常处理不当

1
2
3
4
5
6
7
8
9
10
11
12
13
@Service
public class PaymentService {
    @Transactional
    public void processPayment(Payment payment) {
        try {
            paymentMapper.insert(payment);
            externalPaymentGateway.process(payment); // 可能抛出异常
        } catch (Exception e) {
            log.error("支付处理失败", e);
            // 异常被吞没，事务不回滚
        }
    }
}

问题分析：
捕获异常后未重新抛出，导致Spring无法感知异常，事务不回滚。

解决方案：

  1. 重新抛出异常

  2. 使用TransactionAspectSupport手动回滚

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Service
public class PaymentService {
    @Transactional
    public void processPayment(Payment payment) {
        try {
            paymentMapper.insert(payment);
            externalPaymentGateway.process(payment); // 可能抛出异常
        } catch (Exception e) {
            log.error("支付处理失败", e);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); // 手动标记回滚
            // 或者重新抛出异常
            // throw new RuntimeException("支付处理失败", e);
        }
    }
}

总结

Spring事务失效的原因多种多样，主要包括：

  1. 方法访问权限问题
  2. 方法内部调用
  3. 异常被捕获但未重新抛出
  4. 异常类型不匹配
  5. 事务传播行为设置不当
  6. 数据库引擎不支持事务
  7. 类未被Spring管理
  8. 事务管理器配置错误
  9. 使用final修饰的类或方法
  10. 使用错误的事务注解
  11. 事务超时
  12. 嵌套事务配置错误
  13. 使用了不同的数据源
  14. 事务管理器类型不匹配
  15. 使用了编程式事务但未提交

通过理解这些原因并采取相应的最佳实践，我们可以避免Spring事务失效的问题，确保数据的一致性和完整性。在实际开发中，应当根据业务需求合理设置事务的隔离级别、传播行为和回滚规则，并正确处理异常。

扩展阅读

  1. Spring事务管理详解
  2. AOP与事务实现原理
  3. 分布式事务解决方案