Spring5.2源码学习 - TX - 基于XML事务源码 - 《Spring》

获取命名空间处理器

和 aop 几乎一样，在解析 xml 文件的时候，需要找到特定标签的解析类。

获取命名空间处理器

@Nullable
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
    // 参数校验
    String namespaceUri = getNamespaceURI(ele);
    if (namespaceUri == null) {
        return null;
    }
    // 获取自定义标签解析器
    NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
    if (handler == null) {
        error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
        return null;
    }
    return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}

这里用到的是 TxNamespaceHandler，可见

用于解析标签的工具为 TxAdviceBeanDefinitionParser
用于解析标签的工具为 AnnotationDrivenBeanDefinitionParser
用于解析 jta-transaction-manager 标签的工具为 JtaTransactionManagerBeanDefinitionParser ```java public class TxNamespaceHandler extends NamespaceHandlerSupport {

static final String TRANSACTION_MANAGER_ATTRIBUTE = “transaction-manager”;

static final String DEFAULT_TRANSACTION_MANAGER_BEAN_NAME = “transactionManager”;

static String getTransactionManagerName(Element element) {
    return (element.hasAttribute(TRANSACTION_MANAGER_ATTRIBUTE) ?
            element.getAttribute(TRANSACTION_MANAGER_ATTRIBUTE) : DEFAULT_TRANSACTION_MANAGER_BEAN_NAME);
}
@Override
public void init() {
    registerBeanDefinitionParser("advice", new TxAdviceBeanDefinitionParser());
    registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());
    registerBeanDefinitionParser("jta-transaction-manager", new JtaTransactionManagerBeanDefinitionParser());
}

}

<a name="v4Ps1"></a>
## 解析 tx 标签
先来到父类标签解析的方法，得到解析工具 TxAdviceBeanDefinitionParser<br />spring-beans | org.springframework.beans.factory.xml.NamespaceHandlerSupport#parse
```java
@Override
@Nullable
public BeanDefinition parse(Element element, ParserContext parserContext) {
    // 得到TxAdviceBeanDefinitionParser
    BeanDefinitionParser parser = findParserForElement(element, parserContext);
    return (parser != null ? parser.parse(element, parserContext) : null);
}

来到解析工具父类的解析方法
org.springframework.beans.factory.xml.AbstractBeanDefinitionParser#parse

@Override
@Nullable
public final BeanDefinition parse(Element element, ParserContext parserContext) {
    // 得到 RootBeanDefinition
    AbstractBeanDefinition definition = parseInternal(element, parserContext);
    if (definition != null && !parserContext.isNested()) {
        try {
            String id = resolveId(element, definition, parserContext);
            if (!StringUtils.hasText(id)) {
                parserContext.getReaderContext().error(
                        "Id is required for element '" + parserContext.getDelegate().getLocalName(element)
                                + "' when used as a top-level tag", element);
            }
            String[] aliases = null;
            if (shouldParseNameAsAliases()) {
                String name = element.getAttribute(NAME_ATTRIBUTE);
                if (StringUtils.hasLength(name)) {
                    aliases = StringUtils.trimArrayElements(StringUtils.commaDelimitedListToStringArray(name));
                }
            }
            BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, id, aliases);
            registerBeanDefinition(holder, parserContext.getRegistry());
            if (shouldFireEvents()) {
                BeanComponentDefinition componentDefinition = new BeanComponentDefinition(holder);
                postProcessComponentDefinition(componentDefinition);
                parserContext.registerComponent(componentDefinition);
            }
        }
        catch (BeanDefinitionStoreException ex) {
            String msg = ex.getMessage();
            parserContext.getReaderContext().error((msg != null ? msg : ex.toString()), element);
            return null;
        }
    }
    return definition;
}

parseInternal |

解析得到bean定义，这里解析的是
org.springframework.beans.factory.support.AbstractBeanDefinition

protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
    // bean定义构建器，创建一个空的 AbstractBeanDefinition
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
    String parentName = getParentName(element);
    if (parentName != null) {
        builder.getRawBeanDefinition().setParentName(parentName);
    }
    // 获取标签对应的 bean Class
    // org.springframework.transaction.interceptor.TransactionInterceptor
    Class<?> beanClass = getBeanClass(element);
    if (beanClass != null) {
        builder.getRawBeanDefinition().setBeanClass(beanClass);
    } else {
        String beanClassName = getBeanClassName(element);
        if (beanClassName != null) {
            builder.getRawBeanDefinition().setBeanClassName(beanClassName);
        }
    }
    builder.getRawBeanDefinition().setSource(parserContext.extractSource(element));
    BeanDefinition containingBd = parserContext.getContainingBeanDefinition();
    if (containingBd != null) {
        // Inner bean definition must receive same scope as containing bean.
        builder.setScope(containingBd.getScope());
    }
    // 是否懒加载，默认false
    if (parserContext.isDefaultLazyInit()) {
        // Default-lazy-init applies to custom bean definitions as well.
        builder.setLazyInit(true);
    }
    doParse(element, parserContext, builder);
    return builder.getBeanDefinition();
}

doParse |

这里解析的是
org.springframework.transaction.config.TxAdviceBeanDefinitionParser#doParse

@Override
protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
    builder.addPropertyReference("transactionManager", TxNamespaceHandler.getTransactionManagerName(element));
    // 获取子标签
    List<Element> txAttributes = DomUtils.getChildElementsByTagName(element, ATTRIBUTES_ELEMENT);
    if (txAttributes.size() > 1) {
        // 异常。只能有一个这样的标签
        parserContext.getReaderContext().error(
                "Element <attributes> is allowed at most once inside element <advice>", element);
    } else if (txAttributes.size() == 1) {
        // Using attributes source.
        Element attributeSourceElement = txAttributes.get(0);
        // 解析标签下属性，得到 NameMatchTransactionAttributeSource bean 定义
        RootBeanDefinition attributeSourceDefinition = parseAttributeSource(attributeSourceElement, parserContext);
        builder.addPropertyValue("transactionAttributeSource", attributeSourceDefinition);
    } else {
        // Assume annotations source.
        builder.addPropertyValue("transactionAttributeSource",
                new RootBeanDefinition("org.springframework.transaction.annotation.AnnotationTransactionAttributeSource"));
    }
}

parseAttributeSource |

这里解析的是
org.springframework.transaction.config.TxAdviceBeanDefinitionParser#parseAttributeSource

private RootBeanDefinition parseAttributeSource(Element attrEle, ParserContext parserContext) {
    // 得到所有的 method 标签
    List<Element> methods = DomUtils.getChildElementsByTagName(attrEle, METHOD_ELEMENT);
    ManagedMap<TypedStringValue, RuleBasedTransactionAttribute> transactionAttributeMap =
            new ManagedMap<>(methods.size());
    transactionAttributeMap.setSource(parserContext.extractSource(attrEle));
    //
    for (Element methodEle : methods) {
        // 得到方法的名称
        String name = methodEle.getAttribute(METHOD_NAME_ATTRIBUTE);
        // 名称当做字符串处理
        TypedStringValue nameHolder = new TypedStringValue(name);
        nameHolder.setSource(parserContext.extractSource(methodEle));
        // 事务属性：设置方法的事务传播、隔离机制、超时、是否只读
        RuleBasedTransactionAttribute attribute = new RuleBasedTransactionAttribute();
        String propagation = methodEle.getAttribute(PROPAGATION_ATTRIBUTE);
        String isolation = methodEle.getAttribute(ISOLATION_ATTRIBUTE);
        String timeout = methodEle.getAttribute(TIMEOUT_ATTRIBUTE);
        String readOnly = methodEle.getAttribute(READ_ONLY_ATTRIBUTE);
        if (StringUtils.hasText(propagation)) {
            attribute.setPropagationBehaviorName(RuleBasedTransactionAttribute.PREFIX_PROPAGATION + propagation);
        }
        if (StringUtils.hasText(isolation)) {
            attribute.setIsolationLevelName(RuleBasedTransactionAttribute.PREFIX_ISOLATION + isolation);
        }
        if (StringUtils.hasText(timeout)) {
            try {
                attribute.setTimeout(Integer.parseInt(timeout));
            } catch (NumberFormatException ex) {
                parserContext.getReaderContext().error("Timeout must be an integer value: [" + timeout + "]", methodEle);
            }
        }
        if (StringUtils.hasText(readOnly)) {
            attribute.setReadOnly(Boolean.parseBoolean(methodEle.getAttribute(READ_ONLY_ATTRIBUTE)));
        }
        // 方法回滚的规则
        List<RollbackRuleAttribute> rollbackRules = new ArrayList<>(1);
        if (methodEle.hasAttribute(ROLLBACK_FOR_ATTRIBUTE)) {
            // 如果设置了rollback-for属性
            String rollbackForValue = methodEle.getAttribute(ROLLBACK_FOR_ATTRIBUTE);
            addRollbackRuleAttributesTo(rollbackRules, rollbackForValue);
        }
        if (methodEle.hasAttribute(NO_ROLLBACK_FOR_ATTRIBUTE)) {
            // 设置了no-rollback-for属性
            String noRollbackForValue = methodEle.getAttribute(NO_ROLLBACK_FOR_ATTRIBUTE);
            addNoRollbackRuleAttributesTo(rollbackRules, noRollbackForValue);
        }
        attribute.setRollbackRules(rollbackRules);
        transactionAttributeMap.put(nameHolder, attribute);
    }
    // 新建 NameMatchTransactionAttributeSource bean 定义
    RootBeanDefinition attributeSourceDefinition = new RootBeanDefinition(NameMatchTransactionAttributeSource.class);
    // 设置属性
    attributeSourceDefinition.setSource(parserContext.extractSource(attrEle));
    attributeSourceDefinition.getPropertyValues().add("nameMap", transactionAttributeMap);
    return attributeSourceDefinition;
}

解析结果

最终的结果：
GenericBeanDefinition
beanClass：org.springframework.transaction.interceptor.TransactionInterceptor
Propertyvalues：
transactionManager
transactionAttributesource：
RootBeanDefinition
beanClass：org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource
Propertyvalues：
propertyvalueList：
nameMap：
[add] -> {RuleBasedTransactionAttribute@3649} “PROPAGATION_REQUIRED,ISOLATION_DEFAULT”
[delete] -> {RuleBasedTransactionAttribute@3651} “PROPAGATION_REQUIRED,ISOLATION_DEFAULT”
[update] -> {RuleBasedTransactionAttribute@3653} “PROPAGATION_REQUIRED,ISOLATION_DEFAULT”
[query]-> {RuleBasedTransactionAttribute@3655} “PROPAGATION_REQUIRED,ISOLATION_DEFAULT,readOnly”
可以看出将 tx:advice 标签解析成了 TransactionInterceptor 对象定义，通过属性嵌套了 NameMatchTransactionAttributeSource 对象定义

<tx:advice id="interceptor" transaction-manager="transactionManager">
  <tx:attributes>
    <tx:method name="*add*" propagation="REQUIRED"/>
    <tx:method name="*delete*" propagation="REQUIRED"/>
    <tx:method name="*update*" propagation="REQUIRED"/>
    <tx:method name="*query*" read-only="true"/>
  </tx:attributes>
</tx:advice>

再看下 RootBeanDefinition 、GenericBeanDefinition 父类关系。