Spring之容器底层原理

本文较长（建议阅读时间30min）

所谓的将组件注入容器中包含两方面，一是组件最先肯定是通过"org.xxxx.ClassName"这样的类限定名写在xml配置中，二是所谓的容器就是集合之类的“容器”，通过xml中的类限定路径，对类实例化，然后存储在“容器”中。

而在Spring中，我们将容器给与一个称呼，而不是直呼其名为什么集合，什么Map之类的，而是叫Spring的容器为ApplicationContext或BeanFactory，没错，Spring中有两种类型的容器。而两个容器有什么区别，容器内部究竟是通过ArrayList或Map怎么样实现的容器功能，在后面详解。

在Spring中，BeanDefinition就是一个实例化后的组件信息，其是保存在Map中。

而后在代码中通过主动“拉取”的形式，将实例化后的组件拉入代码逻辑中。如：@Resource，@Autowired。

IOC的实现原理就可以分为两部分，一是：如何通过代码解析xml这些配置文件，因为文件中包含,,,,,等这样的标签内容，而标签中又有id/class等这样的属性。二是：创建“容器”，因为bean就是类实例化后存放在Spring容器中，所以这个容器需要Spring创建出来。三是：初始化bean。

最基本的初始化容器的代码：

public  static  void main(String[] args) {

ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationfile.xml");

}

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

1.png

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

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

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

写一个组件注入并取出使用的简单例子如下。

首先，定义一个接口：

public  interface MessageService {

    String getMessage();

}

定义接口实现类：

public  class MessageServiceImpl implements MessageService {

    public String getMessage() {

        return  "hello world";

    }

}

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

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

public  class App {

    public  static  void main(String[] args) {

        // 用我们的配置文件来启动一个 ApplicationContext

ApplicationContext context = new ClassPathXmlApplicationContext("classpath:application.xml");

        System.out.println("context 启动成功");

        // 从 context 中取出我们的 Bean，而不是用 new MessageServiceImpl() 这种方式

        MessageService messageService = context.getBean(MessageService.class);

        // 这句将输出: hello world

        System.out.println(messageService.getMessage());

    }

}

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

前面说过，Spring中有两种类型的容器，其实前面使用的ApplicationContext实质就是一个BeanFactory，看看两者在类组织结构上的关系。

2.png

从图中可以提取几个关键信息：

1.ApplicationContext容器继承了 ListableBeanFactory，这个 Listable 的意思就是，通过这个接口，我们可以获取多个 Bean，最顶层 BeanFactory 接口的方法都是获取单个 Bean 的。

2.ApplicationContext容器继承了 HierarchicalBeanFactory，Hierarchical 单词本身已经能说明问题了，也就是说我们可以在应用中起多个 BeanFactory，然后可以将各个 BeanFactory 设置为父子关系。

3.AutowireCapableBeanFactory 这个名字中的 Autowire 大家都非常熟悉，它就是用来自动装配 Bean 用的。在 ApplicationContext 中通过方法 getAutowireCapableBeanFactory() 来使用它。

以下代码片段，最好在电脑端打开源码查看。

首先从 ClassPathXmlApplicationContext 的构造方法说起

public  class ClassPathXmlApplicationContext extends AbstractXmlApplicationContext {

  // 将配置文件作为资源都存放到这个数组中

  private Resource[] configResources;

    // 如果已经有 ApplicationContext 并需要配置成父子关系，那么调用这个构造方法

  public ClassPathXmlApplicationContext(ApplicationContext parent) {

    super(parent);

  }

  ...

  public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)

      throws BeansException {

    super(parent);

        // 解析xml配置文件列表，放置到上面说的那个 configResources 数组中

    setConfigLocations(configLocations);

    if (refresh) {

refresh(); // 核心方法

    }

  }

    ...

}

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

@Override

public  void refresh() throws BeansException, IllegalStateException {

   // 来个锁，不然 refresh() 还没结束，你又来个启动或销毁容器的操作，那不就乱套了嘛

   synchronized (this.startupShutdownMonitor) {

      // 准备工作，记录下容器的启动时间、标记已启动状态、处理配置文件中的占位符

      prepareRefresh();

      /** 这步完成后，配置文件就会解析成一个个BeanDefinition，注册到BeanFactory 中，

       * 当然，这里说的 Bean 还没有初始化，只是配置信息都提取出来了，

  * 注册也只是将这些信息都保存到了注册中心(说到底核心是一个beanName->beanDefinition的map)

*/

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // 设置BeanFactory的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean

      prepareBeanFactory(beanFactory);

      try {

       /**【这里需要知道BeanFactoryPostProcessor这个知识点，Bean如果实现了此接口，

         * 那么在容器初始化以后，Spring会负责调用里面的postProcessBeanFactory 方法。】

  * 这里是提供给子类的扩展点，到这里的时候，所有的Bean都加载、注册完成了，但是都还没有初始化

         * 具体的子类可以在这步的时候添加一些特殊的 BeanFactoryPostProcessor 的实现类或做点什么事

*/

         postProcessBeanFactory(beanFactory);

         // 调用BeanFactoryPostProcessor各个实现类的 postProcessBeanFactory(factory) 方法

         invokeBeanFactoryPostProcessors(beanFactory);

       /** 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别

         * 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization

         * 两个方法分别在 Bean 初始化之前和初始化之后得到执行。注意，到这里 Bean 还没初始化

*/

         registerBeanPostProcessors(beanFactory);

         // 初始化当前 ApplicationContext 的事件广播器，这里也不展开了

         initApplicationEventMulticaster();

         /** 从方法名就可以知道，典型的模板方法(钩子方法)，

* 具体的子类可以在这里初始化一些特殊的 Bean（在初始化 singleton beans 之前）

*/

         onRefresh();

         // 注册事件监听器，监听器需要实现 ApplicationListener 接口。这也不是我们的重点，过

         registerListeners();

         // 重点，重点，重点

     // 初始化所有的  singleton beans

     //（lazy-init 的除外）

/** 

该bean默认的设置为:



lazy-init="false"

立即加载，表示在spring启动时，立刻进行实例化。

*/

         finishBeanFactoryInitialization(beanFactory);

         // 最后，广播事件，ApplicationContext 初始化完成

         finishRefresh();

      } catch (BeansException ex) {

  ...

        // 销毁已经初始化的 singleton 的 Beans，以免有些 bean 会一直占用资源

        destroyBeans();

        // 把异常往外抛

        throw ex;

      } finally {

         ...

   }

}

下面开始一步步分析这个refresh()方法做的事情。

首先是prepareRefresh()方法：

protected  void prepareRefresh() {

   // 记录启动时间，

   // 将 active 属性设置为 true，closed 属性设置为 false，它们都是 AtomicBoolean 类型

   this.startupDate = System.currentTimeMillis();

   this.closed.set(false);

   this.active.set(true);

   if (logger.isInfoEnabled()) {

      logger.info("Refreshing " + this);

   }

...

   // 校验 xml 配置文件

   getEnvironment().validateRequiredProperties();

...

}

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

当然，这步结束后，Bean 并没有完成初始化。（这里可能有疑问，我用的ApplicationContext容器，为什么这里又是初始化BeanFactory容器呢，这是因为虽然有两种容器类型的存在，但归根接地ApplicationContext容器是基于BeanFactory容器的，继承于它，可以理解为，其根本就是在创建BeanFactory容器）

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {

   // 关闭旧的 BeanFactory (如果有)，创建新的 BeanFactory，加载 Bean 定义、注册 Bean 等等

   refreshBeanFactory();

   // 返回刚刚创建的 BeanFactory

   ConfigurableListableBeanFactory beanFactory = getBeanFactory();

   if (logger.isDebugEnabled()) {

      logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);

   }

   return beanFactory;

}

obtainFreshBeanFactory()方法中的refreshBeanFactory()需要分析一下：

protected  final  void refreshBeanFactory() throws BeansException {

   /** 如果 ApplicationContext 中已经加载过 BeanFactory 了，销毁所有 Bean，关闭 BeanFactory

    * 注意，应用中 BeanFactory 本来就是可以多个的，这里可不是说应用全局是否有 BeanFactory，而是当前

    * ApplicationContext是否有 BeanFactory

*/

   if (hasBeanFactory()) {

      destroyBeans();

      closeBeanFactory();

   }

   try {

      // 初始化一个 DefaultListableBeanFactory，为什么用这个，我们马上说。

      DefaultListableBeanFactory beanFactory = createBeanFactory();

      // 用于 BeanFactory 的序列化

      beanFactory.setSerializationId(getId());

      // 设置 BeanFactory 的两个配置属性：是否允许 Bean 覆盖、是否允许循环引用

      customizeBeanFactory(beanFactory);

      // 加载 BeanDefinition到 BeanFactory 中，

// 但还不是真正的加载BeanDefinition，只是做准备。

      loadBeanDefinitions(beanFactory);

      synchronized (this.beanFactoryMonitor) {

         this.beanFactory = beanFactory;

      }

   }

   catch (IOException ex) {

      ...

   }

}

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

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

3.png

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

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

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

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

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

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

public  interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {

   // 我们可以看到，默认只提供 sington 和 prototype 两种，

   // 很多读者都知道还有 request, session, globalSession, application, websocket 这几种，

   // 不过，它们属于基于 web 的扩展。

   String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;

   String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;

   // 比较不重要，直接跳过吧

   int ROLE_APPLICATION = 0;

   int ROLE_SUPPORT = 1;

   int ROLE_INFRASTRUCTURE = 2;

   // 设置父 Bean，这里涉及到 bean 继承，不是 java 继承。请参见附录介绍

   void setParentName(String parentName);

   // 获取父 Bean

   String getParentName();

   // 设置 Bean 的类名称

   void setBeanClassName(String beanClassName);

   // 获取 Bean 的类名称

   String getBeanClassName();

   // 设置 bean 的 scope

   void setScope(String scope);

   String getScope();

   // 设置是否懒加载

   void setLazyInit(boolean lazyInit);

   boolean isLazyInit();

   // 设置该 Bean 依赖的所有的 Bean，注意，这里的依赖不是指属性依赖(如 @Autowire 标记的)，

   // 是 depends-on="" 属性设置的值。

   void setDependsOn(String... dependsOn);

   // 返回该 Bean 的所有依赖

   String[] getDependsOn();

   // 设置该 Bean 是否可以注入到其他 Bean 中，只对根据类型注入有效，

   // 如果根据名称注入，即使这边设置了 false，也是可以的

   void setAutowireCandidate(boolean autowireCandidate);

   // 该 Bean 是否可以注入到其他 Bean 中

   boolean isAutowireCandidate();

   // 主要的。同一接口的多个实现，如果不指定名字的话，Spring 会优先选择设置 primary 为 true 的 bean

   void setPrimary(boolean primary);

   // 是否是 primary 的

   boolean isPrimary();

   // 如果该 Bean 采用工厂方法生成，指定工厂名称。对工厂不熟悉的读者，请参加附录

   void setFactoryBeanName(String factoryBeanName);

   // 获取工厂名称

   String getFactoryBeanName();

   // 指定工厂类中的 工厂方法名称

   void setFactoryMethodName(String factoryMethodName);

   // 获取工厂类中的 工厂方法名称

   String getFactoryMethodName();

   // 构造器参数

   ConstructorArgumentValues getConstructorArgumentValues();

   // Bean 中的属性值，后面给 bean 注入属性值的时候会说到

   MutablePropertyValues getPropertyValues();

   // 是否 singleton

   boolean isSingleton();

   // 是否 prototype

   boolean isPrototype();

   // 如果这个 Bean 原生是抽象类，那么不能实例化

   boolean isAbstract();

   int getRole();

   String getDescription();

   String getResourceDescription();

   BeanDefinition getOriginatingBeanDefinition();

}

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

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

customizeBeanFactory(beanFactory);

loadBeanDefinitions(beanFactory);

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

protected  void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {

   if (this.allowBeanDefinitionOverriding != null) {

      // 是否允许 Bean 定义覆盖

      beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);

   }

   if (this.allowCircularReferences != null) {

      // 是否允许 Bean 间的循环依赖

      beanFactory.setAllowCircularReferences(this.allowCircularReferences);

   }

}

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

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

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

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

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

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

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

/** 我们可以看到，此方法将通过一个 XmlBeanDefinitionReader 实例来加载各个 Bean。*/

protected  void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {

   // 给这个 BeanFactory 实例化一个 XmlBeanDefinitionReader

XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

   beanDefinitionReader.setEnvironment(this.getEnvironment());

   beanDefinitionReader.setResourceLoader(this);

   beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

   // 初始化 BeanDefinitionReader，其实这个是提供给子类覆写的，

   // 我看了一下，没有类覆写这个方法，我们姑且当做不重要吧

   initBeanDefinitionReader(beanDefinitionReader);

   // 重点来了，继续往下

   loadBeanDefinitions(beanDefinitionReader);

}

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

protected  void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {

   Resource[] configResources = getConfigResources();

   if (configResources != null) {

      // 往下看

      reader.loadBeanDefinitions(configResources);

   }

   String[] configLocations = getConfigLocations();

   if (configLocations != null) {

      reader.loadBeanDefinitions(configLocations);

   }

}

// 上面虽然有两个分支，不过第二个分支很快通过解析路径转换为 Resource 以后也会进到这里

@Override

public  int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {

Assert.notNull(resources, "Resource array must not be null");

   int counter = 0;

   // 注意这里是个 for 循环，也就是每个文件是一个 resource

   for (Resource resource : resources) {

      // 继续往下看

      counter += loadBeanDefinitions(resource);

   }

   return counter;

}

// XmlBeanDefinitionReader 303

@Override

public  int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {

   return loadBeanDefinitions(new EncodedResource(resource));

}

// XmlBeanDefinitionReader 314

public  int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {

Assert.notNull(encodedResource, "EncodedResource must not be null");

   if (logger.isInfoEnabled()) {

      logger.info("Loading XML bean definitions from " + encodedResource.getResource());

   }

   // 用一个 ThreadLocal 来存放所有的配置文件资源

Set currentResources = this.resourcesCurrentlyBeingLoaded.get();

   if (currentResources == null) {

currentResources = new HashSet(4);

      this.resourcesCurrentlyBeingLoaded.set(currentResources);

   }

   if (!currentResources.add(encodedResource)) {

      throw  new BeanDefinitionStoreException(

            "Detected cyclic loading of " + encodedResource + " - check your import definitions!");

   }

   try {

      InputStream inputStream = encodedResource.getResource().getInputStream();

      try {

InputSource inputSource = new InputSource(inputStream);

         if (encodedResource.getEncoding() != null) {

            inputSource.setEncoding(encodedResource.getEncoding());

         }

         // 核心部分

         return doLoadBeanDefinitions(inputSource, encodedResource.getResource());

      }

      finally {

         inputStream.close();

      }

   }

   catch (IOException ex) {

      throw  new BeanDefinitionStoreException(

            "IOException parsing XML document from " + encodedResource.getResource(), ex);

   }

   finally {

      currentResources.remove(encodedResource);

      if (currentResources.isEmpty()) {

         this.resourcesCurrentlyBeingLoaded.remove();

      }

   }

}

// 还在这个文件中，第 388 行

protected  int doLoadBeanDefinitions(InputSource inputSource, Resource resource)

      throws BeanDefinitionStoreException {

   try {

      // 这里就不看了

      Document doc = doLoadDocument(inputSource, resource);

      // 继续

      return registerBeanDefinitions(doc, resource);

   }

   catch (...

}

// 还在这个文件中，第 505 行

// 返回从当前配置文件加载了多少数量的 Bean

public  int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {

   BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();

   int countBefore = getRegistry().getBeanDefinitionCount();

   documentReader.registerBeanDefinitions(doc, createReaderContext(resource));

   return getRegistry().getBeanDefinitionCount() - countBefore;

}

// DefaultBeanDefinitionDocumentReader 90

@Override

public  void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {

   this.readerContext = readerContext;

   logger.debug("Loading bean definitions");

   Element root = doc.getDocumentElement();

   doRegisterBeanDefinitions(root);

}

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

// DefaultBeanDefinitionDocumentReader 116

protected  void doRegisterBeanDefinitions(Element root) {

   // 我们看名字就知道，BeanDefinitionParserDelegate 必定是一个重要的类，它负责解析 Bean 定义，

   // 这里为什么要定义一个 parent? 看到后面就知道了，是递归问题，

   // 因为  内部是可以定义  的，所以这个方法的 root 其实不一定就是 xml 的根节点，也可以是嵌套在里面的  节点，从源码分析的角度，我们当做根节点就好了

BeanDefinitionParserDelegate parent = this.delegate;

   this.delegate = createDelegate(getReaderContext(), root, parent);

   if (this.delegate.isDefaultNamespace(root)) {

      // 这块说的是根节点  中的 profile 是否是当前环境需要的，

      // 如果当前环境配置的 profile 不包含此 profile，那就直接 return 了，不对此  解析

      // 不熟悉 profile 为何物，不熟悉怎么配置 profile 读者的请移步附录区

      String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);

      if (StringUtils.hasText(profileSpec)) {

         String[] specifiedProfiles = StringUtils.tokenizeToStringArray(

               profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);

         if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {

            if (logger.isInfoEnabled()) {

               logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +

                     "] not matching: " + getReaderContext().getResource());

            }

            return;

         }

      }

   }

preProcessXml(root); // 钩子

parseBeanDefinitions(root, this.delegate);

postProcessXml(root); // 钩子

   this.delegate = parent;

}

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

// default namespace 涉及到的就四个标签 、、 和 ，

// 其他的属于 custom 的

protected  void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {

   if (delegate.isDefaultNamespace(root)) {

      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;

            if (delegate.isDefaultNamespace(ele)) {

               parseDefaultElement(ele, delegate);

            }

            else {

               delegate.parseCustomElement(ele);

            }

         }

      }

   }

   else {

      delegate.parseCustomElement(root);

   }

}

下面是 processBeanDefinition 解析 标签：

protected  void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {

   // 将  节点中的信息提取出来，然后封装到一个 BeanDefinitionHolder 中，细节往下看

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

   }

}

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

4.png

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

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

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {

    return parseBeanDefinitionElement(ele, null);

}

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {

   String id = ele.getAttribute(ID_ATTRIBUTE);

   String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

List aliases = new ArrayList();

   // 将 name 属性的定义按照 ”逗号、分号、空格“ 切分，形成一个别名列表数组，

   // 当然，如果你不定义的话，就是空的了

   // 我在附录中简单介绍了一下 id 和 name 的配置，大家可以看一眼，有个20秒就可以了

   if (StringUtils.hasLength(nameAttr)) {

      String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);

      aliases.addAll(Arrays.asList(nameArr));

   }

   String beanName = id;

   // 如果没有指定id, 那么用别名列表的第一个名字作为beanName

   if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {

      beanName = aliases.remove(0);

      if (logger.isDebugEnabled()) {

         logger.debug("No XML 'id' specified - using '" + beanName +

               "' as bean name and " + aliases + " as aliases");

      }

   }

   if (containingBean == null) {

      checkNameUniqueness(beanName, aliases, ele);

   }

   // 根据 ... 中的配置创建 BeanDefinition，然后把配置中的信息都设置到实例中,

   // 细节后面再说

   AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);

   // 到这里，整个  标签就算解析结束了，一个 BeanDefinition 就形成了。

   if (beanDefinition != null) {

      // 如果都没有设置 id 和 name，那么此时的 beanName 就会为 null，进入下面这块代码产生

      // 如果读者不感兴趣的话，我觉得不需要关心这块代码，对本文源码分析来说，这些东西不重要

      if (!StringUtils.hasText(beanName)) {

         try {

            if (containingBean != null) {// 按照我们的思路，这里 containingBean 是 null 的

               beanName = BeanDefinitionReaderUtils.generateBeanName(

beanDefinition, this.readerContext.getRegistry(), true);

            }

            else {

               // 如果我们不定义 id 和 name，那么我们引言里的那个例子：

               //   1\. beanName 为：com.javadoop.example.MessageServiceImpl#0

               //   2\. beanClassName 为：com.javadoop.example.MessageServiceImpl

beanName = this.readerContext.generateBeanName(beanDefinition);

               String beanClassName = beanDefinition.getBeanClassName();

               if (beanClassName != null &&

                     beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&

                     !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {

                  // 把 beanClassName 设置为 Bean 的别名

                  aliases.add(beanClassName);

               }

            }

            if (logger.isDebugEnabled()) {

               logger.debug("Neither XML 'id' nor 'name' specified - " +

                     "using generated bean name [" + beanName + "]");

            }

         }

         catch (Exception ex) {

            error(ex.getMessage(), ele);

            return  null;

         }

      }

      String[] aliasesArray = StringUtils.toStringArray(aliases);

      // 返回 BeanDefinitionHolder

      return  new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);

   }

   return  null;

}

public AbstractBeanDefinition parseBeanDefinitionElement(

      Element ele, String beanName, BeanDefinition containingBean) {

   this.parseState.push(new BeanEntry(beanName));

String className = null;

   if (ele.hasAttribute(CLASS_ATTRIBUTE)) {

      className = ele.getAttribute(CLASS_ATTRIBUTE).trim();

   }

   try {

String parent = null;

      if (ele.hasAttribute(PARENT_ATTRIBUTE)) {

         parent = ele.getAttribute(PARENT_ATTRIBUTE);

      }

      // 创建 BeanDefinition，然后设置类信息而已，很简单，就不贴代码了

      AbstractBeanDefinition bd = createBeanDefinition(className, parent);

      // 设置 BeanDefinition 的一堆属性，这些属性定义在 AbstractBeanDefinition 中

      parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);

      bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

      /**

       * 下面的一堆是解析 ...... 内部的子元素，

       * 解析出来以后的信息都放到 bd 的属性中

       */

      // 解析 

      parseMetaElements(ele, bd);

      // 解析 

      parseLookupOverrideSubElements(ele, bd.getMethodOverrides());

      // 解析 

      parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

    // 解析 

      parseConstructorArgElements(ele, bd);

      // 解析 

      parsePropertyElements(ele, bd);

      // 解析 

      parseQualifierElements(ele, bd);

      bd.setResource(this.readerContext.getResource());

      bd.setSource(extractSource(ele));

      return bd;

   }

   catch (ClassNotFoundException ex) {

      error("Bean class [" + className + "] not found", ele, ex);

   }

   catch (NoClassDefFoundError err) {

      error("Class that bean class [" + className + "] depends on not found", ele, err);

   }

   catch (Throwable ex) {

      error("Unexpected failure during bean definition parsing", ele, ex);

   }

   finally {

      this.parseState.pop();

   }

   return  null;

}

解析完了标签，之后就根据doRegisterBeanDefinitions进行BeanDefinition的注册。而这也是全文很重要的地方，从这段代码可以看出Spring容器的底层数据结构就是Map和ArrayList。

public  void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)

      throws BeanDefinitionStoreException {

...

   if (beanDefinition instanceof AbstractBeanDefinition) {

      try {

         ((AbstractBeanDefinition) beanDefinition).validate();

      }

      catch (BeanDefinitionValidationException ex) {

         throw  new BeanDefinitionStoreException(...);

      }

   }

   // old? 还记得 “允许 bean 覆盖” 这个配置吗？allowBeanDefinitionOverriding

   BeanDefinition oldBeanDefinition;

   // 之后会看到，所有的 Bean 注册后会放入这个 beanDefinitionMap 中

oldBeanDefinition = this.beanDefinitionMap.get(beanName);

   // 处理重复名称的 Bean 定义的情况

   if (oldBeanDefinition != null) {

      if (!isAllowBeanDefinitionOverriding()) {

         // 如果不允许覆盖的话，抛异常

         throw  new BeanDefinitionStoreException(beanDefinition.getResourceDescription()...

      else  if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {

         // log...用框架定义的 Bean 覆盖用户自定义的 Bean

      }

      else  if (!beanDefinition.equals(oldBeanDefinition)) {

         // log...用新的 Bean 覆盖旧的 Bean

      }

      else {

         // log...用同等的 Bean 覆盖旧的 Bean，这里指的是 equals 方法返回 true 的 Bean

      }

      // 覆盖

      this.beanDefinitionMap.put(beanName, beanDefinition);

   }

   else {

      // 判断是否已经有其他的 Bean 开始初始化了.

      // 注意，"注册Bean" 这个动作结束，Bean 依然还没有初始化，我们后面会有大篇幅说初始化过程，

      // 在 Spring 容器启动的最后，会 预初始化 所有的 singleton beans

      if (hasBeanCreationStarted()) {

         // Cannot modify startup-time collection elements anymore (for stable iteration)

         synchronized (this.beanDefinitionMap) {

            this.beanDefinitionMap.put(beanName, beanDefinition);

List updatedDefinitions = new ArrayList(this.beanDefinitionNames.size() + 1);

            updatedDefinitions.addAll(this.beanDefinitionNames);

            updatedDefinitions.add(beanName);

            this.beanDefinitionNames = updatedDefinitions;

            if (this.manualSingletonNames.contains(beanName)) {

Set updatedSingletons = new LinkedHashSet(this.manualSingletonNames);

               updatedSingletons.remove(beanName);

               this.manualSingletonNames = updatedSingletons;

            }

         }

      }

      else {

         // 最正常的应该是进到这里。

         // 将 BeanDefinition 放到这个 map 中，这个 map 保存了所有的 BeanDefinition

         this.beanDefinitionMap.put(beanName, beanDefinition);

         // 这是个 ArrayList，所以会按照 bean 配置的顺序保存每一个注册的 Bean 的名字

         this.beanDefinitionNames.add(beanName);

         // 这是个 LinkedHashSet，代表的是手动注册的 singleton bean，

         // 注意这里是 remove 方法，到这里的 Bean 当然不是手动注册的

         // 手动指的是通过调用以下方法注册的 bean ：

         // registerSingleton(String beanName, Object singletonObject)

         // 这不是重点，解释只是为了不让大家疑惑。Spring 会在后面"手动"注册一些 Bean，

// 如 "environment"、"systemProperties" 等 bean

         this.manualSingletonNames.remove(beanName);

      }

      ...

   }

   if (oldBeanDefinition != null || containsSingleton(beanName)) {

      resetBeanDefinition(beanName);

   }

}

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

Bean 容器实例化完成后

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

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

public  void refresh() throws BeansException, IllegalStateException {

   // 来个锁，不然 refresh() 还没结束，你又来个启动或销毁容器的操作，那不就乱套了嘛

   synchronized (this.startupShutdownMonitor) {

      // 准备工作，记录下容器的启动时间、标记“已启动”状态、处理配置文件中的占位符

      prepareRefresh();

      // 这步比较关键，这步完成后，配置文件就会解析成一个个 Bean 定义，注册到 BeanFactory 中，

      // 当然，这里说的 Bean 还没有初始化，只是配置信息都提取出来了，

      // 注册也只是将这些信息都保存到了注册中心(说到底核心是一个 beanName-> beanDefinition 的 map)

      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean

      // 这块待会会展开说

      prepareBeanFactory(beanFactory);

      try {

         // 【这里需要知道 BeanFactoryPostProcessor 这个知识点，Bean 如果实现了此接口，

         // 那么在容器初始化以后，Spring 会负责调用里面的 postProcessBeanFactory 方法。】

         // 这里是提供给子类的扩展点，到这里的时候，所有的 Bean 都加载、注册完成了，但是都还没有初始化

         // 具体的子类可以在这步的时候添加一些特殊的 BeanFactoryPostProcessor 的实现类或做点什么事

         postProcessBeanFactory(beanFactory);

         // 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 方法

         invokeBeanFactoryPostProcessors(beanFactory);

         // 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别

         // 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization

         // 两个方法分别在 Bean 初始化之前和初始化之后得到执行。注意，到这里 Bean 还没初始化

         registerBeanPostProcessors(beanFactory);

         // 初始化当前 ApplicationContext 的 MessageSource，国际化这里就不展开说了，不然没完没了了

         initMessageSource();

         // 初始化当前 ApplicationContext 的事件广播器，这里也不展开了

         initApplicationEventMulticaster();

         // 从方法名就可以知道，典型的模板方法(钩子方法)，

         // 具体的子类可以在这里初始化一些特殊的 Bean（在初始化 singleton beans 之前）

         onRefresh();

         // 注册事件监听器，监听器需要实现 ApplicationListener 接口。这也不是我们的重点，过

         registerListeners();

         // 重点，重点，重点

         // 初始化所有的 singleton beans

         //（lazy-init 的除外）

         finishBeanFactoryInitialization(beanFactory);

         // 最后，广播事件，ApplicationContext 初始化完成

         finishRefresh();

      }

      catch (BeansException ex) {

         if (logger.isWarnEnabled()) {

            logger.warn("Exception encountered during context initialization - " +

                  "cancelling refresh attempt: " + ex);

         }

         // Destroy already created singletons to avoid dangling resources.

         // 销毁已经初始化的 singleton 的 Beans，以免有些 bean 会一直占用资源

         destroyBeans();

         // Reset 'active' flag.

         cancelRefresh(ex);

         // 把异常往外抛

         throw ex;

      }

      finally {

         // Reset common introspection caches in Spring's core, since we

         // might not ever need metadata for singleton beans anymore...

         resetCommonCaches();

      }

   }

}

准备 Bean 容器: prepareBeanFactory(factory)

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

/**

 * 设置factory的标准上下文属性

 * 比如 ClassLoader 和 post-processors.

 * @param beanFactory ：要配置的BeanFactory

 */

protected  void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {

   // 设置 BeanFactory 的类加载器，我们知道 BeanFactory 需要加载类，也就需要类加载器，

   // 这里设置为当前 ApplicationContext 的类加载器

   beanFactory.setBeanClassLoader(getClassLoader());

   // 设置 BeanExpressionResolver

   beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));

   //

   beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

   // 添加一个 BeanPostProcessor，这个 processor 比较简单，

   // 实现了 Aware 接口的几个特殊的 beans 在初始化的时候，这个 processor 负责回调

   beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

   // 下面几行的意思就是，如果某个 bean 依赖于以下几个接口的实现类，在自动装配的时候忽略它们，

   // Spring 会通过其他方式来处理这些依赖。

   beanFactory.ignoreDependencyInterface(EnvironmentAware.class);

   beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);

   beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);

   beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);

   beanFactory.ignoreDependencyInterface(MessageSourceAware.class);

   beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

   /**

    * 下面几行就是为特殊的几个 bean 赋值，如果有 bean 依赖了以下几个，会注入这边相应的值，

    * 之前我们说过，"当前 ApplicationContext 持有一个 BeanFactory"，这里解释了第一行

    * ApplicationContext 继承了 ResourceLoader、ApplicationEventPublisher、MessageSource

    * 所以对于这几个，可以赋值为 this，注意 this 是一个 ApplicationContext

    * 那这里怎么没看到为 MessageSource 赋值呢？那是因为 MessageSource 被注册成为了一个普通的 bean

    */

   beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);

   beanFactory.registerResolvableDependency(ResourceLoader.class, this);

   beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);

   beanFactory.registerResolvableDependency(ApplicationContext.class, this);

   // 这个 BeanPostProcessor 也很简单，在 bean 实例化后，如果是 ApplicationListener 的子类，

   // 那么将其添加到 listener 列表中，可以理解成：注册事件监听器

   beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

   // 这里涉及到特殊的 bean，名为：loadTimeWeaver，进行AOP处理

   if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {

      beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));

      // Set a temporary ClassLoader for type matching.

      beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));

   }

   /**

    * 从下面几行代码我们可以知道，Spring 往往很 "智能" 就是因为它会帮我们默认注册一些有用的 bean，

    * 我们也可以选择覆盖

    */

   // 如果没有定义 "environment" 这个 bean，那么 Spring 会 "手动" 注册一个

   if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {

      beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());

   }

   // 如果没有定义 "systemProperties" 这个 bean，那么 Spring 会 "手动" 注册一个

   if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {

      beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());

   }

   // 如果没有定义 "systemEnvironment" 这个 bean，那么 Spring 会 "手动" 注册一个

   if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {

      beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());

   }

}

在上面这块代码中，Spring 对一些特殊的 bean 进行了处理。

初始化所有的 singleton beans

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

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

我们来总结一下，到目前为止，应该说 BeanFactory 已经创建完成，并且所有的实现了 BeanFactoryPostProcessor 接口的 Bean 都已经初始化并且其中的

postProcessBeanFactory(factory) 方法已经得到执行了。所有实现了 BeanPostProcessor 接口的 Bean 也都完成了初始化。

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

// 初始化剩余的 singleton beans

protected  void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {

   // 首先，初始化名字为 conversionService 的 Bean。本着送佛送到西的精神，我在附录中简单介绍了一下 ConversionService，因为这实在太实用了

   // 什么，看代码这里没有初始化 Bean 啊！

   // 注意了，初始化的动作包装在 beanFactory.getBean(...) 中，这里先不说细节，先往下看吧

   if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&

         beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {

      beanFactory.setConversionService(

            beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));

   }

   // Register a default embedded value resolver if no bean post-processor

   // (such as a PropertyPlaceholderConfigurer bean) registered any before:

   // at this point, primarily for resolution in annotation attribute values.

   if (!beanFactory.hasEmbeddedValueResolver()) {

      beanFactory.addEmbeddedValueResolver(new StringValueResolver() {

         @Override

         public String resolveStringValue(String strVal) {

            return getEnvironment().resolvePlaceholders(strVal);

         }

      });

   }

   // 先初始化 LoadTimeWeaverAware 类型的 Bean

   // 一般用于织入第三方模块，在 class 文件载入 JVM 的时候动态织入，这里不展开说

   String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);

   for (String weaverAwareName : weaverAwareNames) {

      getBean(weaverAwareName);

   }

   // Stop using the temporary ClassLoader for type matching.

   beanFactory.setTempClassLoader(null);

   // 没什么别的目的，因为到这一步的时候，Spring 已经开始预初始化 singleton beans 了，

   // 肯定不希望这个时候还出现 bean 定义解析、加载、注册。

   beanFactory.freezeConfiguration();

   // 开始初始化剩下的

   beanFactory.preInstantiateSingletons();

}

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

preInstantiateSingletons

public  void preInstantiateSingletons() throws BeansException {

   if (this.logger.isDebugEnabled()) {

      this.logger.debug("Pre-instantiating singletons in " + this);

   }

List beanNames = new ArrayList(this.beanDefinitionNames);

   // 触发所有的非懒加载的 singleton beans 的初始化操作

   for (String beanName : beanNames) {

      // 合并父 Bean中的配置，注意  中的 parent，用的不多吧，

      // 考虑到这可能会影响大家的理解，我在附录中解释了一下 "Bean 继承"，请移步

      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);

      // 非抽象、非懒加载的 singletons。如果配置了 'abstract = true'，那是不需要初始化的

      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {

         // 处理 FactoryBean(读者如果不熟悉 FactoryBean，请移步附录区了解)

         if (isFactoryBean(beanName)) {

            // FactoryBean 的话，在 beanName 前面加上‘&’符号。再调用 getBean，getBean 方法别急

            final FactoryBean factory = (FactoryBean) getBean(FACTORY_BEAN_PREFIX + beanName);

            // 判断当前 FactoryBean 是否是 SmartFactoryBean 的实现，此处忽略，直接跳过

            boolean isEagerInit;

            if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {

               isEagerInit = AccessController.doPrivileged(new PrivilegedAction() {

                  @Override

                  public Boolean run() {

                     return ((SmartFactoryBean) factory).isEagerInit();

                  }

               }, getAccessControlContext());

            }

            else {

isEagerInit = (factory instanceof SmartFactoryBean &&

                     ((SmartFactoryBean) factory).isEagerInit());

            }

            if (isEagerInit) {

               getBean(beanName);

            }

         }

         else {

            // 对于普通的 Bean，只要调用 getBean(beanName) 这个方法就可以进行初始化了

            getBean(beanName);

         }

      }

   }

   // 到这里说明所有的非懒加载的 singleton beans 已经完成了初始化

   // 如果我们定义的 bean 是实现了 SmartInitializingSingleton 接口的，那么在这里得到回调，忽略

   for (String beanName : beanNames) {

      Object singletonInstance = getSingleton(beanName);

      if (singletonInstance instanceof SmartInitializingSingleton) {

         final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;

         if (System.getSecurityManager() != null) {

            AccessController.doPrivileged(new PrivilegedAction