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

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

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

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

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

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

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

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

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

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

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

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

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

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源码解析默认标签解析2

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

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

3. BeanDefinitionParserDelegate 解析 document，封装成 BeanDefinition

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

4.1 创立 beanDefinition 对象：

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

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

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

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

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

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

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

4.9 返回 BeanDefinition 对象

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

6. 装璜 BeanDefinitionHolder

spi 机制

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

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

总结：

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

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

3. BeanDefinitionParserDelegate 解析 document，封装成 BeanDefinition

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

4.1 创立 beanDefinition 对象：

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

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

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

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

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

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

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

4.9 返回 BeanDefinition 对象

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

6. 装璜 BeanDefinitionHolder

spi 机制

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

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

总结：

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

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