Spring源码学习（二）

1. private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
2. if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
3. importBeanDefinitionResource(ele);
4. }
5. else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
6. processAliasRegistration(ele);
7. }
8. else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
9. processBeanDefinition(ele, delegate);
10. }
11. else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
12. // recurse
13. doRegisterBeanDefinitions(ele);
14. }
15. }

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
  if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
    importBeanDefinitionResource(ele);
  }
  else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
    processAliasRegistration(ele);
  }
  else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
    processBeanDefinition(ele, delegate);
  }
  else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
    // recurse
    doRegisterBeanDefinitions(ele);
  }
}

1. /**
2. * Process the given bean element, parsing the bean <a href="http://zpycloud.com/archives/tag/definition/" title="查看与 definition 相关的文章" target="_blank">definition</a>
3. * and <a href="http://zpycloud.com/archives/tag/register/" title="查看与 register 相关的文章" target="_blank">register</a>ing it with the registry.
4. */
5. protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
6. BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
7. if (bdHolder != null) {
8. bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
9. try {
10. // Register the final decorated instance.
11. BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
12. }
13. catch (BeanDefinitionStoreException ex) {
14. getReaderContext().error("Failed to register bean definition with name '" +
15. bdHolder.getBeanName() + "'", ele, ex);
16. }
17. // Send registration event.
18. getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
19. }
20. }

/**
   * Process the given bean element, parsing the bean <a href="http://zpycloud.com/archives/tag/definition/" title="查看与 definition 相关的文章" target="_blank">definition</a>
   * and <a href="http://zpycloud.com/archives/tag/register/" title="查看与 register 相关的文章" target="_blank">register</a>ing it with the registry.
   */
  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));
    }
  }

1. /**
2. * Parse the bean definition itself, without regard to name or aliases. May return
3. * {@code null} if problems occurred during the parsing of the bean definition.
4. */
5. @Nullable
6. public AbstractBeanDefinition parseBeanDefinitionElement(
7. Element ele, String beanName, @Nullable BeanDefinition containingBean) {
9. this.parseState.push(new BeanEntry(beanName));
11. String className = null;
12. if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
13. className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
14. }
15. String parent = null;
16. if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
17. parent = ele.getAttribute(PARENT_ATTRIBUTE);
18. }
20. try {
21. // 创建继承于AbstractBeanDefinition 的GenericBeanDefinition对象
22. AbstractBeanDefinition bd = createBeanDefinition(className, parent);
24. // 解析bean的各种属性
25. parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
26. bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
28. // 解析meta属性
29. parseMetaElements(ele, bd);
31. // 解析lookup-method属性
32. parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
34. // 解析replace-method属性
35. parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
37. // 解析构造函数参数
38. parseConstructorArgElements(ele, bd);
40. // 解析property子元素
41. parsePropertyElements(ele, bd);
43. // 解析qualifier子元素
44. parseQualifierElements(ele, bd);
46. bd.setResource(this.readerContext.getResource());
47. bd.setSource(extractSource(ele));
49. return bd;
50. }
51. catch (ClassNotFoundException ex) {
52. error("Bean class [" + className + "] not found", ele, ex);
53. }
54. catch (NoClassDefFoundError err) {
55. error("Class that bean class [" + className + "] depends on not found", ele, err);
56. }
57. catch (Throwable ex) {
58. error("Unexpected failure during bean definition parsing", ele, ex);
59. }
60. finally {
61. this.parseState.pop();
62. }
64. return null;
65. }

/**
   * Parse the bean definition itself, without regard to name or aliases. May return
   * {@code null} if problems occurred during the parsing of the bean definition.
   */
  @Nullable
  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 {
      // 创建继承于AbstractBeanDefinition 的GenericBeanDefinition对象
      AbstractBeanDefinition bd = createBeanDefinition(className, parent);

      // 解析bean的各种属性
      parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
      bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

      // 解析meta属性
      parseMetaElements(ele, bd);
      
      // 解析lookup-method属性
      parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
     
      // 解析replace-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;
  }

1. /**
2. * Register the given bean definition with the given bean factory.
3. * @param definitionHolder the bean definition including name and aliases
4. * @param registry the bean factory to register with
5. * @throws BeanDefinitionStoreException if registration failed
6. */
7. public static void registerBeanDefinition(
8. BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
9. throws BeanDefinitionStoreException {
11. // Register bean definition under primary name.
12. String beanName = definitionHolder.getBeanName();
13. registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
15. // Register aliases for bean name, if any.
16. String[] aliases = definitionHolder.getAliases();
17. if (aliases != null) {
18. for (String alias : aliases) {
19. registry.registerAlias(beanName, alias);
20. }
21. }
22. }

/**
   * Register the given bean definition with the given bean factory.
   * @param definitionHolder the bean definition including name and aliases
   * @param registry the bean factory to register with
   * @throws BeanDefinitionStoreException if registration failed
   */
  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);
      }
    }
  }

1. //---------------------------------------------------------------------
2. // Implementation of BeanDefinitionRegistry interface
3. //---------------------------------------------------------------------
5. @Override
6. public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
7. throws BeanDefinitionStoreException {
9. Assert.hasText(beanName, "Bean name must not be empty");
10. Assert.notNull(beanDefinition, "BeanDefinition must not be null");
12. if (beanDefinition instanceof AbstractBeanDefinition) {
13. try {
14. ((AbstractBeanDefinition) beanDefinition).validate();
15. }
16. catch (BeanDefinitionValidationException ex) {
17. throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
18. "Validation of bean definition failed", ex);
19. }
20. }
22. BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
23. if (existingDefinition != null) {
24. if (!isAllowBeanDefinitionOverriding()) {
25. throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
26. "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
27. "': There is already [" + existingDefinition + "] bound.");
28. }
29. else if (existingDefinition.getRole() < beanDefinition.getRole()) {
30. // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
31. if (logger.isWarnEnabled()) {
32. logger.warn("Overriding user-defined bean definition for bean '" + beanName +
33. "' with a framework-generated bean definition: replacing [" +
34. existingDefinition + "] with [" + beanDefinition + "]");
35. }
36. }
37. else if (!beanDefinition.equals(existingDefinition)) {
38. if (logger.isInfoEnabled()) {
39. logger.info("Overriding bean definition for bean '" + beanName +
40. "' with a different definition: replacing [" + existingDefinition +
41. "] with [" + beanDefinition + "]");
42. }
43. }
44. else {
45. if (logger.isDebugEnabled()) {
46. logger.debug("Overriding bean definition for bean '" + beanName +
47. "' with an equivalent definition: replacing [" + existingDefinition +
48. "] with [" + beanDefinition + "]");
49. }
50. }
51. this.beanDefinitionMap.put(beanName, beanDefinition);
52. }
53. else {
54. if (hasBeanCreationStarted()) {
55. // Cannot modify startup-time collection elements anymore (for stable iteration)
56. synchronized (this.beanDefinitionMap) {
57. this.beanDefinitionMap.put(beanName, beanDefinition);
58. List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
59. updatedDefinitions.addAll(this.beanDefinitionNames);
60. updatedDefinitions.add(beanName);
61. this.beanDefinitionNames = updatedDefinitions;
62. if (this.manualSingletonNames.contains(beanName)) {
63. Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
64. updatedSingletons.remove(beanName);
65. this.manualSingletonNames = updatedSingletons;
66. }
67. }
68. }
69. else {
70. // Still in startup registration phase
71. this.beanDefinitionMap.put(beanName, beanDefinition);
72. this.beanDefinitionNames.add(beanName);
73. this.manualSingletonNames.remove(beanName);
74. }
75. this.frozenBeanDefinitionNames = null;
76. }
78. if (existingDefinition != null || containsSingleton(beanName)) {
79. resetBeanDefinition(beanName);
80. }
81. }

//---------------------------------------------------------------------
  // Implementation of BeanDefinitionRegistry interface
  //---------------------------------------------------------------------

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

1. /**
2. * Parse an "import" element and load the bean definitions
3. * from the given resource into the bean factory.
4. */
5. protected void importBeanDefinitionResource(Element ele) {
6. String location = ele.getAttribute(RESOURCE_ATTRIBUTE);
7. if (!StringUtils.hasText(location)) {
8. getReaderContext().error("Resource location must not be empty", ele);
9. return;
10. }
12. // Resolve system properties: e.g. "${user.dir}"
13. location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);
15. Set<Resource> actualResources = new LinkedHashSet<>(4);
17. // Discover whether the location is an absolute or relative URI
18. boolean absoluteLocation = false;
19. try {
20. absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();
21. }
22. catch (URISyntaxException ex) {
23. // cannot convert to an URI, considering the location relative
24. // unless it is the well-known Spring prefix "classpath*:"
25. }
27. // Absolute or relative?
28. if (absoluteLocation) {
29. try {
30. int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);
31. if (logger.isDebugEnabled()) {
32. logger.debug("Imported " + importCount + " bean definitions from URL location [" + location + "]");
33. }
34. }
35. catch (BeanDefinitionStoreException ex) {
36. getReaderContext().error(
37. "Failed to import bean definitions from URL location [" + location + "]", ele, ex);
38. }
39. }
40. else {
41. // No URL -> considering resource location as relative to the current file.
42. try {
43. int importCount;
44. Resource relativeResource = getReaderContext().getResource().createRelative(location);
45. if (relativeResource.exists()) {
46. importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);
47. actualResources.add(relativeResource);
48. }
49. else {
50. String baseLocation = getReaderContext().getResource().getURL().toString();
51. importCount = getReaderContext().getReader().loadBeanDefinitions(
52. StringUtils.applyRelativePath(baseLocation, location), actualResources);
53. }
54. if (logger.isDebugEnabled()) {
55. logger.debug("Imported " + importCount + " bean definitions from relative location [" + location + "]");
56. }
57. }
58. catch (IOException ex) {
59. getReaderContext().error("Failed to resolve current resource location", ele, ex);
60. }
61. catch (BeanDefinitionStoreException ex) {
62. getReaderContext().error("Failed to import bean definitions from relative location [" + location + "]",
63. ele, ex);
64. }
65. }
66. Resource[] actResArray = actualResources.toArray(new Resource[0]);
67. getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
68. }

/**
   * Parse an "import" element and load the bean definitions
   * from the given resource into the bean factory.
   */
  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));
  }