loadBeanDefinitions方法源码跟踪（三）

阅读原文时间：2021年04月20日阅读：1

因为字数超过了限制，所以分成了三篇，承接上篇：

https://www.jianshu.com/p/46e27afd7d96

代码过宽，可以shift + 鼠标滚轮 左右滑动查看

<!-- 事务处理,事务只针对service层 -->
<aop:config>
    <aop:pointcut id="pc" expression="execution(public * cn.mrdear.service.impl..*(..))" />
    <aop:advisor pointcut-ref="pc" advice-ref="txAdvice" />
</aop:config>

非默认名称空间的标签，走的是这个方法

//4.如果该标签属于其他的名称空间比如：context,aop等
//xmlns:aop="http://www.springframework.org/schema/aop"
//xmlns:context="http://www.springframework.org/schema/context"
delegate.parseCustomElement(ele);

进入这个方法，在BeanDefinitionParserDelegate类中

public BeanDefinition parseCustomElement(Element ele) {
    return parseCustomElement(ele, null);
}

public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {

    //拿到标签对应的名称空间URI
    //比如：http://www.springframework.org/schema/aop
    String namespaceUri = getNamespaceURI(ele);

    //4.1拿到名称空间处理器解析器，去解析URI，获取名称空间处理器
    NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
    if (handler == null) {
        error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
        return null;
    }

    //4.2通过处理器的某个解析器解析对应标签
    return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}

4.1 resolve

DefaultNamespaceHandlerResolver是名称空间处理器解析器的默认实现

跟踪标记4.1的方法

//4.1拿到名称空间处理器解析器，去解析URI，获取名称空间处理器
NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);

/**
* Locate the {@link NamespaceHandler} for the supplied namespace URI
* from the configured mappings.
*
* 根据提供的 namespace URI 从配置映射中找到 NamespaceHandler
*/
@Override
public NamespaceHandler resolve(String namespaceUri) {

    //拿到处理器解析器中所有的处理器
    Map<String, Object> handlerMappings = getHandlerMappings();

    //拿到指定的处理器
    Object handlerOrClassName = handlerMappings.get(namespaceUri);

    //如果为null就返回null
    if (handlerOrClassName == null) {
        return null;
    }

    //如果是实例就返回实例
    else if (handlerOrClassName instanceof NamespaceHandler) {
        return (NamespaceHandler) handlerOrClassName;
    }

    //否则就一定是字符串
    else {
        String className = (String) handlerOrClassName;
        try {

            //通过加载器生成处理器的Class对象
            Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);

            //必须要实现NamespaceHandler接口
            if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
                throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +
                                             "] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
            }

            //实例化一个
            NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);

            //初始化，进入这个方法，里面初始化多个解析器
            namespaceHandler.init();

            //用实例覆盖原先handlerMappings中的字符串
            handlerMappings.put(namespaceUri, namespaceHandler);
            return namespaceHandler;
        }
        catch (ClassNotFoundException ex) {
            throw new FatalBeanException("NamespaceHandler class [" + className + "] for namespace [" +
                                         namespaceUri + "] not found", ex);
        }
        catch (LinkageError err) {
            throw new FatalBeanException("Invalid NamespaceHandler class [" + className + "] for namespace [" +
                                         namespaceUri + "]: problem with handler class file or dependent class", err);
        }
    }
}

/**
* 这个方法在类AopNamespaceHandler中
*
* Register the {@link BeanDefinitionParser BeanDefinitionParsers} for the
* '{@code config}', '{@code spring-configured}', '{@code aspectj-autoproxy}'
* and '{@code scoped-proxy}' tags.
*
* 为config、spring-configured、aspectj-autoproxy以及scoped-proxy标签注册BeanDefinitionParsers
*/
@Override
public void init() {

    //这里面每一个解析器都对应着AOP名称空间下的一个标签
    //不同的处理器注册的解析器都不一样
    //这里随便找一个解析器，查看他的注册流程

    // In 2.0 XSD as well as in 2.1 XSD.
    registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
    registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
    registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());

    // Only in 2.0 XSD: moved to context namespace as of 2.1
    registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
}

/**
* 此方法在类AopNamespaceHandler的父类NamespaceHandlerSupport中
*
* Subclasses can call this to register the supplied {@link BeanDefinitionParser} to
* handle the specified element. The element name is the local (non-namespace qualified)
* name.
*
* 子类可以调用这个方法注册指定的BeanDefinitionParser去处理相关的标签
* 这个elementName是个局部名称（不包含名称空间）
*/
protected final void registerBeanDefinitionParser(String elementName, BeanDefinitionParser parser) {

    //将解析器注册到这个名称空间处理器的parsers属性中，
    //parsers是一个HashMap
    this.parsers.put(elementName, parser);
}

4.2 parse

跟踪标记4.2的方法

进入处理器的抽象父类NamespaceHandlerSupport中

入参传递了一个ParserContext解析器上下文，ParserContext中拿到了阅读器上下文的引用，代理的引用，containingBd在这里为null

//4.2通过处理器的某个解析器解析对应标签
return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));

/**
* Parses the supplied {@link Element} by delegating to the {@link BeanDefinitionParser} that is
* registered for that {@link Element}.
*
* 通过委派给根据对应标签所注册的解析器，来解析提供的标签
*/
@Override
public BeanDefinition parse(Element element, ParserContext parserContext) {

    //将标签名称作为key，去处理器内部的parsers属性中，获取对应的value值，也就是解析器
    //利用解析器来解析这个标签，进入这个方法。
    return findParserForElement(element, parserContext).parse(element, parserContext);
}

/**
* 因为解析是的<aop:config>，所以该方法在ConfigBeanDefinitionParser类中
*
* Parse the specified {@link Element} and register the resulting
* {@link BeanDefinition BeanDefinition(s)} with the
* {@link org.springframework.beans.factory.xml.ParserContext#getRegistry() BeanDefinitionRegistry}
* embedded in the supplied {@link ParserContext}.
* <p>Implementations must return the primary {@link BeanDefinition} that results
* from the parse if they will ever be used in a nested fashion (for example as
* an inner tag in a {@code <property/>} tag). Implementations may return
* {@code null} if they will <strong>not</strong> be used in a nested fashion.
*
* 解析指定的标签，并注册最终的结果bean Definition到内嵌在ParserContext中的bean工厂中
*/
@Override
public BeanDefinition parse(Element element, ParserContext parserContext) {

    //一个组件集合，里面包含了多个组件，以标签名（包含了名称空间）作为名称，比如aop:config
    //里面包含的多个组件就是aop:config的子标签，包含对标签属性的描述
    //比如xml中pointcut子标签就是一个组件，advisor子标签也是一个组件
    //这个组件记录了子标签的name属性或者expression属性，根据不同子标签，属性不一样
    CompositeComponentDefinition compositeDef =
        new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element));

    //将组件集合保存在parserContext解析器上下文的containingComponents属性中
    parserContext.pushContainingComponent(compositeDef);

    //4.2.1配置自动代理创建器
    configureAutoProxyCreator(parserContext, element);

    //配置完创建器后拿到所有子标签
    List<Element> childElts = DomUtils.getChildElements(element);

    for (Element elt: childElts) {

        //拿到所有子标签localName，也就是不包括名称空间的标签名字
        String localName = parserContext.getDelegate().getLocalName(elt);

        //如果子标签是pointcut
        if (POINTCUT.equals(localName)) {

            //4.2.2解析pointcut子标签
            parsePointcut(elt, parserContext);
        }

        //如果子标签是advisor
        else if (ADVISOR.equals(localName)) {

            //4.2.3解析advisor子标签
            parseAdvisor(elt, parserContext);
        }

         //如果子标签是aspect
        else if (ASPECT.equals(localName)) {

            //4.2.4解析aspect子标签
            parseAspect(elt, parserContext);
        }
    }

    //4.2.5弹出组件
    parserContext.popAndRegisterContainingComponent();
    return null;
}

4.2.1 configureAutoProxyCreator

跟踪标记4.2.1的方法

此方法在类ConfigBeanDefinitionParser中实现

//4.2.1配置自动代理创建器
configureAutoProxyCreator(parserContext, element);

/**
* Configures the auto proxy creator needed to support the {@link BeanDefinition BeanDefinitions}
* created by the '{@code <aop:config/>}' tag. Will force class proxying if the
* '{@code proxy-target-class}' attribute is set to '{@code true}'.
*
* 配置自动代理创建器，支持由<aop:config/>标签创建的beanDefinition
* 如果标签的proxy-target-class属性被设置为true，那么强制代理
*/
private void configureAutoProxyCreator(ParserContext parserContext, Element element) {
    AopNamespaceUtils.registerAspectJAutoProxyCreatorIfNecessary(parserContext, element);
}

/**
* 进入AopNamespaceUtils类中的静态方法
*/
public static void registerAspectJAutoProxyCreatorIfNecessary(
    ParserContext parserContext, Element sourceElement) {

   //4.2.1.1如果必要的话注册AspectJ自动代理创建器
    BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAutoProxyCreatorIfNecessary(
        parserContext.getRegistry(), parserContext.extractSource(sourceElement));

    //4.2.1.2如果必要的话使用CLass代理
    useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);

    //4.2.1.3如果必要的话注册组件
    registerComponentIfNecessary(beanDefinition, parserContext);
}

4.2.1.1 registerAspectJAutoProxyCreatorIfNecessary

先跟踪标记4.2.1.1的方法

该方法在AopConfigUtils类中实现

//4.2.1.1如果必要的话注册AspectJ自动代理创建器
BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAutoProxyCreatorIfNecessary(
    parserContext.getRegistry(), parserContext.extractSource(sourceElement));

public static BeanDefinition registerAspectJAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {

    //传递了一个AspectJAwareAdvisorAutoProxyCreator的Class，进入这个方法
    return registerOrEscalateApcAsRequired(AspectJAwareAdvisorAutoProxyCreator.class, registry, source);
}

private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, Object source) {
    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");

    //工厂中是否已经注册了org.springframework.aop.config.internalAutoProxyCreator
    if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
        BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);

        //如果已经有注册了internalAutoProxyCreator，并且和入参传递的不是同一个Class，
        //那么就根据优先级进行选择
        if (!cls.getName().equals(apcDefinition.getBeanClassName())) {

            //类AopConfigUtils中有个ArrayList属性APC_PRIORITY_LIST，在类静态构造中依次加入了
            //几个创建器，这个方法就是查找某个创建器在APC_PRIORITY_LIST中的索引，如果没有找到就报错
            int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
            int requiredPriority = findPriorityForClass(cls);

            //internalAutoProxyCreator的索引为0，入参的AspectJAwareAdvisorAutoProxyCreator
            //索引为1，后者要大，所以重新设置下apcDefinition的beanClass
            if (currentPriority < requiredPriority) {
                apcDefinition.setBeanClassName(cls.getName());
            }
        }

        //直接返回null
        return null;
    }
    RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
    beanDefinition.setSource(source);
    beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
    beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
    return beanDefinition;
}

4.2.1.2 useClassProxyingIfNecessary

跟踪标记4.2.1.2

此方法的实现在AopNamespaceUtils类中

//4.2.1.2如果必要的话使用CLass代理
useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);

private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry, Element sourceElement) {
    if (sourceElement != null) {

        //查看是否有设置proxy-target-class属性
        boolean proxyTargetClass = Boolean.valueOf(sourceElement.getAttribute(PROXY_TARGET_CLASS_ATTRIBUTE));
        if (proxyTargetClass) {
            AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
        }

        //查看是否有设置expose-proxy属性
        boolean exposeProxy = Boolean.valueOf(sourceElement.getAttribute(EXPOSE_PROXY_ATTRIBUTE));
        if (exposeProxy) {
            AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
        }
    }
}

4.2.1.3 registerComponentIfNecessary

跟踪标记4.2.1.3

此方法的实现在AopNamespaceUtils类中

//4.2.1.3如果必要的话注册组件
registerComponentIfNecessary(beanDefinition, parserContext);

private static void registerComponentIfNecessary(BeanDefinition beanDefinition, ParserContext parserContext) {

    //因为前面创建器中的beanClass用了新的那个，所以返回的beanDefinition为null，
    //这里的beanDefinition也就为null了，跳过
    if (beanDefinition != null) {
        BeanComponentDefinition componentDefinition =
            new BeanComponentDefinition(beanDefinition, AopConfigUtils.AUTO_PROXY_CREATOR_BEAN_NAME);
        parserContext.registerComponent(componentDefinition);
    }
}