上篇Spring xml解析 源碼學(xué)習(xí)已經(jīng)細(xì)說(shuō)了spring是如何解析xml文件的哑舒，現(xiàn)在就來(lái)學(xué)習(xí)下如何把xml的元素轉(zhuǎn)換為beandefinition甚至于我們需要的bean妇拯。

從DefaultBeanDefinitionDocumentReader的parseBeanDefinitions函數(shù)開(kāi)始解析得出具體的bean，重點(diǎn)分析是默認(rèn)的命名空間洗鸵。
從root根節(jié)點(diǎn)出發(fā)越锈，循環(huán)遍歷其下的所有子節(jié)點(diǎn)，針對(duì)每個(gè)子節(jié)點(diǎn)進(jìn)行判斷和處理膘滨。

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
    if (delegate.isDefaultNamespace(root)) {
       // 這里進(jìn)去的是root元素甘凭，一般都會(huì)是默認(rèn)的beans的命名空間
        NodeList nl = root.getChildNodes();
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            if (node instanceof Element) {
                Element ele = (Element) node;
                if (delegate.isDefaultNamespace(ele)) {
                    parseDefaultElement(ele, delegate);
                }
                else {
                    delegate.parseCustomElement(ele);
                }
            }
        }
    }
    else {
       // 存在用戶(hù)完全自定義的配置，使用自定義解析
        delegate.parseCustomElement(root);
    }
}

那么問(wèn)題來(lái)了火邓，delegate.isDefaultNamespace(ele)是如何判斷當(dāng)前元素是否屬于默認(rèn)命名空間的呢丹弱？

public static final String BEANS_NAMESPACE_URI = "http://www.springframework.org/schema/beans";

public boolean isDefaultNamespace(String namespaceUri) {
    return (!StringUtils.hasLength(namespaceUri) || BEANS_NAMESPACE_URI.equals(namespaceUri));
}

public boolean isDefaultNamespace(Node node) {
    return isDefaultNamespace(getNamespaceURI(node));
}   

在xml中以<bean>標(biāo)識(shí)的肯定被系統(tǒng)默認(rèn)為命名空間，如果是類(lèi)似于<context>呢,只能是使用自定義的命名空間去解析了

image.png

如圖圈住的地方铲咨，生成了具體解析的上下文XmlReaderContext躲胳。

XmlBeanDefinitionReader 文件

public XmlReaderContext createReaderContext(Resource resource) {
    return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
            this.sourceExtractor, this, getNamespaceHandlerResolver());
            // 生成具體的XmlReaderContext對(duì)象
}

public NamespaceHandlerResolver getNamespaceHandlerResolver() {
    if (this.namespaceHandlerResolver == null) {
        this.namespaceHandlerResolver = createDefaultNamespaceHandlerResolver();
    }
    return this.namespaceHandlerResolver;
    // 生成了具體的namespace處理器
}

protected NamespaceHandlerResolver createDefaultNamespaceHandlerResolver() {
    return new DefaultNamespaceHandlerResolver(getResourceLoader().getClassLoader());
}

解決了命名空間的問(wèn)題，開(kāi)始具體解析了

public BeanDefinition parseCustomElement(Element ele, 
            BeanDefinition containingBd) {
    String namespaceUri = getNamespaceURI(ele);
    NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
    // 這里的handlerResolver就是上面所說(shuō)的命名空間處理器DefaultNamespaceHandlerResolver
    // 然后選擇出具體的handler解析器去解析
    if (handler == null) {
       // 如果沒(méi)有具體的解析器纤勒，那肯定就有問(wèn)題坯苹，需要報(bào)錯(cuò)了
        error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
        return null;
    }
    return handler.parse(ele, 
           new ParserContext(this.readerContext, this, containingBd));
}

上面說(shuō)的resolve方法的細(xì)節(jié)在DefaultNamespaceHandlerResolver 類(lèi)

public NamespaceHandler resolve(String namespaceUri) {
    Map<String, Object> handlerMappings = getHandlerMappings();
    // 得到最新的命名空間的情況
    Object handlerOrClassName = handlerMappings.get(namespaceUri);
    if (handlerOrClassName == null) {
        return null;
    }
    else if (handlerOrClassName instanceof NamespaceHandler) {
        return (NamespaceHandler) handlerOrClassName;
    }
    else {
       // 初次生成的map都是<String, String>結(jié)構(gòu)的，需要替換value為NamespaceHandler類(lèi)
        String className = (String) handlerOrClassName;
        try {
            Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
            // value指明的類(lèi)實(shí)例化
            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();
            // 這個(gè)init函數(shù)很重要Ｒ√臁４馀取恐仑！后面說(shuō)
            handlerMappings.put(namespaceUri, namespaceHandler);
            return namespaceHandler;
            // 完成了整個(gè)對(duì)需要的命名空間的解析
        }
        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);
        }
    }
}

// 延遲加載獲取具體的命名空間詳情信息，生成一個(gè)map結(jié)構(gòu)是<String, String>
private Map<String, Object> getHandlerMappings() {
    if (this.handlerMappings == null) {
        synchronized (this) {
            if (this.handlerMappings == null) {
                try {
                    Properties mappings =
                            PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
                    if (logger.isDebugEnabled()) {
                        logger.debug("Loaded NamespaceHandler mappings: " + mappings);
                    }
                    Map<String, Object> handlerMappings = new ConcurrentHashMap<String, Object>(mappings.size());
                    CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
                    this.handlerMappings = handlerMappings;
                }
                catch (IOException ex) {
                    throw new IllegalStateException(
                            "Unable to load NamespaceHandler mappings from location [" + this.handlerMappingsLocation + "]", ex);
                }
            }
        }
    }
    return this.handlerMappings;
}

如下圖再芋，可以確認(rèn)初始化獲取的map的鍵值對(duì)具體情況

image.png

這是dubbo的命名空間配置

image.png

ContextNamespaceHandler 文件 初始化init注冊(cè)進(jìn)去的解析器

public class ContextNamespaceHandler extends NamespaceHandlerSupport {

    @Override
    public void init() {
        registerBeanDefinitionParser("property-placeholder", new PropertyPlaceholderBeanDefinitionParser());
        registerBeanDefinitionParser("property-override", new PropertyOverrideBeanDefinitionParser());
        registerBeanDefinitionParser("annotation-config", new AnnotationConfigBeanDefinitionParser());
        registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser());
        registerBeanDefinitionParser("load-time-weaver", new LoadTimeWeaverBeanDefinitionParser());
        registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
        registerBeanDefinitionParser("mbean-export", new MBeanExportBeanDefinitionParser());
        registerBeanDefinitionParser("mbean-server", new MBeanServerBeanDefinitionParser());
    }

}

同理菊霜，也可以看看dubbo的

public class DubboNamespaceHandler extends NamespaceHandlerSupport {

    static {
        Version.checkDuplicate(DubboNamespaceHandler.class);
        // 檢查是否重復(fù)了
    }

    public void init() {
        registerBeanDefinitionParser("application", new DubboBeanDefinitionParser(ApplicationConfig.class, true));
        // 如代碼所示，關(guān)鍵字是application,也就是我們配置的**dubbo:application** 字段
        registerBeanDefinitionParser("module", new DubboBeanDefinitionParser(ModuleConfig.class, true));
        registerBeanDefinitionParser("registry", new DubboBeanDefinitionParser(RegistryConfig.class, true));
        registerBeanDefinitionParser("monitor", new DubboBeanDefinitionParser(MonitorConfig.class, true));
        registerBeanDefinitionParser("provider", new DubboBeanDefinitionParser(ProviderConfig.class, true));
        registerBeanDefinitionParser("consumer", new DubboBeanDefinitionParser(ConsumerConfig.class, true));
        registerBeanDefinitionParser("protocol", new DubboBeanDefinitionParser(ProtocolConfig.class, true));
        registerBeanDefinitionParser("service", new DubboBeanDefinitionParser(ServiceBean.class, true));
        registerBeanDefinitionParser("reference", new DubboBeanDefinitionParser(ReferenceBean.class, false));
        registerBeanDefinitionParser("annotation", new DubboBeanDefinitionParser(AnnotationBean.class, true));
    }
}

到這里我們基本清楚了選擇的合適的命名空間去解析數(shù)據(jù)了济赎，可是上文知道一個(gè)命名空間處理器handler有多個(gè)具體的parse解析器鉴逞，那就肯定得選擇一個(gè)具體的解析器去解析∷狙担可看抽象類(lèi) NamespaceHandlerSupport

NamespaceHandlerSupport 文件

public BeanDefinition parse(Element element, ParserContext parserContext) {
    return findParserForElement(element, parserContext).parse(element, parserContext);
    // 返回一個(gè)解析器之后构捡，進(jìn)行parse(element, parserContext)
}

// 果然不出我們所料（當(dāng)然我也是看了源碼的），確實(shí)存在了findPrase這個(gè)方法
private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
    String localName = parserContext.getDelegate().getLocalName(element);
    
    BeanDefinitionParser parser = this.parsers.get(localName);
    // 通過(guò)元素的名稱(chēng)壳猜，獲取到具體的parse勾徽，例如上面的PropertyPlaceholderBeanDefinitionParser parse解析器
    if (parser == null) {
        parserContext.getReaderContext().fatal(
                "Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
    }
    return parser;
}

可以看看dubbo的解析器具體工作, DubboBeanDefinitionParser 文件

// 解析element元素的具體屬性，返回一個(gè)beandefinition
private static BeanDefinition parse(Element element, ParserContext parserContext,   Class<?> beanClass, boolean required) {
   RootBeanDefinition beanDefinition = new RootBeanDefinition();
   beanDefinition.setBeanClass(beanClass);
   beanDefinition.setLazyInit(false);
   String id = element.getAttribute("id");
   if ((id == null || id.length() == 0) && required) {
    String generatedBeanName = element.getAttribute("name");
    if (generatedBeanName == null || generatedBeanName.length() == 0) {
        if (ProtocolConfig.class.equals(beanClass)) {
            generatedBeanName = "dubbo";
        } else {
            generatedBeanName = element.getAttribute("interface");
        }
   ......

到這里整個(gè)的解析過(guò)程就全部完成了统扳，本篇學(xué)習(xí)了解了生成beandefinition的全過(guò)程喘帚，還有個(gè)問(wèn)題就是spring本身如何持有這些已經(jīng)解析好的beandefinition呢？（PS：是存儲(chǔ)在一個(gè)map容器中）

又得回到我們上面的那幅圖中虛線(xiàn)指出的位置咒钟，在AbstractXmlApplicationContext中就已經(jīng)生成了一個(gè)XmlBeanDefinitionReader對(duì)象了吹由，然后在XmlBeanDefinitionReader中又把自身當(dāng)做一個(gè)參數(shù)傳遞到XmlReaderContext中，而XmlReaderContext又被當(dāng)做一個(gè)參數(shù)傳遞給具體的parse朱嘴。就這樣整個(gè)的鏈路就打通了倾鲫，層層包裝繼承

    public XmlReaderContext createReaderContext(Resource resource) {
        return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
            // 就這個(gè)this！Ｆ兼摇Ｎ谖簟！很關(guān)鍵的一步
                this.sourceExtractor, this, getNamespaceHandlerResolver());
    }

• 在系統(tǒng)默認(rèn)的命名空間獲取的方式

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    // 已經(jīng)生成的beandefinition
    if (bdHolder != null) {
        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
        try {
            // 最關(guān)鍵的一步Ｈ雷贰？牡馈！存儲(chǔ)行冰，getReaderContext() 返回的是XmlReaderContext上下文
            // getRegistry() 獲取其注冊(cè)倉(cāng)庫(kù)捅厂，也就是常說(shuō)的`DefaultListableBeanFactory`
            // 最關(guān)鍵的那個(gè)管理bean的工廠(chǎng)
            BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error("Failed to register bean definition with name '" +
                    bdHolder.getBeanName() + "'", ele, ex);
        }
        // Send registration event.
        getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
    }
}

public static void registerBeanDefinition(
        BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
        throws BeanDefinitionStoreException {
    String beanName = definitionHolder.getBeanName();
    registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
    // 這一步就是一直在找的存儲(chǔ)到容器中的步驟

    // Register aliases for bean name, if any.
    String[] aliases = definitionHolder.getAliases();
    if (aliases != null) {
        for (String alias : aliases) {
            registry.registerAlias(beanName, alias);
            // bean配置存在別名的情況，也一并考慮
        }
    }
}

• 在自定義命名空間獲取的方式

這個(gè)就比較簡(jiǎn)單了资柔，需要對(duì)外提供接口的，持有一個(gè)ParserContext類(lèi)

image.png

就這樣通個(gè)這個(gè)ParserContext類(lèi)把默認(rèn)的BeanDefinitionParserDelegate本身以及xmlreadcontext上下文存儲(chǔ)了撵割，然后傳遞給用戶(hù)自定義的parse進(jìn)行存儲(chǔ)操作贿堰。
當(dāng)然這個(gè)BeanDefinitionParserDelegate是不是用就看用戶(hù)自身了，看了下dubbo是并沒(méi)有使用

所有的過(guò)程都結(jié)束了啡彬，現(xiàn)在spring容器持有beandefinition類(lèi)型的所有bean羹与，還有g(shù)etBean等著我們呢故硅！