Spring IOC 容器源码分析-白红宇的个人博客

Spring IOC 容器源码分析

发布日期：2021-06-30 12:36:46 浏览次数：4 分类：技术文章

本文共 8795 字，大约阅读时间需要 29 分钟。

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 容器的例子：

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

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


     
    
     org.springframework
      
    
     spring-context
      
    
     4.3.11.RELEASE

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 这两个类。

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

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

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

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

首先，定义一个接口：

public interface MessageService {
       String getMessage();}

定义接口实现类：

public class MessageServiceImpl implements MessageService {
       public String getMessage() {
           return "hello world";    }}

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

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

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 中注入依赖等。

BeanFactory 简介

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

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

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

ApplicationContext 继承了 ListableBeanFactory，这个 Listable 的意思就是，通过这个接口，我们可以获取多个 Bean，大家看源码会发现，最顶层 BeanFactory 接口的方法都是获取单个 Bean 的。

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

AutowireCapableBeanFactory 这个名字中的 Autowire 大家都非常熟悉，它就是用来自动装配 Bean 用的，但是仔细看上图，ApplicationContext 并没有继承它，不过不用担心，不使用继承，不代表不可以使用组合，如果你看到 ApplicationContext 接口定义中的最后一个方法 getAutowireCapableBeanFactory() 就知道了。

ConfigurableListableBeanFactory 也是一个特殊的接口，看图，特殊之处在于它继承了第二层所有的三个接口，而 ApplicationContext 没有。这点之后会用到。

请先不用花时间在其他的接口和类上，先理解我说的这几点就可以了。

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

启动过程分析

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

第一步，我们肯定要从 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);    // 根据提供的路径，处理成配置文件数组(以分号、逗号、空格、tab、换行符分割)    setConfigLocations(configLocations);    if (refresh) {
         refresh(); // 核心方法    }  }    ...}

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

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

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

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

创建 Bean 容器前的准备工作

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

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);   }   // Initialize any placeholder property sources in the context environment   initPropertySources();   // 校验 xml 配置文件   getEnvironment().validateRequiredProperties();   this.earlyApplicationEvents = new LinkedHashSet
   
    ();}

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

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

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

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

// AbstractApplicationContext.java

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

转载地址：https://javalib.blog.csdn.net/article/details/105851753 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！

上一篇：Java 生成 UUID

下一篇：Logback日志添加唯一追踪ID

发表评论

关于作者

喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！

-- 愿君每日到此一游！

引言