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

从它的继承关系可以看出，它是 @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<string> 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; // 方法返回
    }
}