spring源码解析bean定义四（<bean>标签）

前言

上次主要介绍了<import>和alias源码解析，本次接着上次的继续。

正文

上次介绍到这个方法的这行代码

org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#parseDefaultElement <bean>标签解析

//     bean
      else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
         processBeanDefinition(ele, delegate);
      }

进入这个方法

org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#processBeanDefinition

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
//    解析<bean>节点
      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));
      }
   }

//     解析<bean>节点
      BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

进入这个方法

org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseBeanDefinitionElement(org.w3c.dom.Element, org.springframework.beans.factory.config.BeanDefinition)

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

      List<String> aliases = new ArrayList<>();
      if (StringUtils.hasLength(nameAttr)) {
//       name属性值可以是多个，用，分开，会当做别名进行注册
         String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
         aliases.addAll(Arrays.asList(nameArr));
      }

//    把id的值当做beanName
      String beanName = id;
//    如果id值没有，会把name属性值下标是0的当做beanName，并从别名map中删除这个名字
      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) {
//       验证当前执行的beanName和alias没有在其他bean中使用
         checkNameUniqueness(beanName, aliases, ele);
      }

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

找到这行代码

//     bean节点bean定义解析
      AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);

进入这个方法

org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseBeanDefinitionElement(org.w3c.dom.Element, java.lang.String, org.springframework.beans.factory.config.BeanDefinition)

@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 bd = createBeanDefinition(className, parent);

         parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
//       description 属性解析
         bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

//       解析键值对的标签 key value
         parseMetaElements(ele, bd);
//       bean覆盖解析
         parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
//       方法重写解析
         parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

//       解析构造参数节点
         parseConstructorArgElements(ele, bd);
//       解析property节点
         parsePropertyElements(ele, bd);
         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;
   }

找到这行代码

//        解析bean标签的属性
         parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);

进入这个方法

org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseBeanDefinitionAttributes

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
         @Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {
//加载属性值到bean定义中
//    singleton 1.0支持，高版本用scope代替
      if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
         error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
      }
//    scope
      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.如果有内部bean，scope以内部bean的scope为准
         bd.setScope(containingBean.getScope());
      }

//    abstract 是否是抽象类
      if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
         bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
      }

//    lazy-init
      String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
//    如果值是default，beans标签属性值中获取
      if (DEFAULT_VALUE.equals(lazyInit)) {
         lazyInit = this.defaults.getLazyInit();
      }
      bd.setLazyInit(TRUE_VALUE.equals(lazyInit));

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

//    depends-on 依赖的bean会先加载，可以是多个用,分开
      if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
         String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
         bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
      }
//    autowire-candidate
      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));
      }

//    primary 如果有两个名称一致的bean，以这个为主
      if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {
         bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
      }

//    init-method
      if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {
         String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
         bd.setInitMethodName(initMethodName);
      }
      else if (this.defaults.getInitMethod() != null) {
//       如果beans标签指定了init方法，以这个为主
         bd.setInitMethodName(this.defaults.getInitMethod());
         bd.setEnforceInitMethod(false);
      }

//    destroy-method 如果beans标签制定了，以这个为主
      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);
      }

//    factory-method
      if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
         bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
      }
//    factory-bean
      if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
         bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
      }

      return bd;
   }

返回到这个方法的这行代码

org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseBeanDefinitionElement(org.w3c.dom.Element, java.lang.String, org.springframework.beans.factory.config.BeanDefinition)解析key value这种属性

//        解析键值对的标签 key value
         parseMetaElements(ele, bd);

往下找到这行

//        bean覆盖解析
         parseLookupOverrideSubElements(ele, bd.getMethodOverrides());

进入这个方法

org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseLookupOverrideSubElements

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

返回到这个方法

//        方法重写解析
         parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

public void parseReplacedMethodSubElements(Element beanEle, MethodOverrides overrides) {
      NodeList nl = beanEle.getChildNodes();
      for (int i = 0; i < nl.getLength(); i++) {
         Node node = nl.item(i);
//       replaced-method
         if (isCandidateElement(node) && nodeNameEquals(node, REPLACED_METHOD_ELEMENT)) {
            Element replacedMethodEle = (Element) node;
//          name属性
            String name = replacedMethodEle.getAttribute(NAME_ATTRIBUTE);
//          replacer属性
            String callback = replacedMethodEle.getAttribute(REPLACER_ATTRIBUTE);
            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);
         }
      }
   }

返回到这个方法

org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseBeanDefinitionElement(org.w3c.dom.Element, java.lang.String, org.springframework.beans.factory.config.BeanDefinition)

//        解析构造参数节点
         parseConstructorArgElements(ele, bd);

public void parseConstructorArgElements(Element beanEle, BeanDefinition bd) {
      NodeList nl = beanEle.getChildNodes();
      for (int i = 0; i < nl.getLength(); i++) {
         Node node = nl.item(i);
//       constructor-arg
         if (isCandidateElement(node) && nodeNameEquals(node, CONSTRUCTOR_ARG_ELEMENT)) {
            parseConstructorArgElement((Element) node, bd);
         }
      }
   }

public void parseConstructorArgElement(Element ele, BeanDefinition bd) {
//    index属性
      String indexAttr = ele.getAttribute(INDEX_ATTRIBUTE);
//    type属性
      String typeAttr = ele.getAttribute(TYPE_ATTRIBUTE);
//    name属性
      String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
      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));
                  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));
                  if (bd.getConstructorArgumentValues().hasIndexedArgumentValue(index)) {
                     error("Ambiguous constructor-arg entries for index " + index, ele);
                  }
                  else {
                     bd.getConstructorArgumentValues().addIndexedArgumentValue(index, valueHolder);
                  }
               }
               finally {
                  this.parseState.pop();
               }
            }
         }
         catch (NumberFormatException ex) {
            error("Attribute 'index' of tag 'constructor-arg' must be an integer", ele);
         }
      }
      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));
            bd.getConstructorArgumentValues().addGenericArgumentValue(valueHolder);
         }
         finally {
            this.parseState.pop();
         }
      }
   }

返回到这个方法

org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseBeanDefinitionElement(org.w3c.dom.Element, java.lang.String, org.springframework.beans.factory.config.BeanDefinition)

//        解析property节点
         parsePropertyElements(ele, bd);

public void parsePropertyElements(Element beanEle, BeanDefinition bd) {
      NodeList nl = beanEle.getChildNodes();
      for (int i = 0; i < nl.getLength(); i++) {
         Node node = nl.item(i);
//       property节点
         if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {
            parsePropertyElement((Element) node, bd);
         }
      }
   }

public void parsePropertyElement(Element ele, BeanDefinition bd) {
//    name属性
      String propertyName = ele.getAttribute(NAME_ATTRIBUTE);
      if (!StringUtils.hasLength(propertyName)) {
         error("Tag 'property' must have a 'name' attribute", ele);
         return;
      }
      this.parseState.push(new PropertyEntry(propertyName));
      try {
         if (bd.getPropertyValues().contains(propertyName)) {
            error("Multiple 'property' definitions for property '" + propertyName + "'", ele);
            return;
         }
//       解析属性值
         Object val = parsePropertyValue(ele, bd, propertyName);
         PropertyValue pv = new PropertyValue(propertyName, val);
         parseMetaElements(ele, pv);
         pv.setSource(extractSource(ele));
         bd.getPropertyValues().addPropertyValue(pv);
      }
      finally {
         this.parseState.pop();
      }
   }

找到这行代码

//        解析属性值
         Object val = parsePropertyValue(ele, bd, propertyName);

@Nullable
   public Object parsePropertyValue(Element ele, BeanDefinition bd, @Nullable String propertyName) {
      String elementName = (propertyName != null) ?
                  "<property> element for property '" + propertyName + "'" :
                  "<constructor-arg> element";

      // Should only have one child element: ref, value, list, etc.
      NodeList nl = ele.getChildNodes();
      Element subElement = null;
      for (int i = 0; i < nl.getLength(); i++) {
         Node node = nl.item(i);
         if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) &&
               !nodeNameEquals(node, META_ELEMENT)) {
            // Child element is what we're looking for.
            if (subElement != null) {
               error(elementName + " must not contain more than one sub-element", ele);
            }
            else {
               subElement = (Element) node;
            }
         }
      }

//    ref节点
      boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
//    value节点
      boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);
      if ((hasRefAttribute && hasValueAttribute) ||
            ((hasRefAttribute || hasValueAttribute) && subElement != null)) {
         error(elementName +
               " is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
      }

      if (hasRefAttribute) {
         String refName = ele.getAttribute(REF_ATTRIBUTE);
         if (!StringUtils.hasText(refName)) {
            error(elementName + " contains empty 'ref' attribute", ele);
         }
//       ref引用的bean是在运行时解析
         RuntimeBeanReference ref = new RuntimeBeanReference(refName);
         ref.setSource(extractSource(ele));
         return ref;
      }
      else if (hasValueAttribute) {
         TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
         valueHolder.setSource(extractSource(ele));
         return valueHolder;
      }
      else if (subElement != null) {
         return parsePropertySubElement(subElement, bd);
      }
      else {
         // Neither child element nor "ref" or "value" attribute found.
         error(elementName + " must specify a ref or value", ele);
         return null;
      }
   }

返回到这个方法

org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseBeanDefinitionElement(org.w3c.dom.Element, java.lang.String, org.springframework.beans.factory.config.BeanDefinition)

//        qualifier属性解析
         parseQualifierElements(ele, bd);

public void parseQualifierElements(Element beanEle, AbstractBeanDefinition bd) {
      NodeList nl = beanEle.getChildNodes();
      for (int i = 0; i < nl.getLength(); i++) {
         Node node = nl.item(i);
//       找到qualifier节点
         if (isCandidateElement(node) && nodeNameEquals(node, QUALIFIER_ELEMENT)) {
//          解析qualifier节点
            parseQualifierElement((Element) node, bd);
         }
      }
   }

public void parseQualifierElement(Element ele, AbstractBeanDefinition bd) {
//    解析type属性
      String typeName = ele.getAttribute(TYPE_ATTRIBUTE);
      if (!StringUtils.hasLength(typeName)) {
         error("Tag 'qualifier' must have a 'type' attribute", ele);
         return;
      }
      this.parseState.push(new QualifierEntry(typeName));
      try {
         AutowireCandidateQualifier qualifier = new AutowireCandidateQualifier(typeName);
         qualifier.setSource(extractSource(ele));
//       解析value属性值
         String value = ele.getAttribute(VALUE_ATTRIBUTE);
         if (StringUtils.hasLength(value)) {
            qualifier.setAttribute(AutowireCandidateQualifier.VALUE_KEY, value);
         }
         NodeList nl = ele.getChildNodes();
         for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
//          属性值是attribute
            if (isCandidateElement(node) && nodeNameEquals(node, QUALIFIER_ATTRIBUTE_ELEMENT)) {
               Element attributeEle = (Element) node;
//             获得key值
               String attributeName = attributeEle.getAttribute(KEY_ATTRIBUTE);
//             获得value值
               String attributeValue = attributeEle.getAttribute(VALUE_ATTRIBUTE);
               if (StringUtils.hasLength(attributeName) && StringUtils.hasLength(attributeValue)) {
                  BeanMetadataAttribute attribute = new BeanMetadataAttribute(attributeName, attributeValue);
                  attribute.setSource(extractSource(attributeEle));
                  qualifier.addMetadataAttribute(attribute);
               }
               else {
                  error("Qualifier 'attribute' tag must have a 'name' and 'value'", attributeEle);
                  return;
               }
            }
         }
         bd.addQualifier(qualifier);
      }
      finally {
         this.parseState.pop();
      }
   }

返回到这个方法

org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseBeanDefinitionElement(org.w3c.dom.Element, org.springframework.beans.factory.config.BeanDefinition)

//                 自动生成beanName
                  beanName = BeanDefinitionReaderUtils.generateBeanName(
                        beanDefinition, this.readerContext.getRegistry(), true);

进入这个方法

org.springframework.beans.factory.support.BeanDefinitionReaderUtils#generateBeanName(org.springframework.beans.factory.config.BeanDefinition, org.springframework.beans.factory.support.BeanDefinitionRegistry, boolean)

public static String generateBeanName(
         BeanDefinition definition, BeanDefinitionRegistry registry, boolean isInnerBean)
         throws BeanDefinitionStoreException {

//    自动生成的名字是className
      String generatedBeanName = definition.getBeanClassName();
      if (generatedBeanName == null) {
//       如果这个类有父类
         if (definition.getParentName() != null) {
//          自动生成的名字是父类的名字+$child
            generatedBeanName = definition.getParentName() + "$child";
         }
         else if (definition.getFactoryBeanName() != null) {
//          bean定义的factoryName为空，beanName值就是beanFactory的值+$created
            generatedBeanName = definition.getFactoryBeanName() + "$created";
         }
      }
      if (!StringUtils.hasText(generatedBeanName)) {
         throw new BeanDefinitionStoreException("Unnamed bean definition specifies neither " +
               "'class' nor 'parent' nor 'factory-bean' - can't generate bean name");
      }

      String id = generatedBeanName;
//    如果是内部bean
      if (isInnerBean) {
         // Inner bean: generate identity hashcode suffix.中间有#
         id = generatedBeanName + GENERATED_BEAN_NAME_SEPARATOR + ObjectUtils.getIdentityHexString(definition);
      }
      else {
         // Top-level bean: use plain class name.
         // Increase counter until the id is unique.
         int counter = -1;
         while (counter == -1 || registry.containsBeanDefinition(id)) {
            counter++;
            id = generatedBeanName + GENERATED_BEAN_NAME_SEPARATOR + counter;
         }
      }
      return id;
   }

返回到这个方法

org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseBeanDefinitionElement(org.w3c.dom.Element, org.springframework.beans.factory.config.BeanDefinition)这行代码

如果不是匿名bean
                  beanName = this.readerContext.generateBeanName(beanDefinition);

返回到这个方法

org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#processBeanDefinition

bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);

进入到这个方法

org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#decorateBeanDefinitionIfRequired(org.w3c.dom.Element, org.springframework.beans.factory.config.BeanDefinitionHolder, org.springframework.beans.factory.config.BeanDefinition)

//        解析必须要加载的bean定义
         finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);

进入这个方法

org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#decorateIfRequired

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

      String namespaceUri = getNamespaceURI(node);
//    不是默认的命名空间 http://www.springframework.org/schema/beans
      if (namespaceUri != null && !isDefaultNamespace(namespaceUri)) {
//       解析NamespaceHandler
         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;
   }

下次介绍handler解析。

最后

本次介绍到这里，以上内容仅供参考。

扫码关注

进群讨论

快到碗里来

spring源码解析bean定义四（<bean>标签）

猜你喜欢