Spring之容器的启动流程

1.整体启动流程

Spring的启动流程可以归纳为三个步骤：

• 1、初始化Spring容器，注册内置的BeanPostProcessor的BeanDefinition到容器中
• 2、将配置类的BeanDefinition注册到容器中
• 3、调用refresh()方法刷新容器 

因为是基于 java-config 技术分析源码，所以这里的入口是 AnnotationConfigApplicationContext ，如果是使用 xml 分析，那么入口即为 ClassPathXmlApplicationContext ，它们俩的共同特征便是都继承了 AbstractApplicationContext 类，而大名鼎鼎的 refresh()便是在这个类中定义的。我们接着分析 AnnotationConfigApplicationContext 类，源码如下：

?

1 2 3 4 5 6 7 8 9

// 初始化容器 public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {     // 注册 Spring 内置后置处理器的 BeanDefinition 到容器     this();     // 注册配置类 BeanDefinition 到容器     register(annotatedClasses);     // 加载或者刷新容器中的Bean     refresh(); }

　　所以整个Spring容器的启动流程可以绘制成如下流程图：

 2.详细拆解三个入口

一、初始化流程：
1、spring容器的初始化时，通过this()调用了无参构造函数，主要做了以下三个事情：

（1）实例化BeanFactory【DefaultListableBeanFactory】工厂，用于生成Bean对象
（2）实例化BeanDefinitionReader注解配置读取器，用于对特定注解（如@Service、@Repository）的类进行读取转化成 BeanDefinition 对象，（BeanDefinition 是 Spring 中极其重要的一个概念，它存储了 bean 对象的所有特征信息，如是否单例，是否懒加载，factoryBeanName 等）
（3）实例化ClassPathBeanDefinitionScanner路径扫描器，用于对指定的包目录进行扫描查找 bean 对象
2、核心代码剖析：

（1）向容器添加内置组件：org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessors：

根据上图分析，代码运行到这里时候，Spring 容器已经构造完毕，那么就可以为容器添加一些内置组件了，其中最主要的组件便是 ConfigurationClassPostProcessor 和 AutowiredAnnotationBeanPostProcessor ，前者是一个 beanFactory 后置处理器，用来完成 bean 的扫描与注入工作，后者是一个 bean 后置处理器，用来完成 @AutoWired 自动注入。

二、注册SpringConfig配置类到容器中： 

1、将SpringConfig注册到容器中：org.springframework.context.annotation.AnnotatedBeanDefinitionReader#doRegisterBean：

这个步骤主要是用来解析用户传入的 Spring 配置类，解析成一个 BeanDefinition 然后注册到容器中，主要源码如下：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,         @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {     // 解析传入的配置类，实际上这个方法既可以解析配置类，也可以解析 Spring bean 对象     AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);     // 判断是否需要跳过，判断依据是此类上有没有 @Conditional 注解     if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {         return;     }        abd.setInstanceSupplier(instanceSupplier);     ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);     abd.setScope(scopeMetadata.getScopeName());     String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));     // 处理类上的通用注解     AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);     if (qualifiers != null) {         for (Class<? extends Annotation> qualifier : qualifiers) {             if (Primary.class == qualifier) {                 abd.setPrimary(true);             }             else if (Lazy.class == qualifier) {                 abd.setLazyInit(true);             }             else {                 abd.addQualifier(new AutowireCandidateQualifier(qualifier));             }         }     }     // 封装成一个 BeanDefinitionHolder     for (BeanDefinitionCustomizer customizer : definitionCustomizers) {         customizer.customize(abd);     }     BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);     // 处理 scopedProxyMode     definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);        // 把 BeanDefinitionHolder 注册到 registry     BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry); }

　　

三、refresh()容器刷新流程：

refresh()主要用于容器的刷新，Spring 中的每一个容器都会调用 refresh() 方法进行刷新，无论是 Spring 的父子容器，还是 Spring Cloud Feign 中的 feign 隔离容器，每一个容器都会调用这个方法完成初始化。refresh()可划分为12个步骤，其中比较重要的步骤下面会有详细说明。
1、refresh()方法的源码：org.springframework.context.support.AbstractApplicationContext#refresh：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

public void refresh() throws BeansException, IllegalStateException {             synchronized (this.startupShutdownMonitor) {                   // ================= 一、上下文的初始化 =================                 // 1.准备上下文(刷新前的预处理)                 prepareRefresh();                 // 2.通知子类刷新内部工厂( 获取 beanFactory，即前面创建的【DefaultListableBeanFactory】)                 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();                 // 3.准备bean工厂以便在当前上下文中使用(预处理 beanFactory，向容器中添加一些组件)                 prepareBeanFactory(beanFactory);                   try {                     // ================= 二、BeanFactory的初始化 =================                     // 4.对工厂进行默认后置处理(子类通过重写这个方法可以在 BeanFactory 创建并与准备完成以后做进一步的设置)                     postProcessBeanFactory(beanFactory);                     // 5.使用后置处理器对工厂进行处理(执行 BeanFactoryPostProcessor 方法，beanFactory 后置处理器)                     invokeBeanFactoryPostProcessors(beanFactory);                     // 6.注册Bean后置处理器(注册 BeanPostProcessors，bean 后置处理器)                     registerBeanPostProcessors(beanFactory);                       // ================= 三、事件，Bean及其他配置的初始化 =================                     // 7.初始化此上下文的消息源( 初始化 MessageSource 组件（做国际化功能；消息绑定，消息解析）)                     initMessageSource();                     // 8.为此上下文初始化事件广播者(初始化事件派发器，在注册监听器时会用到)                     initApplicationEventMulticaster();                     // 9.初始化特定上下文子类中的其他特殊bean(留给子容器（子类），子类重写这个方法，在容器刷新的时候可以自定义逻辑，web 场景下会使用)                     onRefresh();                     // 10.检查侦听器bean并注册(注册监听器，派发之前步骤产生的一些事件（可能没有）)                     registerListeners();                     // 11.实例化所有非懒加载的剩余单例(初始化所有的非单实例 bean)                     finishBeanFactoryInitialization(beanFactory);                     // 12.完成刷新(发布容器刷新完成事件)                     finishRefresh();                 }                     // ================= 异常处理 =================                 catch (BeansException ex) {                     if (logger.isWarnEnabled()) {                         logger.warn("Exception encountered during context initialization - " +                                 "cancelling refresh attempt: " + ex);                     }                     // 销毁已创建的单例                     destroyBeans();                     // 重置上下文的激活状态                     cancelRefresh(ex);                     throw ex;                 }                 finally {                     // 重置内部的一些元数据缓存                     resetCommonCaches();                 }             }         }

　　

　　首先我们总结一下refresh()方法每一步主要的功能：之后再对每一步的源码做具体的分析

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71

1、prepareRefresh()刷新前的预处理：   （1）initPropertySources()：初始化一些属性设置，子类自定义个性化的属性设置方法； （2）getEnvironment().validateRequiredProperties()：检验属性的合法性 （3）earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>()：保存容器中的一些早期的事件； 2、obtainFreshBeanFactory()：获取在容器初始化时创建的BeanFactory：   （1）refreshBeanFactory()：刷新BeanFactory，设置序列化ID； （2）getBeanFactory()：返回初始化中的GenericApplicationContext创建的BeanFactory对象，即【DefaultListableBeanFactory】类型 3、prepareBeanFactory(beanFactory)：BeanFactory的预处理工作，向容器中添加一些组件：   （1）设置BeanFactory的类加载器、设置表达式解析器等等 （2）添加BeanPostProcessor【ApplicationContextAwareProcessor】 （3）设置忽略自动装配的接口：EnvironmentAware、EmbeddedValueResolverAware、ResourceLoaderAware、ApplicationEventPublisherAware、MessageSourceAware、ApplicationContextAware； （4）注册可以解析的自动装配类，即可以在任意组件中通过注解自动注入：BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext （5）添加BeanPostProcessor【ApplicationListenerDetector】 （6）添加编译时的AspectJ； （7）给BeanFactory中注册的3个组件：environment【ConfigurableEnvironment】、systemProperties【Map<String, Object>】、systemEnvironment【Map<String, Object>】 4、postProcessBeanFactory(beanFactory)：子类重写该方法，可以实现在BeanFactory创建并预处理完成以后做进一步的设置   5、invokeBeanFactoryPostProcessors(beanFactory)：在BeanFactory标准初始化之后执行BeanFactoryPostProcessor的方法，即BeanFactory的后置处理器：   （1）先执行BeanDefinitionRegistryPostProcessor： postProcessor.postProcessBeanDefinitionRegistry(registry)   ① 获取所有的实现了BeanDefinitionRegistryPostProcessor接口类型的集合 ② 先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor ③ 再执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor ④ 最后执行没有实现任何优先级或者是顺序接口的BeanDefinitionRegistryPostProcessors        （2）再执行BeanFactoryPostProcessor的方法：postProcessor.postProcessBeanFactory(beanFactory)   ① 获取所有的实现了BeanFactoryPostProcessor接口类型的集合 ② 先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor ③ 再执行实现了Ordered顺序接口的BeanFactoryPostProcessor ④ 最后执行没有实现任何优先级或者是顺序接口的BeanFactoryPostProcessor 6、registerBeanPostProcessors(beanFactory)：向容器中注册Bean的后置处理器BeanPostProcessor，它的主要作用是干预Spring初始化bean的流程，从而完成代理、自动注入、循环依赖等功能   （1）获取所有实现了BeanPostProcessor接口类型的集合： （2）先注册实现了PriorityOrdered优先级接口的BeanPostProcessor； （3）再注册实现了Ordered优先级接口的BeanPostProcessor； （4）最后注册没有实现任何优先级接口的BeanPostProcessor； （5）最r终注册MergedBeanDefinitionPostProcessor类型的BeanPostProcessor：beanFactory.addBeanPostProcessor(postProcessor); （6）给容器注册一个ApplicationListenerDetector：用于在Bean创建完成后检查是否是ApplicationListener，如果是，就把Bean放到容器中保存起来：applicationContext.addApplicationListener((ApplicationListener<?>) bean); 此时容器中默认有6个默认的BeanProcessor(无任何代理模式下)：【ApplicationContextAwareProcessor】、【ConfigurationClassPostProcessorsAwareBeanPostProcessor】、【PostProcessorRegistrationDelegate】、【CommonAnnotationBeanPostProcessor】、【AutowiredAnnotationBeanPostProcessor】、【ApplicationListenerDetector】   7、initMessageSource()：初始化MessageSource组件，主要用于做国际化功能，消息绑定与消息解析：   （1）看BeanFactory容器中是否有id为messageSource 并且类型是MessageSource的组件：如果有，直接赋值给messageSource；如果没有，则创建一个DelegatingMessageSource； （2）把创建好的MessageSource注册在容器中，以后获取国际化配置文件的值的时候，可以自动注入MessageSource； 8、initApplicationEventMulticaster()：初始化事件派发器，在注册监听器时会用到：   （1）看BeanFactory容器中是否存在自定义的ApplicationEventMulticaster：如果有，直接从容器中获取；如果没有，则创建一个SimpleApplicationEventMulticaster （2）将创建的ApplicationEventMulticaster添加到BeanFactory中，以后其他组件就可以直接自动注入 9、onRefresh()：留给子容器、子类重写这个方法，在容器刷新的时候可以自定义逻辑   10、registerListeners()：注册监听器：将容器中所有的ApplicationListener注册到事件派发器中，并派发之前步骤产生的事件：    （1）从容器中拿到所有的ApplicationListener （2）将每个监听器添加到事件派发器中：getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName); （3）派发之前步骤产生的事件applicationEvents：getApplicationEventMulticaster().multicastEvent(earlyEvent); 11、finishBeanFactoryInitialization(beanFactory)：初始化所有剩下的单实例bean，核心方法是preInstantiateSingletons()，会调用getBean()方法创建对象；   （1）获取容器中的所有beanDefinitionName，依次进行初始化和创建对象 （2）获取Bean的定义信息RootBeanDefinition，它表示自己的BeanDefinition和可能存在父类的BeanDefinition合并后的对象 （3）如果Bean满足这三个条件：非抽象的，单实例，非懒加载，则执行单例Bean创建流程：    （4）所有Bean都利用getBean()创建完成以后，检查所有的Bean是否为SmartInitializingSingleton接口的，如果是；就执行afterSingletonsInstantiated()； 12、finishRefresh()：发布BeanFactory容器刷新完成事件：   （1）initLifecycleProcessor()：初始化和生命周期有关的后置处理器：默认从容器中找是否有lifecycleProcessor的组件【LifecycleProcessor】，如果没有，则创建一个DefaultLifecycleProcessor()加入到容器； （2）getLifecycleProcessor().onRefresh()：拿到前面定义的生命周期处理器（LifecycleProcessor）回调onRefresh()方法 （3）publishEvent(new ContextRefreshedEvent(this))：发布容器刷新完成事件； （4）liveBeansView.registerApplicationContext(this);

　　2、第三步：BeanFactory的预处理：org.springframework.context.support.AbstractApplicationContext#prepareBeanFactory（这一步主要为 beanFactory 工厂添加一些内置组件）：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {     // 设置 classLoader     beanFactory.setBeanClassLoader(getClassLoader());     //设置 bean 表达式解析器     beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));     beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));        // 添加一个 BeanPostProcessor【ApplicationContextAwareProcessor】     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.registerResolvableDependency(BeanFactory.class, beanFactory);     beanFactory.registerResolvableDependency(ResourceLoader.class, this);     beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);     beanFactory.registerResolvableDependency(ApplicationContext.class, this);        // 添加一个 BeanPostProcessor【ApplicationListenerDetector】     beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));        // 添加编译时的 AspectJ     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()));     }        // 注册 environment 组件，类型是【ConfigurableEnvironment】     if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {         beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());     }     // 注册 systemProperties 组件，类型是【Map<String, Object>】     if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {         beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());     }     // 注册 systemEnvironment 组件，类型是【Map<String, Object>】     if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {         beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());     } }

　　

?

1 2 3 4 5 6 7 8 9

执行流程小结：      （1）设置BeanFactory的类加载器、设置表达式解析器等等 （2）添加BeanPostProcessor【ApplicationContextAwareProcessor】 （3）设置忽略自动装配的接口：EnvironmentAware、EmbeddedValueResolverAware、ResourceLoaderAware、ApplicationEventPublisherAware、MessageSourceAware、ApplicationContextAware； （4）注册可以解析的自动装配类，即可以在任意组件中通过注解自动注入：BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext （5）添加BeanPostProcessor【ApplicationListenerDetector】 （6）添加编译时的AspectJ； （7）给BeanFactory中注册的3个组件：environment【ConfigurableEnvironment】、systemProperties【Map<String, Object>】、systemEnvironment【Map<String, Object>】

　　

3、第五步：执行BeanFactory的后置处理器：org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors：

Spring 在扫描完所有的 bean 转成 BeanDefinition 时候，允许我们做一些自定义操作，这得益于 Spring 为我们提供的 BeanFactoryPostProcessor 接口。

其中 BeanFactoryPostProcessor 又有一个子接口 BeanDefinitionRegistryPostProcessor ，前者会把 ConfigurableListableBeanFactory 暴露给我们使用，后者会把 BeanDefinitionRegistry 注册器暴露给我们使用，一旦获取到注册器，我们就可以按需注入了。

同时 Spring 是允许我们控制同类型组件的顺序，比如在 AOP 中我们常用的 @Order 注解，这里的 BeanFactoryPostProcessor 接口当然也是提供了顺序，最先被执行的是实现了 PriorityOrdered 接口的实现类，然后再到实现了 Ordered 接口的实现类，最后就是剩下来的常规 BeanFactoryPostProcessor 类。

 

 此时再看上图，是不是发现和喝水一般简单，首先会回调 postProcessBeanDefinitionRegistry() 方法，然后再回调 postProcessBeanFactory() 方法，最后注意顺序即可，下面一起看看具体的代码实现吧。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180

public static void invokeBeanFactoryPostProcessors(         ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {     // beanFactoryPostProcessors 这个参数是指用户通过 AnnotationConfigApplicationContext.addBeanFactoryPostProcessor() 方法手动传入的 BeanFactoryPostProcessor，没有交给 spring 管理     // Invoke BeanDefinitionRegistryPostProcessors first, if any.     // 代表执行过的 BeanDefinitionRegistryPostProcessor     Set<String> processedBeans = new HashSet<>();        if (beanFactory instanceof BeanDefinitionRegistry) {         BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;         // 常规后置处理器集合，即实现了 BeanFactoryPostProcessor 接口         List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();         // 注册后置处理器集合，即实现了 BeanDefinitionRegistryPostProcessor 接口         List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();         // 处理自定义的 beanFactoryPostProcessors（指调用 context.addBeanFactoryPostProcessor() 方法），一般这里都没有         for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {             if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {                 BeanDefinitionRegistryPostProcessor registryProcessor =                         (BeanDefinitionRegistryPostProcessor) postProcessor;                 // 调用 postProcessBeanDefinitionRegistry 方法                 registryProcessor.postProcessBeanDefinitionRegistry(registry);                 registryProcessors.add(registryProcessor);             }             else {                 regularPostProcessors.add(postProcessor);             }         }            // Do not initialize FactoryBeans here: We need to leave all regular beans         // uninitialized to let the bean factory post-processors apply to them!         // Separate between BeanDefinitionRegistryPostProcessors that implement         // PriorityOrdered, Ordered, and the rest.         // 定义一个变量 currentRegistryProcessors，表示当前要处理的 BeanFactoryPostProcessors         List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();            // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.         // 首先，从容器中查找实现了 PriorityOrdered 接口的 BeanDefinitionRegistryPostProcessor 类型，这里只会查找出一个【ConfigurationClassPostProcessor】         String[] postProcessorNames =                 beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);         for (String ppName : postProcessorNames) {             // 判断是否实现了 PriorityOrdered 接口             if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {                 // 添加到 currentRegistryProcessors                 currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));                 // 添加到 processedBeans，表示已经处理过这个类了                 processedBeans.add(ppName);             }         }         // 设置排列顺序         sortPostProcessors(currentRegistryProcessors, beanFactory);         // 添加到 registry 中         registryProcessors.addAll(currentRegistryProcessors);         // 执行 [postProcessBeanDefinitionRegistry] 回调方法         invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);         // 将 currentRegistryProcessors 变量清空，下面会继续用到         currentRegistryProcessors.clear();            // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.         // 接下来，从容器中查找实现了 Ordered 接口的 BeanDefinitionRegistryPostProcessors 类型，这里可能会查找出多个         // 因为【ConfigurationClassPostProcessor】已经完成了 postProcessBeanDefinitionRegistry() 方法，已经向容器中完成扫描工作，所以容器会有很多个组件         postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);         for (String ppName : postProcessorNames) {             // 判断 processedBeans 是否处理过这个类，且是否实现 Ordered 接口             if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {                 currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));                 processedBeans.add(ppName);             }         }         // 设置排列顺序         sortPostProcessors(currentRegistryProcessors, beanFactory);         // 添加到 registry 中         registryProcessors.addAll(currentRegistryProcessors);         // 执行 [postProcessBeanDefinitionRegistry] 回调方法         invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);         // 将 currentRegistryProcessors 变量清空，下面会继续用到         currentRegistryProcessors.clear();            // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.         // 最后，从容器中查找剩余所有常规的 BeanDefinitionRegistryPostProcessors 类型         boolean reiterate = true;         while (reiterate) {             reiterate = false;             // 根据类型从容器中查找             postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);             for (String ppName : postProcessorNames) {                 // 判断 processedBeans 是否处理过这个类                 if (!processedBeans.contains(ppName)) {                     // 添加到 currentRegistryProcessors                     currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));                     // 添加到 processedBeans，表示已经处理过这个类了                     processedBeans.add(ppName);                     // 将标识设置为 true，继续循环查找，可能随时因为防止下面调用了 invokeBeanDefinitionRegistryPostProcessors() 方法引入新的后置处理器                     reiterate = true;                 }             }             // 设置排列顺序             sortPostProcessors(currentRegistryProcessors, beanFactory);             // 添加到 registry 中             registryProcessors.addAll(currentRegistryProcessors);             // 执行 [postProcessBeanDefinitionRegistry] 回调方法             invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);             // 将 currentRegistryProcessors 变量清空，因为下一次循环可能会用到             currentRegistryProcessors.clear();         }            // Now, invoke the postProcessBeanFactory callback of all processors handled so far.         // 现在执行 registryProcessors 的 [postProcessBeanFactory] 回调方法         invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);         // 执行 regularPostProcessors 的 [postProcessBeanFactory] 回调方法，也包含用户手动调用 addBeanFactoryPostProcessor() 方法添加的 BeanFactoryPostProcessor         invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);     }        else {         // Invoke factory processors registered with the context instance.         invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);     }        // Do not initialize FactoryBeans here: We need to leave all regular beans     // uninitialized to let the bean factory post-processors apply to them!     // 从容器中查找实现了 BeanFactoryPostProcessor 接口的类     String[] postProcessorNames =             beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);        // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,     // Ordered, and the rest.     // 表示实现了 PriorityOrdered 接口的 BeanFactoryPostProcessor     List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();     // 表示实现了 Ordered 接口的 BeanFactoryPostProcessor     List<String> orderedPostProcessorNames = new ArrayList<>();     // 表示剩下来的常规的 BeanFactoryPostProcessors     List<String> nonOrderedPostProcessorNames = new ArrayList<>();     for (String ppName : postProcessorNames) {         // 判断是否已经处理过，因为 postProcessorNames 其实包含了上面步骤处理过的 BeanDefinitionRegistry 类型         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);         }         // 剩下所有常规的         else {             nonOrderedPostProcessorNames.add(ppName);         }     }        // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.     // 先将 priorityOrderedPostProcessors 集合排序     sortPostProcessors(priorityOrderedPostProcessors, beanFactory);     // 执行 priorityOrderedPostProcessors 的 [postProcessBeanFactory] 回调方法     invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);        // Next, invoke the BeanFactoryPostProcessors that implement Ordered.     // 接下来，把 orderedPostProcessorNames 转成 orderedPostProcessors 集合     List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();     for (String postProcessorName : orderedPostProcessorNames) {         orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));     }     // 将 orderedPostProcessors 集合排序     sortPostProcessors(orderedPostProcessors, beanFactory);     // 执行 orderedPostProcessors 的 [postProcessBeanFactory] 回调方法     invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);        // Finally, invoke all other BeanFactoryPostProcessors.     // 最后把 nonOrderedPostProcessorNames 转成 nonOrderedPostProcessors 集合，这里只有一个，myBeanFactoryPostProcessor     List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();     for (String postProcessorName : nonOrderedPostProcessorNames) {         nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));     }     // 执行 nonOrderedPostProcessors 的 [postProcessBeanFactory] 回调方法     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(); }

　　

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14

执行流程小结：   （1）先执行BeanDefinitionRegistryPostProcessor： postProcessor.postProcessBeanDefinitionRegistry(registry)   ① 获取所有的实现了BeanDefinitionRegistryPostProcessor接口类型的集合 ② 先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor ③ 再执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor ④ 最后执行没有实现任何优先级或者是顺序接口的BeanDefinitionRegistryPostProcessors        （2）再执行BeanFactoryPostProcessor的方法：postProcessor.postProcessBeanFactory(beanFactory)   ① 获取所有的实现了BeanFactoryPostProcessor接口类型的集合 ② 先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor ③ 再执行实现了Ordered顺序接口的BeanFactoryPostProcessor ④ 最后执行没有实现任何优先级或者是顺序接口的BeanFactoryPostProcessor

4、第六步：注册Bean的后置处理器：org.springframework.context.support.PostProcessorRegistrationDelegate#registerBeanPostProcessors：

这一步是向容器中注入 BeanPostProcessor 后置处理器，注意这里仅仅是向容器中注入而非使用。关于 BeanPostProcessor ，它的作用主要是会干预 Spring 初始化 bean 的流程，从而完成代理、自动注入、循环依赖等各种功能。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95

public static void registerBeanPostProcessors(         ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {        // 从容器中获取 BeanPostProcessor 类型     String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);        // Register BeanPostProcessorChecker that logs an info message when     // a bean is created during BeanPostProcessor instantiation, i.e. when     // a bean is not eligible for getting processed by all BeanPostProcessors.     int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;     // 向容器中添加【BeanPostProcessorChecker】，主要是用来检查是不是有 bean 已经初始化完成了，     // 如果没有执行所有的 beanPostProcessor（用数量来判断），如果有就会打印一行 info 日志     beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));        // Separate between BeanPostProcessors that implement PriorityOrdered,     // Ordered, and the rest.     // 存放实现了 PriorityOrdered 接口的 BeanPostProcessor     List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();     // 存放 MergedBeanDefinitionPostProcessor 类型的 BeanPostProcessor     List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();     // 存放实现了 Ordered 接口的 BeanPostProcessor 的 name     List<String> orderedPostProcessorNames = new ArrayList<>();     // 存放剩下来普通的 BeanPostProcessor 的 name     List<String> nonOrderedPostProcessorNames = new ArrayList<>();     // 从 beanFactory 中查找 postProcessorNames 里的 bean，然后放到对应的集合中     for (String ppName : postProcessorNames) {         // 判断有无实现 PriorityOrdered 接口         if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {             BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);             priorityOrderedPostProcessors.add(pp);             // 如果实现了 PriorityOrdered 接口，且属于 MergedBeanDefinitionPostProcessor             if (pp instanceof MergedBeanDefinitionPostProcessor) {                 // 把 MergedBeanDefinitionPostProcessor 类型的添加到 internalPostProcessors 集合中                 internalPostProcessors.add(pp);             }         }         else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {             orderedPostProcessorNames.add(ppName);         }         else {             nonOrderedPostProcessorNames.add(ppName);         }     }        // First, register the BeanPostProcessors that implement PriorityOrdered.     // 给 priorityOrderedPostProcessors 排序     sortPostProcessors(priorityOrderedPostProcessors, beanFactory);     // 先注册实现了 PriorityOrdered 接口的 beanPostProcessor     registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);        // Next, register the BeanPostProcessors that implement Ordered.     // 从 beanFactory 中查找 orderedPostProcessorNames 里的 bean，然后放到对应的集合中     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);         }     }     // 给 orderedPostProcessors 排序     sortPostProcessors(orderedPostProcessors, beanFactory);     // 再注册实现了 Ordered 接口的 beanPostProcessor     registerBeanPostProcessors(beanFactory, orderedPostProcessors);        // Now, register all regular BeanPostProcessors.     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);         }     }     // 再注册常规的 beanPostProcessor     registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);        // Finally, re-register all internal BeanPostProcessors.     // 排序 MergedBeanDefinitionPostProcessor 这种类型的 beanPostProcessor     sortPostProcessors(internalPostProcessors, beanFactory);     // 最后注册 MergedBeanDefinitionPostProcessor 类型的 beanPostProcessor     registerBeanPostProcessors(beanFactory, internalPostProcessors);        // Re-register post-processor for detecting inner beans as ApplicationListeners,     // moving it to the end of the processor chain (for picking up proxies etc).     // 给容器中添加【ApplicationListenerDetector】 beanPostProcessor，判断是不是监听器，如果是就把 bean 放到容器中保存起来     // 此时容器中默认会有 6 个内置的 beanPostProcessor         // 0 = {ApplicationContextAwareProcessor@1632}         //  1 = {ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor@1633}         //  2 = {PostProcessorRegistrationDelegate$BeanPostProcessorChecker@1634}         //  3 = {CommonAnnotationBeanPostProcessor@1635}         //  4 = {AutowiredAnnotationBeanPostProcessor@1636}         //  5 = {ApplicationListenerDetector@1637}     beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext)); }

　　

?

1 2 3 4 5 6 7 8

执行流程小结：   （1）获取所有实现了BeanPostProcessor接口类型的集合： （2）先注册实现了PriorityOrdered优先级接口的BeanPostProcessor； （3）再注册实现了Ordered优先级接口的BeanPostProcessor； （4）最后注册没有实现任何优先级接口的BeanPostProcessor； （5）最终注册MergedBeanDefinitionPostProcessor类型的BeanPostProcessor； （6）给容器注册一个ApplicationListenerDetector：用于在Bean创建完成后检查是否是ApplicationListener，如果是，就把Bean放到容器中保存起来：applicationContext.addApplicationListener((ApplicationListener<?>) bean);

　　5、第八步：初始化事件派发器：org.springframework.context.support.AbstractApplicationContext#initApplicationEventMulticaster：

前文我们说到，在整个容器创建过程中，Spring 会发布很多容器事件，如容器启动、刷新、关闭等，这个功能的实现得益于这里的 ApplicationEventMulticaster 广播器组件，通过它来派发事件通知。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

protected void initApplicationEventMulticaster() {     // 获取 beanFactory     ConfigurableListableBeanFactory beanFactory = getBeanFactory();     // 看看容器中是否有自定义的 applicationEventMulticaster     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 {         // 没有，就创建一个 SimpleApplicationEventMulticaster         this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);         // 将创建的 ApplicationEventMulticaster 添加到 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() + "]");         }     } }

　　

?

1 2 3 4

执行流程小结：   （1）看BeanFactory容器中是否存在自定义的ApplicationEventMulticaster：如果有，直接从容器中获取；如果没有，则创建一个SimpleApplicationEventMulticaster （2）将创建的ApplicationEventMulticaster添加到BeanFactory中，以后其他组件就可以直接自动注入

　　

6、第十步：注册ApplicationListener监听器：org.springframework.context.support.AbstractApplicationContext#registerListeners：

这一步主要是将容器中所有的ApplicationListener注册到事件派发器中，并派发之前步骤产生的事件。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

protected void registerListeners() {     // Register statically specified listeners first.     // 获取之前步骤中保存的 ApplicationListener     for (ApplicationListener<?> listener : getApplicationListeners()) {         // getApplicationEventMulticaster() 就是获取之前步骤初始化的 applicationEventMulticaster         getApplicationEventMulticaster().addApplicationListener(listener);     }        // Do not initialize FactoryBeans here: We need to leave all regular beans     // uninitialized to let post-processors apply to them!     // 从容器中获取所有的 ApplicationListener     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...     // 派发之前步骤产生的 application events     Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;     this.earlyApplicationEvents = null;     if (earlyEventsToProcess != null) {         for (ApplicationEvent earlyEvent : earlyEventsToProcess) {             getApplicationEventMulticaster().multicastEvent(earlyEvent);         }     } }

　　

?

1 2 3 4 5

执行流程小结：   （1）从容器中拿到所有的ApplicationListener （2）将每个监听器添加到事件派发器中：getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName); （3）派发之前步骤产生的事件applicationEvents：getApplicationEventMulticaster().multicastEvent(earlyEvent);

　　7、第十一步：初始化所有的单例Bean：org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64

public void preInstantiateSingletons() throws BeansException {     if (logger.isTraceEnabled()) {         logger.trace("Pre-instantiating singletons in " + this);     }        // Iterate over a copy to allow for init methods which in turn register new bean definitions.     // While this may not be part of the regular factory bootstrap, it does otherwise work fine.     // 获取容器中的所有 beanDefinitionName     List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);        // Trigger initialization of all non-lazy singleton beans...     // 循环进行初始化和创建对象     for (String beanName : beanNames) {         // 获取 RootBeanDefinition，它表示自己的 BeanDefinition 和可能存在父类的 BeanDefinition 合并后的对象         RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);         // 如果是非抽象的，且单实例，非懒加载         if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {             // 如果是 factoryBean，利用下面这种方法创建对象             if (isFactoryBean(beanName)) {                 // 如果是 factoryBean，则 加上 &，先创建工厂 bean                 Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);                 if (bean instanceof FactoryBean) {                     final FactoryBean<?> factory = (FactoryBean<?>) bean;                     boolean isEagerInit;                     if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {                         isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)                                         ((SmartFactoryBean<?>) factory)::isEagerInit,                                 getAccessControlContext());                     }                     else {                         isEagerInit = (factory instanceof SmartFactoryBean &&                                 ((SmartFactoryBean<?>) factory).isEagerInit());                     }                     if (isEagerInit) {                         getBean(beanName);                     }                 }             }             else {                 // 不是工厂 bean，用这种方法创建对象                 getBean(beanName);             }         }     }        // Trigger post-initialization callback for all applicable beans...     for (String beanName : beanNames) {         Object singletonInstance = getSingleton(beanName);         // 检查所有的 bean 是否是 SmartInitializingSingleton 接口         if (singletonInstance instanceof SmartInitializingSingleton) {             final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;             if (System.getSecurityManager() != null) {                 AccessController.doPrivileged((PrivilegedAction<Object>) () -> {                     smartSingleton.afterSingletonsInstantiated();                     return null;                 }, getAccessControlContext());             }             else {                 // 回调 afterSingletonsInstantiated() 方法，可以在回调中做一些事情                 smartSingleton.afterSingletonsInstantiated();             }         }     } }

?

1 2 3 4 5 6

执行流程小结：   （1）获取容器中的所有beanDefinitionName，依次进行初始化和创建对象 （2）获取Bean的定义信息RootBeanDefinition，它表示自己的BeanDefinition和可能存在父类的BeanDefinition合并后的对象 （3）如果Bean满足这三个条件：非抽象的，单实例，非懒加载，则执行单例Bean创建流程：    （4）所有Bean都利用getBean()创建完成以后，检查所有的Bean是否为SmartInitializingSingleton接口的，如果是；就执行afterSingletonsInstantiated()；

　　

8、第十二步：发布BeanFactory容器刷新完成事件：org.springframework.context.support.AbstractApplicationContext#finishRefresh：

整个容器初始化完毕之后，会在这里进行一些扫尾工作，如清理缓存，初始化生命周期处理器，发布容器刷新事件等。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

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.     // 拿到前面定义的生命周期处理器【LifecycleProcessor】回调 onRefresh() 方法     getLifecycleProcessor().onRefresh();        // Publish the final event.     // 发布容器刷新完成事件     publishEvent(new ContextRefreshedEvent(this));        // Participate in LiveBeansView MBean, if active.     LiveBeansView.registerApplicationContext(this); }

　　

?

1 2 3 4 5 6

执行流程小结：   （1）initLifecycleProcessor()：初始化和生命周期有关的后置处理器：默认从容器中找是否有lifecycleProcessor的组件【LifecycleProcessor】，如果没有，则创建一个DefaultLifecycleProcessor()加入到容器； （2）getLifecycleProcessor().onRefresh()：拿到前面定义的生命周期处理器（LifecycleProcessor）回调onRefresh()方法 （3）publishEvent(new ContextRefreshedEvent(this))：发布容器刷新完成事件； （4）liveBeansView.registerApplicationContext(this);

　　参考文档：https://blog.csdn.net/a745233700/article/details/113761271