【Spring源码分析系列】加载Bean

 /**
      * Create a new XmlBeanFactory with the given input stream,
      * which must be parsable using DOM.
      * @param resource 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 {
         super(parentBeanFactory);
         this.reader.loadBeanDefinitions(resource);
     }

整个处理过程：

1）封装资源文件

当进入XmlBeanDefinitionReader后首先对参数Resource使用EncodeResource类进行封装

2）获取输入流

从Resource中获取对应的InputSteam并构造InputSource

3）通过构造的InputSource实例和Resource实例继续调用doLoadBeanDefinitions.

loadBeanDefinition的实现：

 /**
      * 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));
     }

new EncodeResource(resource)实现：

 private EncodedResource(Resource resource, String encoding, Charset charset) {
         super();
         Assert.notNull(resource, "Resource must not be null");
         this.resource = resource;
         this.encoding = encoding;
         this.charset = charset;
     }

 /**
      * Open a {@code java.io.Reader} for the specified resource, using the specified
      * {@link #getCharset() Charset} or {@linkplain #getEncoding() encoding}
      * (if any).
      * @throws IOException if opening the Reader failed
      * @see #requiresReader()
      * @see #getInputStream()
      */
     public Reader getReader() throws IOException {
         if (this.charset != null) {
             return new InputStreamReader(this.resource.getInputStream(), this.charset);
         }
         else if (this.encoding != null) {
             return new InputStreamReader(this.resource.getInputStream(), this.encoding);
         }
         else {
             return new InputStreamReader(this.resource.getInputStream());
         }
     }

真正的数据准备阶段：

/**
     * 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 {
        Assert.notNull(encodedResource, "EncodedResource must not be null");
        if (logger.isInfoEnabled()) {
            logger.info("Loading XML bean definitions from " + encodedResource.getResource());
        }
        //通过属性值来记录已经加载的资源
        Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
        if (currentResources == null) {
            currentResources = new HashSet<EncodedResource>(4);
            this.resourcesCurrentlyBeingLoaded.set(currentResources);
        }
        if (!currentResources.add(encodedResource)) {
            throw new BeanDefinitionStoreException(
                    "Detected cyclic loading of " + encodedResource + " - check your import definitions!");
        }
        try {
           //从encodeResource中获取已经封装的Resource对象并再次从Resource中获取其中的inputStream
            InputStream inputStream = encodedResource.getResource().getInputStream();
            try {
                //InputResource这个类不来自与Spring 全类路径是org.xml.sax.InputSource
                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();
            }
        }
    }

首先对传入的resource参数做封装，目的是考虑到Resource可能存在的编码要求的情况，其次，通过SAX读取XML文件的方式来准备InputSource对象，最后将准备的数据通过参数传入真正的核心处理部分doLoadBeanDefinitions(inputSource,encodeResource.getResource()).

 /**
      * 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 {
               //加载XML文件，并得到对应的Document
             Document doc = doLoadDocument(inputSource, resource);
               //根据返回的Document注册Bean信息
             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);
         }
     }

获取XML的验证模式

DTD和XSD区别

DTD即文档类型定义，是一种XML约束模式语言，是XML文件的验证机制，属于XML文件组成的一部分。DTD是一种保证XML文档格式正确的有效方法，可以通过比较XML和DTD文件来看文档是否符合规范，元素和标签使用是否正确。一个DTD文档包含：元素的定义规则，元素间关系的定义规则，元素可使用的属性，可使用的实体或符号规则。

要使用DTD验证模式的时候需要在XML文件的头部声明，以下是在Spring中使用DTD声明方式的代码：

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE beans PUBLIC "-//Spring//DTD BEAN 2.0//EN" "http://www.Springframework.org/dtd/Spring-beans-2.0.dtd">

获取Document

 /**
      * Load the {@link Document} at the supplied {@link InputSource} using the standard JAXP-configured
      * XML parser.
      */
     @Override
     public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
             ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {

         DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
         if (logger.isDebugEnabled()) {
             logger.debug("Using JAXP provider [" + factory.getClass().getName() + "]");
         }
         DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
         return builder.parse(inputSource);
     }

首先创建DocumentBuilderFactory，再通过DocumentBuilderFactory创建DocumentBuilder,进而解析inputSource来返回Document对象。

在上述方法中涉及一个参数EntityResolver何为EntityResolver?如果SAX应用程序需要实现自定义处理外部实体，则必须实现此接口并使用setEntityResolver方法向SAX驱动器注册一个实例，也就是说，对于解析一个XML，SAX首先读取该XML文档的声明，根据声明去寻找相应的DTD定义，以便对文档进行一个严重。默认的寻找规则，即通过网络来下载相应的DTD声明，并进行认证。

EntityResolver的作用是项目本身就可以提供一个如何寻找DTD声明的方法，即由程序来实现寻找DTD声明的过程，比如我们将DTD文件放到项目中某处，在实现时直接将此文档读取并返回给SAX即可。

解析及注册BeanDefinitions

当把文件转换为Document后，接下来的提取及注册Bean就是我们的重头戏，当程序已经拥有XML文档文件的Document实例对象时，就会被引入如下的方法：

 /**
      * Register the bean definitions contained in the given DOM document.
      * Called by {@code loadBeanDefinitions}.
      * <p>Creates a new instance of the parser class and invokes
      * {@code registerBeanDefinitions} on it.
      * @param doc the DOM document
      * @param resource the resource descriptor (for context information)
      * @return the number of bean definitions found
      * @throws BeanDefinitionStoreException in case of parsing errors
      * @see #loadBeanDefinitions
      * @see #setDocumentReaderClass
      * @see BeanDefinitionDocumentReader#registerBeanDefinitions
      */
     public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
        //使用DefaultBeanDefinitionDocumentReader实例化BeanDefinitionDocumentReader
           BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
           //记录统计前BeanDefinition的加载个数
         int countBefore = getRegistry().getBeanDefinitionCount();
           //加载及注册bean
         documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
           //记录本次加载的BeanDefinition个数
         return getRegistry().getBeanDefinitionCount() - countBefore;
     }

 /**
      * Register each bean definition within the given root {@code <beans/>} element.
      */
     protected void doRegisterBeanDefinitions(Element root) {
         // Any nested <beans> elements will cause recursion in this method. In
         // order to propagate and preserve <beans> default-* attributes correctly,
         // keep track of the current (parent) delegate, which may be null. Create
         // the new (child) delegate with a reference to the parent for fallback purposes,
         // then ultimately reset this.delegate back to its original (parent) reference.
         // this behavior emulates a stack of delegates without actually necessitating one.
         BeanDefinitionParserDelegate parent = this.delegate;
         this.delegate = createDelegate(getReaderContext(), root, parent);

         if (this.delegate.isDefaultNamespace(root)) {
               //处理profile属性
             String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
             if (StringUtils.hasText(profileSpec)) {
                 String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
                         profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
                 if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
                     if (logger.isInfoEnabled()) {
                         logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
                                 "] not matching: " + getReaderContext().getResource());
                     }
                     return;
                 }
             }
         }
         //解析前处理，留给子类实现
         preProcessXml(root);
         parseBeanDefinitions(root, this.delegate);
           //解析后处理，留给子类实现
         postProcessXml(root);

         this.delegate = parent;
     }

preProcessXml和postProcessXml两个方法是空的，这是模板方法模式，在面向对象设计方法中常说：一个雷要么面向集成的设计，要么就用final修饰，这两个方法正是为子类设计的，如果继承自DefaultBeanDefinitionDocumentReader的子类需要在Bean解析前后做一些处理的话，那么只需要重写这两个方法就可以了。

解析并注册BeanDefinition:

 /**
      * Parse the elements at the root level in the document:
      * "import", "alias", "bean".
      * @param root the DOM root element of the document
      */
     protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
           //对beans的处理
         if (delegate.isDefaultNamespace(root)) {
             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)) {
                          //对bean的处理
                         parseDefaultElement(ele, delegate);
                     }
                     else {
                          //对bean的处理
                         delegate.parseCustomElement(ele);
                     }
                 }
             }
         }
         else {
             delegate.parseCustomElement(root);
         }
     }

在Spring的XML配置里面有两大类Bean声明，一个是默认的，如：

 <bean id="test" class="com.slp.Test"/>

另一类就是自定义的，如：

 <tx:annotation-driven/>

这两种方式的读取及解析差别是非常大的，如果采用Spring默认的配置，Spring当然知道该如何做，但是如果是自定义的，那么久需要用户实现一些接口及配置了。对于根节点或者子节点如果是默认命名空间的话则采用parseDefaultElement方法进行解析，否则使用delegate.parseCutomElement方法对自定义命名空间进行解析。而判断是否默认命名空间还是自定义命名空间的方法其实是使用node.getNamespaceURI()获取命名空间，并与Spring的命名空间进行对比，如果一致则是默认，否则是自定义。