Spring源码5.0：bean的注册

bean注册

----封装map至内存

AbstractBeanDefinition属性

上一节完成了XML文档到GenericBeanDefinition的转换。至此，XML所有配置都可以在GenericBeanDefinition的实例类中找到对应的配置。
GenericBeanDefiniion只是子类实现，大部分保存在了AbstractBeanDefinition中。
可以从AbstractBeanDefinition 的属性回顾以上都解析了那些对应的配置。
AbstractBeanDefinition.class

public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
      implements BeanDefinition, Cloneable {
省略

解析默认标签中的自定义标签

attention！！！：默认标签的解析和提取。其解析函数的起始函数。

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

已经分析了BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
接下是 bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);

对于此场景

<bean id="test" class="test.MyClass">
<mybean:user username="aaa"/>
</bean>

在默认解析中单独添加一个方法处理。其自定义类型其实是属性。

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

第三个参数为空，其为父类bean，对于某个嵌套配置进行分析时，需要传递父类beanDefinition。这里传递参数其实是为了使用父类的scope属性。以备子类没有设置scope时默认使用父类的属性。这里分析的是顶层配置，所以传递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;
}

上函数分别对原始的所有属性以及子节点进行了decorateIfRequired函数的调用。

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

• 获取属性或者元素命名空间，判断该元素or属性是否适用于自定义标签的解析条件
• 找到自定义类型对应的NamespaceHandler进行进一步解析
  在 decorateBeanDefinitionIfRequired 中可以看到对于程序默认的标签处理其实是直接略过的。
  因为默认的标签已经处理完了。这里的自定义标签orbean自定义属性甘心并且。
  在方法中寻找了实现自定义标签并根据自定义标签寻找命名空间处理器，进行进一步的解析

注册解析的BeanDefinition

对于配置文件，解析完，装饰完。对于得到的beanDefintion已经可以满足后续的使用要求了。其剩下注册。
便是processBeanDefintioin函数中的BeanDefinitionReaderUtils.registerBeanDefintion(BeanDefinitionHolder definition, BeanDefinitionRegistry registry) 的解析

BeanDefinitionReaderUtils.class

public static void registerBeanDefinition(
      BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
      throws BeanDefinitionStoreException {

   // Register bean definition under primary name.
   String beanName = definitionHolder.getBeanName();
   registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

   // Register aliases for bean name, if any.
   String[] aliases = definitionHolder.getAliases();
   if (aliases != null) {
      for (String alias : aliases) {
         registry.registerAlias(beanName, alias);
      }
   }
}

可得解析的beanDefinitoin都会被注册至BeanDefinitoinRegistry的实例registry中
beanDefinitoin的注册分成两部分

• 通过beanName注册
• 通过别名注册
  所以两个接口
  registerBeanDefinition.class
  AliasRegistry.class

beanName注册BeanDefinitoin

将beanDefintiion直接放入map中，使用beanName作为kry。Spring除此之外也做了其他事情。
回到DefaultListableBeanFactory.class

@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 {
         ((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 BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
               "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
               "': There is already [" + existingDefinition + "] bound.");
      }
      else if (existingDefinition.getRole() < beanDefinition.getRole()) {
         // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
         if (logger.isWarnEnabled()) {
            logger.warn("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.isInfoEnabled()) {
            logger.info("Overriding bean definition for bean '" + beanName +
                  "' with a different definition: replacing [" + existingDefinition +
                  "] with [" + beanDefinition + "]");
         }
      }
      else {
         if (logger.isDebugEnabled()) {
            logger.debug("Overriding bean definition for bean '" + beanName +
                  "' with an equivalent definition: replacing [" + existingDefinition +
                  "] with [" + beanDefinition + "]");
         }
      }
      this.beanDefinitionMap.put(beanName, beanDefinition);
   }
   else {
      if (hasBeanCreationStarted()) {
         // Cannot modify startup-time collection elements anymore (for stable iteration)
         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 {
         // Still in startup registration phase
         this.beanDefinitionMap.put(beanName, beanDefinition);
         this.beanDefinitionNames.add(beanName);
         this.manualSingletonNames.remove(beanName);
      }
      this.frozenBeanDefinitionNames = null;
   }

   if (existingDefinition != null || containsSingleton(beanName)) {
      resetBeanDefinition(beanName);
   }
}

代码可看出，对于bean的注册处理方式上，进行了如下步骤

• 对AbstractBeanDefintion的校验。此校验是对于AbstractBeanDefinition的methodOverrides属性的。
• 对beanName已经注册的情况的处理，若设置不允许bean覆盖，则需要抛出异常，否则直接覆盖
• 加入map缓存
• 清除解析之前留下的对于beanName缓存

通过别名注册BeanDefintion

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) {
      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;
            }
            if (!allowAliasOverriding()) {
               throw new IllegalStateException("Cannot define alias '" + alias + "' for name '" +
                     name + "': It is already registered for name '" + registeredName + "'.");
            }
            if (logger.isInfoEnabled()) {
               logger.info("Overriding alias '" + alias + "' definition for registered name '" +
                     registeredName + "' with new target name '" + name + "'");
            }
         }
         checkForAliasCircle(name, alias);
         this.aliasMap.put(alias, name);
         if (logger.isDebugEnabled()) {
            logger.debug("Alias definition '" + alias + "' registered for name '" + name + "'");
         }
      }
   }
}

• alias与beanName相同情况处理，若相同则不需要处理并删掉原有的alias
• alias 覆盖处理，若aliasName已经使用并已经指向另一beanName则需要用户设置进行处理。
• alias循环检查，当A->B存在时，若再次出现A->B->C则抛出异常
• 注册alias

通知监听器解析及注册完成

通过代码getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder))此工作。这里的实现只为拓展，当开发需要对注册BeanDefintion事件进行监听时，可以通过注册监听器的方式并将处理逻辑写入监听器中，目前在Spring中并没有对此事件做任何逻辑处理。

alias标签的解析

在对bean进行定义时，除了使用id属性指定名称除外，为了提供多个名称可以使用alias标签进行指定。而所有的这些名称都指向同一个bean，为了让应用的每一个组件能更容易地对公共租界进行引用。
具体alias标签使用网上查询
实现代码
DefaultBeanDefinitionDocumentReader.class

protected void processAliasRegistration(Element ele) {
   String name = ele.getAttribute(NAME_ATTRIBUTE);
   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 {
         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));
   }
}

最后bean和alias解析大同小异。都是将别名与beanName组成一对注册至registry中。

import标签的解析

对于大项目，多模块最合适不过，使用import配置

protected void importBeanDefinitionResource(Element ele) {
   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 {
      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 {
         int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);
         if (logger.isDebugEnabled()) {
            logger.debug("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 {
         int importCount;
         Resource relativeResource = getReaderContext().getResource().createRelative(location);
         if (relativeResource.exists()) {
            importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);
            actualResources.add(relativeResource);
         }
         else {
            String baseLocation = getReaderContext().getResource().getURL().toString();
            importCount = getReaderContext().getReader().loadBeanDefinitions(
                  StringUtils.applyRelativePath(baseLocation, location), actualResources);
         }
         if (logger.isDebugEnabled()) {
            logger.debug("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));
}

其解析步骤

• 获取resource属性表示的路径
• 解析路径中的系统属性，格式如 ${user.dir}
• 判定location是绝对路径还是相对路径
• 绝对路径？递归调用bean解析过程，进行另一次的解析
• 相对路径？计算出绝对路径并进行解析
• 通知监听器，解析完成

嵌入式bean标签解析