源码学习之IOC容器初始化三部曲(二)

接上篇BeanDefinition的资源定位，这篇主要介绍BeanDefinition的载入。

BeanDefinition的载入

BeanDefinition的载入过程就是将用户定义的Bean对象解析转换为BeanDifinition对象。

载入过程

           接上文介绍到的Resource定位部分：

AbstractBeanDefinitionReader#loadBeanDefinitions(String location,Set<Resource>)

/**
 * Load bean definitions from the specified resource location.
 * <p>The location can also be a location pattern, provided that the
 * ResourceLoader of this bean definition reader is a ResourcePatternResolver.
 * @param location the resource location, to be loaded with the ResourceLoader
 * (or ResourcePatternResolver) of this bean definition reader
 * @param actualResources a Set to be filled with the actual Resource objects
 * that have been resolved during the loading process. May be {@code null}
 * to indicate that the caller is not interested in those Resource objects.
 * @return the number of bean definitions found
 * @throws BeanDefinitionStoreException in case of loading or parsing errors
 * @see #getResourceLoader()
 * @see #loadBeanDefinitions(org.springframework.core.io.Resource)
 * @see #loadBeanDefinitions(org.springframework.core.io.Resource[])
 */
public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
   ResourceLoader resourceLoader = getResourceLoader();
   if (resourceLoader == null) {
      throw new BeanDefinitionStoreException(
            "Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
   }

   if (resourceLoader instanceof ResourcePatternResolver) {
      // Resource pattern matching available.
      try {
         Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
         int loadCount = loadBeanDefinitions(resources);
         if (actualResources != null) {
            for (Resource resource : resources) {
               actualResources.add(resource);
            }
         }
         if (logger.isDebugEnabled()) {
            logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
         }
         return loadCount;
      }
      catch (IOException ex) {
         throw new BeanDefinitionStoreException(
               "Could not resolve bean definition resource pattern [" + location + "]", ex);
      }
   }
   else {
      // Can only load single resources by absolute URL.
      Resource resource = resourceLoader.getResource(location);
      int loadCount = loadBeanDefinitions(resource);
      if (actualResources != null) {
         actualResources.add(resource);
      }
      if (logger.isDebugEnabled()) {
         logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
      }
      return loadCount;
   }
}

         Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);

         int loadCount = loadBeanDefinitions(resources);

其中绿色部分是我们Resource定位的入口;

红色部分就是我们将要分析的BeanDefinition的载入的入口：

我们这里使用的容器还是之前用到的FileSystemXmlApplicationContext,真正执行loadBeanDefinitions的地方是XmlBeanDefinitionReader中:

XmlBeanDefinitionReader#loadBeanDefinitions(EncodedResource)

/**
 * 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 {
	//省略部分无关代码
   try {
      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();
      }
   }
}

上面就是XmlBeanDefinitionReader中的代码，我省去了部分功能，主要关注本次的主线：载入过程:

XmlBeanDefinitionReader#doLoadBeanDefinitions(InputSource,Resource)

/**
 * 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 doc = doLoadDocument(inputSource, resource);
      return registerBeanDefinitions(doc, resource);
   }
}

可以看到在真正执行load工作的方法中，spring通过doLoadocument将Resource对象转化为Document对象,我们看下这个转化的过程是怎么实现的：

private DocumentLoader documentLoader = new DefaultDocumentLoader();

/**
 * Actually load the specified document using the configured DocumentLoader.
 * @param inputSource the SAX InputSource to read from
 * @param resource the resource descriptor for the XML file
 * @return the DOM Document
 * @throws Exception when thrown from the DocumentLoader
 * @see #setDocumentLoader
 * @see DocumentLoader#loadDocument
 */
protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
   return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
         getValidationModeForResource(resource), isNamespaceAware());
}

这里通过DocumentLoader对象实现载入功能：

DefaultDocumentLoader#loadDocument

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

在DefaultDocumentLoader中通过DocumentBuilder对象完成解析工作，具体的解析过程就不深入分析，与这部分的主线内容无关。

  此时我们的Resource对象已经被处理成了Document对象，接下来我们还会对document再进行解析：

           DefaultBeanDefinitionDocumentReader#doRegisterBeanDefinitions

/**
 * Register each bean definition within the given root {@code <beans/>} element.
 */
protected void doRegisterBeanDefinitions(Element root) {
   BeanDefinitionParserDelegate parent = this.delegate;
   this.delegate = createDelegate(getReaderContext(), root, parent);

   if (this.delegate.isDefaultNamespace(root)) {
      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)) {
            return;
         }
      }
   }

   preProcessXml(root);
   parseBeanDefinitions(root, this.delegate);
   postProcessXml(root);

   this.delegate = parent;
}

虽然这个方法的名称是叫注册BeanDefinitions,但其实里面处理了两部分内容：解析成BeanDefinition对象 和 BeanDefinition的注册。

           还有一个需要注意，这里的preProcessXml(root) 和 postProcessXml(root)是两个hook方法，当子类需要时才会实现具体内容。

           DefaultBeanDefinitionDocumentReader#parseBeanDefinitions(Element,BeanDefinitionParserDelegate):

/**
 * 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) {
   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)) {
               parseDefaultElement(ele, delegate);
            }
            else {
               delegate.parseCustomElement(ele);
            }
         }
      }
   }
   else {
      delegate.parseCustomElement(root);
   }
}

可以看到这边的解析有两个分支，一个分支会处理默认的标签，在这里具体的来说就是指：import，Bean，Beans和alias这四个标签，其他的标签都是作为自定义元素来处理。

           我们这里看一下最常见的<bean>标签的处理：

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
   if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
      importBeanDefinitionResource(ele);
   }
   else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
      processAliasRegistration(ele);
   }
   else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
      processBeanDefinition(ele, delegate);
   }
   else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
      // recurse
      doRegisterBeanDefinitions(ele);
   }
}

 

 下面红色部分就是解析为BeanDefinition的地方，这里的解析是通过BeanDefinitionParserDelegate来实现的：

/**
 * Process the given bean element, parsing the bean definition
 * and registering it with the registry.
 */
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
   BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
   if (bdHolder != null) {
      bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
      try {
         // Register the final decorated instance.
         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));
   }
}

 

           BeanDefinitionParserDelegate#parseBeanDefinitionElement:

/**
 * Parses the supplied {@code <bean>} element. May return {@code null}
 * if there were errors during parse. Errors are reported to the
 * {@link org.springframework.beans.factory.parsing.ProblemReporter}.
 */
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
   String id = ele.getAttribute(ID_ATTRIBUTE);
   String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

   List<String> aliases = new ArrayList<String>();
   if (StringUtils.hasLength(nameAttr)) {
      String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
      aliases.addAll(Arrays.asList(nameArr));
   }

   String beanName = id;
   if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
      beanName = aliases.remove(0);
   }

   if (containingBean == null) {
      checkNameUniqueness(beanName, aliases, ele);
   }

   AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
   if (beanDefinition != null) {
      if (!StringUtils.hasText(beanName)) {
         try {
            if (containingBean != null) {
               beanName = BeanDefinitionReaderUtils.generateBeanName(
                     beanDefinition, this.readerContext.getRegistry(), true);
            }
            else {
               beanName = this.readerContext.generateBeanName(beanDefinition);
               // Register an alias for the plain bean class name, if still possible,
               // if the generator returned the class name plus a suffix.
               // This is expected for Spring 1.2/2.0 backwards compatibility.
               String beanClassName = beanDefinition.getBeanClassName();
               if (beanClassName != null &&
                     beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
                     !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
                  aliases.add(beanClassName);
               }
            }
               }
      }
      String[] aliasesArray = StringUtils.toStringArray(aliases);
      return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
   }

   return null;
}

这里对bean的id，name基础属性进行处理,针对里面的其他配置项则调用parseBeanDefinitionElement()进行处理：

 

下面对bean的配置项进行解析：

parseBeanDefinitionElement:

/**

 * Parse the bean definition itself, without regard to name or aliases. May return

 * {@code null} if problems occurred during the parsing of the bean definition.

 */

public AbstractBeanDefinition parseBeanDefinitionElement(

      Element ele, String beanName, BeanDefinition containingBean) {



   this.parseState.push(new BeanEntry(beanName));



   String className = null;

   if (ele.hasAttribute(CLASS_ATTRIBUTE)) {

      className = ele.getAttribute(CLASS_ATTRIBUTE).trim();

   }



   try {

      String parent = null;

      if (ele.hasAttribute(PARENT_ATTRIBUTE)) {

         parent = ele.getAttribute(PARENT_ATTRIBUTE);

      }

      AbstractBeanDefinition bd = createBeanDefinition(className, parent);



      parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);

      bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));



      parseMetaElements(ele, bd);

      parseLookupOverrideSubElements(ele, bd.getMethodOverrides());

      parseReplacedMethodSubElements(ele, bd.getMethodOverrides());



      parseConstructorArgElements(ele, bd);

      parsePropertyElements(ele, bd);

      parseQualifierElements(ele, bd);



      bd.setResource(this.readerContext.getResource());

      bd.setSource(extractSource(ele));



      return bd;

   }

   finally {

      this.parseState.pop();

   }



   return null;

}

这里对bean定义中各个配置项进行处理，可以理解为对beanDefinition对象的一个初始化过程。

           至此，我们就已经将我们的Resource对象转换成了BeanDefinition对象，后面就是对beanDefinition对象进行最后的注册工作。

 

总结

           BeanDefinition的载入过程就是对IOC容器中的数据的一个准备过程，将Resource对象，也即是用户配置的bean对象，转换为我们所需要的BeanDefinition对象。

          

 

注：

Document:整个XML文档代表的对象

Element:文档的节点

NodeList:文档中的有序列表

Node:文档的某个节点