Spring事务源码

启动事务

@EnableTransactionManagement 注解来启用事务能力。

参数解释
proxyTargetClass:默认为false,表示使用 JDK 的代理模式,true表示用 CGLib 的代理模式,仅在 mode 是 PROXY 时才有效。
mode:默认为PROXY,表示使用 AOP 代理来实现事务,ASPECTJ表示用 ASPECTJ 来实现事务,ASPECTJ 相比 PROXY 减少了一些使用限制,比如支持在同一个类内部方法调用。
order:事务通知执行的顺序,默认优先级最低

@Transactional 可以标注在类、接口、方法上,表示应用事务机制,

参数解释
value/transactionManager:如果有多个事务管理器时,指定一个事务管理器
propagation:事务传播类型,默认 REQUIRED。还有 SUPPORTS/MANDATORY/REQUIRES_NEW/NOT_SUPPORTED/NEVER/NESTED
isolation:事务隔离级别,默认为数据库的隔离级别,包括 READ_UNCOMMITTED/READ_COMMITTED/REPEATABLE_READ/SERIALIZABLE
timeout:事务超时时间
readOnly:是否只读,默认false
rollbackFor:指定哪种类型的异常需要回滚
rollbackForClassName:类似rollbackFor
noRollbackFor:指定哪种类型的异常不需要回滚
noRollbackForClassName:类似noRollbackFor

事务传播类型说明

枚举 描述
REQUIRED 如果当前存在事务,方法会在该事务中运行,否则创建一个新事务。
SUPPORTS 方法可以不需要事务,但是如果存在当前事务,则会在该事务中运行。
MANDATORY 方法必须运行在事务中,如果当前事务不存在,则抛出异常。
REQUIRES_NEW 方法必须运行在它自己的事务中,如果存在当前事务,该事务将被挂起。
NOT_SUPPORTED 方法不应该运行在事务中,如果存在当前事务,该事务将被挂起。
NEVER 方法不应该运行在事务中,如果存在当前事务,则抛出异常。
NESTED 如果当前已经存在一个事物,方法会在嵌套事务中运行;如果不存在事务,其行为和 PROPAGATION_REQUIRED 一致。

@EnableTransactionManagement 使用 @Import 导入 TransactionManagementConfigurationSelector,这个类继承了 AdviceModeImportSelector,也就是实现了 ImportSelector,所以配置类解析器会执行它的 selectImports() 方法,如下:

protected String[] selectImports(AdviceMode adviceMode) {
    switch (adviceMode) {
        case PROXY:
            return new String[] {AutoProxyRegistrar.class.getName(), ProxyTransactionManagementConfiguration.class.getName()};
        case ASPECTJ:
            return new String[] {determineTransactionAspectClass()};
        default:
            return null;
    }
}

这个方法根据通知模式 PROXY/ASPECTJ,选择导入不同的事务管理器。

以默认方式 PROXY 为例,导入 ProxyTransactionManagementConfiguration 和 AutoProxyRegistrar。

ProxyTransactionManagementConfiguration

Spring事务源码_第1张图片

从它的继承关系可以看出,它是 @Configuration 配置类,并且实现了 ImportAware 接口,所以它会被注入 Spring 容器,此外,它还会通过 @Bean 注入下面这些组件:

  • AnnotationTransactionAttributeSource 解析 @Transactional 事务注解属性信息
  • TransactionInterceptor 保存事务注解的属性信息和事务管理器信息,它是实现 MethodInterceptor 的事务拦截器,所以会在目标方法执行时执行拦截。

AutoProxyRegistrar

AutoProxyRegistrar 是 ImportBeanDefinitionRegistrar 的实现类,所以 ConfigurationClassBeanDefinitionReader 会执行它的方法 registerBeanDefinitions(),并且在执行后置处理器时,会回调 ImportAware.setImportMetadata(),将 @EnableTransactionManagement 配置属性缓存至 AnnotationAttributes。

public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    boolean candidateFound = false;
    Set annTypes = importingClassMetadata.getAnnotationTypes();
    for (String annType : annTypes) {
        AnnotationAttributes candidate = AnnotationConfigUtils.attributesFor(importingClassMetadata, annType);
        if (candidate == null) {
            continue;
        }
        Object mode = candidate.get("mode");
        Object proxyTargetClass = candidate.get("proxyTargetClass");
        if (mode != null && proxyTargetClass != null && AdviceMode.class == mode.getClass() &&
                Boolean.class == proxyTargetClass.getClass()) {
            candidateFound = true;
            if (mode == AdviceMode.PROXY) {
                // 注册 InfrastructureAdvisorAutoProxyCreator
                AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
                if ((Boolean) proxyTargetClass) {
                    // CGLib
                    AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
                    return;
                }
            }
        }
    }
}
  • 如果是 PROXY 类型的通知模式,注册 InfrastructureAdvisorAutoProxyCreator 到 BeanFactory;
  • 如果是 CGlib 代理,还要注册 AnnotationAwareAspectJAutoProxyCreator 到 BeanFactory;

查看 InfrastructureAdvisorAutoProxyCreator 的继承关系,实际上和 AnnotationAwareAspectJAutoProxyCreator 是类似的,都继承 AbstractAdvisorAutoProxyCreator,可以回看 Spring AOP源码。也就是说,事务实际上就是利用 AOP 原理来实现的:通过 JDK/CGLib 动态代理技术,给需要事务增强的类创建增强后的代理对象,待代理方法执行时,利用代理对象来实现事务机制。

执行代理对象

和 Spring AOP源码 类似,只不过拦截器链中是 TransactionInterceptor,所以会执行其 invoke() 方法:

@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
    return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
}
protected Object invokeWithinTransaction(Method method, @Nullable Class targetClass, final InvocationCallback invocation) throws Throwable {

    // 获取 @Transactional 注解事务属性
    TransactionAttributeSource tas = getTransactionAttributeSource();
    final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
    // 如果没有指定,则按照类型获取事务管理器 PlatformTransactionManager
    // 比如事务管理器 DataSourceTransactionManager
    final PlatformTransactionManager tm = determineTransactionManager(txAttr);
    // 获取需要执行的目标方法
    final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

    if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
        // 将事务信息绑定到线程局部变量
        TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);

        Object retVal;
        try {
            // 类似方法的环绕通知,会执行目标方法
            retVal = invocation.proceedWithInvocation();
        }
        catch (Throwable ex) {
            // 异常,使用事务管理器进行回滚
            completeTransactionAfterThrowing(txInfo, ex);
            throw ex;
        }
        finally {
            // 重置线程局部变量的事务信息
            cleanupTransactionInfo(txInfo);
        }
        // 正常,使用事务管理器提交事务
        commitTransactionAfterReturning(txInfo);
        return retVal; // 方法返回
    }
}

你可能感兴趣的:(Spring事务源码)