关于spring:Spring源码解析默认标签解析2

69次阅读

共计 19063 个字符，预计需要花费 48 分钟才能阅读完成。

1. 默认标签判断类型别离解析

  • import
  • alias
  • bean（重点）
  • beans
// 默认标签解析
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
   //import 标签解析  重要水平 1，可看可不看
   if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {importBeanDefinitionResource(ele);
   }
   //alias 标签解析 别名标签  重要水平 1，可看可不看
   else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {processAliasRegistration(ele);
   }
   //bean 标签，重要水平  5，必须看
   else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {processBeanDefinition(ele, delegate);
   }
   else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
      // recurse
      doRegisterBeanDefinitions(ele);
   }
}

2. 默认标签 bean 元素的解析 

//bean 标签解析
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
   // 重点看这个办法，重要水平 5，解析 document，封装成 BeanDefinition
   BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
   if (bdHolder != null) {

      // 该办法性能不重要，设计模式重点看一下，装璜者设计模式，加上 SPI 设计思维
      bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
      try {

         // 实现 document 到 BeanDefinition 对象转换后，对 BeanDefinition 对象进行缓存注册
         // 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));
   }
}

3. BeanDefinitionParserDelegate 解析 document，封装成 BeanDefinition

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
   // bean 元素的属性 id、name（别名，能够配置多个 以,; 分隔）String id = ele.getAttribute(ID_ATTRIBUTE);
   String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

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

   // id 就是 bean 的名称，如果 id 没有配置，然而 name 配置了，就应用 name 的值作为 bean 的名称
   String beanName = id;
   if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {beanName = aliases.remove(0);
      if (logger.isTraceEnabled()) {
         logger.trace("No XML'id'specified - using'" + beanName +
               "'as bean name and" + aliases + "as aliases");
      }
   }

   // 查看 beanName 是否反复
   if (containingBean == null) {
      // 查看配置的 beanName 和别名是否惟一，之前是否有 bean 曾经应用了这个名称
      checkNameUniqueness(beanName, aliases, ele);
   }

   // 解析并创立 beanDefinition 对象
   // 最初解析实现后，把名称、类型以及值的信息封装到对象上，// 而后设置到 beanDefinition 对象上。// bean 元素解析实现，将属性设置到 beanDefinition 对象上，// 而后返回到上一步，封装到了 BeanDefinitionHolder 对象上保护
   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);
               }
            }
            if (logger.isTraceEnabled()) {
               logger.trace("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;
}

4. 解析 bean 元素的属性、子元素的次要逻辑都在这个办法外面：

public AbstractBeanDefinition parseBeanDefinitionElement(Element ele, String beanName, @Nullable BeanDefinition containingBean) {this.parseState.push(new BeanEntry(beanName));

   String className = null;
   if (ele.hasAttribute(CLASS_ATTRIBUTE)) {className = ele.getAttribute(CLASS_ATTRIBUTE).trim();}
   String parent = null;
   if (ele.hasAttribute(PARENT_ATTRIBUTE)) {parent = ele.getAttribute(PARENT_ATTRIBUTE);
   }

   try {
      //1. 创立 GenericBeanDefinition 对象
      AbstractBeanDefinition bd = createBeanDefinition(className, parent);

      //2. 解析 bean 标签的属性，并把解析进去的属性设置到 BeanDefinition 对象中 (scope 等)（**********）parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
      bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

      //3. 解析 bean 中的 meta 标签（参见 spring-xml）parseMetaElements(ele, bd);

      //4. 解析 bean 中的 lookup-method 标签（代理，作用：多态形式）重要水平：2，可看可不看
      parseLookupOverrideSubElements(ele, bd.getMethodOverrides());

      //5. 解析 bean 中的 replaced-method 标签  重要水平：2，可看可不看
      parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

      //6. 解析 bean 中的 constructor-arg 标签  重要水平：2，可看可不看
      parseConstructorArgElements(ele, bd);

      //7. 解析 bean 中的 property 标签  重要水平：2，可看可不看
      parsePropertyElements(ele, bd);

      //8. 解析 qualifier 能够不看，用不到
      parseQualifierElements(ele, bd);

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

      return bd;
   }
   //catch 省略......
   return null;
}

4.1 创立 beanDefinition 对象：

public static AbstractBeanDefinition createBeanDefinition(@Nullable String parentName, @Nullable String className, @Nullable ClassLoader classLoader) throws ClassNotFoundException {
    // 创立 BeanDefinition 对象，并设置 beanClass 和 beanClassName 属性
   GenericBeanDefinition bd = new GenericBeanDefinition();
   bd.setParentName(parentName);
   if (className != null) {if (classLoader != null) {bd.setBeanClass(ClassUtils.forName(className, classLoader));
      }
      else {bd.setBeanClassName(className);
      }
   }
   return bd;
}

4.2 解析 bean 标签的属性，并把解析进去的属性设置到 BeanDefinition 对象中 

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
      @Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {error("Old 1.x'singleton'attribute in use - upgrade to'scope'declaration", ele);
   }
   else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
   }
   else if (containingBean != null) {
      // Take default from containing bean in case of an inner bean definition.
      bd.setScope(containingBean.getScope());
   }

   if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
   }

   String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
   if (DEFAULT_VALUE.equals(lazyInit)) {lazyInit = this.defaults.getLazyInit();
   }
   bd.setLazyInit(TRUE_VALUE.equals(lazyInit));

   String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
   bd.setAutowireMode(getAutowireMode(autowire));

   if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
      bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
   }

   // 这个属性有代码案例演示，请参看案例
   String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);
   if ("".equals(autowireCandidate) || DEFAULT_VALUE.equals(autowireCandidate)) {String candidatePattern = this.defaults.getAutowireCandidates();
      if (candidatePattern != null) {String[] patterns = StringUtils.commaDelimitedListToStringArray(candidatePattern);
         bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));
      }
   }
   else {bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));
   }

   // 这个属性有代码案例演示，请参看案例
   if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
   }

   // 这个属性有代码案例演示，请参看案例
   if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
      bd.setInitMethodName(initMethodName);
   }
   else if (this.defaults.getInitMethod() != null) {bd.setInitMethodName(this.defaults.getInitMethod());
      bd.setEnforceInitMethod(false);
   }

   // 这个属性有代码案例演示，请参看案例
   if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);
      bd.setDestroyMethodName(destroyMethodName);
   }
   else if (this.defaults.getDestroyMethod() != null) {bd.setDestroyMethodName(this.defaults.getDestroyMethod());
      bd.setEnforceDestroyMethod(false);
   }

   // 这个属性有代码案例演示，请参看案例
   if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
   }
   // 这个属性有代码案例演示，请参看案例
   if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
   }

   return bd;
}

4.3 解析 bean 中的 meta 标签（参见 spring-xml）

4.4 设置元数据，做一个标识解析 bean 中的 lookup-method 标签（代理，作用：多态形式）重要水平：2，可看可不看 

public void parseLookupOverrideSubElements(Element beanEle, MethodOverrides overrides) {NodeList nl = beanEle.getChildNodes();
   for (int i = 0; i < nl.getLength(); i++) {Node node = nl.item(i);
      if (isCandidateElement(node) && nodeNameEquals(node, LOOKUP_METHOD_ELEMENT)) {Element ele = (Element) node;
         String methodName = ele.getAttribute(NAME_ATTRIBUTE);
         String beanRef = ele.getAttribute(BEAN_ELEMENT);
         LookupOverride override = new LookupOverride(methodName, beanRef);
         override.setSource(extractSource(ele));
         overrides.addOverride(override);
      }
   }
}

4.5 解析 bean 中的 replaced-method 标签 重要水平：2，可看可不看 

public void parseReplacedMethodSubElements(Element beanEle, MethodOverrides overrides) {NodeList nl = beanEle.getChildNodes();
   for (int i = 0; i < nl.getLength(); i++) {Node node = nl.item(i);
      if (isCandidateElement(node) && nodeNameEquals(node, REPLACED_METHOD_ELEMENT)) {Element replacedMethodEle = (Element) node;
         String name = replacedMethodEle.getAttribute(NAME_ATTRIBUTE);
         String callback = replacedMethodEle.getAttribute(REPLACER_ATTRIBUTE);

         // 一个 replaced-method 标签封装成一个 ReplaceOverride 对象，最初退出到 BeanDefinition 对象中
         ReplaceOverride replaceOverride = new ReplaceOverride(name, callback);
         // Look for arg-type match elements.
         List<Element> argTypeEles = DomUtils.getChildElementsByTagName(replacedMethodEle, ARG_TYPE_ELEMENT);
         for (Element argTypeEle : argTypeEles) {

            // 依据办法参数类型来辨别同名的不同的办法
            String match = argTypeEle.getAttribute(ARG_TYPE_MATCH_ATTRIBUTE);
            match = (StringUtils.hasText(match) ? match : DomUtils.getTextValue(argTypeEle));
            if (StringUtils.hasText(match)) {replaceOverride.addTypeIdentifier(match);
            }
         }
         replaceOverride.setSource(extractSource(replacedMethodEle));
         overrides.addOverride(replaceOverride);
      }
   }
}

4.6 解析 bean 中的 constructor-arg 标签，结构器注入 

public void parseConstructorArgElements(Element beanEle, BeanDefinition bd) {NodeList nl = beanEle.getChildNodes();
   for (int i = 0; i < nl.getLength(); i++) {Node node = nl.item(i);
      if (isCandidateElement(node) && nodeNameEquals(node, CONSTRUCTOR_ARG_ELEMENT)) {
          // 解析结构器参数元素
         parseConstructorArgElement((Element) node, bd);
      }
   }
}

public void parseConstructorArgElement(Element ele, BeanDefinition bd) {String indexAttr = ele.getAttribute(INDEX_ATTRIBUTE);
   String typeAttr = ele.getAttribute(TYPE_ATTRIBUTE);
   String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
   // 蕴含 index 属性
   if (StringUtils.hasLength(indexAttr)) {
      try {int index = Integer.parseInt(indexAttr);
         if (index < 0) {error("'index' cannot be lower than 0", ele);
         }
         else {
            try {this.parseState.push(new ConstructorArgumentEntry(index));
               // 解析 value 值, 解析元素的 value 值，过程和解析 set 注入 property 的流程一样，// 而后封装到 valueHolder 对象中，// 最初把 index 和 valueHolder 设置到 beanDefinition 的 contructorArgumentValues 的属性上
               Object value = parsePropertyValue(ele, bd, null);
               ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);
               if (StringUtils.hasLength(typeAttr)) {valueHolder.setType(typeAttr);
               }
               if (StringUtils.hasLength(nameAttr)) {valueHolder.setName(nameAttr);
               }
               valueHolder.setSource(extractSource(ele));
               // 如果 index 索引反复，那么赋值时会报错
               if (bd.getConstructorArgumentValues().hasIndexedArgumentValue(index)) {error("Ambiguous constructor-arg entries for index" + index, ele);
               }
               else {
                   // 把 index 与 valueHolder 封装到 ConstructorArgumentValues 对象，再把该对象设置到 bd 上
                  bd.getConstructorArgumentValues().addIndexedArgumentValue(index, valueHolder);
               }
            }
            finally {this.parseState.pop();
            }
         }
      }
      catch (NumberFormatException ex) {error("Attribute'index'of tag'constructor-arg'must be an integer", ele);
      }
   }
   //index 不存在
   else {
      try {this.parseState.push(new ConstructorArgumentEntry());
         Object value = parsePropertyValue(ele, bd, null);
         ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);
         if (StringUtils.hasLength(typeAttr)) {valueHolder.setType(typeAttr);
         }
         if (StringUtils.hasLength(nameAttr)) {valueHolder.setName(nameAttr);
         }
         valueHolder.setSource(extractSource(ele));
         // 会把 valueHolder 的值封装到 GenericArgumengValue 中
         bd.getConstructorArgumentValues().addGenericArgumentValue(valueHolder);
      }
      finally {this.parseState.pop();
      }
   }
}

4.7 解析 bean 中 的 property 标签 (和结构相似)

4.8 解析 qualifier 能够不看，用不到

4.9 返回 BeanDefinition 对象

5.（承接第 4 点）该办法性能不重要，设计模式重点看一下，装璜者设计模式，加上 SPI 设计思维，将持有的 BeanDefinitionHolder 对象进行装璜 

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

   BeanDefinitionHolder finalDefinition = definitionHolder;

   // 依据 bean 标签属性装璜 BeanDefinitionHolder，比方 <bean class="xx" p:username="jack"/>
   //
   // 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);
   }

   // 依据 bean 标签子元素装璜 BeanDefinitionHolder
   // 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;
}

6. 装璜 BeanDefinitionHolder

public BeanDefinitionHolder decorateIfRequired(Node node, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) {

   // 依据 node 获取到 node 的命名空间，形如：http://www.springframework.org/schema/p
   String namespaceUri = getNamespaceURI(node);
   if (namespaceUri != null && !isDefaultNamespace(namespaceUri)) {

      // 这里有 SPI 服务发现的思维，依据配置文件获取 namespaceUri 对应的解决类
      NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
      if (handler != null) {

         // 调用 NamespaceHandler 解决类的 decorate 办法，开始具体装璜过程，并返回装璜完的对象
         BeanDefinitionHolder decorated =
               handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd));
         if (decorated != null) {return decorated;}
      }
      // 略......
   }
   return originalDef;
}

spi 机制 

public NamespaceHandler resolve(String namespaceUri) {
   // 获取 spring 中所有 jar 包外面的 "META-INF/spring.handlers" 文件，并且建设映射关系
   Map<String, Object> handlerMappings = getHandlerMappings();

   // 依据 namespaceUri：http://www.springframework.org/schema/p，获取到这个命名空间的解决类
   Object handlerOrClassName = handlerMappings.get(namespaceUri);
   if (handlerOrClassName == null) {return null;}
   else if (handlerOrClassName instanceof NamespaceHandler) {return (NamespaceHandler) handlerOrClassName;
   }
   else {String className = (String) handlerOrClassName;
      try {
         // 反射进去类
         Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
         if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +
                  "] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
         }
         // 实例化
         NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);

         // 调用解决类的 init 办法，在 init 办法中实现标签元素解析类的注册 *** 重要
         namespaceHandler.init();
         handlerMappings.put(namespaceUri, namespaceHandler);
         return namespaceHandler;
      }
      catch (ClassNotFoundException ex) {
         throw new FatalBeanException("Could not find NamespaceHandler class [" + className +
               "] for namespace [" + namespaceUri + "]", ex);
      }
      catch (LinkageError err) {
         throw new FatalBeanException("Unresolvable class definition for NamespaceHandler class [" +
               className + "] for namespace [" + namespaceUri + "]", err);
      }
   }
}
private Map<String, Object> getHandlerMappings() {
   Map<String, Object> handlerMappings = this.handlerMappings;
   if (handlerMappings == null) {synchronized (this) {
         handlerMappings = this.handlerMappings;
         if (handlerMappings == null) {if (logger.isTraceEnabled()) {logger.trace("Loading NamespaceHandler mappings from [" + this.handlerMappingsLocation + "]");
            }
            try {
               // 加载 "META-INF/spring.handlers" 文件过程
               Properties mappings =
                     PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
               if (logger.isTraceEnabled()) {logger.trace("Loaded NamespaceHandler mappings:" + mappings);
               }

               // 所有 "META-INF/spring.handlers" 文件外面的内容建设映射关系
               handlerMappings = new ConcurrentHashMap<>(mappings.size());
               CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
               this.handlerMappings = handlerMappings;
            }
            catch (IOException ex) {
               throw new IllegalStateException("Unable to load NamespaceHandler mappings from location [" + this.handlerMappingsLocation + "]", ex);
            }
         }
      }
   }
   return handlerMappings;
}

7. 返回第 2 点，实现 document 到 BeanDefinition 对象转换后，对 BeanDefinition 对象进行缓存注册 

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

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

   // 实现 BeanDefinition 的注册，重点看，重要水平 5
   registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

   // 建设别名和 id 的映射，这样就能够依据别名获取到 id (别名逻辑暂不关注)
   // Register aliases for bean name, if any.
   String[] aliases = definitionHolder.getAliases();
   if (aliases != null) {for (String alias : aliases) {registry.registerAlias(beanName, alias);
      }
   }
}
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 是否曾经注册
   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()) {// 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 {
         // 把 beanDefinition 缓存到 map 中
         // Still in startup registration phase
         this.beanDefinitionMap.put(beanName, beanDefinition);

         // 把 beanName 放到 beanDefinitionNames list 中，这个 list 着重记住，bean 实例化的时候须要用到
         this.beanDefinitionNames.add(beanName);
         this.manualSingletonNames.remove(beanName);
      }
      this.frozenBeanDefinitionNames = null;
   }

   if (existingDefinition != null || containsSingleton(beanName)) {
       // 重置容器，外部会递归
      resetBeanDefinition(beanName);
   }
}

到这里默认标签的解析工作就实现了

总结：

  • 默认标签次要包含 import bean alias 等，以 bean 元素为例，
  • 首先解析 id、class 属性，创立 beanDefinition 对象
  • 解析 bean 元素可能配置的属性，子元素等信息。例如：property 元素，constructor 元素，lookup 等元素，解析实现后，将数据封装到对应的对象上，而后设置到 beanDefinition 对象属性中，而后返回。
  • 将 beanDefinition 放在到 holder 上，判断默认元素是否蕴含自定义元素（<bean class=”xx” p:username=”jack”/>），包含则进行解析，将数据设置到 beanDefinition 对象上
  • 注册 beanDefinition 到 beanDefinitionMap 汇合中，注册 beanName 到 beanDefinitionNames 汇合中，注册别名 aliasMap 中

正文完
spring
发表至： spring
2021-05-17
 0
源码剖析bean的生命周期
关于spring:SpringBoot-WebFlux-系列-header-参数解析
关于spring:面试工作必备3种常用的缓存读写策略
关于spring:Spring认证中国教育管理中心Apache-Solr-的-Spring-数据教程一