Spring 事务管理与传播机制详解

运行测试时，如果手动提交，数据库中会增加记录；如果执行回滚，虽然日志显示成功，但刷新数据库会发现没有新纪录。

Spring 声明式事务 @Transactional

在方法上添加 @Transactional 注解即可，无需手动处理开启和提交。进入方法自动开启，结束自动提交，未捕获的异常会自动回滚。

package com.hbu.springtransdemo.controller;

import com.hbu.springtransdemo.service.UserInfoService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.io.IOException;

import static org.springframework.transaction.annotation.Isolation.READ_COMMITTED;

@RestController
@Slf4j
@RequestMapping("/User2")
public class UserController2 {
    @Autowired
    private UserInfoService userInfoService;

    @Transactional()
    @RequestMapping("/regist")
    public String registryUser(String name, String password) throws IOException {
        Integer result = userInfoService.registryUser(name, password);
        log.info("用户信息插入成功");
        return "注册成功";
    }
}

若方法内抛出未捕获的异常（如除零错误），事务会回滚，数据不会写入。

注意：@Transactional 修饰类时，对类中所有 public 方法生效；修饰方法时，仅对 public 方法生效。默认情况下，只有运行时异常（RuntimeException）和 Error 才会触发回滚，受检异常（Exception）不会。

@Transactional 详解

除了基本使用，我们还需要关注三个关键属性：rollbackFor、isolation 和 propagation。

rollbackFor

默认只回滚运行时异常。如果需要受检异常也触发回滚，需显式指定。

@Transactional(rollbackFor = Exception.class)
@RequestMapping("/regist")
public String registryUser(String name, String password) throws IOException {
    // ... 业务逻辑
    if (true) {
        throw new IOException();
    }
    return "注册成功";
}

事务隔离级别

MySQL 事务隔离级别

SQL 标准定义了四种，MySQL 均支持：

1. 读未提交 (READ UNCOMMITTED)：可能读到脏数据（脏读）。
2. 读已提交 (READ COMMITTED)：解决脏读，但可能出现不可重复读。
3. 可重复读 (REPEATABLE READ)：MySQL 默认，解决不可重复读，但存在幻读风险。
4. 串行化 (SERIALIZABLE)：最高级别，效率低，解决所有并发问题。

Spring 事务隔离级别

Spring 封装了五种对应级别：

• Isolation.DEFAULT：依赖数据库默认配置。
• Isolation.READ_UNCOMMITTED / READ_COMMITTED / REPEATABLE_READ / SERIALIZABLE。

@Transactional(isolation = READ_COMMITTED)
@RequestMapping("/r1")
public String r1(String name, String password) {
    return "r1";
}

Spring 事务传播机制

当多个事务方法相互调用时，事务如何传播？这是本节的重点。

Spring 定义了七种传播行为：

1. REQUIRED：默认值。有事务则加入，无事务则新建。
2. SUPPORTS：有事务则加入，无事务则以非事务方式运行。
3. MANDATORY：必须有事务，否则抛异常。
4. REQUIRES_NEW：总是新建事务，挂起当前事务。
5. NOT_SUPPORTED：以非事务方式运行，挂起当前事务。
6. NEVER：以非事务方式运行，有事务则抛异常。
7. NESTED：嵌套事务。有事务则创建保存点，无事务则等价于 REQUIRED。

场景演示

1. 都使用默认传播机制 (REQUIRED) 主事务 A 调用子事务 B。它们属于同一个事务上下文。A 回滚，B 也会回滚。

@Transactional
@RequestMapping("/r2")
public String r2(String name, String password) {
    userInfoService.registryUser(name, password); // 子方法
    logInfoService.insert();                     // 子方法
    return "成功！！！";
}

2. REQUIRES_NEW 内部方法开启独立事务，互不影响。外部回滚不影响内部已提交的数据。

3. NESTED 类似 REQUIRED，但允许局部回滚。如果内部方法回滚，可以恢复到保存点，而外部事务继续。

总结

1. Spring 事务分为编程式和声明式，推荐使用 @Transactional。
2. 通过 isolation 设置隔离级别，默认为数据库默认值。
3. 通过 propagation 设置传播机制，重点关注 REQUIRED 和 REQUIRES_NEW。
4. 注意异常类型对回滚的影响，必要时配置 rollbackFor。