【Spring源码】IOC实现-默认标签解析

（一）bean

1.解析出配置文件的各种属性(元素解析，信息提取)

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
   // 元素解析，得到bdHolder （包含配置文件中配置的各种属性，例如class、name、id、alias）
   BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
   // 如果bdHolder不为空，若存在默认标签的子节点下再有自定义属性，需要再次对自定义标签进行解析
   if (bdHolder != null) {
      bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
      try {
         // 解析完成后，对解析后的bdHolder 进行注册
         BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
      }
      catch (BeanDefinitionStoreException ex) {
         getReaderContext().error("Failed to register bean definition with name '" + bdHolder.getBeanName() + "'", ele, ex);
      }
      // 发出响应事件，通知相关的监听器，这个bean已经加载完成了
      getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
   }
}

    1.1 提取元素中的 id 和 name 属性
    1.2 进一步解析其他所有属性，统一封装至GenericBeanDefinition 类型的实例中
        1.2.1 <定义解析完的位置> 创建 BeanDefinition（Bean信息的承载实例）
        1.2.2 <开始解析> 解析各种属性
    1.3 如果检测到bean没有指定beanName，那么使用默认规则为此 bean 生成 beanName
    1.4 将获取到的信息（解析到的所有属性，beanName，别名数组）封装到 BeanDefinitionHolder 的实例中

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
   //解析id属性 
   String id = ele.getAttribute(ID_ATTRIBUTE);
   //解析name属性
   String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

   //分割name属性
   List<String> aliases = new ArrayList<>();
   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 (logger.isDebugEnabled()) {
         logger.debug("No XML 'id' specified - using '" + beanName + "' as bean name and " + aliases + " as aliases");
      }
   }

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

   AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
   if (beanDefinition != null) {
      if (!StringUtils.hasText(beanName)) {
         try {
            // 如果不存在beanName，根据Spring中提供的命名规则为当前bean生成对应的beanName 
            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);
               }
            }
            if (logger.isDebugEnabled()) {
               logger.debug("Neither XML 'id' nor 'name' specified - " + "using generated bean name [" + beanName + "]");
            }
         }
         catch (Exception ex) {
            error(ex.getMessage(), ele);
            return null;
         }
      }
      String[] aliasesArray = StringUtils.toStringArray(aliases);
      return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
   }
   return null;
}

      对标签其他属性的解析过程

@Nullable
public AbstractBeanDefinition parseBeanDefinitionElement(Element ele, String beanName, @Nullable BeanDefinition containingBean) {

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

   String className = null;
   // 解析class属性
   if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
      className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
   }
   String parent = null;
   // 解析parent属性
   if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
      parent = ele.getAttribute(PARENT_ATTRIBUTE);
   }

   try {
      // 创建用于承载属性的 AbstractBeanDefinition 类型的 GenericBeanDefinition
      AbstractBeanDefinition bd = createBeanDefinition(className, parent);
 
      // 硬编码解析默认 bean 的各种属性
      parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
      // 提取 description
      bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

      // 解析元数据
      parseMetaElements(ele, bd);
      // 解析 lookup-method 属性
      parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
      // 解析 replaced-method 属性
      parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

      // 解析构造函数参数
      parseConstructorArgElements(ele, bd);
      // 解析 property 子元素
      parsePropertyElements(ele, bd);
      // 解析 qualifier 子元素
      parseQualifierElements(ele, bd);

      bd.setResource(this.readerContext.getResource());
      bd.setSource(extractSource(ele));

      return bd;
   }
   catch (ClassNotFoundException ex) {
      error("Bean class [" + className + "] not found", ele, ex);
   }
   catch (NoClassDefFoundError err) {
      error("Class that bean class [" + className + "] depends on not found", ele, err);
   }
   catch (Throwable ex) {
      error("Unexpected failure during bean definition parsing", ele, ex);
   }
   finally {
      this.parseState.pop();
   }
   return null;
}

 

2.解析自定义标签

    2.1 获取属性或者元素的命名空间 -->   判断该元素或者属性是否适用于自定义标签的解析条件
    2.2 找出自定义类型所对应的 NamespaceHandler并进一步解析

public BeanDefinitionHolder decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder definitionHolder) {
   return decorateBeanDefinitionIfRequired(ele, definitionHolder, null);
}

public BeanDefinitionHolder decorateBeanDefinitionIfRequired(
      Element ele, BeanDefinitionHolder definitionHolder, @Nullable BeanDefinition containingBd) {

   BeanDefinitionHolder finalDefinition = definitionHolder;

   // Decorate based on custom attributes first.
   NamedNodeMap attributes = ele.getAttributes();
   // 遍历所有属性，看看是否有适用于修饰的属性
   for (int i = 0; i < attributes.getLength(); i++) {
      Node node = attributes.item(i);
      finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
   }

   // Decorate based on custom nested elements.
   NodeList children = ele.getChildNodes();
   // 遍历所有的子节点，看看是否有适用于修饰的子元素
   for (int i = 0; i < children.getLength(); i++) {
      Node node = children.item(i);
      if (node.getNodeType() == Node.ELEMENT_NODE) {
         finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
      }
   }
   return finalDefinition;
}

public BeanDefinitionHolder decorateIfRequired(
      Node node, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) {
   // 获取自定义标签的命名空间       
   String namespaceUri = getNamespaceURI(node);
   // 对于非默认标签进行修饰
   if (namespaceUri != null && !isDefaultNamespace(namespaceUri)) {
      // 根据命名空间找到对应的处理器 
      NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
      if (handler != null) {
         BeanDefinitionHolder decorated =
               handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd));
         if (decorated != null) {
            // 进行修饰 
            return decorated;
         }
      }
      else if (namespaceUri.startsWith("http://www.springframework.org/")) {
         error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", node);
      }
      else {
         // A custom namespace, not to be handled by Spring - maybe "xml:...".
         if (logger.isDebugEnabled()) {
            logger.debug("No Spring NamespaceHandler found for XML schema namespace [" + namespaceUri + "]");
         }
      }
   }
   return originalDef;
}

3.对解析后配置文件的内容进行注册

    3.1 通过 beanName 注册 BeanDefinition
        3.1.1 对 AbstractBeanDefinition 进行校验（校验 methodOverrides属性）
        3.1.2 对 beanName 已经注册的情况的处理。如果设置了不允许bean的覆盖，则需要抛出异常，否则直接覆盖
        3.1.3 加入 map 缓存
        3.1.4 清除：解析之前留下的对应 beanName 的缓存

@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException {

   Assert.hasText(beanName, "Bean name must not be empty");
   Assert.notNull(beanDefinition, "BeanDefinition must not be null");

   if (beanDefinition instanceof AbstractBeanDefinition) {
      try {
          // 校验 methodOverrides属性
         ((AbstractBeanDefinition) beanDefinition).validate();
      }
      catch (BeanDefinitionValidationException ex) {
         throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Validation of bean definition failed", ex);
      }
   }

   BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
   if (existingDefinition != null) {
      if (!isAllowBeanDefinitionOverriding()) {
         throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
      }
      else if (existingDefinition.getRole() < beanDefinition.getRole()) {
         // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
         if (logger.isInfoEnabled()) {
            logger.info("Overriding user-defined bean definition for bean '" + beanName +
                  "' with a framework-generated bean definition: replacing [" +
                  existingDefinition + "] with [" + beanDefinition + "]");
         }
      }
      else if (!beanDefinition.equals(existingDefinition)) {
         if (logger.isDebugEnabled()) {
            logger.debug("Overriding bean definition for bean '" + beanName +
                  "' with a different definition: replacing [" + existingDefinition +
                  "] with [" + beanDefinition + "]");
         }
      }
      else {
         if (logger.isTraceEnabled()) {
            logger.trace("Overriding bean definition for bean '" + beanName +
                  "' with an equivalent definition: replacing [" + existingDefinition +
                  "] with [" + beanDefinition + "]");
         }
      }
      this.beanDefinitionMap.put(beanName, beanDefinition);
   }
   else {
      if (hasBeanCreationStarted()) {
         // beanDefinitionMap 是全局变量，存在并发访问
         synchronized (this.beanDefinitionMap) {
            this.beanDefinitionMap.put(beanName, beanDefinition);
            List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
            updatedDefinitions.addAll(this.beanDefinitionNames);
            updatedDefinitions.add(beanName);
            this.beanDefinitionNames = updatedDefinitions;
            if (this.manualSingletonNames.contains(beanName)) {
               Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
               updatedSingletons.remove(beanName);
               this.manualSingletonNames = updatedSingletons;
            }
         }
      }
      else {
         // 注册 beanDefinition
         this.beanDefinitionMap.put(beanName, beanDefinition);
         // 注册 beanName
         this.beanDefinitionNames.add(beanName);
         this.manualSingletonNames.remove(beanName);
      }
      this.frozenBeanDefinitionNames = null;
   }

   if (existingDefinition != null || containsSingleton(beanName)) {
      // 重置所有 beanName 对应的缓存 
      resetBeanDefinition(beanName);
   }
}

    3.2 通过别名注册 BeanDefiniton
        3.2.1 alias 和 beanName 相同：不处理，删除原有的 alias
        3.2.2 alias 覆盖：如果 aliasName 已经使用，并已指向另一 beanName，则需要用户的设置进行处理
        3.2.3 alias 循环检查：当 A->B 存在时，若再次出现 A->C->B 时，则会抛异常
        3.2.4 注册 alias    

@Override
public void registerAlias(String name, String alias) {
   Assert.hasText(name, "'name' must not be empty");
   Assert.hasText(alias, "'alias' must not be empty");
   synchronized (this.aliasMap) {
      // 如果 beanName 与 alias 相同的话不记录 alias，并删除对应的 alias 
      if (alias.equals(name)) {
         this.aliasMap.remove(alias);
         if (logger.isDebugEnabled()) {
            logger.debug("Alias definition '" + alias + "' ignored since it points to same name");
         }
      }
      else {
         String registeredName = this.aliasMap.get(alias);
         if (registeredName != null) {
            if (registeredName.equals(name)) {
               // An existing alias - no need to re-register
               return;
            }
            // 如果 alias 不允许被覆盖则抛出异常
            if (!allowAliasOverriding()) {
               throw new IllegalStateException("Cannot define alias '" + alias + "' for name '" +
                     name + "': It is already registered for name '" + registeredName + "'.");
            }
            if (logger.isDebugEnabled()) {
               logger.debug("Overriding alias '" + alias + "' definition for registered name '" +
                     registeredName + "' with new target name '" + name + "'");
            }
         }
         // 当 A->B 存在时，若再次出现 A->C->B 时，则会抛异常
         checkForAliasCircle(name, alias);
         this.aliasMap.put(alias, name);
         if (logger.isTraceEnabled()) {
            logger.trace("Alias definition '" + alias + "' registered for name '" + name + "'");
         }
      }
   }
}

4.通知监听器，bean已经加载完成(目前 Spring 对此未做处理)

（二）alias

对 bean 进行定义时，alias 标签可提供多个名称，这些名称指向同一个 bean

每个组件及主程序可以通过唯一名字来引用同一数据源而互不干扰

声明别名的方式：

name

<bean id="testBean" name="testBean,testBean2">

alias

 <bean id="testBean">
 <alias name="testBean" alias="testBean,testBean2"/>
 <alias name="testBean" alias="testBean3"/>

 

 

源码

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

protected void processAliasRegistration(Element ele) {
   // 获取beanName 
   String name = ele.getAttribute(NAME_ATTRIBUTE);
   // 获取 alias
   String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
   boolean valid = true;
   if (!StringUtils.hasText(name)) {
      getReaderContext().error("Name must not be empty", ele);
      valid = false;
   }
   if (!StringUtils.hasText(alias)) {
      getReaderContext().error("Alias must not be empty", ele);
      valid = false;
   }
   if (valid) {
      try {
         // 注册 alias 
         getReaderContext().getRegistry().registerAlias(name, alias);
      }
      catch (Exception ex) {
         getReaderContext().error("Failed to register alias '" + alias + "' for bean with name '" + name + "'", ele, ex);
      }
      // 别名注册后通知监听器做相应处理
      getReaderContext().fireAliasRegistered(name, alias, extractSource(ele));
   }
}

（三）import

过程

    1.获取 resource 属性所表示的路径
    2.解析路径中的系统属性，格式如“${user.dir}”
    3.判定 location 是绝对路径还是相对路径
    4.如果是绝对路径：递归调用bean的解析过程，进行另一次的解析
    5.如果是相对路径：计算出绝对路径，进行解析
    6.通知监听器，解析完成 

rotected void importBeanDefinitionResource(Element ele) {
   // 获取 resource 属性 
   String location = ele.getAttribute(RESOURCE_ATTRIBUTE);
   // 如果不存在 resource 属性，则不做任何处理
   if (!StringUtils.hasText(location)) {
      getReaderContext().error("Resource location must not be empty", ele);
      return;
   }

   // 解析系统属性，格式如： "${user.dir}"
   location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);

   Set<Resource> actualResources = new LinkedHashSet<>(4);

   // 判定 location 是绝对 URI 还是相对 URI
   boolean absoluteLocation = false;
   try {
      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*:"
   }

   // 如果是绝对 URI ，直接根据地质加载对应的配置文件
   if (absoluteLocation) {
      try {
         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 {
      // 如果是相对地址，则根据相对对峙算出绝对地址
      try {
         int importCount;
         // 尝试解析
         Resource relativeResource = getReaderContext().getResource().createRelative(location);
         if (relativeResource.exists()) {
            importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);
            actualResources.add(relativeResource);
         }
         else {
            // 解析不成功，则使用默认的解析器 ResourcePatternResolver 进行解析 
            String baseLocation = getReaderContext().getResource().getURL().toString();
            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]);
   getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
}