Spring中REQUIRES_NEW真的新建事务了吗？底层源码级剖析

第一章：Spring中REQUIRES_NEW真的新建事务了吗？

REQUIRES_NEW的行为逻辑

• 如果当前存在事务，则将其挂起（suspend）
• 创建一个新的、独立的事务实例
• 在新事务中执行目标方法
• 提交或回滚后，恢复之前挂起的事务

代码示例说明

@Service
public class TransactionService {

    @Autowired
    private UserService userService;

    @Transactional(propagation = Propagation.REQUIRED)
    public void outerMethod() {
        userService.saveUser("Alice"); // 在事务1中
        try {
            userService.saveWithNewTransaction("Bob"); // 启动REQUIRES_NEW事务
        } catch (Exception e) {
            // 即使这里捕获异常，outerMethod的事务仍可继续
        }
        throw new RuntimeException("Trigger rollback");
    }
}

@Service
class UserService {

    @Autowired
    private UserRepository userRepository;

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void saveWithNewTransaction(String name) {
        userRepository.save(new User(name)); // 独立事务，即使外层回滚也会提交
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public void saveUser(String name) {
        userRepository.save(new User(name));
    }
}

关键区别对比

第二章：REQUIRES_NEW事务传播机制理论解析

2.1 REQUIRES_NEW的定义与使用场景

事务传播行为的核心机制

典型使用场景

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void logOperation(String message) {
    auditRepository.save(new AuditLog(message));
}

2.2 与其他传播行为的对比分析

数据同步机制

1. 配置传播：强一致性要求，如ZooKeeper的Watcher机制
2. 事件广播：弱一致性，适用于状态变更通知
3. 消息队列：解耦生产与消费，具备缓冲能力

性能与一致性权衡

// 示例：监听配置变更
watcher := client.Watch("/config")
for event := range watcher {
    if event.Type == "UPDATE" {
        reloadConfig(event.Value) // 重新加载配置
    }
}

2.3 事务挂起与恢复的底层逻辑

事务状态保存结构

• 事务ID：全局唯一标识，用于后续恢复匹配
• 隔离级别：挂起前的事务隔离状态
• 资源锁信息：已持有的数据库行锁或表锁
• 回滚日志：记录变更前的数据镜像

挂起与恢复代码示例

// 挂起当前事务，返回上下文
TransactionContext ctx = TransactionManager.suspend();

// 执行非事务操作或子事务
subTask.execute();

// 恢复原事务上下文
TransactionManager.resume(ctx);

2.4 事务隔离性与并发控制的影响

隔离级别及其行为

MVCC与锁机制协同工作

-- 读已提交隔离级别下的快照读
SELECT * FROM users WHERE id = 1; -- 使用最新已提交版本

2.5 异常传递与回滚边界的处理机制

回滚边界定义

  
@Transactional(rollbackFor = Exception.class)
public void transfer(String from, String to, BigDecimal amount) {
    // 扣款操作
    accountMapper.debit(from, amount);
    // 若网络异常，抛出RuntimeException
    if (!remoteService.credit(to, amount)) {
        throw new RuntimeException("Credit failed");
    }
}

异常分类与传播策略

• 系统异常：直接触发回滚
• 业务异常：可配置是否回滚
• 校验异常：通常不触发回滚

第三章：REQUIRES_NEW源码级实现剖析

3.1 TransactionAspectSupport中的拦截逻辑

拦截流程概述

1. 解析方法上的事务属性
2. 获取事务管理器（PlatformTransactionManager）
3. 根据传播行为决定事务策略
4. 执行事务的开启、提交或回滚

关键代码片段

protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
    TransactionAttributeSource transactionAttributeSource) {
  TransactionAttribute txAttr = transactionAttributeSource.getTransactionAttribute(method, targetClass);
  PlatformTransactionManager tm = determineTransactionManager(txAttr);
  TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, methodIdentification);

  Object result;
  try {
    result = invocation.proceedWithInvocation();
  } catch (Throwable ex) {
    completeTransactionAfterThrowing(txInfo, ex);
    throw ex;
  } finally {
    cleanupTransactionInfo(txInfo);
  }
  commitTransactionAfterReturning(txInfo);
  return result;
}

3.2 AbstractPlatformTransactionManager的事务创建流程

事务创建主流程

• 检查是否存在现有事务（通过TransactionSynchronizationManager）
• 若无事务，创建新事务并绑定到当前线程
• 根据传播行为决定是否挂起、复用或新建事务

protected TransactionStatus handleTransactionCreation(
    TransactionDefinition definition, Object transaction) {
    if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED) {
        return newTransactionStatus(definition, transaction, true, true, debugEnabled, null);
    }
    // ...
}

3.3 SavepointManager与挂起事务的管理

SavepointManager 的核心职责

挂起事务的管理机制

Object suspended = transactionManager.suspend(currentTransaction);
try {
    // 执行非事务性或新事务逻辑
} finally {
    transactionManager.resume(null, suspended);
}

支持的操作类型

• 创建保存点：允许部分回滚
• 回滚至保存点：不中断外层事务
• 释放保存点：提交成功后清理资源

第四章：REQUIRES_NEW实践验证与案例分析

4.1 模拟嵌套调用中事务独立提交的实验

实验代码结构

func ServiceC(db *sql.DB) error {
    tx, _ := db.Begin()
    _, err := tx.Exec("INSERT INTO log_c (msg) VALUES (?)", "from B")
    if err != nil { tx.Rollback(); return err }
    tx.Commit()
    return nil
}

func ServiceB(db *sql.DB) error {
    tx, _ := db.Begin()
    tx.Exec("INSERT INTO log_b (msg) VALUES (?)", "from A")
    ServiceC(db) // 独立事务，不影响B的提交
    tx.Commit()
    return nil
}

事务行为对比表

4.2 主事务回滚不影响子事务的场景验证

典型应用场景

代码实现示例

func createAuditLog(ctx context.Context) error {
    // 开启独立事务，不继承父事务上下文
    independentCtx := context.Background()
    return db.Transaction(independentCtx, func(tx *gorm.DB) error {
        return tx.Create(&AuditLog{Action: "user_update"}).Error
    })
}

验证流程

1. 启动主事务并执行核心业务逻辑
2. 在主事务中调用独立子事务写入审计日志
3. 主动抛出异常使主事务回滚
4. 验证数据库中审计日志是否依然存在

4.3 多数据源环境下REQUIRES_NEW的行为表现

事务独立性验证

@Transactional(propagation = Propagation.REQUIRES_NEW, value = "dataSourceA")
public void innerMethod() {
    // 使用数据源 A 执行操作
}

@Transactional(propagation = Propagation.REQUIRED, value = "dataSourceB")
public void outerMethod() {
    // 调用 innerMethod()
}

数据源与事务绑定机制

• 每个数据源对应独立的事务管理器
• 动态数据源路由依赖于事务前绑定
• REQUIRES_NEW 触发事务切换时，必须明确指定事务管理器

4.4 性能开销与连接资源管理的实测分析

连接池参数对比测试

Go语言连接池配置示例

db.SetMaxOpenConns(100)    // 最大打开连接数
db.SetMaxIdleConns(10)     // 最大空闲连接数
db.SetConnMaxLifetime(time.Minute * 5) // 连接最长生命周期

第五章：结论与最佳实践建议

持续集成中的配置管理

• 确保所有服务通过环境变量注入配置参数
• 敏感信息应加密存储并由密钥管理系统（如 Hashicorp Vault）动态注入
• 配置变更需触发 CI/CD 流水线重新验证服务兼容性

性能监控与日志聚合

scrape_configs:
  - job_name: 'service-metrics'
    static_configs:
      - targets: ['service-a:8080', 'service-b:8080']
loki:
  configs:
    - name: 'default'
      clients:
        - url: http://loki:3100/loki/api/v1/push

安全加固建议

自动化回滚机制设计

# 示例脚本片段
  helm history my-app | grep FAILED
  if [ $? -eq 0 ]; then
    helm rollback my-app latest
  fi