剖析Spring源码:加载IOC容器

本文接上一篇文章 阅读Spring源码:IOC控制反转前的处理,继续进行下面的分析

首先贴出 Spring bean容器的刷新的核心 11个步骤进行祭拜(一定要让我学会了…阿门)

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
// 完成IoC容器的创建及初始化工作
@Override
public void refresh() throws BeansException, IllegalStateException {
  synchronized (this.startupShutdownMonitor) {
 
    // 1: 刷新前的准备工作。
    prepareRefresh();
 
    // 告诉子类刷新内部bean 工厂。
    //  2:创建IoC容器(DefaultListableBeanFactory),加载解析XML文件(最终存储到Document对象中)
    // 读取Document对象,并完成BeanDefinition的加载和注册工作
    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
 
    //  3: 对IoC容器进行一些预处理(设置一些公共属性)
    prepareBeanFactory(beanFactory);
 
    try {
 
      //  4:  允许在上下文子类中对bean工厂进行后处理。
      postProcessBeanFactory(beanFactory);
 
      //  5: 调用BeanFactoryPostProcessor后置处理器对BeanDefinition处理
      invokeBeanFactoryPostProcessors(beanFactory);
 
      //  6: 注册BeanPostProcessor后置处理器
      registerBeanPostProcessors(beanFactory);
 
      //  7: 初始化一些消息源(比如处理国际化的i18n等消息源)
      initMessageSource();
 
      //  8: 初始化应用事件多播器
      initApplicationEventMulticaster();
 
      //  9: 初始化一些特殊的bean
      onRefresh();
 
      //  10: 注册一些监听器
      registerListeners();
 
      //  11: 实例化剩余的单例bean(非懒加载方式)
      //      注意事项:Bean的IoC、DI和AOP都是发生在此步骤
      finishBeanFactoryInitialization(beanFactory);
 
      //  12: 完成刷新时,需要发布对应的事件
      finishRefresh();
    }
 
    catch (BeansException ex) {
      if (logger.isWarnEnabled()) {
        logger.warn("Exception encountered during context initialization - " +
                    "cancelling refresh attempt: " + ex);
      }
 
      // 销毁已经创建的单例避免占用资源
      destroyBeans();
 
      // 重置'active' 标签。
      cancelRefresh(ex);
 
      // 传播异常给调用者
      throw ex;
    }
 
    finally {
 
      // 重置Spring核心中的常见内省缓存,因为我们可能不再需要单例bean的元数据了...
      resetCommonCaches();
    }
  }
}

下面来分析上述流程中的第二个步骤:创建并解析IOC容器

我们开始进入分析,首先会调用到 AbstractApplicationContext 中的 obtainFreshBeanFactory 方法,此方法会进行IOC容器的刷新并取出BeanFactory,代码如下

1
2
3
4
5
6
7
8
9
10
// 告诉内部子类刷新内部的bean factory
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        // 主要是通过该方法完成IoC容器的刷新
        // ClassPathXmlApplicationContext.refreshBeanFactory 调用的是 AbstractRefreshApplicationContext
        // AnnotationConfigApplicationContext.refreshBeanFactory调用的是GenericApplicationContext
        refreshBeanFactory();
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
      ...
        return beanFactory;
    }

1.首先第一步, refreshBeanFactory,刷新Bean工厂,refreshBeanFactory是一个接口,此接口在 AbstractApplicationContext 中进行定义,先看一下这个JavaDoc对这个接口的定义

1
2
3
4
5
6
/**
     * 子类必须实现这个方法才能执行实际的配置加载。此方法在任何其他初始化工作开始之前由refresh()方法调用
     * 一个子类创建了一个新的 bean factory 并且持有对它的引用,或者返回它拥有的单个BeanFactory实例。
     * 在后一种情况下,如果多次刷新上下文,它通常会抛出 IllegalStateException。
     */
    protected abstract void refreshBeanFactory() throws BeansException, IllegalStateException;

剖析Spring源码:加载IOC容器

它有两个实现类,默认的是 AbstractRefreshableApplicationContext 类,它的refreshBeanFactory方法如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@Override
protected final void refreshBeanFactory() throws BeansException {
  // 如果之前有IoC容器,则销毁
  if (hasBeanFactory()) {
    destroyBeans();
    closeBeanFactory();
  }
  try {
    // 创建IoC容器,也就是 DefaultListableBeanFactory, 初始化AbstractBeanFactory
    // 注册BeanNameAware,BeanClassLoaderAware,BeanFactoryAware, 设置当前BeanFactory
    DefaultListableBeanFactory beanFactory = createBeanFactory();
    beanFactory.setSerializationId(getId());
    // 设置工厂的属性:是否允许BeanDefinition覆盖和是否允许循环依赖
    customizeBeanFactory(beanFactory);
    // 调用载入BeanDefinition的方法,在当前类中只定义了抽象的loadBeanDefinitions方法,具体的实现调用子类容器
    loadBeanDefinitions(beanFactory);
    synchronized (this.beanFactoryMonitor) {
      this.beanFactory = beanFactory;
    }
  }
  catch (IOException ex) {
    throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
  }
}

如果之前有IOC容器的话,就进行销毁,并且关闭容器。适用于第二次调用ClassPathXmlApplicationContext("配置文件"),由于是第一次加载配置文件,还未创建BeanFactory,所以hasBeanFactory()返回false。

下面这一步就是创建IOC容器,也就是DefaultListableBeanFactory

1
2
3
4
5
// 为上下文创建一个内部工厂,默认的实现创建了一个内部的DefaultListableBeanFactory.getInternalParentBeanFactory(),
// 在子类中被重写,例如自定义DefaultListableBeanFactory的设置。
protected DefaultListableBeanFactory createBeanFactory() {
  return new DefaultListableBeanFactory(getInternalParentBeanFactory());
}

上述方法传递的是一个getInternalParentBeanFactory()方法,我们先来看一下这个方法:

1
2
3
4
protected BeanFactory getInternalParentBeanFactory() {
  return (getParent() instanceof ConfigurableApplicationContext) ?
    ((ConfigurableApplicationContext) getParent()).getBeanFactory() : getParent();
}

getParent()这个方法会返回父类上下文,如果没有(父类)的话,返回null(也就表明这个上下文是继承树的根节点。)这句代码的意思也就是说如果它实现了 ConfigurableApplicationContext,则返回父类上下文的BeanFactory,如果没有的话,就返回父上下文本身。因为没有设置过父节点上下文,所以此时的getInternalParentBeanFactory()方法返回为null。

下一步返回一个DefaultListableBeanFactory,首先来看一下DefaultListableBeanFactory的继承体系

剖析Spring源码:加载IOC容器

它的调用流程如下:

  • AbstractRefreshableApplicationContext类中返回一个DefaultListableBeanFactory的构造函数
  • DefaultListableBeanFactory构造函数中调用AbstractAutowireCapableBeanFactory的构造函数
  • AbstractAutowireCapableBeanFactory带参数的构造函数会调用AbstractAutowireCapableBeanFactory无参数的构造函数,并注册了BeanNameAware、BeanFactoryAware、BeanClassLoaderAware接口。并设置setParentBeanFactory(parentBeanFactory) 为null(parentBeanFactory就是上面getInternalParentBeanFactory()方法的返回值);

剖析Spring源码:加载IOC容器

  • AbstractAutowireCapableBeanFactory会调用父类AbstractBeanFactory无参构造方法并初始化。

此时的DefaultListableBeanFactory会带上一系列的初始化字段。Bean工厂说的也就是DefaultListableBeanFactory

2.在createBeanFactory()之后,会给ClassPathXmlApplicationContext设置全局唯一Id

1
beanFactory.setSerializationId(getId());

3.第三步,设置DefaultListableBeanFactory的属性,是否允许重写Bean的定义信息和是否允许循环依赖。没有设置,默认为null

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/*
* 通过上下文自定义内部bean工厂。 尝试调用每一个refresh 方法。
     * 默认实现应用此上下文setAllowBeanDefinitionOverriding 是否允许Bean定义重写
     * 和 setAllowCircularReferences 是否允许循环依赖设置。
     * 如果特殊情况,可以在子类中重写以任何自定义DefaultListableBeanFactory 设置。
*/
protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
        if (this.allowBeanDefinitionOverriding !null) {
            beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
        }
        if (this.allowCircularReferences !null) {
            beanFactory.setAllowCircularReferences(this.allowCircularReferences);
        }
    }

4.最关键的一步,加载Bean的定义信息。所有关于Bean Definitions都会在这一步的这个方法进行解析。调用载入BeanDefinition的方法,在当前类中只定义了抽象的loadBeanDefinitions方法,具体的实现调用子类容器AbstractXmlApplicationContext 中的loadBeanDefinitions方法,具体代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 通过XmlBeanDefinitionReader 加载bean 定义信息。
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
  // 创建一个BeanDefinition阅读器,通过阅读XML文件,真正完成BeanDefinition的加载和注册
  XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
 
  // 配置bean 定义阅读器和上下文资源加载环境。
  beanDefinitionReader.setEnvironment(this.getEnvironment());
  beanDefinitionReader.setResourceLoader(this);
  beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
 
  // 允许子类提供自定义初始化的reader,然后继续加载bean定义信息。
  initBeanDefinitionReader(beanDefinitionReader);
 
  // 委托给BeanDefinition阅读器去加载BeanDefinition
  loadBeanDefinitions(beanDefinitionReader);
}

首先来看第一步,创建XmlBeanDefinitionReader并进行BeanDefinition的加载和注册。初始化XmlBeanDefinitionReader(beanFactory)构造方法,然后调用AbstractBeanDefinitionReader(BeanDefinitionRegistry registry)的构造方法,因为DefaultListableBeanFactory实现了BeanDefinitionRegistry接口,所以就把DefaultListableBeanFactory当作一个BeanDefinitionRegistry传递进去。下面看代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/* 通过bean 工厂创建一个新的 AbstractBeanDefinitionReader。
      如果传入的bean 工厂不仅实现了BeanDefinitionRegistry 接口还实现了ResourceLoader 接口。
   将会使用默认的ResourceLoader。 这是 ApplicationContext 实现的情况。
   如果给定一个普通的BeanDefinitionRegistry,则默认的 ResourceLoader 会是PathMatchingResourcePatternResolver
   如果传入的bean 工厂实现了 EnvironmentCapable,则此读取器将使用此环境。否则,这个读取器
   将会初始化并且使用 StandardEnvironment。 所有ApplicationContext的实现都是 EnvironmentCapable,
      然而通常BeanFactory 的实现则不是。
 */
protected AbstractBeanDefinitionReader(BeanDefinitionRegistry registry) {
  ...
  if (this.registry instanceof ResourceLoader) {
    this.resourceLoader = (ResourceLoader) this.registry;
  }
  else {
    this.resourceLoader = new PathMatchingResourcePatternResolver();
  }
  if (this.registry instanceof EnvironmentCapable) {
    this.environment = ((EnvironmentCapable) this.registry).getEnvironment();
  }
  else {
    this.environment = new StandardEnvironment();
  }
}

上面代码的意思就是,如果BeanDefinitionRegistry实现了ResourceLoader接口,就会强制转换为ResourceLoader,否则,将会new 一个PathMatchingResourcePatternResolver(),如果实现了EnvironmentCapable接口,就直接获取系统环境,否则就直接new一个StandardEnvironment

  • 完成第一步之后,然后配置bean阅读器和上下文资源加载环境,允许子类提供自定义初始化的reader,然后继续加载bean定义信息。这一步希望子类实现自定义的bean加载信息
  • 最后一步进行真正意义上当bean加载,委托给BeanDefinition阅读器去加载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
    
    // 委托给XmlBeanDefinition阅读器去加载BeanDefinition
     // loadBeanDefinitions(beanDefinitionReader);  ↓
     
      @Override
        public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
            // 将读入的XML资源进行特殊编码处理
            return loadBeanDefinitions(new EncodedResource(resource));
        }
     
      // loadBeanDefinitions  ↓
     
        // loadBeanDefinitions(resources) 经过一系列的调用最终会调用到下面的代码
      // XmlBeanDefinitionReader 部分代码省略
        public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
            ...
        // 从InputStream中得到XML的解析源
        InputSource inputSource = new InputSource(inputStream);
        if (encodedResource.getEncoding() !null) {
           inputSource.setEncoding(encodedResource.getEncoding());
        }
        // 这里是具体的读取过程
        return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
        }
     
      // doLoadBeanDefinitions ↓
      protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
                throws BeanDefinitionStoreException {
     
                // 通过DOM4J加载解析XML文件,最终形成Document对象
                Document doc = doLoadDocument(inputSource, resource);
               // 通过对Document对象的操作,完成BeanDefinition的加载和注册工作
            return registerBeanDefinitions(doc, resource);
        }
     
      // registerBeanDefinitions  ↓
      public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
            // 创建BeanDefinitionDocumentReader来解析Document对象,完成BeanDefinition解析
            BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
            // 获得容器中已经注册的BeanDefinition数量
            int countBefore = getRegistry().getBeanDefinitionCount();
            // 解析过程入口,BeanDefinitionDocumentReader只是个接口,具体的实现过程在DefaultBeanDefinitionDocumentReader完成
            documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
            // 统计新的的BeanDefinition数量
            return getRegistry().getBeanDefinitionCount() - countBefore;
        }

到这一步仍旧只是创建了各种需要解析的阅读器对象,文档解析对象,解析之前的准备工作,

这里说一下BeanDefinitionDocumentReader 这个接口:

1
2
3
4
5
6
7
8
9
10
11
12
/*
 * 每个要解析的文档实例化:实现可以在执行
 * registerBeanDefinitions 方法时保存实例变量中的状态
 * 例如,为文档中的所有bean定义定义的全局设置。
*/
public interface BeanDefinitionDocumentReader {
  /*
  * 从 DOM 文档中读取Bean 定义信息并且通过阅读器上下文环境把它们注册进registry中
  */
  void registerBeanDefinitions(Document doc, XmlReaderContext readerContext)
            throws BeanDefinitionStoreException;
}

它的默认实现类只有一个,就是 DefaultBeanDefinitionDocumentReader ,此类负责做真正的bean 解析工作。

下面registerBeanDefinitions之后的方法会完成真正的bean解析工作:

DefaultBeanDefinitionDocumentReader.java

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
// 这个实现用来解析 spring-beans 约束
// 打开DOM 文档,初始化默认<beans/>的设置;然后解析其中的bean定义信息。
@Override
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
  this.readerContext = readerContext;
  logger.debug("Loading bean definitions");
  // 获得Document的根元素<beans>标签
  Element root = doc.getDocumentElement();
  // 真正实现BeanDefinition解析和注册工作
  doRegisterBeanDefinitions(root);
}
 
//        doRegisterBeanDefinitions(root);  ↓
protected void doRegisterBeanDefinitions(Element root) {
 
          /*
            任何嵌套的<beans>元素都将导致此方法中的递归。 为了正确传播和保留<beans>default-* 属性,跟踪当前的
            父委托,可能为null。
            创建新的(子)委托,引用父项以进行回退,然后最终将this.delegate重置为其原始(父)引用。 此行为模拟了一堆代理,而实际上并不需要一个代理。
         */
 
        // 这里使用了委托模式,将具体的BeanDefinition解析工作交给了BeanDefinitionParserDelegate去完成
        BeanDefinitionParserDelegate parent = this.delegate;
        this.delegate = createDelegate(getReaderContext(), root, parent);
 
        // 判断该根标签是否包含http://www.springframework.org/schema/beans默认命名空间
        ...
 
 
        // 在解析Bean定义之前,进行自定义的解析,增强解析过程的可扩展性
        preProcessXml(root);
        // 委托给BeanDefinitionParserDelegate,从Document的根元素开始进行BeanDefinition的解析
        parseBeanDefinitions(root, this.delegate);
        // 在解析Bean定义之后,进行自定义的解析,增加解析过程的可扩展性
        postProcessXml(root);
 
        this.delegate = parent;
    }

看到这里已经真心不容易了,需要休息一下吗?怎么说呢,源码这个东西是需要耐住性子并且需要你投入大量精力的,看过一遍没有印象太正常了,并且看源码的前提是没人打扰,需要一个极度安静的环境。

tips: 戴上耳机会好很多

在回到正题之前,我先来问你一个问题,你知道代理模式和委托模式的区别吗?

我是这样理解的

委托模式是自己不做这件事情呢,而是把事情交给别人去做
代理模式是让别人搭把手,而自己是真正做这件事情的主角,因为代理实现类(实现了InvocationHandler 的类)只是个打嘴炮的人。

回到正题,在真正做解析工作的时候,会首先创建一个委托类BeanDefinitionParserDelegate ,那么先来认识一下这个类。

1
2
3
4
5
6
7
8
9
10
11
12
// 用于解析XML bean定义的有状态委托类。 旨在供主解析器和任何扩展使用
public class BeanDefinitionParserDelegate {
 
  // 此方法也就是委托给 BeanDefinitionParserDelegate 去做的事情
  protected BeanDefinitionParserDelegate createDelegate(
            XmlReaderContext readerContext, Element root, @Nullable BeanDefinitionParserDelegate parentDelegate) {
 
        BeanDefinitionParserDelegate delegate = new BeanDefinitionParserDelegate(readerContext);
        delegate.initDefaults(root, parentDelegate);
        return delegate;
    }
}

它主要完成的事情在initDefaults 方法中,一起看下这个方法

1
2
3
4
5
6
7
8
/*
     * 初始化默认的 懒加载,自动注入,依赖检查设置, 初始化方法,销毁方法和合并设置。
     * 如果未在本地显式设置默认值,则通过回退到给定父级来支持嵌套的“beans”元素用例。
     */
public void initDefaults(Element root, @Nullable BeanDefinitionParserDelegate parent) {
  populateDefaults(this.defaults(parent !null ? parent.defaults : null), root);
  this.readerContext.fireDefaultsRegistered(this.defaults);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/**
     * in case the defaults are not explicitly set locally.
     * 使用默认的 lazy-init,autowire,依赖检查设置,init-method,destroy-method 和 合并设置 属性 填充给定的
     * DocumentDefaultsDefinition,如果未在本地显式设置默认值,则支持嵌套的'beans'元素用例,返回parentDefaults
     */
    protected void populateDefaults(DocumentDefaultsDefinition defaults, @Nullable DocumentDefaultsDefinition parentDefaults, Element root) {
        // default-lazy-init
        String lazyInit = root.getAttribute(DEFAULT_LAZY_INIT_ATTRIBUTE);
        if (DEFAULT_VALUE.equals(lazyInit)) {
            // Potentially inherited from outer <beans> sections, otherwise falling back to false.
            lazyInit = (parentDefaults !null ? parentDefaults.getLazyInit() : FALSE_VALUE);
        }
        defaults.setLazyInit(lazyInit);
 
    // 余下的代码和lazyinit 的逻辑相同,也是解析方法注释中的各种属性。 这里碍于篇幅原因暂不贴出了
        ...
      //   
 
        defaults.setSource(this.readerContext.extractSource(root));
    }

然后方法一直返回到创建委托的入口也就是 BeanDefinitionParserDelegate parent = this.delegate;,然后是 Spring 留给开发人员的两个接口,用于开发人员自己实现

1
2
3
4
5
6
7
...
// 在解析Bean定义之前,进行自定义的解析,增强解析过程的可扩展性
preProcessXml(root);
// 委托给 BeanDefinitionParserDelegate,从Document的根元素开始进行BeanDefinition的解析
parseBeanDefinitions(root, this.delegate);
// 在解析Bean定义之后,进行自定义的解析,增加解析过程的可扩展性
postProcessXml(root);

我们再来看一下 parseBeanDefinitions(root, this.delegate); 这个方法是交给刚刚创建的 BeanDefinitionParserDelegate 委托用来解析具体的 lazy-init 等属性的标签的

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
/**
     * 解析文档对象的根目录节点:import, alias, bean
     */
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
  // 加载的Document对象是否使用了Spring默认的XML命名空间(beans命名空间)
  if (delegate.isDefaultNamespace(root)) {
    // 获取Document对象根元素的所有子节点(bean标签、import标签、alias标签和其他自定义标签context、aop等)
    NodeList nl = root.getChildNodes();
    for (int i = 0; i < nl.getLength(); i++) {
      Node node = nl.item(i);
      if (node instanceof Element) {
        Element ele = (Element) node;
        // bean标签、import标签、alias标签,则使用默认解析规则
        if (delegate.isDefaultNamespace(ele)) {
          parseDefaultElement(ele, delegate);
        }
        else {//像context标签、aop标签、tx标签,则使用用户自定义的解析规则解析元素节点
          delegate.parseCustomElement(ele);
        }
      }
    }
  }
  else {
    // 如果不是默认的命名空间,则使用用户自定义的解析规则解析元素节点
    delegate.parseCustomElement(root);
  }
}

上述步骤主要分为三步:

一,先判断是否委托类使用Spring默认的XML命名空间(beans命名空间),在判断如果取出来的节点是bean、import、alias的话就使用默认的解析规则

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

二,如果判断取出来的不是默认节点,则会使用自定义的默认解析规则,context标签,aop标签, tx标签则会默认使用此解析方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Nullable
public BeanDefinition parseCustomElement(Element ele) {
  // 解析自定义标签
  return parseCustomElement(ele, null);
}
 
@Nullable
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
  // 获取命名空间URI(就是获取beans标签的xmlns:aop或者xmlns:context属性的值)
  String namespaceUri = getNamespaceURI(ele);
  if (namespaceUri == null) {
    return null;
  }
  // 根据不同的命名空间URI,去匹配不同的NamespaceHandler(一个命名空间对应一个NamespaceHandler)
  // 此处会调用DefaultNamespaceHandlerResolver类的resolve方法
  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.readerContextthis, containingBd));
}

三,如果不是使用 beans 的命名空间,也会使用自定义的解析方法进行解析

然后方法解析完成,一直返回到 AbstractApplicationContext 中的 刷新 bean Factory 的方法、、、

1
2
3
4
5
6
7
8
9
10
11
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
  // 主要是通过该方法完成IoC容器的刷新
  // ClassPathXmlApplicationContext.refreshBeanFactory 调用的是 AbstractRefreshApplicationContext
  // AnnotationConfigApplicationContext.refreshBeanFactory调用的是GenericApplicationContext
  refreshBeanFactory();
  ConfigurableListableBeanFactory beanFactory = getBeanFactory();
  if (logger.isDebugEnabled()) {
    logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
  }
  return beanFactory;
}

这样取出的 Bean 对象就可以进行使用了。

下一篇文章来 解析一下第三个步骤:对IoC容器进行一些预处理