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

代码结构

项目依赖包括 Spring Web、MyBatis 及 MySQL 驱动。配置文件需指定数据源及 MyBatis 日志输出。

实体类定义如下：

@Data
public class UserInfo {
    private Integer id;
    private String userName;
    private String password;
    private Date createTime;
    private Date updateTime;
}

@Data
public class LogInfo {
    private Integer id;
    private String userName;
    private String op;
    private Date createTime;
    private Date updateTime;
}

Mapper 接口：

@Mapper
public interface UserInfoMapper {
    @Insert("insert into user_info(`user_name`,`password`) values(#{name}, #{password})")
    Integer insert(String name, String password);
}

@Mapper
public interface LogInfoMapper {
    @Insert("insert into log_info(`user_name`,`op`) values(#{name}, #{op})")
    Integer insertLog(String name, String op);
}

Service 层：

@Slf4j
@Service
public class UserService {
    @Autowired
    private UserInfoMapper userInfoMapper;

    public void registryUser(String name, String password) {
        userInfoMapper.insert(name, password);
    }
}

@Slf4j
@Service
public class LogService {
    @Autowired
    private LogInfoMapper logInfoMapper;

    public void insertLog(String name, String op) {
        logInfoMapper.insertLog(name, "用户注册");
    }
}

Controller 层：

@RequestMapping("/user")
@RestController
public class UserController {
    @Autowired
    private UserService userService;

    @RequestMapping("/registry")
    public String registry(String name, String password) {
        userService.registryUser(name, password);
        return "注册成功";
    }
}

Spring 编程式事务

编程式事务类似于原生 JDBC 操作，需手动控制事务状态。SpringBoot 内置了 DataSourceTransactionManager 用于管理事务生命周期，以及 TransactionDefinition 定义事务属性。

实现示例：

@RequestMapping("/user")
@RestController
public class UserController {
    @Autowired
    private DataSourceTransactionManager dataSourceTransactionManager;
    @Autowired
    private TransactionDefinition transactionDefinition;
    @Autowired
    private UserService userService;

    @RequestMapping("/registry")
    public String registry(String name, String password) {
        // 开启事务
        TransactionStatus transactionStatus = dataSourceTransactionManager.getTransaction(transactionDefinition);
        try {
            userService.registryUser(name, password);
            // 提交事务
            dataSourceTransactionManager.commit(transactionStatus);
        } catch (Exception e) {
            // 回滚事务
            dataSourceTransactionManager.rollback(transactionStatus);
            throw e;
        }
        return "注册成功";
    }
}

虽然可行，但这种方式代码侵入性强，维护成本高。实际开发中更倾向于使用声明式事务。

Spring 声明式事务 @Transactional

声明式事务通过注解自动管理，无需手动编写事务控制代码。只需在方法上添加 @Transactional，框架会在方法执行前开启事务，执行成功后提交，若抛出未捕获的异常则自动回滚。

@RequestMapping("/trans")
@RestController
public class TransactionalController {
    @Autowired
    private UserService userService;

    @Transactional
    @RequestMapping("/registry")
    public String registry(String name, String password) {
        userService.registryUser(name, password);
        return "注册成功";
    }
}

若强制抛出异常（如除零错误），观察发现数据库并未新增数据，说明事务已回滚。值得注意的是，@Transactional 仅对 public 方法生效。若方法内部捕获了异常而未重新抛出，事务将被视为成功并提交。此时可通过 TransactionAspectSupport.currentTransactionStatus().setRollbackOnly() 手动标记回滚。

三、@Transactional 详解

rollbackFor

默认情况下，Spring 仅在遇到运行时异常（RuntimeException）或 Error 时回滚，受检异常（Checked Exception）不会触发回滚。若需所有异常均回滚，可配置 rollbackFor 属性。

@Transactional(rollbackFor = Exception.class)
@RequestMapping("/r2")
public String r2(String name, String password) throws IOException {
    userService.registryUser(name, password);
    if (true) {
        throw new IOException();
    }
    return "r2";
}

事务隔离级别

MySQL 事务隔离级别

SQL 标准定义了四种隔离级别，MySQL 均支持：

• 读未提交 (READ UNCOMMITTED)：可能读到其他事务未提交的数据（脏读）。
• 读提交 (READ COMMITTED)：只能读到已提交数据，避免脏读，但可能出现不可重复读。
• 可重复读 (REPEATABLE READ)：MySQL 默认级别。保证同一事务内多次查询结果一致，但可能存在幻读。
• 串行化 (SERIALIZABLE)：最高隔离级别，效率低，彻底解决并发问题。

Spring 事务隔离级别

Spring 封装了五种隔离级别，对应关系如下：

• Isolation.DEFAULT：继承数据库默认设置。
• Isolation.READ_UNCOMMITTED / READ_COMMITTED / REPEATABLE_READ / SERIALIZABLE。

可通过 isolation 属性指定：

@Transactional(isolation = Isolation.READ_COMMITTED)

Spring 事务传播机制

事务传播机制决定了当一个事务方法调用另一个事务方法时，事务如何传递。

什么是事务传播机制？

假设有两个被 @Transactional 修饰的方法 A 和 B，A 调用 B。当 A 开启事务后，B 是加入 A 的事务还是新建一个？这就是传播机制要解决的问题。

事务的传播机制有哪些

@Transactional 的 propagation 属性支持七种行为：

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

场景演示

我们重点关注最常用的 REQUIRED 和 REQUIRES_NEW。

REQUIRED（加入事务）

当外部方法 A 和内部方法 B 均使用 REQUIRED 时，它们共享同一个事务上下文。若 B 发生异常导致回滚，A 中的操作也会一并回滚。

// Controller
@Transactional(propagation = Propagation.REQUIRED)
public String p1(...) {
    userService.registryUser(...); // 成功
    logService.insertLog(...);     // 异常，回滚
}

// Service
@Transactional(propagation = Propagation.REQUIRED)
public void registryUser(...) { ... }

@Transactional(propagation = Propagation.REQUIRED)
public void insertLog(...) {
    int a = 10 / 0; // 触发异常
    logInfoMapper.insertLog(...);
}

执行结果：用户表和日志表均无数据写入。因为两者属于同一事务，B 的失败触发了整体回滚。

REQUIRES_NEW（新建事务）

若将内部方法改为 REQUIRES_NEW，它将在独立的新事务中运行，不受外部事务影响。

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void insertLog(...) {
    int a = 10 / 0;
    logInfoMapper.insertLog(...);
}

执行结果：用户数据插入成功，日志数据因异常回滚。两个事务互不干扰，适用于希望部分操作失败不影响主流程的场景。

NEVER（不支持当前事务）

若方法标记为 NEVER 却在事务上下文中调用，会直接抛出异常，确保该方法绝不在事务中执行。

NESTED（嵌套事务）

NESTED 基于数据库保存点（Savepoint）实现。若外部事务存在，内部方法作为子事务运行；若外部无事务，则等同于 REQUIRED。

@Transactional(propagation = Propagation.NESTED)
public void insertLog(...) {
    try {
        int a = 10 / 0;
    } catch (Exception e) {
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    logInfoMapper.insertLog(...);
}

若内部方法手动回滚保存点，外部事务仍可继续执行并成功提交。这与 REQUIRED 不同，后者一旦回滚即全盘否定。

NESTED 和 REQUIRED 的区别

• REQUIRED：加入当前事务，无法局部回滚。一旦任一环节失败，整个事务回滚。
• NESTED：创建嵌套事务（保存点）。允许局部回滚而不影响父事务，前提是父事务未被标记为回滚。

总结

1. Spring 事务分为编程式和声明式，推荐优先使用 @Transactional 注解。
2. 默认情况下，仅运行时异常触发回滚，可通过 rollbackFor 扩展至所有异常类型。
3. 事务隔离级别由数据库决定，Spring 提供配置接口进行覆盖。
4. 传播机制中，REQUIRED 是最常用的默认选项，REQUIRES_NEW 用于隔离独立事务，NESTED 则提供了更细粒度的回滚控制能力。