概述

Spring 中 org.springframework.context.support.AbstractApplicationContext#refresh 中 refresh() 的作用：初始化 SpringContext 对象；
容器必须调用 refresh 才能正常工作，它的内部主要会调用 12 个方法，我们把它们称为 refresh 的 12 个步骤：

  1. prepareRefresh
  2. obtainFreshBeanFactory
  3. prepareBeanFactory
  4. postProcessBeanFactory
  5. invokeBeanFactoryPostProcessors
  6. registerBeanPostProcessors
  7. initMessageSource
  8. initApplicationEventMulticaster
  9. onRefresh
  10. registerListeners
  11. finishBeanFactoryInitialization
  12. finishRefresh

1～12 作用概述：

  • 1 为准备环境
  • 2 3 4 5 6 为准备 BeanFactory
  • 7 8 9 10 12 为准备 ApplicationContext
  • 11 为初始化 BeanFactory 中非延迟单例 bean 
  1. @Override
  2.     public void refresh() throws BeansException, IllegalStateException {
  3.         synchronized (this.startupShutdownMonitor) {
  4.             // 1. Prepare this context for refreshing.
  5.             prepareRefresh();
  7.             // 2. Tell the subclass to refresh the internal bean factory.
  8.             ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
  10.             // 3. Prepare the bean factory for use in this context.
  11.             prepareBeanFactory(beanFactory);
  13.             try {
  14.                 // 4. Allows post-processing of the bean factory in context subclasses.
  15.                 postProcessBeanFactory(beanFactory);
  17.                 // 5. Invoke factory processors registered as beans in the context.
  18.                 invokeBeanFactoryPostProcessors(beanFactory);
  20.                 // 6. Register bean processors that intercept bean creation.
  21.                 registerBeanPostProcessors(beanFactory);
  23.                 // 7. Initialize message source for this context.
  24.                 initMessageSource();
  26.                 // 8. Initialize event multicaster for this context.
  27.                 initApplicationEventMulticaster();
  29.                 // 9. Initialize other special beans in specific context subclasses.
  30.                 onRefresh();
  32.                 // 10. Check for listener beans and register them.
  33.                 registerListeners();
  35.                 // 11. Instantiate all remaining (non-lazy-init) singletons.
  36.                 finishBeanFactoryInitialization(beanFactory);
  38.                 // 12. Last step: publish corresponding event.
  39.                 finishRefresh();
  40.             }
  42.             catch (BeansException ex) {
  43.                 if (logger.isWarnEnabled()) {
  44.                     logger.warn("Exception encountered during context initialization - " +
  45.                             "cancelling refresh attempt: " + ex);
  46.                 }
  48.                 // Destroy already created singletons to avoid dangling resources.
  49.                 destroyBeans();
  51.                 // Reset 'active' flag.
  52.                 cancelRefresh(ex);
  54.                 // Propagate exception to caller.
  55.                 throw ex;
  56.             }
  58.             finally {
  59.                 // Reset common introspection caches in Spring's core, since we
  60.                 // might not ever need metadata for singleton beans anymore...
  61.                 resetCommonCaches();
  62.             }
  63.         }
  64.     }

refresh 中 12 个方法介绍

prepareRefresh

  • 这一步创建和准备了 Environment 对象，它作为 ApplicationContext 的一个成员变量
  • Environment 对象的作用之一是为后续 @Value，值注入时提供键值
  • Environment 分成三个主要部分
    • systemProperties - 保存 java 环境键值
    • systemEnvironment - 保存系统环境键值
    • 自定义 PropertySource - 保存自定义键值，例如来自于 *.properties 文件的键值

image.png

obtainFreshBeanFactory

  • 这一步获取（或创建） BeanFactory，它也是作为 ApplicationContext 的一个成员变量
  • BeanFactory 的作用是负责 bean 的创建、依赖注入和初始化，bean 的各项特征由 BeanDefinition 定义
    • BeanDefinition 作为 bean 的设计蓝图，规定了 bean 的特征，如单例多例、依赖关系、初始销毁方法等
    • BeanDefinition 的来源有多种多样，可以是通过 xml 获得、配置类获得、组件扫描获得，也可以是编程添加
  • 所有的 BeanDefinition 会存入 BeanFactory 中的 beanDefinitionMap 集合

image.png

prepareBeanFactory

  • 这一步会进一步完善 BeanFactory，为它的各项成员变量赋值
  • beanExpressionResolver 用来解析 SpEL，常见实现为 StandardBeanExpressionResolver
  • propertyEditorRegistrars 会注册类型转换器
    • 它在这里使用了 ResourceEditorRegistrar 实现类
    • 并应用 ApplicationContext 提供的 Environment 完成 ${ } 解析
  • registerResolvableDependency 来注册 beanFactory 以及 ApplicationContext，让它们也能用于依赖注入
  • beanPostProcessors 是 bean 后处理器集合，会工作在 bean 的生命周期各个阶段，此处会添加两个：
    • ApplicationContextAwareProcessor 用来解析 Aware 接口
    • ApplicationListenerDetector 用来识别容器中 ApplicationListener 类型的 bean

image.png

postProcessBeanFactory

  • 这一步是空实现，留给子类扩展。
    • 一般 Web 环境的 ApplicationContext 都要利用它注册新的 Scope，完善 Web 下的 BeanFactory
  • 这里体现的是模板方法设计模式

invokeBeanFactoryPostProcessors

  • 这一步会调用 beanFactory 后处理器
  • beanFactory 后处理器，充当 beanFactory 的扩展点，可以用来补充或修改 BeanDefinition
  • 常见的 beanFactory 后处理器有
    • ConfigurationClassPostProcessor – 解析 @Configuration、@Bean、@Import、@PropertySource 等
    • PropertySourcesPlaceHolderConfigurer – 替换 BeanDefinition 中的 ${ }
    • MapperScannerConfigurer – 补充 Mapper 接口对应的 BeanDefinition

image.png

registerBeanPostProcessors

  • 这一步是继续从 beanFactory 中找出 bean 后处理器，添加至 beanPostProcessors 集合中
  • bean 后处理器，充当 bean 的扩展点，可以工作在 bean 的实例化、依赖注入、初始化阶段，常见的有：
    • AutowiredAnnotationBeanPostProcessor 功能有：解析 @Autowired，@Value 注解
    • CommonAnnotationBeanPostProcessor 功能有：解析 @Resource，@PostConstruct，@PreDestroy
    • AnnotationAwareAspectJAutoProxyCreator 功能有：为符合切点的目标 bean 自动创建代理

image.png

initMessageSource

  • 这一步是为 ApplicationContext 添加 messageSource 成员，实现国际化功能
  • 去 beanFactory 内找名为 messageSource 的 bean，如果没有，则提供空的 MessageSource 实现

image.png

initApplicationEventMulticaster

  • 这一步为 ApplicationContext 添加事件广播器成员，即 applicationContextEventMulticaster
  • 它的作用是发布事件给监听器
  • 去 beanFactory 找名为 applicationEventMulticaster 的 bean 作为事件广播器，若没有，会创建默认的事件广播器
  • 之后就可以调用 ApplicationContext.publishEvent(事件对象) 来发布事件

image.png

onRefresh

  • 这一步是空实现，留给子类扩展
    • SpringBoot 中的子类在这里准备了 WebServer，即内嵌 web 容器
  • 体现的是模板方法设计模式

registerListeners

  • 这一步会从多种途径找到事件监听器，并添加至 applicationEventMulticaster
  • 事件监听器顾名思义，用来接收事件广播器发布的事件，有如下来源
    • 事先编程添加的
    • 来自容器中的 bean
    • 来自于 @EventListener 的解析
  • 要实现事件监听器，只需要实现 ApplicationListener 接口，重写其中 onApplicationEvent(E e) 方法即可

image.png

finishBeanFactoryInitialization

  • 这一步会将 beanFactory 的成员补充完毕，并初始化所有非延迟单例 bean
  • conversionService 也是一套转换机制，作为对 PropertyEditor 的补充
  • embeddedValueResolvers 即内嵌值解析器，用来解析 @Value 中的 ${ }，借用的是 Environment 的功能
  • singletonObjects 即单例池，缓存所有单例对象
    • 对象的创建都分三个阶段，每一阶段都有不同的 bean 后处理器参与进来，扩展功能

image.png

finishRefresh

  • 这一步会为 ApplicationContext 添加 lifecycleProcessor 成员，用来控制容器内需要生命周期管理的 bean
  • 如果容器中有名称为 lifecycleProcessor 的 bean 就用它，否则创建默认的生命周期管理器
  • 准备好生命周期管理器，就可以实现
    • 调用 context 的 start，即可触发所有实现 LifeCycle 接口 bean 的 start
    • 调用 context 的 stop，即可触发所有实现 LifeCycle 接口 bean 的 stop
  • 发布 ContextRefreshed 事件，整个 refresh 执行完成

image.png