Spring DefaultBeanDefinitionDocumentReader

public class DefaultBeanDefinitionDocumentReader  implements BeanDefinitionDocumentReader {

   /**
    * bean 元素标签
    */
   public static final String BEAN_ELEMENT = BeanDefinitionParserDelegate.BEAN_ELEMENT;


   public static final String NESTED_BEANS_ELEMENT = "beans";


   public static final String ALIAS_ELEMENT = "alias";


   public static final String NAME_ATTRIBUTE = "name";


   public static final String ALIAS_ATTRIBUTE = "alias";


   public static final String IMPORT_ELEMENT = "import";


   public static final String RESOURCE_ATTRIBUTE = "resource";


   public static final String PROFILE_ATTRIBUTE = "profile";

	protected final Log logger = LogFactory.getLog(getClass());

	/**
	 * xml读取器的上下文
	 */
	@Nullable
	private XmlReaderContext readerContext;

	/**
	 * bean 定义解析委托对象
	 */
	@Nullable
	private BeanDefinitionParserDelegate delegate;

}

@SuppressWarnings("deprecation")  // for Environment.acceptsProfiles(String...)
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 一开始为null
   BeanDefinitionParserDelegate parent = this.delegate;
   // 创建 BeanDefinitionParserDelegate
   this.delegate = createDelegate(getReaderContext(), root, parent);

   // 判断命名空间是否为默认的命名空间
   // 默认命名空间: http://www.springframework.org/schema/beans
   if (this.delegate.isDefaultNamespace(root)) {
      // 获取 profile 属性
      String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
      // 是否存在 profile
      if (StringUtils.hasText(profileSpec)) {
         // profile 切分后的数据
         String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
               profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
         // We cannot use Profiles.of(...) since profile expressions are not supported
         // in XML config. See SPR-12458 for details.
         if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
            if (logger.isDebugEnabled()) {
               logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec +
                     "] not matching: " + getReaderContext().getResource());
            }
            return;
         }
      }
   }

   // 前置处理
   preProcessXml(root);
   // bean definition 处理
   parseBeanDefinitions(root, this.delegate);
   // 后置 xml 处理
   postProcessXml(root);

   this.delegate = parent;
}

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

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
   // 解析 import 标签
   if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
      importBeanDefinitionResource(ele);
   }
   // 解析 alias 标签
   else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
      processAliasRegistration(ele);
   }
   // 解析 bean 标签
   else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
      processBeanDefinition(ele, delegate);
   }
   // 解析 beans 标签
   // 嵌套的 beans
   else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
      // recurse
      doRegisterBeanDefinitions(ele);
   }
}

// 获取 resource 属性
String location = ele.getAttribute(RESOURCE_ATTRIBUTE);
// 是否存在地址
if (!StringUtils.hasText(location)) {
   getReaderContext().error("Resource location must not be empty", ele);
   return;
}

// Resolve system properties: e.g. "${user.dir}"
// 处理配置文件占位符
location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);

// 资源集合
Set<Resource> actualResources = new LinkedHashSet<>(4);

// Discover whether the location is an absolute or relative URI
// 是不是绝对地址
boolean absoluteLocation = false;
try {
   // 1. 判断是否为 url
   // 2. 通过转换成URI判断是否是绝对地址
   absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();
}
catch (URISyntaxException ex) {
   // cannot convert to an URI, considering the location relative
   // unless it is the well-known Spring prefix "classpath*:"
}

// 第二部分
// Absolute or relative?
// 是不是绝对地址
if (absoluteLocation) {
   try {
      // 获取 import 的数量(bean定义的数量)
      int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);
      if (logger.isTraceEnabled()) {
         logger.trace("Imported " + importCount + " bean definitions from URL location [" + location + "]");
      }
   }
   catch (BeanDefinitionStoreException ex) {
      getReaderContext().error(
            "Failed to import bean definitions from URL location [" + location + "]", ele, ex);
   }
}

else {
   // No URL -> considering resource location as relative to the current file.
   try {
      // import 的数量
      int importCount;
      // 资源信息
      Resource relativeResource = getReaderContext().getResource().createRelative(location);
      // 资源是否存在
      if (relativeResource.exists()) {
         // 确定加载的bean定义数量
         importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);
         // 加入资源集合
         actualResources.add(relativeResource);
      }
      // 资源不存在处理方案
      else {
         // 获取资源URL的数据
         String baseLocation = getReaderContext().getResource().getURL().toString();
         // 获取import数量
         importCount = getReaderContext().getReader().loadBeanDefinitions(
               StringUtils.applyRelativePath(baseLocation, location), actualResources);
      }
      if (logger.isTraceEnabled()) {
         logger.trace("Imported " + importCount + " bean definitions from relative location [" + location + "]");
      }
   }
   catch (IOException ex) {
      getReaderContext().error("Failed to resolve current resource location", ele, ex);
   }
   catch (BeanDefinitionStoreException ex) {
      getReaderContext().error(
            "Failed to import bean definitions from relative location [" + location + "]", ele, ex);
   }
}

// 第四部分
Resource[] actResArray = actualResources.toArray(new Resource[0]);
// 唤醒 import 处理事件
getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));

/**
 * Parse an "import" element and load the bean definitions
 * from the given resource into the bean factory.
 *
 * 解析 import 标签
 */
protected void importBeanDefinitionResource(Element ele) {
   // 第一部分
   // 获取 resource 属性
   String location = ele.getAttribute(RESOURCE_ATTRIBUTE);
   // 是否存在地址
   if (!StringUtils.hasText(location)) {
      getReaderContext().error("Resource location must not be empty", ele);
      return;
   }

   // Resolve system properties: e.g. "${user.dir}"
   // 处理配置文件占位符
   location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);

   // 资源集合
   Set<Resource> actualResources = new LinkedHashSet<>(4);

   // Discover whether the location is an absolute or relative URI
   // 是不是绝对地址
   boolean absoluteLocation = false;
   try {
      // 1. 判断是否为 url
      // 2. 通过转换成URI判断是否是绝对地址
      absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();
   }
   catch (URISyntaxException ex) {
      // cannot convert to an URI, considering the location relative
      // unless it is the well-known Spring prefix "classpath*:"
   }

   // 第二部分
   // Absolute or relative?
   // 是不是绝对地址
   if (absoluteLocation) {
      try {
         // 获取 import 的数量(bean定义的数量)
         int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);
         if (logger.isTraceEnabled()) {
            logger.trace("Imported " + importCount + " bean definitions from URL location [" + location + "]");
         }
      }
      catch (BeanDefinitionStoreException ex) {
         getReaderContext().error(
               "Failed to import bean definitions from URL location [" + location + "]", ele, ex);
      }
   }
   // 第三部分
   else {
      // No URL -> considering resource location as relative to the current file.
      try {
         // import 的数量
         int importCount;
         // 资源信息
         Resource relativeResource = getReaderContext().getResource().createRelative(location);
         // 资源是否存在
         if (relativeResource.exists()) {
            // 确定加载的bean定义数量
            importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);
            // 加入资源集合
            actualResources.add(relativeResource);
         }
         // 资源不存在处理方案
         else {
            // 获取资源URL的数据
            String baseLocation = getReaderContext().getResource().getURL().toString();
            // 获取import数量
            importCount = getReaderContext().getReader().loadBeanDefinitions(
                  StringUtils.applyRelativePath(baseLocation, location), actualResources);
         }
         if (logger.isTraceEnabled()) {
            logger.trace("Imported " + importCount + " bean definitions from relative location [" + location + "]");
         }
      }
      catch (IOException ex) {
         getReaderContext().error("Failed to resolve current resource location", ele, ex);
      }
      catch (BeanDefinitionStoreException ex) {
         getReaderContext().error(
               "Failed to import bean definitions from relative location [" + location + "]", ele, ex);
      }
   }
   // 第四部分
   Resource[] actResArray = actualResources.toArray(new Resource[0]);
   // 唤醒 import 处理事件
   getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
}

/**
 * Process the given alias element, registering the alias with the registry.
 * 解析 alias 标签
 */
protected void processAliasRegistration(Element ele) {
   // 获取 name 属性
   String name = ele.getAttribute(NAME_ATTRIBUTE);
   // 获取 alias 属性
   String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
   boolean valid = true;
   // name 属性验证
   if (!StringUtils.hasText(name)) {
      getReaderContext().error("Name must not be empty", ele);
      valid = false;
   }
   // alias 属性验证
   if (!StringUtils.hasText(alias)) {
      getReaderContext().error("Alias must not be empty", ele);
      valid = false;
   }
   if (valid) {
      try {
         // 注册
         getReaderContext().getRegistry().registerAlias(name, alias);
      }
      catch (Exception ex) {
         getReaderContext().error("Failed to register alias '" + alias +
               "' for bean with name '" + name + "'", ele, ex);
      }
      // alias注册事件触发
      getReaderContext().fireAliasRegistered(name, alias, extractSource(ele));
   }
}

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
   // 创建 bean definition
   BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
   if (bdHolder != null) {
      // bean definition 装饰
      bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
      try {
         // Register the final decorated instance.
         // 注册beanDefinition
         BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
      }
      catch (BeanDefinitionStoreException ex) {
         getReaderContext().error("Failed to register bean definition with name '" +
               bdHolder.getBeanName() + "'", ele, ex);
      }
      // Send registration event.
      // component注册事件触发
      getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
   }
}