「死磕 Spring」—– 深入分析 ApplicationContext 的 refresh()

原文出自：http://cmsblogs.com

作者：作者：chenssy

上篇博客只是对 ApplicationContext 相关的接口做了一个简单的介绍，作为一个高富帅级别的 Spring 容器，它涉及的方法实在是太多了，全部介绍是不可能的，而且大部分功能都已经在前面系列博客中做了详细的介绍，所以这篇博问介绍 ApplicationContext 最重要的方法（小编认为的） ：refresh()。

refresh() 是定义在 ConfigurableApplicationContext 类中的，如下：

 /**
 * Load or refresh the persistent representation of the configuration,
 * which might an XML file, properties file, or relational database schema.
 * As this is a startup method, it should destroy already created singletons
 * if it fails, to avoid dangling resources. In other words, after invocation
 * of that method, either all or no singletons at all should be instantiated.
 * @throws BeansException if the bean factory could not be initialized
 * @throws IllegalStateException if already initialized and multiple refresh
 * attempts are not supported
 */
 void refresh() throws BeansException, IllegalStateException;

作用就是：刷新 Spring 的应用上下文。其实现是在 AbstractApplicationContext 中实现。如下：

 @Override
 public void refresh() throws BeansException, IllegalStateException {
 synchronized (this.startupShutdownMonitor) {
 // 准备刷新上下文环境
 prepareRefresh();
 // 创建并初始化 BeanFactory
 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
 // 填充BeanFactory功能
 prepareBeanFactory(beanFactory);
 try {
 // 提供子类覆盖的额外处理，即子类处理自定义的BeanFactoryPostProcess
 postProcessBeanFactory(beanFactory);
 // 激活各种BeanFactory处理器
 invokeBeanFactoryPostProcessors(beanFactory);
 // 注册拦截Bean创建的Bean处理器，即注册 BeanPostProcessor
 registerBeanPostProcessors(beanFactory);
 // 初始化上下文中的资源文件，如国际化文件的处理等
 initMessageSource();
 // 初始化上下文事件广播器
 initApplicationEventMulticaster();
 // 给子类扩展初始化其他Bean
 onRefresh();
 // 在所有bean中查找listener bean，然后注册到广播器中
 registerListeners();
 // 初始化剩下的单例Bean(非延迟加载的)
 finishBeanFactoryInitialization(beanFactory);
 // 完成刷新过程,通知生命周期处理器lifecycleProcessor刷新过程,同时发出ContextRefreshEvent通知别人
 finishRefresh();
 }
 catch (BeansException ex) {
 if (logger.isWarnEnabled()) {
 logger.warn("Exception encountered during context initialization - " +
 "cancelling refresh attempt: " + ex);
 }
 // 销毁已经创建的Bean
 destroyBeans();
 // 重置容器激活标签
 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();
 }
 }
 }

这里每一个方法都非常重要，需要一个一个地解释说明。

prepareRefresh()

初始化上下文环境，对系统的环境变量或者系统属性进行准备和校验,如环境变量中必须设置某个值才能运行，否则不能运行，这个时候可以在这里加这个校验，重写initPropertySources方法就好了

该方法主要是做一些准备工作，如：

1. 设置 context 启动时间
2. 设置 context 的当前状态
3. 初始化 context environment 中占位符
4. 对属性进行必要的验证

obtainFreshBeanFactory()

创建并初始化 BeanFactory

核心方法就在 refreshBeanFactory() ，该方法的核心任务就是创建 BeanFactory 并对其就行一番初始化。如下：

1. 判断当前容器是否存在一个 BeanFactory，如果存在则对其进行销毁和关闭
2. 调用 createBeanFactory() 创建一个 BeanFactory 实例，其实就是 DefaultListableBeanFactory
3. 自定义 BeanFactory
4. 加载 BeanDefinition
5. 将创建好的 bean 工厂的引用交给的 context 来管理

上面 5 个步骤，都是比较简单的，但是有必要讲解下第 4 步：加载 BeanDefinition。如果各位看过 【死磕 Spring】系列的话，在刚刚开始分析源码的时候，小编就是以 loadBeanDefinitions() 为入口来分析的，如下：

ClassPathResource resource = new ClassPathResource("bean.xml");
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
reader.loadBeanDefinitions(resource);

只不过这段代码的 loadBeanDefinitions() 是定义在 BeanDefinitionReader 中，而此处的 loadBeanDefinitions() 则是定义在 AbstractRefreshableApplicationContext 中，如下：

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

由具体的子类实现，我们以 AbstractXmlApplicationContext 为例，实现如下：

新建 XmlBeanDefinitionReader 实例对象 beanDefinitionReader，调用 initBeanDefinitionReader() 对其进行初始化，然后调用 loadBeanDefinitions() 加载 BeanDefinition。

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

到这里我们发现，其实内部依然是调用 BeanDefinitionReader#loadBeanDefinitionn() 进行 BeanDefinition 的加载进程。

prepareBeanFactory(beanFactory)

填充 BeanFactory 功能

上面获取获取的 BeanFactory 除了加载了一些 BeanDefinition 就没有其他任何东西了，这个时候其实还不能投入生产，因为还少配置了一些东西，比如 context的 ClassLoader 和 后置处理器等等。

看上面的源码知道这个就是对 BeanFactory 设置各种各种的功能。

postProcessBeanFactory()

提供子类覆盖的额外处理，即子类处理自定义的BeanFactoryPostProcess

 protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
 beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));
 beanFactory.ignoreDependencyInterface(ServletContextAware.class);
 beanFactory.ignoreDependencyInterface(ServletConfigAware.class);
 WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
 WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);
 }

1. 添加 ServletContextAwareProcessor 到 BeanFactory 容器中，该 processor 实现 BeanPostProcessor 接口，主要用于将ServletContext 传递给实现了 ServletContextAware 接口的 bean
2. 忽略 ServletContextAware、ServletConfigAware
3. 注册 WEB 应用特定的域（scope）到 beanFactory 中，以便 WebApplicationContext 可以使用它们。比如 "request" , "session" , "globalSession" , "application"
4. 注册 WEB 应用特定的 Environment bean 到 beanFactory 中，以便WebApplicationContext 可以使用它们。如："contextParameters", "contextAttributes"

invokeBeanFactoryPostProcessors()

激活各种BeanFactory处理器

 public static void invokeBeanFactoryPostProcessors(
 ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
 // 定义一个 set 保存所有的 BeanFactoryPostProcessors
 Set<String> processedBeans = new HashSet<>();
 // 如果当前 BeanFactory 为 BeanDefinitionRegistry
 if (beanFactory instanceof BeanDefinitionRegistry) {
 BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
 // BeanFactoryPostProcessor 集合
 List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
 // BeanDefinitionRegistryPostProcessor 集合
 List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
 // 迭代注册的 beanFactoryPostProcessors
 for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
 // 如果是 BeanDefinitionRegistryPostProcessor，则调用 postProcessBeanDefinitionRegistry 进行注册，
 // 同时加入到 registryProcessors 集合中
 if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
 BeanDefinitionRegistryPostProcessor registryProcessor =
 (BeanDefinitionRegistryPostProcessor) postProcessor;
 registryProcessor.postProcessBeanDefinitionRegistry(registry);
 registryProcessors.add(registryProcessor);
 }
 else {
 // 否则当做普通的 BeanFactoryPostProcessor 处理
 // 添加到 regularPostProcessors 集合中即可，便于后面做后续处理
 regularPostProcessors.add(postProcessor);
 }
 }
 // 用于保存当前处理的 BeanDefinitionRegistryPostProcessor
 List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
 // 首先处理实现了 PriorityOrdered (有限排序接口)的 BeanDefinitionRegistryPostProcessor
 String[] postProcessorNames =
 beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
 for (String ppName : postProcessorNames) {
 if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
 currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
 processedBeans.add(ppName);
 }
 }
 // 排序
 sortPostProcessors(currentRegistryProcessors, beanFactory);
 // 加入registryProcessors集合
 registryProcessors.addAll(currentRegistryProcessors);
 // 调用所有实现了 PriorityOrdered 的 BeanDefinitionRegistryPostProcessors 的 postProcessBeanDefinitionRegistry()
 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
 // 清空，以备下次使用
 currentRegistryProcessors.clear();
 // 其次，调用是实现了 Ordered（普通排序接口）的 BeanDefinitionRegistryPostProcessors
 // 逻辑和 上面一样
 postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
 for (String ppName : postProcessorNames) {
 if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
 currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
 processedBeans.add(ppName);
 }
 }
 sortPostProcessors(currentRegistryProcessors, beanFactory);
 registryProcessors.addAll(currentRegistryProcessors);
 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
 currentRegistryProcessors.clear();
 // 最后调用其他的 BeanDefinitionRegistryPostProcessors
 boolean reiterate = true;
 while (reiterate) {
 reiterate = false;
 // 获取 BeanDefinitionRegistryPostProcessor
 postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
 for (String ppName : postProcessorNames) {
 // 没有包含在 processedBeans 中的（因为包含了的都已经处理了）
 if (!processedBeans.contains(ppName)) {
 currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
 processedBeans.add(ppName);
 reiterate = true;
 }
 }
 // 与上面处理逻辑一致
 sortPostProcessors(currentRegistryProcessors, beanFactory);
 registryProcessors.addAll(currentRegistryProcessors);
 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
 currentRegistryProcessors.clear();
 }
 // 调用所有 BeanDefinitionRegistryPostProcessor (包括手动注册和通过配置文件注册)
 // 和 BeanFactoryPostProcessor(只有手动注册)的回调函数(postProcessBeanFactory())
 invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
 invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
 }
 else {
 // 如果不是 BeanDefinitionRegistry 只需要调用其回调函数（postProcessBeanFactory()）即可
 invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
 }
 //
 String[] postProcessorNames =
 beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
 // 这里同样需要区分 PriorityOrdered 、Ordered 和 no Ordered
 List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
 List<String> orderedPostProcessorNames = new ArrayList<>();
 List<String> nonOrderedPostProcessorNames = new ArrayList<>();
 for (String ppName : postProcessorNames) {
 // 已经处理过了的，跳过
 if (processedBeans.contains(ppName)) {
 // skip - already processed in first phase above
 }
 // PriorityOrdered
 else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
 priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
 }
 // Ordered
 else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
 orderedPostProcessorNames.add(ppName);
 }
 // no Ordered
 else {
 nonOrderedPostProcessorNames.add(ppName);
 }
 }
 // First, PriorityOrdered 接口
 sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
 invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
 // Next, Ordered 接口
 List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
 for (String postProcessorName : orderedPostProcessorNames) {
 orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
 }
 sortPostProcessors(orderedPostProcessors, beanFactory);
 invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
 // Finally, no ordered
 List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
 for (String postProcessorName : nonOrderedPostProcessorNames) {
 nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
 }
 invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
 // Clear cached merged bean definitions since the post-processors might have
 // modified the original metadata, e.g. replacing placeholders in values...
 beanFactory.clearMetadataCache();
 }

上述代码较长，但是处理逻辑较为单一，就是对所有的 BeanDefinitionRegistryPostProcessors 、手动注册的 BeanFactoryPostProcessor 以及通过配置文件方式的 BeanFactoryPostProcessor 按照 PriorityOrdered 、 Ordered、no ordered 三种方式分开处理、调用。

registerBeanPostProcessors

注册拦截Bean创建的Bean处理器，即注册 BeanPostProcessor

与 BeanFactoryPostProcessor 一样，也是委托给 PostProcessorRegistrationDelegate 来实现的。

 public static void registerBeanPostProcessors(
 ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
 // 所有的 BeanPostProcessors
 String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
 // 注册 BeanPostProcessorChecker
 // 主要用于记录一些 bean 的信息，这些 bean 不符合所有 BeanPostProcessors 处理的资格时
 int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
 beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
 // 区分 PriorityOrdered、Ordered 、 no ordered
 List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
 List<String> orderedPostProcessorNames = new ArrayList<>();
 List<String> nonOrderedPostProcessorNames = new ArrayList<>();
 // MergedBeanDefinition
 List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
 for (String ppName : postProcessorNames) {
 if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
 BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
 priorityOrderedPostProcessors.add(pp);
 if (pp instanceof MergedBeanDefinitionPostProcessor) {
 internalPostProcessors.add(pp);
 }
 }
 else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
 orderedPostProcessorNames.add(ppName);
 }
 else {
 nonOrderedPostProcessorNames.add(ppName);
 }
 }
 // First, PriorityOrdered
 sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
 registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
 // Next, Ordered
 List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
 for (String ppName : orderedPostProcessorNames) {
 BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
 orderedPostProcessors.add(pp);
 if (pp instanceof MergedBeanDefinitionPostProcessor) {
 internalPostProcessors.add(pp);
 }
 }
 sortPostProcessors(orderedPostProcessors, beanFactory);
 registerBeanPostProcessors(beanFactory, orderedPostProcessors);
 // onOrdered
 List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
 for (String ppName : nonOrderedPostProcessorNames) {
 BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
 nonOrderedPostProcessors.add(pp);
 if (pp instanceof MergedBeanDefinitionPostProcessor) {
 internalPostProcessors.add(pp);
 }
 }
 registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
 // Finally, all internal BeanPostProcessors.
 sortPostProcessors(internalPostProcessors, beanFactory);
 registerBeanPostProcessors(beanFactory, internalPostProcessors);
 // 重新注册用来自动探测内部ApplicationListener的post-processor，这样可以将他们移到处理器链条的末尾
 beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
 }

initMessageSource

初始化上下文中的资源文件，如国际化文件的处理等

其实该方法就是初始化一个 MessageSource 接口的实现类，主要用于国际化/i18n。

initApplicationEventMulticaster

初始化上下文事件广播器

如果当前容器中存在 applicationEventMulticaster 的 bean，则对 applicationEventMulticaster 赋值，否则新建一个 SimpleApplicationEventMulticaster 的对象（默认的），并完成注册。

onRefresh

给子类扩展初始化其他Bean

预留给 AbstractApplicationContext 的子类用于初始化其他特殊的 bean，该方法需要在所有单例 bean 初始化之前调用。

registerListeners

在所有 bean 中查找 listener bean，然后注册到广播器中

finishBeanFactoryInitialization

初始化剩下的单例Bean(非延迟加载的)

finishRefresh

完成刷新过程,通知生命周期处理器 lifecycleProcessor 刷新过程,同时发出 ContextRefreshEvent 通知别人

主要是调用 LifecycleProcessor#onRefresh() ，并且发布事件（ContextRefreshedEvent）。