Spring 最重要的概念是 IOC 和 AOP，本篇文章其实就是要带领大家来分析下 Spring 的 IOC 容器。既然大家平时都要用到 Spring，怎么可以不好好了解 Spring 呢？阅读本文并不能让你成为 Spring 专家，不过一定有助于大家理解 Spring 的很多概念，帮助大家排查应用中和 Spring 相关的一些问题。

本文采用的源码版本是 4.3.11.RELEASE，算是 5.0.x 前比较新的版本了。为了降低难度，本文所说的所有的内容都是基于 xml 的配置的方式，实际使用已经很少人这么做了，至少不是纯 xml 配置，不过从理解源码的角度来看用这种方式来说无疑是最合适的。

阅读建议：读者至少需要知道怎么配置 Spring，了解 Spring 中的各种概念，少部分内容我还假设读者使用过 SpringMVC。本文要说的 IOC 总体来说有两处地方最重要，一个是创建 Bean 容器，一个是初始化 Bean，如果读者觉得一次性看完本文压力有点大，那么可以按这个思路分两次消化。读者不一定对 Spring 容器的源码感兴趣，也许附录部分介绍的知识对读者有些许作用。

希望通过本文可以让读者不惧怕阅读 Spring 源码，也希望大家能反馈表述错误或不合理的地方。

目录

引言

先看下最基本的启动 Spring 容器的例子：

1public static void main(String[] args) {
2    ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationfile.xml");
3}

以上代码就可以利用配置文件来启动一个 Spring 容器了，请使用 maven 的小伙伴直接在 dependencies 中加上以下依赖即可，个人比较反对那些不知道要添加什么依赖，然后把 Spring 的所有相关的东西都加进来的方式。

1<dependency>
2  <groupId>org.springframework</groupId>
3  <artifactId>spring-context</artifactId>
4  <version>4.3.11.RELEASE</version>
5</dependency>

spring-context 会自动将 spring-core、spring-beans、spring-aop、spring-expression 这几个基础 jar 包带进来。

多说一句，很多开发者入门就直接接触的 SpringMVC，对 Spring 其实不是很了解，Spring 是渐进式的工具，并不具有很强的侵入性，它的模块也划分得很合理，即使你的应用不是 web 应用，或者之前完全没有使用到 Spring，而你就想用 Spring 的依赖注入这个功能，其实完全是可以的，它的引入不会对其他的组件产生冲突。

废话说完，我们继续。ApplicationContext context = new ClassPathXmlApplicationContext(...) 其实很好理解，从名字上就可以猜出一二，就是在 ClassPath 中寻找 xml 配置文件，根据 xml 文件内容来构建 ApplicationContext。当然，除了 ClassPathXmlApplicationContext 以外，我们也还有其他构建 ApplicationContext 的方案可供选择，我们先来看看大体的继承结构是怎么样的：

读者可以大致看一下类名，源码分析的时候不至于找不着看哪个类，因为 Spring 为了适应各种使用场景，提供的各个接口都可能有很多的实现类。对于我们来说，就是揪着一个完整的分支看完。

当然，读本文的时候读者也不必太担心，每个代码块分析的时候，我都会告诉读者我们在说哪个类第几行。

我们可以看到，ClassPathXmlApplicationContext 兜兜转转了好久才到 ApplicationContext 接口，同样的，我们也可以使用绿颜色的 FileSystemXmlApplicationContext 和 AnnotationConfigApplicationContext 这两个类。

FileSystemXmlApplicationContext 的构造函数需要一个 xml 配置文件在系统中的路径，其他和 ClassPathXmlApplicationContext 基本上一样。

AnnotationConfigApplicationContext 是基于注解来使用的，它不需要配置文件，采用 java 配置类和各种注解来配置，是比较简单的方式，也是大势所趋吧。

不过本文旨在帮助大家理解整个构建流程，所以决定使用 ClassPathXmlApplicationContext 进行分析。

我们先来一个简单的例子来看看怎么实例化 ApplicationContext。

首先，定义一个接口：

1public interface MessageService {
2    String getMessage();
3}

定义接口实现类：

1public class MessageServiceImpl implements MessageService {
2
3    public String getMessage() {
4        return "hello world";
5    }
6}

接下来，我们在 resources 目录新建一个配置文件，文件名随意，通常叫 application.xml 或 application-xxx.xml 就可以了：

1<?xml version="1.0" encoding="UTF-8" ?>
2<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3       xmlns="http://www.springframework.org/schema/beans"
4       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd" default-autowire="byName">
5
6    <bean id="messageService" class="com.javadoop.example.MessageServiceImpl"/>
7</beans>

这样，我们就可以跑起来了：

1public class App {
2    public static void main(String[] args) {
3        // 用我们的配置文件来启动一个 ApplicationContext
4        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:application.xml");
5
6        System.out.println("context 启动成功");
7
8        // 从 context 中取出我们的 Bean，而不是用 new MessageServiceImpl() 这种方式
9        MessageService messageService = context.getBean(MessageService.class);
10        // 这句将输出: hello world
11        System.out.println(messageService.getMessage());
12    }
13}

以上例子很简单，不过也够引出本文的主题了，就是怎么样通过配置文件来启动 Spring 的 ApplicationContext？也就是我们今天要分析的 IOC 的核心了。ApplicationContext 启动过程中，会负责创建实例 Bean，往各个 Bean 中注入依赖等。

BeanFactory 简介

BeanFactory，从名字上也很好理解，生产 bean 的工厂，它负责生产和管理各个 bean 实例。

初学者可别以为我之前说那么多和 BeanFactory 无关，前面说的 ApplicationContext 其实就是一个 BeanFactory。我们来看下和 BeanFactory 接口相关的主要的继承结构：

我想，大家看完这个图以后，可能就不是很开心了。ApplicationContext 往下的继承结构前面一张图说过了，这里就不重复了。这张图呢，背下来肯定是不需要的，有几个重点和大家说明下就好。

1. ApplicationContext 继承了 ListableBeanFactory，这个 Listable 的意思就是，通过这个接口，我们可以获取多个 Bean，大家看源码会发现，最顶层 BeanFactory 接口的方法都是获取单个 Bean 的。
2. ApplicationContext 继承了 HierarchicalBeanFactory，Hierarchical 单词本身已经能说明问题了，也就是说我们可以在应用中起多个 BeanFactory，然后可以将各个 BeanFactory 设置为父子关系。
3. AutowireCapableBeanFactory 这个名字中的 Autowire 大家都非常熟悉，它就是用来自动装配 Bean 用的，但是仔细看上图，ApplicationContext 并没有继承它，不过不用担心，不使用继承，不代表不可以使用组合，如果你看到 ApplicationContext 接口定义中的最后一个方法 getAutowireCapableBeanFactory() 就知道了。
4. ConfigurableListableBeanFactory 也是一个特殊的接口，看图，特殊之处在于它继承了第二层所有的三个接口，而 ApplicationContext 没有。这点之后会用到。
5. 请先不用花时间在其他的接口和类上，先理解我说的这几点就可以了。

然后，请读者打开编辑器，翻一下 BeanFactory、ListableBeanFactory、HierarchicalBeanFactory、AutowireCapableBeanFactory、ApplicationContext 这几个接口的代码，大概看一下各个接口中的方法，大家心里要有底，限于篇幅，我就不贴代码介绍了。

启动过程分析

下面将会是冗长的代码分析，记住，一定要自己打开源码来看，不然纯看是很累的。

第一步，我们肯定要从 ClassPathXmlApplicationContext 的构造方法说起。

1public class ClassPathXmlApplicationContext extends AbstractXmlApplicationContext {
2  private Resource[] configResources;
3
4  // 如果已经有 ApplicationContext 并需要配置成父子关系，那么调用这个构造方法
5  public ClassPathXmlApplicationContext(ApplicationContext parent) {
6    super(parent);
7  }
8  ...
9  public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
10      throws BeansException {
11
12    super(parent);
13    // 根据提供的路径，处理成配置文件数组(以分号、逗号、空格、tab、换行符分割)
14    setConfigLocations(configLocations);
15    if (refresh) {
16      refresh(); // 核心方法
17    }
18  }
19    ...
20}

接下来，就是 refresh()，这里简单说下为什么是 refresh()，而不是 init() 这种名字的方法。因为 ApplicationContext 建立起来以后，其实我们是可以通过调用 refresh() 这个方法重建的，refresh() 会将原来的 ApplicationContext 销毁，然后再重新执行一次初始化操作。

往下看，refresh() 方法里面调用了那么多方法，就知道肯定不简单了，请读者先看个大概，细节之后会详细说。

1@Override
2public void refresh() throws BeansException, IllegalStateException {
3   // 来个锁，不然 refresh() 还没结束，你又来个启动或销毁容器的操作，那不就乱套了嘛
4   synchronized (this.startupShutdownMonitor) {
5
6      // 准备工作，记录下容器的启动时间、标记“已启动”状态、处理配置文件中的占位符
7      prepareRefresh();
8
9      // 这步比较关键，这步完成后，配置文件就会解析成一个个 Bean 定义，注册到 BeanFactory 中，
10      // 当然，这里说的 Bean 还没有初始化，只是配置信息都提取出来了，
11      // 注册也只是将这些信息都保存到了注册中心(说到底核心是一个 beanName-> beanDefinition 的 map)
12      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
13
14      // 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean
15      // 这块待会会展开说
16      prepareBeanFactory(beanFactory);
17
18      try {
19         // 【这里需要知道 BeanFactoryPostProcessor 这个知识点，Bean 如果实现了此接口，
20         // 那么在容器初始化以后，Spring 会负责调用里面的 postProcessBeanFactory 方法。】
21
22         // 这里是提供给子类的扩展点，到这里的时候，所有的 Bean 都加载、注册完成了，但是都还没有初始化
23         // 具体的子类可以在这步的时候添加一些特殊的 BeanFactoryPostProcessor 的实现类或做点什么事
24         postProcessBeanFactory(beanFactory);
25         // 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 方法
26         invokeBeanFactoryPostProcessors(beanFactory);
27
28         // 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别
29         // 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
30         // 两个方法分别在 Bean 初始化之前和初始化之后得到执行。注意，到这里 Bean 还没初始化
31         registerBeanPostProcessors(beanFactory);
32
33         // 初始化当前 ApplicationContext 的 MessageSource，国际化这里就不展开说了，不然没完没了了
34         initMessageSource();
35
36         // 初始化当前 ApplicationContext 的事件广播器，这里也不展开了
37         initApplicationEventMulticaster();
38
39         // 从方法名就可以知道，典型的模板方法(钩子方法)，
40         // 具体的子类可以在这里初始化一些特殊的 Bean（在初始化 singleton beans 之前）
41         onRefresh();
42
43         // 注册事件监听器，监听器需要实现 ApplicationListener 接口。这也不是我们的重点，过
44         registerListeners();
45
46         // 重点，重点，重点
47         // 初始化所有的 singleton beans
48         //（lazy-init 的除外）
49         finishBeanFactoryInitialization(beanFactory);
50
51         // 最后，广播事件，ApplicationContext 初始化完成
52         finishRefresh();
53      }
54
55      catch (BeansException ex) {
56         if (logger.isWarnEnabled()) {
57            logger.warn("Exception encountered during context initialization - " +
58                  "cancelling refresh attempt: " + ex);
59         }
60
61         // Destroy already created singletons to avoid dangling resources.
62         // 销毁已经初始化的 singleton 的 Beans，以免有些 bean 会一直占用资源
63         destroyBeans();
64
65         // Reset 'active' flag.
66         cancelRefresh(ex);
67
68         // 把异常往外抛
69         throw ex;
70      }
71
72      finally {
73         // Reset common introspection caches in Spring's core, since we
74         // might not ever need metadata for singleton beans anymore...
75         resetCommonCaches();
76      }
77   }
78}

下面，我们开始一步步来肢解这个 refresh() 方法。

创建 Bean 容器前的准备工作

这个比较简单，直接看代码中的几个注释即可。

1protected void prepareRefresh() {
2   // 记录启动时间，
3   // 将 active 属性设置为 true，closed 属性设置为 false，它们都是 AtomicBoolean 类型
4   this.startupDate = System.currentTimeMillis();
5   this.closed.set(false);
6   this.active.set(true);
7
8   if (logger.isInfoEnabled()) {
9      logger.info("Refreshing " + this);
10   }
11
12   // Initialize any placeholder property sources in the context environment
13   initPropertySources();
14
15   // 校验 xml 配置文件
16   getEnvironment().validateRequiredProperties();
17
18   this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
19}

创建 Bean 容器，加载并注册 Bean

我们回到 refresh() 方法中的下一行 obtainFreshBeanFactory()。

注意，这个方法是全文最重要的部分之一，这里将会初始化 BeanFactory、加载 Bean、注册 Bean 等等。

当然，这步结束后，Bean 并没有完成初始化。这里指的是 Bean 实例并未在这一步生成。

// AbstractApplicationContext.java

1protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
2   // 关闭旧的 BeanFactory (如果有)，创建新的 BeanFactory，加载 Bean 定义、注册 Bean 等等
3   refreshBeanFactory();
4
5   // 返回刚刚创建的 BeanFactory
6   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
7   if (logger.isDebugEnabled()) {
8      logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
9   }
10   return beanFactory;
11}

// AbstractRefreshableApplicationContext.java 120

1@Override
2protected final void refreshBeanFactory() throws BeansException {
3   // 如果 ApplicationContext 中已经加载过 BeanFactory 了，销毁所有 Bean，关闭 BeanFactory
4   // 注意，应用中 BeanFactory 本来就是可以多个的，这里可不是说应用全局是否有 BeanFactory，而是当前
5   // ApplicationContext 是否有 BeanFactory
6   if (hasBeanFactory()) {
7      destroyBeans();
8      closeBeanFactory();
9   }
10   try {
11      // 初始化一个 DefaultListableBeanFactory，为什么用这个，我们马上说。
12      DefaultListableBeanFactory beanFactory = createBeanFactory();
13      // 用于 BeanFactory 的序列化，我想不部分人应该都用不到
14      beanFactory.setSerializationId(getId());
15
16      // 下面这两个方法很重要，别跟丢了，具体细节之后说
17      // 设置 BeanFactory 的两个配置属性：是否允许 Bean 覆盖、是否允许循环引用
18      customizeBeanFactory(beanFactory);
19
20      // 加载 Bean 到 BeanFactory 中
21      loadBeanDefinitions(beanFactory);
22      synchronized (this.beanFactoryMonitor) {
23         this.beanFactory = beanFactory;
24      }
25   }
26   catch (IOException ex) {
27      throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
28   }
29}

看到这里的时候，我觉得读者就应该站在高处看 ApplicationContext 了，ApplicationContext 继承自 BeanFactory，但是它不应该被理解为 BeanFactory 的实现类，而是说其内部持有一个实例化的 BeanFactory（DefaultListableBeanFactory）。以后所有的 BeanFactory 相关的操作其实是委托给这个实例来处理的。

我们说说为什么选择实例化 DefaultListableBeanFactory ？前面我们说了有个很重要的接口 ConfigurableListableBeanFactory，它实现了 BeanFactory 下面一层的所有三个接口，我把之前的继承图再拿过来大家再仔细看一下：

我们可以看到 ConfigurableListableBeanFactory 只有一个实现类 DefaultListableBeanFactory，而且实现类 DefaultListableBeanFactory 还通过实现右边的 AbstractAutowireCapableBeanFactory 通吃了右路。所以结论就是，最底下这个家伙 DefaultListableBeanFactory 基本上是最牛的 BeanFactory 了，这也是为什么这边会使用这个类来实例化的原因。

如果你想要在程序运行的时候动态往 Spring IOC 容器注册新的 bean，就会使用到这个类。那我们怎么在运行时获得这个实例呢？

之前我们说过 ApplicationContext 接口能获取到 AutowireCapableBeanFactory，就是最右上角那个，然后它向下转型就能得到 DefaultListableBeanFactory 了。

在继续往下之前，我们需要先了解 BeanDefinition。我们说 BeanFactory 是 Bean 容器，那么 Bean 又是什么呢？

这里的 BeanDefinition 就是我们所说的 Spring 的 Bean，我们自己定义的各个 Bean 其实会转换成一个个 BeanDefinition 存在于 Spring 的 BeanFactory 中。

所以，如果有人问你 Bean 是什么的时候，你要知道 Bean 在代码层面上可以认为是 BeanDefinition 的实例。

BeanDefinition 中保存了我们的 Bean 信息，比如这个 Bean 指向的是哪个类、是否是单例的、是否懒加载、这个 Bean 依赖了哪些 Bean 等等。

BeanDefinition 接口定义

我们来看下 BeanDefinition 的接口定义：

1public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
2
3   // 我们可以看到，默认只提供 sington 和 prototype 两种，
4   // 很多读者可能知道还有 request, session, globalSession, application, websocket 这几种，
5   // 不过，它们属于基于 web 的扩展。
6   String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
7   String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;
8
9   // 比较不重要，直接跳过吧
10   int ROLE_APPLICATION = 0;
11   int ROLE_SUPPORT = 1;
12   int ROLE_INFRASTRUCTURE = 2;
13
14   // 设置父 Bean，这里涉及到 bean 继承，不是 java 继承。请参见附录的详细介绍
15   // 一句话就是：继承父 Bean 的配置信息而已
16   void setParentName(String parentName);
17
18   // 获取父 Bean
19   String getParentName();
20
21   // 设置 Bean 的类名称，将来是要通过反射来生成实例的
22   void setBeanClassName(String beanClassName);
23
24   // 获取 Bean 的类名称
25   String getBeanClassName();
26
27
28   // 设置 bean 的 scope
29   void setScope(String scope);
30
31   String getScope();
32
33   // 设置是否懒加载
34   void setLazyInit(boolean lazyInit);
35
36   boolean isLazyInit();
37
38   // 设置该 Bean 依赖的所有的 Bean，注意，这里的依赖不是指属性依赖(如 @Autowire 标记的)，
39   // 是 depends-on="" 属性设置的值。
40   void setDependsOn(String... dependsOn);
41
42   // 返回该 Bean 的所有依赖
43   String[] getDependsOn();
44
45   // 设置该 Bean 是否可以注入到其他 Bean 中，只对根据类型注入有效，
46   // 如果根据名称注入，即使这边设置了 false，也是可以的
47   void setAutowireCandidate(boolean autowireCandidate);
48
49   // 该 Bean 是否可以注入到其他 Bean 中
50   boolean isAutowireCandidate();
51
52   // 主要的。同一接口的多个实现，如果不指定名字的话，Spring 会优先选择设置 primary 为 true 的 bean
53   void setPrimary(boolean primary);
54
55   // 是否是 primary 的
56   boolean isPrimary();
57
58   // 如果该 Bean 采用工厂方法生成，指定工厂名称。对工厂不熟悉的读者，请参加附录
59   // 一句话就是：有些实例不是用反射生成的，而是用工厂模式生成的
60   void setFactoryBeanName(String factoryBeanName);
61   // 获取工厂名称
62   String getFactoryBeanName();
63   // 指定工厂类中的 工厂方法名称
64   void setFactoryMethodName(String factoryMethodName);
65   // 获取工厂类中的 工厂方法名称
66   String getFactoryMethodName();
67
68   // 构造器参数
69   ConstructorArgumentValues getConstructorArgumentValues();
70
71   // Bean 中的属性值，后面给 bean 注入属性值的时候会说到
72   MutablePropertyValues getPropertyValues();
73
74   // 是否 singleton
75   boolean isSingleton();
76
77   // 是否 prototype
78   boolean isPrototype();
79
80   // 如果这个 Bean 是被设置为 abstract，那么不能实例化，
81   // 常用于作为 父bean 用于继承，其实也很少用......
82   boolean isAbstract();
83
84   int getRole();
85   String getDescription();
86   String getResourceDescription();
87   BeanDefinition getOriginatingBeanDefinition();
88}

这个 BeanDefinition 其实已经包含很多的信息了，暂时不清楚所有的方法对应什么东西没关系，希望看完本文后读者可以彻底搞清楚里面的所有东西。

这里接口虽然那么多，但是没有类似 getInstance() 这种方法来获取我们定义的类的实例，真正的我们定义的类生成的实例到哪里去了呢？别着急，这个要很后面才能讲到。

有了 BeanDefinition 的概念以后，我们再往下看 refreshBeanFactory() 方法中的剩余部分：

1customizeBeanFactory(beanFactory);
2loadBeanDefinitions(beanFactory);

虽然只有两个方法，但路还很长啊。。。

customizeBeanFactory

customizeBeanFactory(beanFactory) 比较简单，就是配置是否允许 BeanDefinition 覆盖、是否允许循环引用。

1protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
2   if (this.allowBeanDefinitionOverriding != null) {
3      // 是否允许 Bean 定义覆盖
4      beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
5   }
6   if (this.allowCircularReferences != null) {
7      // 是否允许 Bean 间的循环依赖
8      beanFactory.setAllowCircularReferences(this.allowCircularReferences);
9   }
10}

BeanDefinition 的覆盖问题可能会有开发者碰到这个坑，就是在配置文件中定义 bean 时使用了相同的 id 或 name，默认情况下，allowBeanDefinitionOverriding 属性为 null，如果在同一配置文件中重复了，会抛错，但是如果不是同一配置文件中，会发生覆盖。

循环引用也很好理解：A 依赖 B，而 B 依赖 A。或 A 依赖 B，B 依赖 C，而 C 依赖 A。

默认情况下，Spring 允许循环依赖，当然如果你在 A 的构造方法中依赖 B，在 B 的构造方法中依赖 A 是不行的。

至于这两个属性怎么配置？我在附录中进行了介绍，尤其对于覆盖问题，很多人都希望禁止出现 Bean 覆盖，可是 Spring 默认是不同文件的时候可以覆盖的。

之后的源码中还会出现这两个属性，读者有个印象就可以了。

加载 Bean: loadBeanDefinitions

接下来是最重要的 loadBeanDefinitions(beanFactory) 方法了，这个方法将根据配置，加载各个 Bean，然后放到 BeanFactory 中。

读取配置的操作在 XmlBeanDefinitionReader 中，其负责加载配置、解析。

// AbstractXmlApplicationContext.java 80

1/** 我们可以看到，此方法将通过一个 XmlBeanDefinitionReader 实例来加载各个 Bean。*/
2@Override
3protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
4   // 给这个 BeanFactory 实例化一个 XmlBeanDefinitionReader
5   XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
6
7   // Configure the bean definition reader with this context's
8   // resource loading environment.
9   beanDefinitionReader.setEnvironment(this.getEnvironment());
10   beanDefinitionReader.setResourceLoader(this);
11   beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
12
13   // 初始化 BeanDefinitionReader，其实这个是提供给子类覆写的，
14   // 我看了一下，没有类覆写这个方法，我们姑且当做不重要吧
15   initBeanDefinitionReader(beanDefinitionReader);
16   // 重点来了，继续往下
17   loadBeanDefinitions(beanDefinitionReader);
18}

现在还在这个类中，接下来用刚刚初始化的 Reader 开始来加载 xml 配置，这块代码读者可以选择性跳过，不是很重要。也就是说，下面这个代码块，读者可以很轻松地略过。

// AbstractXmlApplicationContext.java 120

1protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
2   Resource[] configResources = getConfigResources();
3   if (configResources != null) {
4      // 往下看
5      reader.loadBeanDefinitions(configResources);
6   }
7   String[] configLocations = getConfigLocations();
8   if (configLocations != null) {
9      // 2
10      reader.loadBeanDefinitions(configLocations);
11   }
12}
13
14// 上面虽然有两个分支，不过第二个分支很快通过解析路径转换为 Resource 以后也会进到这里
15@Override
16public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
17   Assert.notNull(resources, "Resource array must not be null");
18   int counter = 0;
19   // 注意这里是个 for 循环，也就是每个文件是一个 resource
20   for (Resource resource : resources) {
21      // 继续往下看
22      counter += loadBeanDefinitions(resource);
23   }
24   // 最后返回 counter，表示总共加载了多少的 BeanDefinition
25   return counter;
26}
27
28// XmlBeanDefinitionReader 303
29@Override
30public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
31   return loadBeanDefinitions(new EncodedResource(resource));
32}
33
34// XmlBeanDefinitionReader 314
35public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
36   Assert.notNull(encodedResource, "EncodedResource must not be null");
37   if (logger.isInfoEnabled()) {
38      logger.info("Loading XML bean definitions from " + encodedResource.getResource());
39   }
40   // 用一个 ThreadLocal 来存放配置文件资源
41   Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
42   if (currentResources == null) {
43      currentResources = new HashSet<EncodedResource>(4);
44      this.resourcesCurrentlyBeingLoaded.set(currentResources);
45   }
46   if (!currentResources.add(encodedResource)) {
47      throw new BeanDefinitionStoreException(
48            "Detected cyclic loading of " + encodedResource + " - check your import definitions!");
49   }
50   try {
51      InputStream inputStream = encodedResource.getResource().getInputStream();
52      try {
53         InputSource inputSource = new InputSource(inputStream);
54         if (encodedResource.getEncoding() != null) {
55            inputSource.setEncoding(encodedResource.getEncoding());
56         }
57         // 核心部分是这里，往下面看
58         return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
59      }
60      finally {
61         inputStream.close();
62      }
63   }
64   catch (IOException ex) {
65      throw new BeanDefinitionStoreException(
66            "IOException parsing XML document from " + encodedResource.getResource(), ex);
67   }
68   finally {
69      currentResources.remove(encodedResource);
70      if (currentResources.isEmpty()) {
71         this.resourcesCurrentlyBeingLoaded.remove();
72      }
73   }
74}
75
76// 还在这个文件中，第 388 行
77protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
78      throws BeanDefinitionStoreException {
79   try {
80      // 这里就不看了，将 xml 文件转换为 Document 对象
81      Document doc = doLoadDocument(inputSource, resource);
82      // 继续
83      return registerBeanDefinitions(doc, resource);
84   }
85   catch (...
86}
87// 还在这个文件中，第 505 行
88// 返回值：返回从当前配置文件加载了多少数量的 Bean
89public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
90   BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
91   int countBefore = getRegistry().getBeanDefinitionCount();
92   // 这里
93   documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
94   return getRegistry().getBeanDefinitionCount() - countBefore;
95}
96// DefaultBeanDefinitionDocumentReader 90
97@Override
98public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
99   this.readerContext = readerContext;
100   logger.debug("Loading bean definitions");
101   Element root = doc.getDocumentElement();
102   // 从 xml 根节点开始解析文件
103   doRegisterBeanDefinitions(root);
104}         

经过漫长的链路，一个配置文件终于转换为一颗 DOM 树了，注意，这里指的是其中一个配置文件，不是所有的，读者可以看到上面有个 for 循环的。下面开始从根节点开始解析：

doRegisterBeanDefinitions：

1// DefaultBeanDefinitionDocumentReader 116
2protected void doRegisterBeanDefinitions(Element root) {
3   // 我们看名字就知道，BeanDefinitionParserDelegate 必定是一个重要的类，它负责解析 Bean 定义，
4   // 这里为什么要定义一个 parent? 看到后面就知道了，是递归问题，
5   // 因为 <beans /> 内部是可以定义 <beans /> 的，所以这个方法的 root 其实不一定就是 xml 的根节点，也可以是嵌套在里面的 <beans /> 节点，从源码分析的角度，我们当做根节点就好了
6   BeanDefinitionParserDelegate parent = this.delegate;
7   this.delegate = createDelegate(getReaderContext(), root, parent);
8
9   if (this.delegate.isDefaultNamespace(root)) {
10      // 这块说的是根节点 <beans ... profile="dev" /> 中的 profile 是否是当前环境需要的，
11      // 如果当前环境配置的 profile 不包含此 profile，那就直接 return 了，不对此 <beans /> 解析
12      // 不熟悉 profile 为何物，不熟悉怎么配置 profile 读者的请移步附录区
13      String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
14      if (StringUtils.hasText(profileSpec)) {
15         String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
16               profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
17         if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
18            if (logger.isInfoEnabled()) {
19               logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
20                     "] not matching: " + getReaderContext().getResource());
21            }
22            return;
23         }
24      }
25   }
26
27   preProcessXml(root); // 钩子
28   // 往下看
29   parseBeanDefinitions(root, this.delegate);
30   postProcessXml(root); // 钩子
31
32   this.delegate = parent;
33}

preProcessXml(root) 和 postProcessXml(root) 是给子类用的钩子方法，鉴于没有被使用到，也不是我们的重点，我们直接跳过。

这里涉及到了 profile 的问题，对于不了解的读者，我在附录中对 profile 做了简单的解释，读者可以参考一下。

接下来，看核心解析方法 parseBeanDefinitions(root, this.delegate) :

1// default namespace 涉及到的就四个标签 <import />、<alias />、<bean /> 和 <beans />，
2// 其他的属于 custom 的
3protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
4   if (delegate.isDefaultNamespace(root)) {
5      NodeList nl = root.getChildNodes();
6      for (int i = 0; i < nl.getLength(); i++) {
7         Node node = nl.item(i);
8         if (node instanceof Element) {
9            Element ele = (Element) node;
10            if (delegate.isDefaultNamespace(ele)) {
11               // 解析 default namespace 下面的几个元素
12               parseDefaultElement(ele, delegate);
13            }
14            else {
15               // 解析其他 namespace 的元素
16               delegate.parseCustomElement(ele);
17            }
18         }
19      }
20   }
21   else {
22      delegate.parseCustomElement(root);
23   }
24}

从上面的代码，我们可以看到，对于每个配置来说，分别进入到 parseDefaultElement(ele, delegate); 和 delegate.parseCustomElement(ele); 这两个分支了。

parseDefaultElement(ele, delegate) 代表解析的节点是 <import />、<alias />、<bean />、<beans /> 这几个。

这里的四个标签之所以是 default 的，是因为它们是处于这个 namespace 下定义的：

http://www.springframework.org/schema/beans

又到初学者科普时间，不熟悉 namespace 的读者请看下面贴出来的 xml，这里的第二行 xmlns 就是咯。

1<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
2       xmlns="http://www.springframework.org/schema/beans"
3       xsi:schemaLocation="
4            http://www.springframework.org/schema/beans
5          http://www.springframework.org/schema/beans/spring-beans.xsd"
6       default-autowire="byName">

而对于其他的标签，将进入到 delegate.parseCustomElement(element) 这个分支。如我们经常会使用到的 <mvc />、<task />、<context />、<aop />等。

这些属于扩展，如果需要使用上面这些 ”非 default“ 标签，那么上面的 xml 头部的地方也要引入相应的 namespace 和 .xsd 文件的路径，如下所示。同时代码中需要提供相应的 parser 来解析，如 MvcNamespaceHandler、TaskNamespaceHandler、ContextNamespaceHandler、AopNamespaceHandler 等。

假如读者想分析 <context:property-placeholder location="classpath:xx.properties" /> 的实现原理，就应该到 ContextNamespaceHandler 中找答案。

1<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
2      xmlns="http://www.springframework.org/schema/beans"
3      xmlns:context="http://www.springframework.org/schema/context"
4      xmlns:mvc="http://www.springframework.org/schema/mvc"
5      xsi:schemaLocation="
6           http://www.springframework.org/schema/beans 
7           http://www.springframework.org/schema/beans/spring-beans.xsd
8           http://www.springframework.org/schema/context
9           http://www.springframework.org/schema/context/spring-context.xsd
10           http://www.springframework.org/schema/mvc   
11           http://www.springframework.org/schema/mvc/spring-mvc.xsd  
12       "
13      default-autowire="byName">

回过神来，看看处理 default 标签的方法：

1private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
2   if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
3      // 处理 <import /> 标签
4      importBeanDefinitionResource(ele);
5   }
6   else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
7      // 处理 <alias /> 标签定义
8      // <alias name="fromName" alias="toName"/>
9      processAliasRegistration(ele);
10   }
11   else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
12      // 处理 <bean /> 标签定义，这也算是我们的重点吧
13      processBeanDefinition(ele, delegate);
14   }
15   else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
16      // 如果碰到的是嵌套的 <beans /> 标签，需要递归
17      doRegisterBeanDefinitions(ele);
18   }
19}

如果每个标签都说，那我不吐血，你们都要吐血了。我们挑我们的重点 <bean /> 标签出来说。

processBeanDefinition 解析 bean 标签

下面是 processBeanDefinition 解析 <bean /> 标签：

// DefaultBeanDefinitionDocumentReader 298

1protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
2   // 将 <bean /> 节点中的信息提取出来，然后封装到一个 BeanDefinitionHolder 中，细节往下看
3   BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
4
5   // 下面的几行先不要看，跳过先，跳过先，跳过先，后面会继续说的
6
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}

继续往下看怎么解析之前，我们先看下 <bean /> 标签中可以定义哪些属性：

Property

class

类的全限定名

name

可指定 id、name(用逗号、分号、空格分隔)

scope

作用域

constructor arguments

指定构造参数

properties

设置属性的值

autowiring mode

no(默认值)、byName、byType、 constructor

lazy-initialization mode

是否懒加载(如果被非懒加载的bean依赖了那么其实也就不能懒加载了)

initialization method

bean 属性设置完成后，会调用这个方法

destruction method

bean 销毁后的回调方法

上面表格中的内容我想大家都非常熟悉吧，如果不熟悉，那就是你不够了解 Spring 的配置了。

简单地说就是像下面这样子：

1<bean id="exampleBean" name="name1, name2, name3" class="com.javadoop.ExampleBean"
2      scope="singleton" lazy-init="true" init-method="init" destroy-method="cleanup">
3
4    <!-- 可以用下面三种形式指定构造参数 -->
5    <constructor-arg type="int" value="7500000"/>
6    <constructor-arg name="years" value="7500000"/>
7    <constructor-arg index="0" value="7500000"/>
8
9    <!-- property 的几种情况 -->
10    <property name="beanOne">
11        <ref bean="anotherExampleBean"/>
12    </property>
13    <property name="beanTwo" ref="yetAnotherBean"/>
14    <property name="integerProperty" value="1"/>
15</bean>

当然，除了上面举例出来的这些，还有 factory-bean、factory-method、<lockup-method />、<replaced-method />、<meta />、<qualifier /> 这几个，大家是不是熟悉呢？自己检验一下自己对 Spring 中 bean 的了解程度。

有了以上这些知识以后，我们再继续往里看怎么解析 bean 元素，是怎么转换到 BeanDefinitionHolder 的。

// BeanDefinitionParserDelegate 428

1public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
2    return parseBeanDefinitionElement(ele, null);
3}
4
5public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
6   String id = ele.getAttribute(ID_ATTRIBUTE);
7   String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
8
9   List<String> aliases = new ArrayList<String>();
10
11   // 将 name 属性的定义按照 “逗号、分号、空格” 切分，形成一个 别名列表数组，
12   // 当然，如果你不定义 name 属性的话，就是空的了
13   // 我在附录中简单介绍了一下 id 和 name 的配置，大家可以看一眼，有个20秒就可以了
14   if (StringUtils.hasLength(nameAttr)) {
15      String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
16      aliases.addAll(Arrays.asList(nameArr));
17   }
18
19   String beanName = id;
20   // 如果没有指定id, 那么用别名列表的第一个名字作为beanName
21   if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
22      beanName = aliases.remove(0);
23      if (logger.isDebugEnabled()) {
24         logger.debug("No XML 'id' specified - using '" + beanName +
25               "' as bean name and " + aliases + " as aliases");
26      }
27   }
28
29   if (containingBean == null) {
30      checkNameUniqueness(beanName, aliases, ele);
31   }
32
33   // 根据 <bean ...>...</bean> 中的配置创建 BeanDefinition，然后把配置中的信息都设置到实例中,
34   // 细节后面细说，先知道下面这行结束后，一个 BeanDefinition 实例就出来了。
35   AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
36
37   // 到这里，整个 <bean /> 标签就算解析结束了，一个 BeanDefinition 就形成了。
38   if (beanDefinition != null) {
39      // 如果都没有设置 id 和 name，那么此时的 beanName 就会为 null，进入下面这块代码产生
40      // 如果读者不感兴趣的话，我觉得不需要关心这块代码，对本文源码分析来说，这些东西不重要
41      if (!StringUtils.hasText(beanName)) {
42         try {
43            if (containingBean != null) {// 按照我们的思路，这里 containingBean 是 null 的
44               beanName = BeanDefinitionReaderUtils.generateBeanName(
45                     beanDefinition, this.readerContext.getRegistry(), true);
46            }
47            else {
48               // 如果我们不定义 id 和 name，那么我们引言里的那个例子：
49               //   1. beanName 为：com.javadoop.example.MessageServiceImpl#0
50               //   2. beanClassName 为：com.javadoop.example.MessageServiceImpl
51
52               beanName = this.readerContext.generateBeanName(beanDefinition);
53
54               String beanClassName = beanDefinition.getBeanClassName();
55               if (beanClassName != null &&
56                     beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
57                     !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
58                  // 把 beanClassName 设置为 Bean 的别名
59                  aliases.add(beanClassName);
60               }
61            }
62            if (logger.isDebugEnabled()) {
63               logger.debug("Neither XML 'id' nor 'name' specified - " +
64                     "using generated bean name [" + beanName + "]");
65            }
66         }
67         catch (Exception ex) {
68            error(ex.getMessage(), ele);
69            return null;
70         }
71      }
72      String[] aliasesArray = StringUtils.toStringArray(aliases);
73      // 返回 BeanDefinitionHolder
74      return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
75   }
76
77   return null;
78}

然后，我们再看看怎么根据配置创建 BeanDefinition 实例的：

1public AbstractBeanDefinition parseBeanDefinitionElement(
2      Element ele, String beanName, BeanDefinition containingBean) {
3
4   this.parseState.push(new BeanEntry(beanName));
5
6   String className = null;
7   if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
8      className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
9   }
10
11   try {
12      String parent = null;
13      if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
14         parent = ele.getAttribute(PARENT_ATTRIBUTE);
15      }
16      // 创建 BeanDefinition，然后设置类信息而已，很简单，就不贴代码了
17      AbstractBeanDefinition bd = createBeanDefinition(className, parent);
18
19      // 设置 BeanDefinition 的一堆属性，这些属性定义在 AbstractBeanDefinition 中
20      parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
21      bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
22
23      /**
24       * 下面的一堆是解析 <bean>......</bean> 内部的子元素，
25       * 解析出来以后的信息都放到 bd 的属性中
26       */
27
28      // 解析 <meta />
29      parseMetaElements(ele, bd);
30      // 解析 <lookup-method />
31      parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
32      // 解析 <replaced-method />
33      parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
34    // 解析 <constructor-arg />
35      parseConstructorArgElements(ele, bd);
36      // 解析 <property />
37      parsePropertyElements(ele, bd);
38      // 解析 <qualifier />
39      parseQualifierElements(ele, bd);
40
41      bd.setResource(this.readerContext.getResource());
42      bd.setSource(extractSource(ele));
43
44      return bd;
45   }
46   catch (ClassNotFoundException ex) {
47      error("Bean class [" + className + "] not found", ele, ex);
48   }
49   catch (NoClassDefFoundError err) {
50      error("Class that bean class [" + className + "] depends on not found", ele, err);
51   }
52   catch (Throwable ex) {
53      error("Unexpected failure during bean definition parsing", ele, ex);
54   }
55   finally {
56      this.parseState.pop();
57   }
58
59   return null;
60}

到这里，我们已经完成了根据 <bean /> 配置创建了一个 BeanDefinitionHolder 实例。注意，是一个。

我们回到解析 <bean /> 的入口方法:

1protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
2   // 将 <bean /> 节点转换为 BeanDefinitionHolder，就是上面说的一堆
3   BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
4   if (bdHolder != null) {
5      // 如果有自定义属性的话，进行相应的解析，先忽略
6      bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
7      try {
8         // 我们把这步叫做 注册Bean 吧
9         BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
10      }
11      catch (BeanDefinitionStoreException ex) {
12         getReaderContext().error("Failed to register bean definition with name '" +
13               bdHolder.getBeanName() + "'", ele, ex);
14      }
15      // 注册完成后，发送事件，本文不展开说这个
16      getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
17   }
18}

大家再仔细看一下这块吧，我们后面就不回来说这个了。这里已经根据一个 <bean /> 标签产生了一个 BeanDefinitionHolder 的实例，这个实例里面也就是一个 BeanDefinition 的实例和它的 beanName、aliases 这三个信息，注意，我们的关注点始终在 BeanDefinition 上：

1public class BeanDefinitionHolder implements BeanMetadataElement {
2
3  private final BeanDefinition beanDefinition;
4
5  private final String beanName;
6
7  private final String[] aliases;
8...

然后我们准备注册这个 BeanDefinition，最后，把这个注册事件发送出去。

下面，我们开始说说注册 Bean 吧。

注册 Bean

// BeanDefinitionReaderUtils 143

1public static void registerBeanDefinition(
2      BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
3      throws BeanDefinitionStoreException {
4
5   String beanName = definitionHolder.getBeanName();
6   // 注册这个 Bean
7   registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
8
9   // 如果还有别名的话，也要根据别名全部注册一遍，不然根据别名就会找不到 Bean 了
10   String[] aliases = definitionHolder.getAliases();
11   if (aliases != null) {
12      for (String alias : aliases) {
13         // alias -> beanName 保存它们的别名信息，这个很简单，用一个 map 保存一下就可以了，
14         // 获取的时候，会先将 alias 转换为 beanName，然后再查找
15         registry.registerAlias(beanName, alias);
16      }
17   }
18}

别名注册的放一边，毕竟它很简单，我们看看怎么注册 Bean。

// DefaultListableBeanFactory 793

1@Override
2public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
3      throws BeanDefinitionStoreException {
4
5   Assert.hasText(beanName, "Bean name must not be empty");
6   Assert.notNull(beanDefinition, "BeanDefinition must not be null");
7
8   if (beanDefinition instanceof AbstractBeanDefinition) {
9      try {
10         ((AbstractBeanDefinition) beanDefinition).validate();
11      }
12      catch (BeanDefinitionValidationException ex) {
13         throw new BeanDefinitionStoreException(...);
14      }
15   }
16
17   // old? 还记得 “允许 bean 覆盖” 这个配置吗？allowBeanDefinitionOverriding
18   BeanDefinition oldBeanDefinition;
19
20   // 之后会看到，所有的 Bean 注册后会放入这个 beanDefinitionMap 中
21   oldBeanDefinition = this.beanDefinitionMap.get(beanName);
22
23   // 处理重复名称的 Bean 定义的情况
24   if (oldBeanDefinition != null) {
25      if (!isAllowBeanDefinitionOverriding()) {
26         // 如果不允许覆盖的话，抛异常
27         throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription()...
28      }
29      else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
30         // log...用框架定义的 Bean 覆盖用户自定义的 Bean 
31      }
32      else if (!beanDefinition.equals(oldBeanDefinition)) {
33         // log...用新的 Bean 覆盖旧的 Bean
34      }
35      else {
36         // log...用同等的 Bean 覆盖旧的 Bean，这里指的是 equals 方法返回 true 的 Bean
37      }
38      // 覆盖
39      this.beanDefinitionMap.put(beanName, beanDefinition);
40   }
41   else {
42      // 判断是否已经有其他的 Bean 开始初始化了.
43      // 注意，"注册Bean" 这个动作结束，Bean 依然还没有初始化，我们后面会有大篇幅说初始化过程，
44      // 在 Spring 容器启动的最后，会 预初始化 所有的 singleton beans
45      if (hasBeanCreationStarted()) {
46         // Cannot modify startup-time collection elements anymore (for stable iteration)
47         synchronized (this.beanDefinitionMap) {
48            this.beanDefinitionMap.put(beanName, beanDefinition);
49            List<String> updatedDefinitions = new ArrayList<String>(this.beanDefinitionNames.size() + 1);
50            updatedDefinitions.addAll(this.beanDefinitionNames);
51            updatedDefinitions.add(beanName);
52            this.beanDefinitionNames = updatedDefinitions;
53            if (this.manualSingletonNames.contains(beanName)) {
54               Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames);
55               updatedSingletons.remove(beanName);
56               this.manualSingletonNames = updatedSingletons;
57            }
58         }
59      }
60      else {
61         // 最正常的应该是进到这个分支。
62
63         // 将 BeanDefinition 放到这个 map 中，这个 map 保存了所有的 BeanDefinition
64         this.beanDefinitionMap.put(beanName, beanDefinition);
65         // 这是个 ArrayList，所以会按照 bean 配置的顺序保存每一个注册的 Bean 的名字
66         this.beanDefinitionNames.add(beanName);
67         // 这是个 LinkedHashSet，代表的是手动注册的 singleton bean，
68         // 注意这里是 remove 方法，到这里的 Bean 当然不是手动注册的
69         // 手动指的是通过调用以下方法注册的 bean ：
70         //     registerSingleton(String beanName, Object singletonObject)
71         // 这不是重点，解释只是为了不让大家疑惑。Spring 会在后面"手动"注册一些 Bean，
72         // 如 "environment"、"systemProperties" 等 bean，我们自己也可以在运行时注册 Bean 到容器中的
73         this.manualSingletonNames.remove(beanName);
74      }
75      // 这个不重要，在预初始化的时候会用到，不必管它。
76      this.frozenBeanDefinitionNames = null;
77   }
78
79   if (oldBeanDefinition != null || containsSingleton(beanName)) {
80      resetBeanDefinition(beanName);
81   }
82}

总结一下，到这里已经初始化了 Bean 容器，<bean /> 配置也相应的转换为了一个个 BeanDefinition，然后注册了各个 BeanDefinition 到注册中心，并且发送了注册事件。

到这里是一个分水岭，前面的内容都还算比较简单，大家要清楚地知道前面都做了哪些事情。

Bean 容器实例化完成后

说到这里，我们回到 refresh() 方法，我重新贴了一遍代码，看看我们说到哪了。是的，我们才说完 obtainFreshBeanFactory() 方法。

考虑到篇幅，这里开始大幅缩减掉没必要详细介绍的部分，大家直接看下面的代码中的注释就好了。

1@Override
2public void refresh() throws BeansException, IllegalStateException {
3   // 来个锁，不然 refresh() 还没结束，你又来个启动或销毁容器的操作，那不就乱套了嘛
4   synchronized (this.startupShutdownMonitor) {
5
6      // 准备工作，记录下容器的启动时间、标记“已启动”状态、处理配置文件中的占位符
7      prepareRefresh();
8
9      // 这步比较关键，这步完成后，配置文件就会解析成一个个 Bean 定义，注册到 BeanFactory 中，
10      // 当然，这里说的 Bean 还没有初始化，只是配置信息都提取出来了，
11      // 注册也只是将这些信息都保存到了注册中心(说到底核心是一个 beanName-> beanDefinition 的 map)
12      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
13
14      // 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean
15      // 这块待会会展开说
16      prepareBeanFactory(beanFactory);
17
18      try {
19         // 【这里需要知道 BeanFactoryPostProcessor 这个知识点，Bean 如果实现了此接口，
20         // 那么在容器初始化以后，Spring 会负责调用里面的 postProcessBeanFactory 方法。】
21
22         // 这里是提供给子类的扩展点，到这里的时候，所有的 Bean 都加载、注册完成了，但是都还没有初始化
23         // 具体的子类可以在这步的时候添加一些特殊的 BeanFactoryPostProcessor 的实现类或做点什么事
24         postProcessBeanFactory(beanFactory);
25         // 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 回调方法
26         invokeBeanFactoryPostProcessors(beanFactory);          
27
28
29
30         // 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别
31         // 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
32         // 两个方法分别在 Bean 初始化之前和初始化之后得到执行。这里仅仅是注册，之后会看到回调这两方法的时机
33         registerBeanPostProcessors(beanFactory);
34
35         // 初始化当前 ApplicationContext 的 MessageSource，国际化这里就不展开说了，不然没完没了了
36         initMessageSource();
37
38         // 初始化当前 ApplicationContext 的事件广播器，这里也不展开了
39         initApplicationEventMulticaster();
40
41         // 从方法名就可以知道，典型的模板方法(钩子方法)，不展开说
42         // 具体的子类可以在这里初始化一些特殊的 Bean（在初始化 singleton beans 之前）
43         onRefresh();
44
45         // 注册事件监听器，监听器需要实现 ApplicationListener 接口。这也不是我们的重点，过
46         registerListeners();
47
48         // 重点，重点，重点
49         // 初始化所有的 singleton beans
50         //（lazy-init 的除外）
51         finishBeanFactoryInitialization(beanFactory);
52
53         // 最后，广播事件，ApplicationContext 初始化完成，不展开
54         finishRefresh();
55      }
56
57      catch (BeansException ex) {
58         if (logger.isWarnEnabled()) {
59            logger.warn("Exception encountered during context initialization - " +
60                  "cancelling refresh attempt: " + ex);
61         }
62
63         // Destroy already created singletons to avoid dangling resources.
64         // 销毁已经初始化的 singleton 的 Beans，以免有些 bean 会一直占用资源
65         destroyBeans();
66
67         // Reset 'active' flag.
68         cancelRefresh(ex);
69
70         // 把异常往外抛
71         throw ex;
72      }
73
74      finally {
75         // Reset common introspection caches in Spring's core, since we
76         // might not ever need metadata for singleton beans anymore...
77         resetCommonCaches();
78      }
79   }
80}

准备 Bean 容器: prepareBeanFactory

之前我们说过，Spring 把我们在 xml 配置的 bean 都注册以后，会"手动"注册一些特殊的 bean。

这里简单介绍下 prepareBeanFactory(factory) 方法：

1/**
2 * Configure the factory's standard context characteristics,
3 * such as the context's ClassLoader and post-processors.
4 * @param beanFactory the BeanFactory to configure
5 */
6protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
7   // 设置 BeanFactory 的类加载器，我们知道 BeanFactory 需要加载类，也就需要类加载器，
8   // 这里设置为加载当前 ApplicationContext 类的类加载器
9   beanFactory.setBeanClassLoader(getClassLoader());
10
11   // 设置 BeanExpressionResolver
12   beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
13   // 
14   beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
15
16   // 添加一个 BeanPostProcessor，这个 processor 比较简单：
17   // 实现了 Aware 接口的 beans 在初始化的时候，这个 processor 负责回调，
18   // 这个我们很常用，如我们会为了获取 ApplicationContext 而 implement ApplicationContextAware
19   // 注意：它不仅仅回调 ApplicationContextAware，
20   //   还会负责回调 EnvironmentAware、ResourceLoaderAware 等，看下源码就清楚了
21   beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
22
23   // 下面几行的意思就是，如果某个 bean 依赖于以下几个接口的实现类，在自动装配的时候忽略它们，
24   // Spring 会通过其他方式来处理这些依赖。
25   beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
26   beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
27   beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
28   beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
29   beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
30   beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
31
32   /**
33    * 下面几行就是为特殊的几个 bean 赋值，如果有 bean 依赖了以下几个，会注入这边相应的值，
34    * 之前我们说过，"当前 ApplicationContext 持有一个 BeanFactory"，这里解释了第一行
35    * ApplicationContext 还继承了 ResourceLoader、ApplicationEventPublisher、MessageSource
36    * 所以对于这几个依赖，可以赋值为 this，注意 this 是一个 ApplicationContext
37    * 那这里怎么没看到为 MessageSource 赋值呢？那是因为 MessageSource 被注册成为了一个普通的 bean
38    */
39   beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
40   beanFactory.registerResolvableDependency(ResourceLoader.class, this);
41   beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
42   beanFactory.registerResolvableDependency(ApplicationContext.class, this);
43
44   // 这个 BeanPostProcessor 也很简单，在 bean 实例化后，如果是 ApplicationListener 的子类，
45   // 那么将其添加到 listener 列表中，可以理解成：注册 事件监听器
46   beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
47
48   // 这里涉及到特殊的 bean，名为：loadTimeWeaver，这不是我们的重点，忽略它
49   // tips: ltw 是 AspectJ 的概念，指的是在运行期进行织入，这个和 Spring AOP 不一样，
50   //    感兴趣的读者请参考我写的关于 AspectJ 的另一篇文章 https://www.javadoop.com/post/aspectj
51   if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
52      beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
53      // Set a temporary ClassLoader for type matching.
54      beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
55   }
56
57   /**
58    * 从下面几行代码我们可以知道，Spring 往往很 "智能" 就是因为它会帮我们默认注册一些有用的 bean，
59    * 我们也可以选择覆盖
60    */
61
62   // 如果没有定义 "environment" 这个 bean，那么 Spring 会 "手动" 注册一个
63   if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
64      beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
65   }
66   // 如果没有定义 "systemProperties" 这个 bean，那么 Spring 会 "手动" 注册一个
67   if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
68      beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
69   }
70   // 如果没有定义 "systemEnvironment" 这个 bean，那么 Spring 会 "手动" 注册一个
71   if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
72      beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
73   }
74}

在上面这块代码中，Spring 对一些特殊的 bean 进行了处理，读者如果暂时还不能消化它们也没有关系，慢慢往下看。

初始化所有的 singleton beans

我们的重点当然是 finishBeanFactoryInitialization(beanFactory); 这个巨头了，这里会负责初始化所有的 singleton beans。

注意，后面的描述中，我都会使用初始化或预初始化来代表这个阶段，Spring 会在这个阶段完成所有的 singleton beans 的实例化。

我们来总结一下，到目前为止，应该说 BeanFactory 已经创建完成，并且所有的实现了 BeanFactoryPostProcessor 接口的 Bean 都已经初始化并且其中的 postProcessBeanFactory(factory) 方法已经得到回调执行了。而且 Spring 已经“手动”注册了一些特殊的 Bean，如 ‘environment’、‘systemProperties’ 等。

剩下的就是初始化 singleton beans 了，我们知道它们是单例的，如果没有设置懒加载，那么 Spring 会在接下来初始化所有的 singleton beans。

// AbstractApplicationContext.java 834

1// 初始化剩余的 singleton beans
2protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
3
4   // 首先，初始化名字为 conversionService 的 Bean。本着送佛送到西的精神，我在附录中简单介绍了一下 ConversionService，因为这实在太实用了
5   // 什么，看代码这里没有初始化 Bean 啊！
6   // 注意了，初始化的动作包装在 beanFactory.getBean(...) 中，这里先不说细节，先往下看吧
7   if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
8         beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
9      beanFactory.setConversionService(
10            beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
11   }
12
13   // Register a default embedded value resolver if no bean post-processor
14   // (such as a PropertyPlaceholderConfigurer bean) registered any before:
15   // at this point, primarily for resolution in annotation attribute values.
16   if (!beanFactory.hasEmbeddedValueResolver()) {
17      beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
18         @Override
19         public String resolveStringValue(String strVal) {
20            return getEnvironment().resolvePlaceholders(strVal);
21         }
22      });
23   }
24
25   // 先初始化 LoadTimeWeaverAware 类型的 Bean
26   // 之前也说过，这是 AspectJ 相关的内容，放心跳过吧
27   String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
28   for (String weaverAwareName : weaverAwareNames) {
29      getBean(weaverAwareName);
30   }
31
32   // Stop using the temporary ClassLoader for type matching.
33   beanFactory.setTempClassLoader(null);
34
35   // 没什么别的目的，因为到这一步的时候，Spring 已经开始预初始化 singleton beans 了，
36   // 肯定不希望这个时候还出现 bean 定义解析、加载、注册。
37   beanFactory.freezeConfiguration();
38
39   // 开始初始化
40   beanFactory.preInstantiateSingletons();
41}

从上面最后一行往里看，我们就又回到 DefaultListableBeanFactory 这个类了，这个类大家应该都不陌生了吧。

preInstantiateSingletons

// DefaultListableBeanFactory 728

1@Override
2public void preInstantiateSingletons() throws BeansException {
3   if (this.logger.isDebugEnabled()) {
4      this.logger.debug("Pre-instantiating singletons in " + this);
5   }
6   // this.beanDefinitionNames 保存了所有的 beanNames
7   List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
8
9   // 触发所有的非懒加载的 singleton beans 的初始化操作
10   for (String beanName : beanNames) {
11
12      // 合并父 Bean 中的配置，注意 <bean id="" class="" parent="" /> 中的 parent，用的不多吧，
13      // 考虑到这可能会影响大家的理解，我在附录中解释了一下 "Bean 继承"，不了解的请到附录中看一下
14      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
15
16      // 非抽象、非懒加载的 singletons。如果配置了 'abstract = true'，那是不需要初始化的
17      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
18         // 处理 FactoryBean(读者如果不熟悉 FactoryBean，请移步附录区了解)
19         if (isFactoryBean(beanName)) {
20            // FactoryBean 的话，在 beanName 前面加上 ‘&’ 符号。再调用 getBean，getBean 方法别急
21            final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
22            // 判断当前 FactoryBean 是否是 SmartFactoryBean 的实现，此处忽略，直接跳过
23            boolean isEagerInit;
24            if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
25               isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
26                  @Override
27                  public Boolean run() {
28                     return ((SmartFactoryBean<?>) factory).isEagerInit();
29                  }
30               }, getAccessControlContext());
31            }
32            else {
33               isEagerInit = (factory instanceof SmartFactoryBean &&
34                     ((SmartFactoryBean<?>) factory).isEagerInit());
35            }
36            if (isEagerInit) {
37
38               getBean(beanName);
39            }
40         }
41         else {
42            // 对于普通的 Bean，只要调用 getBean(beanName) 这个方法就可以进行初始化了
43            getBean(beanName);
44         }
45      }
46   }
47
48
49   // 到这里说明所有的非懒加载的 singleton beans 已经完成了初始化
50   // 如果我们定义的 bean 是实现了 SmartInitializingSingleton 接口的，那么在这里得到回调，忽略
51   for (String beanName : beanNames) {
52      Object singletonInstance = getSingleton(beanName);
53      if (singletonInstance instanceof SmartInitializingSingleton) {
54         final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
55         if (System.getSecurityManager() != null) {
56            AccessController.doPrivileged(new PrivilegedAction<Object>() {
57               @Override
58               public Object run() {
59                  smartSingleton.afterSingletonsInstantiated();
60                  return null;
61               }
62            }, getAccessControlContext());
63         }
64         else {
65            smartSingleton.afterSingletonsInstantiated();
66         }
67      }
68   }
69}