Spring IoC 源码系列（二）IoC 容器启动流程分析

朱雀 2023-07-14 08:09 198阅读 0赞

private static final String configLocation = "applicationContext.xml";
    
        @Test
        public void beanTest() { 
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext(configLocation);
            System.out.println("user -> " + applicationContext.getBean("user"));
        }

在没有看源码之前，对于上面的例子一直以为是在执行 `applicationContext.getBean("user")` 时创建的 bean 实例，带着这种想法去看了 `getBean` 方法的内部实现，发现有很多地方串不起来，比如 `beanDefinition` 是什么时候初始化的，`beanPostProcessor` 是什么时候设置的，看的过程中一头雾水。

IoC 的源码也跟踪了一段时间，后来在 `ClassPathXmlApplicationContext` 的构造函数中找到了答案，在执行 `new ClassPathXmlApplicationContext(configLocation)` 时 IoC 容器其实已经创建完成了，并会初始化所有的非懒加载配置的单例 bean。下面是看源码过程中的一些记录，如果有不对的地方还望大家指正。由于启动过程中完整的代码非常多，这里只总结一些重要的流程，相关的细节有兴趣的可以自己 debug 查看。

### 1.入口 ###

`ClassPathXmlApplicationContext` 入口：

public ClassPathXmlApplicationContext(String configLocation) throws BeansException { 
            this(new String[] { configLocation}, true, null);
        }
    
        public ClassPathXmlApplicationContext(
                String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
                throws BeansException { 
    
            super(parent);
            setConfigLocations(configLocations);
            if (refresh) { 
                refresh();
            }
        }

`ClassPathXmlApplicationContext` 的构造函数主要做了 3 件事：

1.  设置父容器，这里为 null
2.  设置 XML 配置文件的位置
3.  调用 `resresh` 方法，启动容器

### 2.解析并设置 XML 配置文件 ###

`setConfigLocations` 方法用于将解析过的文件路径添加到 `configLocations` 数组中，用于后面 `beanDefitnion` 初始化。

public void setConfigLocations(@Nullable String... locations) { 
            if (locations != null) { 
                Assert.noNullElements(locations, "Config locations must not be null");
                this.configLocations = new String[locations.length];
                for (int i = 0; i < locations.length; i++) { 
                    this.configLocations[i] = resolvePath(locations[i]).trim();
                }
            }
            else { 
                this.configLocations = null;
            }
        }

### 3.启动流程一览 ###

下面简化了一些无用的代码，IoC 容器启动的流程主要是通过 `refresh` 方法实现的，流程比较复杂，后面分步来总结。从 `refresh()` 方法中我们可以看出 IoC 启动流程是线程安全的，`startupShutdownMonitor` 是一个 `Object` 对象，当容器启动或者销毁时使用。

@Override
        public void refresh() throws BeansException, IllegalStateException { 
            // 线程安全，startupShutdownMonitor 是一个 Object 对象，当容器启动或者销毁时使用
            synchronized (this.startupShutdownMonitor) { 
                prepareRefresh();
                ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
                prepareBeanFactory(beanFactory);
                try { 
                    postProcessBeanFactory(beanFactory);
                    invokeBeanFactoryPostProcessors(beanFactory);
                    registerBeanPostProcessors(beanFactory);
                    initMessageSource();
                    initApplicationEventMulticaster();
                    onRefresh();
                    registerListeners();
                    finishBeanFactoryInitialization(beanFactory);
                    finishRefresh();
                }
                catch (BeansException ex) { 
                }
    
                finally { 
                    resetCommonCaches();
                }
            }
        }

简要的看完了启动流程代码，下面简单的梳理一下每个方法的作用，具体细节会在方法实现中解释。

*  prepareRefresh：设置启动信息、属性信息、初始化监听器存储集合等
 *  obtainFreshBeanFactory：创建 `BeanFactory`，初始化 `BeanDefinition` 等
 *  prepareBeanFactory：设置 bean 类加载器、解析器、注册环境信息等
 *  postProcessBeanFactory：空实现，用于子类重写
 *  invokeBeanFactoryPostProcessors：发现并执行 `BeanDefinitionRegistryPostProcessor` 与 `BeanFactoryPostProcessor`
 *  registerBeanPostProcessors：发现并注册 `BeanPostProcessor`，并不会执行
 *  initMessageSource：初始化国际化信息
 *  initApplicationEventMulticaster：初始化事件广播器
 *  onRefresh：模板方法空实现，子类重写
 *  registerListeners：注册监听器，监听器的发现基于 `ApplicationListenerDetector` 实现，// TODO 待验证
 *  finishBeanFactoryInitialization：冻结配置文件、初始化所有非懒加载切是单例配置的 bean 等
 *  finishRefresh：发布事件（清除缓存等）
 *  resetCommonCaches：清除相关反射缓存数据

### 4.启动前准备 ###

容器启动前会做一些准备工作，当准备工作完成后才会创建 `BeanFactory`。

protected void prepareRefresh() { 
            this.startupDate = System.currentTimeMillis();
            this.closed.set(false);
            this.active.set(true);
    
            if (logger.isDebugEnabled()) { 
                if (logger.isTraceEnabled()) { 
                    logger.trace("Refreshing " + this);
                } else { 
                    logger.debug("Refreshing " + getDisplayName());
                }
            }
    
            // Initialize any placeholder property sources in the context environment.
            initPropertySources();
    
            // Validate that all properties marked as required are resolvable:
            // see ConfigurablePropertyResolver#setRequiredProperties
            getEnvironment().validateRequiredProperties();
    
            // Store pre-refresh ApplicationListeners...
            // 启动监听器，此时并未注册
            if (this.earlyApplicationListeners == null) { 
                this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
            } else { 
                // Reset local application listeners to pre-refresh state.
                this.applicationListeners.clear();
                this.applicationListeners.addAll(this.earlyApplicationListeners);
            }
    
            // Allow for the collection of early ApplicationEvents,
            // to be published once the multicaster is available...
            this.earlyApplicationEvents = new LinkedHashSet<>();
        }

1.  设置启动信息：启动时间，活跃状态
2.  初始化属性信息，是一个空方法，具体交给子类去实现，用来设置环境属性信息
3.  验证必要的属性信息
4.  初始化存储监听器的集合，此时并没有监听器注册

### 5.创建 `BeanFactory` 并初始化 `BeanDefinition` ###

这个流程中最值得一提的是 `loadBeanDefinitions` 方法，该方法用于将 Spring 的配置文件转成 `Document` 对象，然后解析 `Document` 将 XML 文件中的配置转化成 `BeanDefinition`，保存在 `beanDefinitionMap` 中用于创建 bean 对象。`loadBeanDefinitions` 方法之前已经总结过，大家可以在以前的文章中找到。

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() { 
            refreshBeanFactory();
            // 返回 beanFactory
            return getBeanFactory();
        }
    
        @Override
        protected final void refreshBeanFactory() throws BeansException { 
            if (hasBeanFactory()) { 
                destroyBeans();
                closeBeanFactory();
            }
            try { 
                DefaultListableBeanFactory beanFactory = createBeanFactory();
                beanFactory.setSerializationId(getId());
                customizeBeanFactory(beanFactory);
                loadBeanDefinitions(beanFactory);
                synchronized (this.beanFactoryMonitor) { 
                    this.beanFactory = beanFactory;
                }
            }
            catch (IOException ex) { 
                throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
            }
        }
    
        @Override
        public final ConfigurableListableBeanFactory getBeanFactory() { 
            synchronized (this.beanFactoryMonitor) { 
                if (this.beanFactory == null) { 
                    throw new IllegalStateException("BeanFactory not initialized or already closed - " +
                            "call 'refresh' before accessing beans via the ApplicationContext");
                }
                return this.beanFactory;
            }
        }

1.  如果存在 `beanFactory` 则销毁，并销毁创建的 bean，就是清空各种缓存 map
2.  创建 `BeanFactory（DefaultListableBeanFactory）`
3.  设置序列 ID，根据当前对象生成
4.  设置是否允许循环依赖与覆盖 `beanDefinition`，默认都是不允许的，set 方法没有调用
5.  加载 `beanDefinition`

### 6.完善 `BeanFactory` ###

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) { 
            // Tell the internal bean factory to use the context's class loader etc.
            // 设置类加载器
            beanFactory.setBeanClassLoader(getClassLoader());
            beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
            beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
    
            // Configure the bean factory with context callbacks.
            // 设置与取消对应 beanPostProcessor
            beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
            beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
            beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
            beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
            beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
            beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
            beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
    
            // BeanFactory interface not registered as resolvable type in a plain factory.
            // MessageSource registered (and found for autowiring) as a bean.
            beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
            beanFactory.registerResolvableDependency(ResourceLoader.class, this);
            beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
            beanFactory.registerResolvableDependency(ApplicationContext.class, this);
    
            // Register early post-processor for detecting inner beans as ApplicationListeners.
            beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
    
            // Detect a LoadTimeWeaver and prepare for weaving, if found.
            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()));
            }
    
            // Register default environment beans.
            // 注册默认的环境 bean 信息，比如：environment、systemProperties、systemEnvironment
            if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) { 
                beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
            }
            if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) { 
                beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
            }
            if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) { 
                beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
            }
        }

1.  设置 bean 的类加载器，解析器
2.  设置与排除对应 `beanPostProcessor`，这里设置了 `ApplicationContextAwareProcessor`、`ApplicationListenerDetector`，`ApplicationContextAwareProcessor` 会处理对应的 …Aware 接口，可以联想项目中经常使用类继承 `ApplicationAware`，然后获取到 `ApplicationContext`，这个 `ApplicationContext` 就是通过 `BeanPostProcessor` 实现的
3.  设置依赖信息，TODO 没看懂
4.  注册默认的环境 bean 信息，比如：`environment`、`systemProperties`、`systemEnvironment`

在项目里我们经常通过继承 `ApplicationContextAware` 来获取到 `applicationContext`，从而创建一些辅助 bean 来帮助我们实现一些架构设计，这个 `applicationContext` 就是通过 `BeanPostProcessor` 完成配置的，`BeanPostProcessor` 相关内容我会在后续的文章里讲到。

`ApplicationContextAwareProcessor` 继承自 `BeanPostProcessor`，会在每个 bean 创建前后执行对应的方法。下面我们一起来简单的看一下 `ApplicationContextAwareProcessor` 中的 `postProcessBeforeInitialization` 方法，看完后你就知道原因了。

public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException { 
            AccessControlContext acc = null;
    
            if (System.getSecurityManager() != null &&
                    (bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
                            bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
                            bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) { 
                acc = this.applicationContext.getBeanFactory().getAccessControlContext();
            }
    
            if (acc != null) { 
                AccessController.doPrivileged((PrivilegedAction<Object>) () -> { 
                    invokeAwareInterfaces(bean);
                    return null;
                }, acc);
            }
            else { 
                invokeAwareInterfaces(bean);
            }
    
            return bean;
        }
    
        private void invokeAwareInterfaces(Object bean) { 
            if (bean instanceof Aware) { 
                if (bean instanceof EnvironmentAware) { 
                    ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
                }
                if (bean instanceof EmbeddedValueResolverAware) { 
                    ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
                }
                if (bean instanceof ResourceLoaderAware) { 
                    ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
                }
                if (bean instanceof ApplicationEventPublisherAware) { 
                    ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
                }
                if (bean instanceof MessageSourceAware) { 
                    ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
                }
                // 设置 applicationContext
                if (bean instanceof ApplicationContextAware) { 
                    ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
                }
            }
        }

### 7.postProcessBeanFactory ###

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) { 
        }

这个方法没有任何操作，当代码执行到这里的时候 `beanDefinition` 已经初始化完成，而 bean 实例还没有创建，在这个方法中你可以设置 `BeanPostProcessors` 来达到某种效果。比如在 `StaticWebApplicationContext` 实现类中会设置 `ServletContextAwareProcessor` 来完成 web 相关的一些配置。

### 8.执行 BeanFactoryPostProcessor ###

在 Spring 中有多种类型的 processor，不同的类型可以获取到不同资源，我们可以根据对应的资源进行一些自定义处理。

*  `BeanDefinitionRegistryPostProcessor`： 继承自 `BeanFactoryPostProcessor`，在 `beanDefinition` 注册之后执行，可以获取到所有已注册的 `beanDefinition`进行额外处理
 *  `BeanFactoryPostProcessor`：在 `BeanDefinitionRegistryPostProcessor` 执行完成之后执行，可以获取到 `beanFactory` 进行额外处理
 *  `BeanPostProcessor`：在 bean 实例创建前后执行

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) { 
    
            PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
    
            // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
            // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
            if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) { 
                beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
                beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
            }
        }

该方法会执行所有实现了 `BeanFactoryPostProcessor` 类型的 processor。下面是一个 `BeanDefinitionRegistryPostProcessor` 的例子

public class BeanDefinitionRegistryPostProcessorTest implements BeanDefinitionRegistryPostProcessor { 
    
        public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException { 
            // 获取所有 beanDefinitionNames
            String[] beanDefinitionNames = registry.getBeanDefinitionNames();
            for (String beanDefinitionName : beanDefinitionNames) { 
                // 根据 beanDefinitionName 获取到 beanDefinition
                BeanDefinition beanDefinition = registry.getBeanDefinition(beanDefinitionName);
                System.out.println(beanDefinitionName + " is singleton:" + beanDefinition.isSingleton());
            }
            System.out.println("------------BeanDefinitionRegistryPostProcessor start-------------");
        }
    
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { 
            System.out.println("------------BeanDefinitionRegistryPostProcessor end-------------");
        }
    }

![在这里插入图片描述][20200313204357996.png]  
`postProcessBeanDefinitionRegistry` 方法有一个 `BeanDefinitionRegistry` 参数，通过该参数，我们可以获取到所有已经注册过的 `beanDefinition`，有了 `beanDefinition` 我们就可以在 bean 创建前动态的修改一些配置，其他类型的 processor 同理。

通过上面的截图可以看出 `BeanDefinitionRegistryPostProcessorTest` 本身也是一个 bean，在执行前会先从 `beanFactory` 中获取已注册的 `processor`，如果该 `processor` 没有创建会先在 `getBean` 方法中创建。因此 IoC 容器中的 bean 并不全是在 `finishBeanFactoryInitialization` 中实例化的。

### 9.发现并注册 `BeanPostProcessor` ###

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) { 
            PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
        }

通过方法名就能看出来这个方法用来发现并注册所有的 `BeanPostProcessor`，`BeanPostProcessor` 中有两个方法，分别在 bean 创建前后执行。

### 10.初始化国际化配置 ###

`initMessageSource` 方法用于给容器初始化一个 `messageSource` 用来支持一些国际化的操作。

protected void initMessageSource() { 
            ConfigurableListableBeanFactory beanFactory = getBeanFactory();
            if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) { 
                this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
                // Make MessageSource aware of parent MessageSource.
                if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) { 
                    HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
                    if (hms.getParentMessageSource() == null) { 
                        // Only set parent context as parent MessageSource if no parent MessageSource
                        // registered already.
                        hms.setParentMessageSource(getInternalParentMessageSource());
                    }
                }
                if (logger.isTraceEnabled()) { 
                    logger.trace("Using MessageSource [" + this.messageSource + "]");
                }
            } else { 
                // Use empty MessageSource to be able to accept getMessage calls.
                DelegatingMessageSource dms = new DelegatingMessageSource();
                dms.setParentMessageSource(getInternalParentMessageSource());
                this.messageSource = dms;
                beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
                if (logger.isTraceEnabled()) { 
                    logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
                }
            }
        }

### 11.初始化事件多播器 ###

Spring 支持事件通知机制，主要组件包括：

*  ApplicationEvent：事件
 *  ApplicationListener：事件监听器
 *  ApplicationEventPublisher：事件发布
 *  ApplicationEventMulticaster：事件广播

关于事件发布机制，后面会单独写一篇文章介绍原理，有兴趣的可以也参考 [Spring Event事件通知机制][Spring Event] 这篇文章进行详细了解。

protected void initApplicationEventMulticaster() { 
            ConfigurableListableBeanFactory beanFactory = getBeanFactory();
            if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) { 
                this.applicationEventMulticaster =
                        beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
                if (logger.isTraceEnabled()) { 
                    logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
                }
            } else { 
                this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
                beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
                if (logger.isTraceEnabled()) { 
                    logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
                            "[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
                }
            }
        }

这个方法主要用来给容器初始化一个事件多播器，后面会通过多播器将事件广播给所有的监听者。

### 12.onRefresh ###

protected void onRefresh() throws BeansException { 
            // For subclasses: do nothing by default.
        }

`onRefresh` 是一个模板方法，用来自定义一些实现。

### 13.注册监听器并发布事件 ###

protected void registerListeners() { 
            // Register statically specified listeners first.
            for (ApplicationListener<?> listener : getApplicationListeners()) { 
                getApplicationEventMulticaster().addApplicationListener(listener);
            }
    
            // Do not initialize FactoryBeans here: We need to leave all regular beans
            // uninitialized to let post-processors apply to them!
            // 发现并注册监听器
            String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
            for (String listenerBeanName : listenerBeanNames) { 
                getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
            }
    
            // Publish early application events now that we finally have a multicaster...
            // 如果存在早期要发布的事件，则发布出去
            Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
            this.earlyApplicationEvents = null;
            if (earlyEventsToProcess != null) { 
                for (ApplicationEvent earlyEvent : earlyEventsToProcess) { 
                    getApplicationEventMulticaster().multicastEvent(earlyEvent);
                }
            }
        }

`registerListeners` 方法会注册所有监听器，然后判断是否有早期要发布的事件，如果有则进行事件发布。

### 14.实例化单例 bean ###

到这里准备工作基本上都完成了，也就到了最重要的一步，实例化所有单例 bean（非懒加载），实例化的流程比较复杂，后面会通过几篇文章进行详细的梳理，这里就不展开了。

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { 
            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));
            }
    
            if (!beanFactory.hasEmbeddedValueResolver()) { 
                beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
            }
    
            // TODO 这个是干嘛用的
            String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
            for (String weaverAwareName : weaverAwareNames) { 
                getBean(weaverAwareName);
            }
    
            beanFactory.setTempClassLoader(null);
    
            beanFactory.freezeConfiguration();
    
            beanFactory.preInstantiateSingletons();
        }

1.  初始化 property 转换服务 bean
2.  设置注解 value 解析器
3.  `LoadTimeWeaverAware` 目前还没有搞懂是干啥的
4.  禁用临时类加载器，并冻结配置文件
5.  初始化单例 bean

### 15.收尾工作 ###

protected void finishRefresh() { 
            // Clear context-level resource caches (such as ASM metadata from scanning).
            // 清除资源缓存
            clearResourceCaches();
    
            // Initialize lifecycle processor for this context.
            initLifecycleProcessor();
    
            // Propagate refresh to lifecycle processor first.
            getLifecycleProcessor().onRefresh();
    
            // Publish the final event.
            publishEvent(new ContextRefreshedEvent(this));
    
            // Participate in LiveBeansView MBean, if active.
            LiveBeansView.registerApplicationContext(this);
        }

1.  清除资源缓存
2.  初始化容器生命周期处理器，这里是初始化的是一个 `LifecycleProcessor` 对象，这个对象主要用来管理容器的生命周期
3.  设置处理器生命周期开始
4.  发布容器刷新完成（ContextRefreshedEvent）事件
5.  `LiveBeansView.registerApplicationContext(this)` 没有看懂什么意思 // TODO

//TODO

### 16.resetCommonCaches ###

protected void resetCommonCaches() { 
            ReflectionUtils.clearCache();
            AnnotationUtils.clearCache();
            ResolvableType.clearCache();
            CachedIntrospectionResults.clearClassLoader(getClassLoader());
        }

当所有步骤完成时清除相关缓存信息。

### 总结 ###

整个启动流程非常长，有的步骤会涉及到很多细节，如果要让我说该从哪里着手源码，说真的我也说不清楚，因为很多流程是环环相扣的，基本上最近一有空闲时间我就看一部分，有的部分会重复的看，每次都会有收获，慢慢的才对一些组件熟悉起来，好事多磨。

[20200313204357996.png]: /images/20230529/3d9b47a5952d4175a5e63279dcba6aef.png
[Spring Event]: https://blog.wangqi.love/articles/Java/Spring%20Event%E4%BA%8B%E4%BB%B6%E9%80%9A%E7%9F%A5%E6%9C%BA%E5%88%B6.html