Spring通过一系列精妙的抽象和实现来完成事务的融入、挂起和嵌套操作。下面我将详细解析Spring如何实现这些事务行为。

1. 核心组件

Spring事务管理的核心组件包括：

• PlatformTransactionManager：事务管理器的抽象接口

• TransactionDefinition：定义事务属性(传播行为、隔离级别等)

• TransactionStatus：表示事务状态

• TransactionSynchronizationManager：事务同步管理器(线程绑定资源管理)

2. 事务融入(REQUIRED)实现

当传播行为为PROPAGATION_REQUIRED时：

// 简化版AbstractPlatformTransactionManager处理逻辑
if (isExistingTransaction(transaction)) {
    // 已存在事务：融入现有事务
    return handleExistingTransaction(def, transaction, debugEnabled);
} else {
    // 不存在事务：创建新事务
    return startTransaction(def, transaction, debugEnabled, suspendedResources);
}

融入过程：

1. 通过TransactionSynchronizationManager判断当前线程是否已有事务

2. 如果有，获取当前事务信息并加入

3. 通过线程绑定机制(ThreadLocal)共享同一事务资源

3. 事务挂起(REQUIRES_NEW/NOT_SUPPORTED)实现

当传播行为需要挂起当前事务时：

// 挂起当前事务的典型实现
protected final SuspendedResourcesHolder suspend(@Nullable Object transaction) {
    // 1. 从当前线程解绑事务资源
    List<TransactionSynchronization> suspendedSynchronizations = 
        TransactionSynchronizationManager.getSynchronizations();
    
    // 2. 解绑所有事务相关资源
    Map<Object, Object> suspendedResources = 
        TransactionSynchronizationManager.unbindResource(obtainTransactionSynchronizationRegistry());
    
    // 3. 重置线程绑定状态
    TransactionSynchronizationManager.clear();
    
    return new SuspendedResourcesHolder(
        suspendedResources, suspendedSynchronizations);
}

挂起过程：

1. 保存当前事务状态到SuspendedResourcesHolder

2. 从TransactionSynchronizationManager清理线程绑定

3. 后续操作将在无事务或新事务中执行

4. 事务嵌套(NESTED)实现

对于PROPAGATION_NESTED的实现：

// DataSourceTransactionManager中的实现
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
    if (!useSavepointForNestedTransaction()) {
        throw new NestedTransactionNotSupportedException(...);
    }
    // 创建保存点
    Object savepoint = getSavepointManager().createSavepoint();
    return prepareTransactionStatus(definition, transaction, false, true, debugEnabled, savepoint);
}

嵌套实现关键点：

1. 检查数据库是否支持保存点

2. 通过JDBC Savepoint机制实现

3. 内部事务回滚只回滚到保存点

4. 外部事务回滚会导致全部回滚

5. 底层实现技术

Spring实现这些行为的底层技术包括：

5.1 线程绑定机制

• 使用TransactionSynchronizationManager维护线程绑定资源

• 基于ThreadLocal存储当前事务状态

• 关键方法：bindResource/unbindResource

5.2 JDBC抽象

• 对Connection的包装(TransactionAwareDataSourceProxy)

• 保存点管理(通过Connection#setSavepoint)

• 事务隔离级别控制

5.3 事务同步

• TransactionSynchronization接口

• 注册回调处理(如afterCommit, afterCompletion)

• 保证资源清理和状态恢复

6. 典型处理流程

// 简化版事务处理流程
public final TransactionStatus getTransaction(TransactionDefinition definition) {
    // 1. 获取或创建事务
    Object transaction = doGetTransaction();
    
    // 2. 检查当前线程是否已有事务
    if (isExistingTransaction(transaction)) {
        // 处理已存在事务的情况(融入/挂起/嵌套等)
        return handleExistingTransaction(definition, transaction, debugEnabled);
    }
    
    // 3. 处理无事务的情况
    return startTransaction(definition, transaction, debugEnabled, null);
}

7. 不同传播行为的实现对比

传播行为	实现机制
REQUIRED	加入现有事务或新建事务(线程绑定同一Connection)
REQUIRES_NEW	挂起当前事务→新建事务→新Connection绑定到线程→原事务保存在SuspendedResourcesHolder
NESTED	使用JDBC Savepoint机制(不创建新Connection)
NOT_SUPPORTED	挂起当前事务→无事务执行→恢复原事务
MANDATORY	强制检查当前是否存在事务

8. 事务恢复机制

当事务挂起后需要恢复时：

protected final void resume(@Nullable Object transaction, 
                          @Nullable SuspendedResourcesHolder resourcesHolder) {
    if (resourcesHolder != null) {
        // 恢复线程绑定的资源
        TransactionSynchronizationManager.bindResource(
            obtainTransactionSynchronizationRegistry(), 
            resourcesHolder.getSuspendedResources());
        // 恢复同步器
        resourcesHolder.register();
    }
}

Spring通过这些精细的控制机制，实现了灵活的事务传播行为，为复杂业务场景提供了可靠的事务管理能力。