上一節(jié)分析了XmlBeanDefinitionReader以及系統(tǒng)環(huán)境的初始化门驾，本小節(jié)分析Spring解析xml的過程中的將Xml文件解析為Document對象登馒。

先來回顧一下Java解析xml的方式。包括DOM解析婴噩、SAX解析XML、JDOM解析XML、DOM4J解析XML等爬虱，每種解析方式各有優(yōu)缺點。Spring使用的是第一種解析方式DOM解析腾它，先通過一個例子來看一下Java是如何將xml文件解析為Document對象的跑筝。這將有助于接下來對Spring源碼的分析。

1. Java DOM解析xml文件

• DOM解析

@Test
public void test14() throws ParserConfigurationException, IOException, SAXException {
    // 解析xml文件
    // 1瞒滴、獲取InputStream輸入流
    InputStream in = new ClassPathResource("v2/day01.xml").getInputStream();
    // 2曲梗、獲取DocumentBuilderFactory實例
    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    // 3、獲取DocumentBuilder實例
    DocumentBuilder docBuilder = factory.newDocumentBuilder();
    // 4、將docBuilder轉(zhuǎn)換為Document
    Document doc = docBuilder.parse(in);
    // 5稀并、獲取節(jié)點并循環(huán)輸出節(jié)點值
    Element element = doc.getDocumentElement();
    NodeList childNodes = element.getChildNodes();
    for (int i = 0; i < childNodes.getLength(); i++) {
        Node node = childNodes.item(i);
        //System.out.println(node.getNodeName());
        NamedNodeMap attributes = node.getAttributes();
        if (null != attributes) {
            System.out.println(attributes.getNamedItem("id"));
            System.out.println(attributes.getNamedItem("class"));
        }
    }
}

• 輸出

========測試方法開始=======

id="dog1"
class="com.lyc.cn.v2.day01.Dog"
id="dog2"
class="com.lyc.cn.v2.day01.Dog"
id="dog3"
class="com.lyc.cn.v2.day01.DogStaticFactory"
id="dogFactory"
class="com.lyc.cn.v2.day01.DogFactory"
id="dog4"
null
id="outer"
class="com.lyc.cn.v2.day01.inner.Outer"
id="father"
class="com.lyc.cn.v2.day01.parent.Father"
id="sun"
class="com.lyc.cn.v2.day01.parent.Sun"
id="cat"
class="com.lyc.cn.v2.day01.collection.Cat"
id="car"
class="com.lyc.cn.v2.day01.method.lookupMethod.Car"
id="taxi"
class="com.lyc.cn.v2.day01.method.lookupMethod.Taxi"
id="dogReplaceMethod"
class="com.lyc.cn.v2.day01.method.replaceMethod.ReplaceDog"
id="originalDogReplaceMethod"
class="com.lyc.cn.v2.day01.method.replaceMethod.OriginalDog"
id="student"
class="com.lyc.cn.v2.day01.factoryBean.StudentFactoryBean"
id="furniture"
class="com.lyc.cn.v2.day01.factoryBean.FurnitureFactoryBean"
id="myLifeCycleBean"
class="com.lyc.cn.v2.day01.lifecycle.LifeCycleBean"
id="myBeanPostProcessor"
class="com.lyc.cn.v2.day01.lifecycle.LifeCycleBeanPostProcessor"
id="dog"
class="com.lyc.cn.v2.day01.Dog"
id="myBeanFactoryPostProcessor"
class="com.lyc.cn.v2.day01.lifecycle.MyBeanFactoryPostProcessor"

========測試方法結(jié)束=======

非常簡單仅颇，不再做過的分析。

2. Spring將xml轉(zhuǎn)換為Document對象分析

打開XmlBeanFactory類

/**
 * 通過指定Resource對象和父BeanFactory創(chuàng)建XmlBeanFactory實例
 * Create a new XmlBeanFactory with the given input stream,
 * which must be parsable using DOM.
 * @param resource          the XML resource to load bean definitions from
 * @param parentBeanFactory parent bean factory
 * @throws BeansException in case of loading or parsing errors
 */
public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
    // 依次向上實例化父類構(gòu)造器
    super(parentBeanFactory);
    // 解析xml配置文件,將其轉(zhuǎn)換為IoC容器的內(nèi)部表示
    this.reader.loadBeanDefinitions(resource);
}

this.reader.loadBeanDefinitions(resource); 該代碼的作用就是解析xml配置文件,將其轉(zhuǎn)換為IoC容器的內(nèi)部表示碘举。我們先分析其第一步操作：解析xml配置文件忘瓦。

跟蹤代碼，依次打開

• 方法入口

/**
 * 加載BeanDefinition
 * Load bean definitions from the specified XML file.
 * @param resource the resource descriptor for the XML file
 * @return the number of bean definitions found
 * @throws BeanDefinitionStoreException in case of loading or parsing errors
 */
@Override
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
    return loadBeanDefinitions(new EncodedResource(resource));
}

• 獲取InputStream對象

/**
 * 加載BeanDefinition
 * Load bean definitions from the specified XML file.
 * @param encodedResource the resource descriptor for the XML file,
 * allowing to specify an encoding to use for parsing the file
 * @return the number of bean definitions found
 * @throws BeanDefinitionStoreException in case of loading or parsing errors
 */
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
    // 1引颈、使用ThreadLocal防止資源文件循環(huán)加載
    Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
    if (currentResources == null) {
        currentResources = new HashSet<>(4);
        this.resourcesCurrentlyBeingLoaded.set(currentResources);
    }
    if (!currentResources.add(encodedResource)) {
        throw new BeanDefinitionStoreException("Detected cyclic loading of " + encodedResource + " - check your import definitions!");
    }
    try {
        // 2耕皮、加載BeanDefinition
        InputStream inputStream = encodedResource.getResource().getInputStream();
        try {
            InputSource inputSource = new InputSource(inputStream);
            if (encodedResource.getEncoding() != null) {
                inputSource.setEncoding(encodedResource.getEncoding());
            }
            return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
        }
        finally {
            inputStream.close();
        }
    }
    catch (IOException ex) {
        throw new BeanDefinitionStoreException("IOException parsing XML document from " + encodedResource.getResource(), ex);
    }
    finally {
        currentResources.remove(encodedResource);
        if (currentResources.isEmpty()) {
            this.resourcesCurrentlyBeingLoaded.remove();
        }
    }
}

• 將xml轉(zhuǎn)換為Document對象并執(zhí)行BeanDefinition注冊

/**
 * 真正開始執(zhí)行BeanDefinition的注冊
 * Actually load bean definitions from the specified XML file.
 * @param inputSource the SAX InputSource to read from
 * @param resource the resource descriptor for the XML file
 * @return the number of bean definitions found
 * @throws BeanDefinitionStoreException in case of loading or parsing errors
 * @see #doLoadDocument
 * @see #registerBeanDefinitions
 */
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException {
    try {
        // 資源文件解析為Document對象
        Document doc = doLoadDocument(inputSource, resource);
        // 注冊BeanDefinitions
        return registerBeanDefinitions(doc, resource);
    }
    catch (BeanDefinitionStoreException ex) {
        throw ex;
    }
    catch (SAXParseException ex) {
        throw new XmlBeanDefinitionStoreException(resource.getDescription(),"Line "
                + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
    }
    catch (SAXException ex) {
        throw new XmlBeanDefinitionStoreException(resource.getDescription(),"XML document from " + resource + " is invalid", ex);
    }
    catch (ParserConfigurationException ex) {
        throw new BeanDefinitionStoreException(resource.getDescription(),"Parser configuration exception parsing XML from " + resource, ex);
    }
    catch (IOException ex) {
        throw new BeanDefinitionStoreException(resource.getDescription(),"IOException parsing XML document from " + resource, ex);
    }
    catch (Throwable ex) {
        throw new BeanDefinitionStoreException(resource.getDescription(),"Unexpected exception parsing XML document from " + resource, ex);
    }
}

通過上面代碼的分析，已經(jīng)接觸到了將xml文件轉(zhuǎn)換為Document的核心Document doc = doLoadDocument(inputSource, resource);蝙场，其實并沒有我們想象中那么神秘凌停，跟我們之前分析的DOM解析是一樣的。但是其中有一些細節(jié)還是值得我們?nèi)シ治龅摹?/p>

• 執(zhí)行轉(zhuǎn)換

@Override
public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
        ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {

    // 1售滤、創(chuàng)建DocumentBuilderFactory對象
    DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
    // 2罚拟、創(chuàng)建DocumentBuilder對象
    DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
    // 3、將inputSource解析為Document對象
    return builder.parse(inputSource);
}

轉(zhuǎn)換過程一共分為了三步完箩，這與DOM解析的流程差不多赐俗，來具體分析一下其中的一些細節(jié)。

1.創(chuàng)建DocumentBuilderFactory對象

protected DocumentBuilderFactory createDocumentBuilderFactory(int validationMode, boolean namespaceAware)
            throws ParserConfigurationException {

    // 1弊知、獲取DocumentBuilderFactory實例
    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    factory.setNamespaceAware(namespaceAware);

    // 2阻逮、如果開啟xml驗證的話，則驗證xml
    if (validationMode != XmlValidationModeDetector.VALIDATION_NONE) {
        factory.setValidating(true);
        // 如果xml驗證模式為XSD則需要強制指定由此代碼生成的解析器將提供對XML名稱空間的支持
        if (validationMode == XmlValidationModeDetector.VALIDATION_XSD) {
            // Enforce namespace aware for XSD...
            factory.setNamespaceAware(true);
            try {
                factory.setAttribute(SCHEMA_LANGUAGE_ATTRIBUTE, XSD_SCHEMA_LANGUAGE);
            }
            catch (IllegalArgumentException ex) {
                ParserConfigurationException pcex = new ParserConfigurationException(
                        "Unable to validate using XSD: Your JAXP provider [" + factory +
                        "] does not support XML Schema. Are you running on Java 1.4 with Apache Crimson? " +
                        "Upgrade to Apache Xerces (or Java 1.5) for full XSD support.");
                pcex.initCause(ex);
                throw pcex;
            }
        }
    }

    return factory;
}

• 2.創(chuàng)建DocumentBuilder對象

protected DocumentBuilder createDocumentBuilder(DocumentBuilderFactory factory,
            @Nullable EntityResolver entityResolver, @Nullable ErrorHandler errorHandler)
            throws ParserConfigurationException {
    // 1秩彤、創(chuàng)建DocumentBuilder對象
    DocumentBuilder docBuilder = factory.newDocumentBuilder();
    // 2叔扼、嘗試設(shè)置entityResolver
    if (entityResolver != null) {
        docBuilder.setEntityResolver(entityResolver);
    }
    // 3、嘗試設(shè)置errorHandler
    if (errorHandler != null) {
        docBuilder.setErrorHandler(errorHandler);
    }
    return docBuilder;
}

這里有一個EntityResolver類漫雷，該類的作用是避免從網(wǎng)絡(luò)上尋找DTD聲明瓜富。至于轉(zhuǎn)換方法本節(jié)不在分析，因為涉及到了jdk的源碼珊拼，且不是我們分析的重點食呻。

總之Spring將Xml文件解析為Document對象的過程就是使用了Java的DOM解析，只不過在解析之上做了一些額外的操作澎现，例如防止文件重復加載仅胞、xml驗證模式、
設(shè)置EntityResolver剑辫、設(shè)置errorHandler等等干旧。