loadBeanDefinitions方法源码跟踪（三）

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

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

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

4.parseCustomElement

<!-- 事务处理,事务只针对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);

    }

}