事务管理机制

深入理解Spring事务管理的工作原理，掌握PlatformTransactionManager接口、声明式事务的实现、事务传播机制、事务隔离级别、事务回滚规则等核心概念。

📋 事务管理概览

Spring事务管理提供了声明式事务和编程式事务两种方式，通过AOP实现事务的自动管理。

🎯 一、事务抽象

1.1 PlatformTransactionManager

PlatformTransactionManager是Spring事务管理的核心接口：

java

public interface PlatformTransactionManager {
    TransactionStatus getTransaction(@Nullable TransactionDefinition definition)
            throws TransactionException;
    
    void commit(TransactionStatus status) throws TransactionException;
    
    void rollback(TransactionStatus status) throws TransactionException;
}

核心方法：

getTransaction：获取事务状态，如果当前存在事务，则返回该事务
commit：提交事务
rollback：回滚事务

1.2 TransactionDefinition

TransactionDefinition定义了事务的传播行为、隔离级别、超时时间等属性：

java

public interface TransactionDefinition {
    // 传播行为
    int PROPAGATION_REQUIRED = 0;
    int PROPAGATION_SUPPORTS = 1;
    int PROPAGATION_MANDATORY = 2;
    int PROPAGATION_REQUIRES_NEW = 3;
    int PROPAGATION_NOT_SUPPORTED = 4;
    int PROPAGATION_NEVER = 5;
    int PROPAGATION_NESTED = 6;
    
    // 隔离级别
    int ISOLATION_DEFAULT = -1;
    int ISOLATION_READ_UNCOMMITTED = 1;
    int ISOLATION_READ_COMMITTED = 2;
    int ISOLATION_REPEATABLE_READ = 4;
    int ISOLATION_SERIALIZABLE = 8;
    
    int getPropagationBehavior();
    int getIsolationLevel();
    int getTimeout();
    boolean isReadOnly();
    String getName();
}

🎯 二、声明式事务

2.1 @Transactional注解

@Transactional注解用于声明式事务：

java

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Transactional {
    @AliasFor("transactionManager")
    String value() default "";
    
    @AliasFor("value")
    String transactionManager() default "";
    
    Propagation propagation() default Propagation.REQUIRED;
    
    Isolation isolation() default Isolation.DEFAULT;
    
    int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;
    
    boolean readOnly() default false;
    
    Class<? extends Throwable>[] rollbackFor() default {};
    
    String[] rollbackForClassName() default {};
    
    Class<? extends Throwable>[] noRollbackFor() default {};
    
    String[] noRollbackForClassName() default {};
}

2.2 TransactionInterceptor

TransactionInterceptor是事务拦截器，负责事务的开启、提交和回滚：

java

public class TransactionInterceptor extends TransactionAspectSupport 
        implements MethodInterceptor, Serializable {
    
    @Override
    @Nullable
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Class<?> targetClass = (invocation.getThis() != null ? 
                AopUtils.getTargetClass(invocation.getThis()) : null);
        
        return invokeWithinTransaction(invocation.getMethod(), targetClass, 
                invocation::proceed);
    }
}

2.3 事务执行流程

🎯 三、事务传播机制

3.1 传播行为类型

PROPAGATION_REQUIRED（默认）：如果当前存在事务，则加入该事务；如果当前不存在事务，则创建一个新的事务。

PROPAGATION_SUPPORTS：如果当前存在事务，则加入该事务；如果当前不存在事务，则以非事务的方式继续运行。

PROPAGATION_MANDATORY：如果当前存在事务，则加入该事务；如果当前不存在事务，则抛出异常。

PROPAGATION_REQUIRES_NEW：创建一个新的事务，如果当前存在事务，则把当前事务挂起。

PROPAGATION_NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。

PROPAGATION_NEVER：以非事务方式运行，如果当前存在事务，则抛出异常。

PROPAGATION_NESTED：如果当前存在事务，则创建一个嵌套事务；如果当前不存在事务，则创建一个新的事务。

3.2 传播行为实现

java

private TransactionStatus handleExistingTransaction(
        TransactionDefinition definition, Object transaction, boolean debugEnabled)
        throws TransactionException {
    
    if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
        throw new IllegalTransactionStateException(
                "Existing transaction found for transaction marked with propagation 'never'");
    }
    
    if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
        if (debugEnabled) {
            logger.debug("Suspending current transaction");
        }
        Object suspendedResources = suspend(transaction);
        boolean newSynchronization = (getTransactionSynchronization() == 
                SYNCHRONIZATION_ALWAYS);
        return prepareTransactionStatus(definition, null, false, 
                newSynchronization, debugEnabled, suspendedResources);
    }
    
    if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
        if (debugEnabled) {
            logger.debug("Suspending current transaction, creating new transaction with name [" +
                    definition.getName() + "]");
        }
        SuspendedResourcesHolder suspendedResources = suspend(transaction);
        try {
            return startTransaction(definition, transaction, debugEnabled, 
                    suspendedResources);
        }
        catch (RuntimeException | Error beginEx) {
            resumeAfterBeginException(transaction, suspendedResources, beginEx);
            throw beginEx;
        }
    }
    
    if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
        if (!isNestedTransactionAllowed()) {
            throw new NestedTransactionNotSupportedException(...);
        }
        if (debugEnabled) {
            logger.debug("Creating nested transaction with name [" + definition.getName() + "]");
        }
        if (useSavepointForNestedTransaction()) {
            DefaultTransactionStatus status = prepareTransactionStatus(
                    definition, transaction, false, false, debugEnabled, null);
            status.createAndHoldSavepoint();
            return status;
        }
        else {
            return startTransaction(definition, transaction, debugEnabled, null);
        }
    }
    
    if (debugEnabled) {
        logger.debug("Participating in existing transaction");
    }
    if (isValidateExistingTransaction()) {
        if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
            Integer currentIsolationLevel = TransactionSynchronizationManager
                    .getCurrentTransactionIsolationLevel();
            if (currentIsolationLevel == null || 
                    currentIsolationLevel != definition.getIsolationLevel()) {
                Constants isoConstants = DefaultTransactionDefinition.constants;
                throw new IllegalTransactionStateException(...);
            }
        }
        if (!definition.isReadOnly()) {
            if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
                throw new IllegalTransactionStateException(...);
            }
        }
    }
    boolean newSynchronization = (getTransactionSynchronization() != 
            SYNCHRONIZATION_NEVER);
    return prepareTransactionStatus(definition, transaction, false, 
            newSynchronization, debugEnabled, null);
}

🎯 四、事务隔离级别

4.1 隔离级别类型

ISOLATION_DEFAULT：使用数据库默认隔离级别
ISOLATION_READ_UNCOMMITTED：读未提交
ISOLATION_READ_COMMITTED：读已提交
ISOLATION_REPEATABLE_READ：可重复读
ISOLATION_SERIALIZABLE：串行化

4.2 隔离级别实现

不同的事务管理器实现不同的隔离级别，大多数情况下使用数据库的默认隔离级别。

🎯 五、事务回滚

5.1 回滚规则

默认情况下，只有运行时异常（RuntimeException）和错误（Error）才会触发回滚，检查异常（Checked Exception）不会触发回滚。

rollbackOn方法：

java

@Override
public boolean rollbackOn(Throwable ex) {
    return (ex instanceof RuntimeException || ex instanceof Error);
}

5.2 自定义回滚规则

可以通过@Transactional注解的rollbackFor和noRollbackFor属性自定义回滚规则。

📖 学习资源

视频教程

书籍推荐

《Spring源码深度解析》 - 郝佳
《Spring技术内幕》 - 计文柯

网站资源

Spring事务管理文档

✅ 学习检查清单

[ ] 已理解PlatformTransactionManager接口
[ ] 已理解声明式事务实现
[ ] 已理解事务传播机制
[ ] 已理解事务隔离级别
[ ] 已理解事务回滚规则
[ ] 已绘制事务执行流程图
[ ] 已总结核心知识点

上一章节：AOP实现原理
下一章节：Bean生命周期
返回目录：Spring源码深度解析

开发与调试

测试能力

运维与监控

NoSQL

中间件

存储

接入层

操作系统

框架

硬件知识

缓存

品质

经验底蕴

能力

任务拆分

文档能力

协议设计

基本理论

接入层架构

数据层架构

通讯机制

逻辑层架构

事务管理机制 ​

📋 事务管理概览 ​

🎯 一、事务抽象 ​

1.1 PlatformTransactionManager ​

1.2 TransactionDefinition ​

🎯 二、声明式事务 ​

2.1 @Transactional注解 ​

2.2 TransactionInterceptor ​

2.3 事务执行流程 ​

🎯 三、事务传播机制 ​

3.1 传播行为类型 ​

3.2 传播行为实现 ​

🎯 四、事务隔离级别 ​

4.1 隔离级别类型 ​

4.2 隔离级别实现 ​

🎯 五、事务回滚 ​

5.1 回滚规则 ​

5.2 自定义回滚规则 ​

📖 学习资源 ​

视频教程 ​

书籍推荐 ​

网站资源 ​

✅ 学习检查清单 ​

事务管理机制

📋 事务管理概览

🎯 一、事务抽象

1.1 PlatformTransactionManager

1.2 TransactionDefinition

🎯 二、声明式事务

2.1 @Transactional注解

2.2 TransactionInterceptor

2.3 事务执行流程

🎯 三、事务传播机制

3.1 传播行为类型

3.2 传播行为实现

🎯 四、事务隔离级别

4.1 隔离级别类型

4.2 隔离级别实现

🎯 五、事务回滚

5.1 回滚规则

5.2 自定义回滚规则

📖 学习资源

视频教程

书籍推荐

网站资源

✅ 学习检查清单