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

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

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
    if (delegate.isDefaultNamespace(root)) {
       // 這里進去的是root元素，一般都會是默認(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 {
       // 存在用戶完全自定義的配置，使用自定義解析
        delegate.parseCustomElement(root);
    }
}

那么問題來了，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)識的肯定被系統(tǒng)默認(rèn)為命名空間，如果是類似于<context>呢,只能是使用自定義的命名空間去解析了

image.png

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

XmlBeanDefinitionReader 文件

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

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

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

解決了命名空間的問題，開始具體解析了

public BeanDefinition parseCustomElement(Element ele, 
            BeanDefinition containingBd) {
    String namespaceUri = getNamespaceURI(ele);
    NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
    // 這里的handlerResolver就是上面所說的命名空間處理器DefaultNamespaceHandlerResolver
    // 然后選擇出具體的handler解析器去解析
    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));
}

上面說的resolve方法的細節(jié)在DefaultNamespaceHandlerResolver 類

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類
        String className = (String) handlerOrClassName;
        try {
            Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
            // value指明的類實例化
            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();
            // 這個init函數(shù)很重要！！！后面說
            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);
        }
    }
}

// 延遲加載獲取具體的命名空間詳情信息，生成一個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的鍵值對具體情況

image.png

這是dubbo的命名空間配置

image.png

ContextNamespaceHandler 文件 初始化init注冊進去的解析器

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ù)了，可是上文知道一個命名空間處理器handler有多個具體的parse解析器，那就肯定得選擇一個具體的解析器去解析。可看抽象類 NamespaceHandlerSupport

NamespaceHandlerSupport 文件

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

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

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

// 解析element元素的具體屬性，返回一個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");
        }
   ......

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

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

    public XmlReaderContext createReaderContext(Resource resource) {
        return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
            // 就這個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)鍵的一步！！！存儲，getReaderContext() 返回的是XmlReaderContext上下文
            // getRegistry() 獲取其注冊倉庫，也就是常說的`DefaultListableBeanFactory`
            // 最關(guān)鍵的那個管理bean的工廠
            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());
    // 這一步就是一直在找的存儲到容器中的步驟

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

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

這個就比較簡單了，需要對外提供接口的，持有一個ParserContext類

image.png

就這樣通個這個ParserContext類把默認(rèn)的BeanDefinitionParserDelegate本身以及xmlreadcontext上下文存儲了，然后傳遞給用戶自定義的parse進行存儲操作。
當(dāng)然這個BeanDefinitionParserDelegate是不是用就看用戶自身了，看了下dubbo是并沒有使用

所有的過程都結(jié)束了，現(xiàn)在spring容器持有beandefinition類型的所有bean，還有g(shù)etBean等著我們呢！