Spring 源码之核心加载方法(2) 配置文件加载2

发表于 更新于 分类于

2.1.1 解析 xml 文件

DefaultBeanDefinitionDocumentReader#parseDefaultElement

解析默认标签

定位: org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#parseDefaultElement

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 默认标签的解析
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
   if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
      // 解析 import 标签
      importBeanDefinitionResource(ele);
   }
   else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
      // 解析 alias 标签
      processAliasRegistration(ele);
   }
   else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
      // 解析 bean 标签
      processBeanDefinition(ele, delegate);
   }
   else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
      // 解析 beans 标签 (递归调用)
      doRegisterBeanDefinitions(ele);
   }
}

DefaultBeanDefinitionDocumentReader#processBeanDefinition

定位: org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#processBeanDefinition

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
   // beanDefinitionHolder 是 beanDefinition 对象的封装类，封装了BeanDefinition, bean的名字和别名, 用它来完成向IOC容器的注册
   // new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray)
   // 得到 beanDefinitionHolder 就意味着 beanDefinition 是通过 BeanDefinitionParserDelegate 对 xml 元素的信息按照 spring 的 bean 规则进行解析得到的
   BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
   if (bdHolder != null) {
      bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
      try {
         // Register the final decorated instance.
         // 向ioc容器注册解析得到的 beanDefinition
         BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
      }
      catch (BeanDefinitionStoreException ex) {
         getReaderContext().error("Failed to register bean definition with name '" +
               bdHolder.getBeanName() + "'", ele, ex);
      }
      // Send registration event.
      // 在 beanDefinition 向 ioc 容器注册完成之后发送消息
      getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
   }
}

BeanDefinitionParserDelegate#parseBeanDefinitionElement

解析 bean 基本属性 (id, name, aliases)

定位: org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseBeanDefinitionElement(Element, BeanDefinition)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
   // 解析id属性
   String id = ele.getAttribute(ID_ATTRIBUTE);
   // 解析name属性
   String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
   // 如果bean有别名，则将别名分割解析
   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.isTraceEnabled()) {
         logger.trace("No XML 'id' specified - using '" + beanName +
               "' as bean name and " + aliases + " as aliases");
      }
   }

   if (containingBean == null) {
      checkNameUniqueness(beanName, aliases, ele);
   }
   // 如果在解析bean定义期间发生问题, 则返回null
   // 对bean元素的详细解析
   AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
   if (beanDefinition != null) {
      if (!StringUtils.hasText(beanName)) {
         try {
            if (containingBean != null) {
               // 如果不存在 beanName，那么根据 spring 中提供的命名规则为当前 beanDefinition 生成对应的 beanName
               // beanName = (([parentName + $child]) | ([factoryBeanName + $created])) + beanClassName + # + ObjectUtils.getIdentityHexString(definition)
               beanName = BeanDefinitionReaderUtils.generateBeanName(
                     beanDefinition, this.readerContext.getRegistry(), true);
            }
            else {
               // 生成 Spring 内部的 beanName 和 aliases
               // beanName = beanClassName + # + index(索引 0, 1, 2, 3 ...)
               // eg: beanName = com.devinx3.service.impl.UserServiceImpl#0
               // eg: aliases = com.devinx3.service.impl.UserServiceImpl
               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;
}
BeanDefinitionParserDelegate#parseBeanDefinitionElement

解析 bean 的其他属性

定位: org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseBeanDefinitionElement(Element, String, BeanDefinition)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
public AbstractBeanDefinition parseBeanDefinitionElement(
      Element ele, String beanName, @Nullable BeanDefinition containingBean) {

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

   try {
      // 创建装在bean信息的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;
}
BeanDefinitionParserDelegate#parseBeanDefinitionAttributes

定位: org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseBeanDefinitionAttributes

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
// 解析bean标签的各种其他属性
public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
      @Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {

   // 解析 singleton 属性, 在 1.x 后废弃
   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.
      // 如果是内部BeanDefinition，则从 containingBean 中获取 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);
   if (isDefaultValue(lazyInit)) {
      lazyInit = this.defaults.getLazyInit();
   }
   // 如果没有设置或者设置成其他字符都会被设置为false
   bd.setLazyInit(TRUE_VALUE.equals(lazyInit));

   // 解析 autowire 属性
   String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
   bd.setAutowireMode(getAutowireMode(autowire));

   // 解析 depends-on 属性
   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 (isDefaultValue(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 属性
   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) {
      bd.setInitMethodName(this.defaults.getInitMethod());
      bd.setEnforceInitMethod(false);
   }

   // 解析 destroy-method 属性
   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;
}
BeanDefinitionParserDelegate#parseMetaElements

定位: org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseMetaElements

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 解析元数据
public void parseMetaElements(Element ele, BeanMetadataAttributeAccessor attributeAccessor) {
   // 获取当前节点的所有子节点
   NodeList nl = ele.getChildNodes();
   for (int i = 0; i < nl.getLength(); i++) {
      Node node = nl.item(i);
      if (isCandidateElement(node) && nodeNameEquals(node, META_ELEMENT)) {
         // meta 节点
         Element metaElement = (Element) node;
         String key = metaElement.getAttribute(KEY_ATTRIBUTE);
         String value = metaElement.getAttribute(VALUE_ATTRIBUTE);
         // 使用 key/value 构造 beanMetadataAttribute
         BeanMetadataAttribute attribute = new BeanMetadataAttribute(key, value);
         attribute.setSource(extractSource(metaElement));
         // 记录信息
         attributeAccessor.addMetadataAttribute(attribute);
      }
   }
}

DefaultBeanDefinitionDocumentReader#parseDefaultElement

解析自定义标签

定位: org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseCustomElement(Element, BeanDefinition)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
   // 获取标签对应的命名空间
   String namespaceUri = getNamespaceURI(ele);
   if (namespaceUri == null) {
      return null;
   }
   // XmlBeanDefinitionReader#registerBeanDefinitions 创建的 namespaceHandlerResolver
   // 根据命名空间找到对应的 NamespaceHandler (对应关系文件 spring.schemas)
   // 通过继承 NamespaceHandlerSupport 来定制 NamespaceHandler
   NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
   if (handler == null) {
      error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
      return null;
   }
   // 调用定制的 NamespaceHandler 进行解析
   return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}

NamespaceHandler#parse

定位: org.springframework.beans.factory.xml.NamespaceHandlerSupport#parse

1
2
3
4
5
6
public BeanDefinition parse(Element element, ParserContext parserContext) {
   // 获取自定义组件名 对应的解析方法
   BeanDefinitionParser parser = findParserForElement(element, parserContext);
   // 调用ComponentScanBeanDefinitionParser实现类中的 parse方法
   return (parser != null ? parser.parse(element, parserContext) : null);
}

NamespaceHandlerSupport#findParserForElement

定位: org.springframework.beans.factory.xml.NamespaceHandlerSupport#findParserForElement

1
2
3
4
5
6
7
8
9
10
11
12
// 从map中根据组件名称获取绑定的解析方法
private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
    // 获取组件名称
    String localName = parserContext.getDelegate().getLocalName(element);
    // this.parsers 成员变量定义: Map<String, BeanDefinitionParser> parsers = new HashMap<>();
    BeanDefinitionParser parser = this.parsers.get(localName);
    if (parser == null) {
        parserContext.getReaderContext().fatal(
            "Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
    }
    return parser;
}