loadBeanDefinitions方法源碼跟蹤（三）

時間 2019-11-19

標籤 loadbeandefinitions 方法源碼跟蹤简体版

原文原文鏈接

由於字數超過了限制，因此分紅了三篇，承接上篇：
https://www.jianshu.com/p/46e27afd7d96java

代碼過寬，能夠shift + 鼠標滾輪 左右滑動查看node

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>

非默認名稱空間的標籤，走的是這個方法spring

//4.若是該標籤屬於其餘的名稱空間好比：context,aop等
//xmlns:aop="http://www.springframework.org/schema/aop"
//xmlns:context="http://www.springframework.org/schema/context"
delegate.parseCustomElement(ele);

進入這個方法，在BeanDefinitionParserDelegate類中express

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是名稱空間處理器解析器的默認實現app

跟蹤標記4.1的方法ide

//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的方法oop

進入處理器的抽象父類NamespaceHandlerSupport中ui

入參傳遞了一個ParserContext解析器上下文，ParserContext中拿到了閱讀器上下文的引用，代理的引用，containingBd在這裏爲nullthis

//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的方法spa

此方法在類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);
    }
}