Spring boot 2.x 源码分析- SpringApplication 启动分析

使用spring boot，无xml配置。将Java 开发从繁重的配置解脱出来。

一. SpringApplication 创建:

org.springframework.boot.SpringApplication(Class<?>... primarySources)

org.springframework.boot.SpringApplication#SpringApplication(ResourceLoader, Class<?>...)

1. 设置资源引导(ResourceLoader)。

2. 设置主要资源信息(primarySources)。

3. 推断Web应用类型(webApplicationType)。默认有三种：java标准的 SERVLET 类型，反应式 REACTIVE 类型，以及未知的 NONE 类型。

4. 设置初始化程序(ApplicationContextInitializer)对象实例列表（List>）。即读取 jar 文件中 META-INF/spring.factories 配置的所有 org.springframework.context.ApplicationContextInitializer 实现。

常用的实现类：

org.springframework.boot.devtools.restart.RestartScopeInitializer 
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener
org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer
org.springframework.boot.context.ContextIdApplicationContextInitializer
org.springframework.boot.context.config.DelegatingApplicationContextInitializer
org.springframework.boot.rsocket.context.RSocketPortInfoApplicationContextInitializer
org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer

5. 设置监听器(ApplicationListener)对象实例列表 (List>)。即 jar 文件中 META-INF/spring.factories 配置的所有 org.springframework.context.ApplicationListener 实现。

常用的实现类：

org.springframework.boot.devtools.restart.RestartApplicationListener
org.springframework.boot.devtools.logger.DevToolsLogFactory.Listener
org.springframework.boot.autoconfigure.BackgroundPreinitializer
org.springframework.boot.ClearCachesApplicationListener
org.springframework.boot.builder.ParentContextCloserApplicationListener
org.springframework.boot.cloud.CloudFoundryVcapEnvironmentPostProcessor
org.springframework.boot.context.FileEncodingApplicationListener
org.springframework.boot.context.config.AnsiOutputApplicationListener
org.springframework.boot.context.config.ConfigFileApplicationListener
org.springframework.boot.context.config.DelegatingApplicationListener
org.springframework.boot.context.logging.ClasspathLoggingApplicationListener
org.springframework.boot.context.logging.LoggingApplicationListener
org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener

　 6. 推断运行程序的主类类型(mainApplicationClass)。

    /**
     * Create a new {@link SpringApplication} instance. The application context will load
     * beans from the specified primary sources (see {@link SpringApplication class-level}
     * documentation for details. The instance can be customized before calling
     * {@link #run(String...)}.
     * @param resourceLoader the resource loader to use
     * @param primarySources the primary bean sources
     * @see #run(Class, String[])
     * @see #setSources(Set)
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");
        this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        this.mainApplicationClass = deduceMainApplicationClass();
    }

二. Springboot 的SPI机制加载类逻辑

org.springframework.boot.SpringApplication#getSpringFactoriesInstances(Class type)
org.springframework.boot.SpringApplication#getSpringFactoriesInstances(Class type, Class<?>[] parameterTypes, Object... args)
org.springframework.core.io.support.SpringFactoriesLoader#loadFactoryNames(Class<?> factoryType, ClassLoader classLoader)
org.springframework.boot.SpringApplication#createSpringFactoriesInstances(Class type, Class<?>[] parameterTypes,
ClassLoader classLoader, Object[] args, Set names)

1. 获得当前环境的类加载器。默认是从 Thread.currentThread().getContextClassLoader() 获取的。

JDK8中为：sun.misc.Launcher$AppClassLoader。

JDK9及以后版本：jdk.internal.loader.ClassLoaders$AppClassLoader

2. 从 META-INF/spring.factories 配置中寻找 type 实现类的配置列表。如果已加载，则从本地缓存中读取。

3. 根据传递的参数，实例化 type 的实例。

4. 排序 type 实现类列表，并返回。

    private  Collection getSpringFactoriesInstances(Class type, Class<?>[] parameterTypes, Object... args) {
        ClassLoader classLoader = getClassLoader();
        // Use names and ensure unique to protect against duplicates
        Set names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
        List instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
        AnnotationAwareOrderComparator.sort(instances);
        return instances;
    }

三. SpringApplication#run() 分析

org.springframework.boot.SpringApplication#run(java.lang.Class<?>, java.lang.String...)

org.springframework.boot.SpringApplication#run(java.lang.Class<?>[], java.lang.String[])

org.springframework.boot.SpringApplication#run(java.lang.String...)

(一) run 方法概述：

1. 创建 StopWatch 实例，记录当前开始时间，以及任务名称等信息。

2. 设置系统属性 java.awt.headless 值。默认为true。Headless是指服务器的无显示设备状态。

3. 获取程序运行监听器辅助类(SpringApplicationRunListeners)实例，并触发 starting() 事件。SpringApplicationRunListeners#starting()

SpringApplicationRunListener 监听 SpringApplication 类执行run方法触发的七个事件。这七个事件对应运行时的七个周期节点，开发人员根据需要，可以在相关节点进行扩展。

该接口默认只有一个实现 EventPublishingRunListener 类。创建时注入了 SpringApplication 类，事件广播类 SimpleApplicationEventMulticaster 实例。最终将SpringApplication 事件监听器和Spring的事件监听器关联上。

4. 创建请求参数包装类实例。

5. 预处理环境变量信息。SpringApplication#prepareEnvironment()

6. 设置是否忽略 beanInfo 信息参数。 spring.beaninfo.ignore

7. 打印 Banner 信息。SpringApplication#printBanner() 。创建对象 SpringApplicationBannerPrinter 实例，打印Banner。

8. 根据Web应用类型(webApplicationType) 创建程序上下文实例(ConfigurableApplicationContext)。

SERVLET AnnotationConfigServletWebServerApplicationContext

REACTIVE AnnotationConfigReactiveWebServerApplicationContext

默认类型 AnnotationConfigApplicationContext

当前环境创建 AnnotationConfigServletWebServerApplicationContext 实例，进行spring 逻辑的处理。

9. 获得异常报告处理接口(SpringBootExceptionReporter)的所有实现，并创建实例。默认实现类： org.springframework.boot.diagnostics.FailureAnalyzers

10. 预处理程序上下文。SpringApplication#prepareContext()

11. 刷新程序上下文。注册程序停机Hook，并调用Spring 的 AbstractApplicationContext#refresh() 方法，进行Spring 的程序运行环境的创建。

12. 刷新程序上下文后置处理。留给用户扩展的方法。

13. 调用 StopWatch 实例stop() 方法，标记任务执行完成，记录任务结束时间。

14. 执行 started() 方法。SpringApplicationRunListeners#started()

15. 找到注入的所有 ApplicationRunner,CommandLineRunner 实现类，依次调用。默认没用实现类。

16. 执行 runing() 方法。SpringApplicationRunListeners#running(ConfigurableApplicationContext context)。

17. 如果出现异常，进行异常处理。

SpringApplication#handleRunFailure(ConfigurableApplicationContext context, Throwable exception, Collection exceptionReporters, SpringApplicationRunListeners listeners)

(二) 重要步骤详解

SpringApplicationRunListeners#starting() 事件详解：

org.springframework.boot.SpringApplicationRunListeners#starting()
org.springframework.boot.context.event.EventPublishingRunListener#starting()
this.initialMulticaster.multicastEvent(new ApplicationStartingEvent(this.application, this.args));

org.springframework.context.event.SimpleApplicationEventMulticaster#multicastEvent(org.springframework.context.ApplicationEvent)

常见支持 ApplicationStartingEvent 事件的监听器有如下几个：

org.springframework.boot.devtools.restart.RestartApplicationListener,
org.springframework.boot.context.logging.LoggingApplicationListener,
org.springframework.boot.autoconfigure.BackgroundPreinitializer,
org.springframework.boot.context.config.DelegatingApplicationListener,
org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener

RestartApplicationListener 监听器，程序调试时使用的，方便自动重启服务。经过相关逻辑处理后，设置使用 org.springframework.boot.devtools.restart.RestartLauncher 类实现服务的重新启动。

org.springframework.boot.devtools.restart.RestartApplicationListener#onApplicationEvent(ApplicationEvent event)
org.springframework.boot.devtools.restart.RestartApplicationListener#onApplicationStartingEvent(ApplicationStartingEvent event)
org.springframework.boot.devtools.restart.Restarter#initialize(java.lang.String[], boolean, org.springframework.boot.devtools.restart.RestartInitializer, boolean)
org.springframework.boot.devtools.restart.Restarter#initialize(boolean)
org.springframework.boot.devtools.restart.Restarter#immediateRestart

LoggingApplicationListener 监听器，进行日志的初始化处理。当前环境配置的是Logback日志实现。

org.springframework.boot.context.logging.LoggingApplicationListener#onApplicationEvent(ApplicationEvent event)
org.springframework.boot.context.logging.LoggingApplicationListener#onApplicationStartingEvent(ApplicationStartingEvent event)
org.springframework.boot.logging.logback.LogbackLoggingSystem#beforeInitialize()

BackgroundPreinitializer 监听器，后台线程早期初始化处理器。当前事件不触发逻辑处理。

DelegatingApplicationListener 监听器，和 EventPublishingRunListener 类功能类似。当前事件不触发逻辑处理。

LiquibaseServiceLocatorApplicationListener 监听器, 当前事件不触发。LiquiBase是一个用于数据库重构和迁移的开源工具，通过日志文件的形式记录数据库的变更，然后执行日志文件中的修改，将数据库更新或回滚到一致的状态。

环境变量预处理 SpringApplication#prepareEnvironment(SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments)

1. 创建环境变量(ConfigurableEnvironment)的实现类。

SERVLET StandardServletEnvironment
REACTIVE StandardReactiveWebEnvironment
default StandardEnvironment

2. 用程序启动参数和默认环境变量配置处理。

3. 进行环境属性 configurationProperties 处理。ConfigurationPropertySources.attach(environment)。

4. 执行SpringApplicationRunListeners#environmentPrepared(ConfigurableEnvironment environment)方法，触发 ApplicationEnvironmentPreparedEvent 事件。

满足 ApplicationEnvironmentPreparedEvent 事件的监听器：

org.springframework.boot.devtools.restart.RestartApplicationListener, 未触发相关逻辑处理。
org.springframework.boot.context.config.ConfigFileApplicationListener, 配置处理逻辑

读取 EnvironmentPostProcessor 接口实现列表，依次处理属性配置：

org.springframework.boot.env.SystemEnvironmentPropertySourceEnvironmentPostProcessor,
org.springframework.boot.env.SpringApplicationJsonEnvironmentPostProcessor,
org.springframework.boot.cloud.CloudFoundryVcapEnvironmentPostProcessor,
org.springframework.boot.context.config.ConfigFileApplicationListener,
org.springframework.boot.devtools.env.DevToolsHomePropertiesPostProcessor,
org.springframework.boot.devtools.env.DevToolsPropertyDefaultsPostProcessor,
org.springframework.boot.reactor.DebugAgentEnvironmentPostProcessor

org.springframework.boot.context.config.AnsiOutputApplicationListener,
org.springframework.boot.context.logging.LoggingApplicationListener, 日志处理初始化
org.springframework.boot.autoconfigure.BackgroundPreinitializer, 后台线程早期初始化处理。
org.springframework.boot.context.logging.ClasspathLoggingApplicationListener, 打印ClassPath路径。
org.springframework.boot.context.config.DelegatingApplicationListener, 委派处理。此处无满足条件，无处理逻辑。
org.springframework.boot.context.FileEncodingApplicationListener 文件字符配置检查 spring.mandatory-file-encoding

5. 将环境变量信息绑定到应用程序上。 Binder.get(environment).bind("spring.main", Bindable.ofInstance(this));

6. 重新进行环境属性 configurationProperties 处理。ConfigurationPropertySources.attach(environment)。

根据Web应用类型(webApplicationType) 创建程序上下文实例(ConfigurableApplicationContext)

AnnotationConfigServletWebServerApplicationContext 实例化分析：

1. 创建BeanFactory 默认实现类 DefaultListableBeanFactory 实例。

2. 创建 AnnotatedBeanDefinitionReader 实例，添加 BeanDefinition 配置处理器。

org.springframework.context.annotation.AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry)
org.springframework.context.annotation.AnnotatedBeanDefinitionReader#AnnotatedBeanDefinitionReader(BeanDefinitionRegistry, Environment)
org.springframework.context.annotation.AnnotatedBeanDefinitionReader#AnnotatedBeanDefinitionReader(BeanDefinitionRegistry, Environment)
org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessors(BeanDefinitionRegistry)
org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessors(BeanDefinitionRegistry, Object)

① 如果 BeanFactory 中没用配置 org.springframework.context.annotation.internalConfigurationAnnotationProcessor 名称的bean，则使用默认的 ConfigurationClassPostProcessor。

② 如果 BeanFactory 中没用配置 org.springframework.context.annotation.internalAutowiredAnnotationProcessor 名称的bean，则使用默认的 AutowiredAnnotationBeanPostProcessor。

② 如果 BeanFactory 中没用配置 org.springframework.context.annotation.internalCommonAnnotationProcessor 名称的bean，则使用默认的 CommonAnnotationBeanPostProcessor。

② 如果 BeanFactory 中配置JPA实现，但没用配置 org.springframework.context.annotation.internalPersistenceAnnotationProcessor 名称的bean，则使用默认的 PersistenceAnnotationBeanPostProcessor。

② 如果 BeanFactory 中没用配置 org.springframework.context.event.internalEventListenerProcessor 名称的bean，则使用默认的 EventListenerMethodProcessor。

② 如果 BeanFactory 中没用配置 org.springframework.context.event.internalEventListenerFactory 名称的bean，则使用默认的 DefaultEventListenerFactory。

3. 创建 ClassPathBeanDefinitionScanner 实例，扫描 @Component, @Repository, @Service, @Controller 配置的工具类。

预处理程序上下文(ConfigurableApplicationContext)。SpringApplication#prepareContext()

1. 设置上下文环境(ConfigurableApplicationContext) 的环境变量信息。

2. 处理上下文环境(ConfigurableApplicationContext) 相关信息。默认主要设置 ApplicationConversionService 实例。

3. 遍历执行 ApplicationContextInitializer 接口实现，进行相关初始化处理。

常用的 ApplicationContextInitializer 接口实现类：

org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer

向上下文环境(ConfigurableApplicationContext) 添加(CachingMetadataReaderFactoryPostProcessor) 处理器。
org.springframework.boot.context.config.DelegatingApplicationContextInitializer,

读取 context.initializer.classes 配置，委派处理自定义的 ApplicationContextInitializer 实现。
org.springframework.boot.context.ContextIdApplicationContextInitializer,

向上下文环境(ConfigurableApplicationContext) 注册 ContextId 实例。
org.springframework.boot.devtools.restart.RestartScopeInitializer,

向上下文环境(ConfigurableApplicationContext) 注册 RestartScope 实例。
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener,

添加 ConditionEvaluationReportLoggingListener 监听器。
org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer,

向上下文环境(ConfigurableApplicationContext) 添加(ConfigurationWarningsPostProcessor) 处理器。
org.springframework.boot.rsocket.context.RSocketPortInfoApplicationContextInitializer,

添加 RSocketPortInfoApplicationContextInitializer.Listener 监听器。
org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer

添加 ServerPortInfoApplicationContextInitializer 监听器。

4. 执行 SpringApplicationRunListeners#contextPrepared() 方法，触发 ApplicationContextInitializedEvent 事件。

满足 ApplicationContextInitializedEvent 事件的监听器：

org.springframework.boot.devtools.restart.RestartApplicationListener, 未满足执行条件，无处理逻辑。
org.springframework.boot.autoconfigure.BackgroundPreinitializer, 未满足执行条件，无处理逻辑。
org.springframework.boot.context.config.DelegatingApplicationListener 未满足执行条件，无处理逻辑。

5. 打印程序启动日志信息。

6. 设置 beanFactory 信息。注册 ApplicationArguments 和 Banner 的 bean实例。根据配置添加 LazyInitializationBeanFactoryPostProcessor 处理器。

7. 加载所有 bean 资源配置信息，并转换成 BeanDefinition 配置对象。

创建 BeanDefinitionLoader 实例，设置资源对象，并创建读取资源的默认实现类， AnnotatedBeanDefinitionReader， XmlBeanDefinitionReader， GroovyBeanDefinitionReader，ClassPathBeanDefinitionScanner。然后根据资源对象的类型，读取资源里面配置的 BeanDefinition 信息。spring boot 默认是使用 AnnotatedBeanDefinitionReader 实现读取资源。

8. 执行SpringApplicationRunListeners#contextLoaded() 方法，触发ApplicationPreparedEvent 事件。

满足 ApplicationPreparedEvent 事件的监听器：

org.springframework.boot.devtools.restart.RestartApplicationListener,

执行Restarter#prepare(org.springframework.context.ConfigurableApplicationContext) 方法。
org.springframework.boot.cloud.CloudFoundryVcapEnvironmentPostProcessor,

解析 VCAP（又名 Cloud Foundry）元数据。
org.springframework.boot.context.config.ConfigFileApplicationListener,

添加配置文件相关的 PropertySourceOrderingPostProcessor 处理器。
org.springframework.boot.context.logging.LoggingApplicationListener,

注册日志相关的 LogbackLoggingSystem 和 LoggerGroups 的 bean 实例。
org.springframework.boot.autoconfigure.BackgroundPreinitializer, 未满足执行条件，无处理逻辑。
org.springframework.boot.context.config.DelegatingApplicationListener, 未满足执行条件，无处理逻辑。
org.springframework.boot.devtools.logger.DevToolsLogFactory$Listener 日志处理。

执行 started() 方法。SpringApplicationRunListeners#started()

满足 ApplicationStartedEvent 事件监听器，

执行 AvailabilityChangeEvent.publish(context, LivenessState.CORRECT) 方法，触发 AvailabilityChangeEvent 事件：

org.springframework.boot.devtools.restart.RestartApplicationListener, 未满足执行条件，无处理逻辑。
org.springframework.boot.context.config.DelegatingApplicationListener, 未满足执行条件，无处理逻辑。
org.springframework.boot.availability.ApplicationAvailabilityBean 记录 AvailabilityChangeEvent 事件。

执行 runing() 方法。SpringApplicationRunListeners#running(ConfigurableApplicationContext context)

满足 ApplicationReadyEvent 事件监听器：

org.springframework.boot.devtools.restart.RestartApplicationListener, 调用 Restarter.getInstance().finish() 方法。
org.springframework.boot.autoconfigure.BackgroundPreinitializer, 检查后台线程早期初始化处理器是否完成，如果没完成则等待。
org.springframework.boot.context.config.DelegatingApplicationListener, 未满足执行条件，无处理逻辑。
org.springframework.boot.devtools.autoconfigure.ConditionEvaluationDeltaLoggingListener 重启时相关信息。

执行 AvailabilityChangeEvent.publish(context, ReadinessState.ACCEPTING_TRAFFIC) 方法，触发 AvailabilityChangeEvent 事件：

当出现异常，进行异常处理

SpringApplication#handleRunFailure(ConfigurableApplicationContext context,

Throwable exception,

Collection exceptionReporters,

SpringApplicationRunListeners listeners)

1. 获得退出异常的退出码(exitCode)。如果找到了，则触发 ExitCodeEvent 事件，并用 SpringBootExceptionHandler 记录退出码信息。

2. 执行 SpringApplicationRunListeners#failed()方法，触发 ApplicationFailedEvent 事件，进行相关事件处理。

3. SpringBootExceptionHandler 记录异常类信息。

四. Spring 的 PostProcessor 分析

Spring 调用 BeanFactoryPostProcessor 处理器，进行 bean 配置的处理。

PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List beanFactoryPostProcessors)

SharedMetadataReaderFactoryContextInitializer$CachingMetadataReaderFactoryPostProcessor,
ConfigurationWarningsApplicationContextInitializer$ConfigurationWarningsPostProcessor@7baba5c4,
ConfigFileApplicationListener$PropertySourceOrderingPostProcessor

（一）：依次执行BeanFactory的 BeanDefinitionRegistryPostProcessor 处理器 BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)方法。

1. SharedMetadataReaderFactoryContextInitializer$CachingMetadataReaderFactoryPostProcessor 注册在 ConfigurationClassPostProcessor 和 Spring Boot 之间共享元数据的bean对象SharedMetadataReaderFactoryBean。

2.ConfigurationWarningsApplicationContextInitializer$ConfigurationWarningsPostProcessor 检查@ComponentScan 配置是否有问题。即是否配置了 org.springframework 和 org 包扫描路径。

3. ConfigurationClassPostProcessor 处理注册配置的 BeanDefinition 信息。spring中所有注解配置，都是通过这个类来实现的。

org.springframework.context.annotation.ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)
org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions(BeanDefinitionRegistry registry)

① 获取当前 BeanDefinitionRegistry 上加载的所有 BeanDefinition 配置。

② 循环处理加载的 BeanDefinition 配置。如果满足指定条件，则将其添加到待处理配置bean列表中（configCandidates）。

如果 BeanDefinition 实例以及被 ConfigurationClassPostProcessor 类处理，则不进行后续处理。

如果没有经过处理，则判断 BeanDefinition 配置的类是否使用 @Configuration 修饰。或者是否使用 @Component, @ComponentScan, @Import, @ImportResource 修饰，或者方法是否使用 @Bean 修饰。

③ 根据当前环境，创建 ConfigurationClassParser 实例。

ConfigurationClassParser(MetadataReaderFactory metadataReaderFactory,

ProblemReporter problemReporter, Environment environment,

ResourceLoader resourceLoader,

BeanNameGenerator componentScanBeanNameGenerator,

BeanDefinitionRegistry registry)

④ 使用 ConfigurationClassParser 工具类实例，循环处理 @Configuration 修饰的类BeanDefinition 配置。

a. 依次解析 @Component, @PropertySource,@ComponentScan,@ComponentScans,@Import,@ImportResource,@Bean 注解的配置，

或实现 ImportBeanDefinitionRegistrar 接口的配置。

b. 校验解析的配置。

c. 创建读取 Bean配置的 ConfigurationClassBeanDefinitionReader 实例reader。

d. 使用reader读取 ConfigurationClass 配置的 BeanDefinition 信息。

e. 重新获取 BeanDefinitionRegistry 上加载的所有 BeanDefinition 配置，去掉已经解析过的 @Configuration 配置。

f. 检查是否还有待处理配置 bean 。如果有则循环 a 至 e 步骤。

（二）：依次执行BeanFactory的 BeanFactoryPostProcessor 处理器 BeanFactoryPostProcessor#postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) 方法

SharedMetadataReaderFactoryContextInitializer$CachingMetadataReaderFactoryPostProcessor, 无处理逻辑
ConfigurationWarningsApplicationContextInitializer$ConfigurationWarningsPostProcessor, 无处理逻辑
ConfigurationClassPostProcessor 处理配置类。如果配置类中属性 ConfigurationClassPostProcessor.configurationClass = "full"(即@Configuration(proxyBeanMethods=true)),则将beanClass设置为cglib代理的类。ConfigurationClassEnhancer#enhance(Class<?> configClass, @Nullable ClassLoader classLoader)

ConfigFileApplicationListener$PropertySourceOrderingPostProcessor 无满足条件，无处理逻辑

PropertySourcesPlaceholderConfigurer 解析 ${...} 配置

PropertySourcesPlaceholderConfigurer#postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
PropertySourcesPlaceholderConfigurer#processProperties(ConfigurableListableBeanFactory, ConfigurablePropertyResolver)
PlaceholderConfigurerSupport#doProcessProperties(ConfigurableListableBeanFactory, StringValueResolver)

1. 创建 BeanDefinitionVisitor 实例visitor。

2. 依次取出所有 BeanDefinition 配置，使用 visitor 实例解析 BeanDefinition 配置的属性。即将 ${...} 配置替换成实际的值。

3. 依次取出所有别名配置，使用 valueResolver 实例解析 alias, registeredName 值。即将 ${...} 配置替换成实际的值。

4. 将 valueResolver 解析器添加到 beanFactory 上。

EventListenerMethodProcessor, 将EventListenerFactory类型bean 取出，添加到 eventListenerFactories 属性上。处理将 @EventListener 修饰的类包装成ApplicationListener 。
ErrorMvcAutoConfiguration$PreserveErrorControllerTargetClassPostProcessor 确保在使用 AOP 时保留 ErrorController MVC bean 的目标类。

（三）：在创建bean 对象实例时，再通过 BeanPostProcessor 进行bean对象实例的增强处理。在创建 bean 实例时，有六个位置调用BeanPostProcessor 实现进行bean增强处理。

1. 开始创建 bean 实例之前，尝试快捷方式创建 bean 实例。如果创建成功，则创建逻辑不再执行。

AbstractAutowireCapableBeanFactory#createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd)
AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName)
InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation(Class<?> beanClass, String beanName)
AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
BeanPostProcessor#postProcessAfterInitialization(Object bean, String beanName)

ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor 无处理逻辑
CommonAnnotationBeanPostProcessor 无处理逻辑
AutowiredAnnotationBeanPostProcessor 无处理逻辑

2. 创建 bean 实例后，检查 BeanDefinition 配置是否需要合并。

AbstractAutowireCapableBeanFactory#createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
AbstractAutowireCapableBeanFactory#doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
AbstractAutowireCapableBeanFactory#applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName)
MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName)

3. 在填充 bean 属性之前，进行 bean 实例后处理。

AbstractAutowireCapableBeanFactory#createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
AbstractAutowireCapableBeanFactory#doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
AbstractAutowireCapableBeanFactory#populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw)
InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation(Object bean, String beanName)

4. 使用 InstantiationAwareBeanPostProcessor 处理器，进行bean 属性的处理

AbstractAutowireCapableBeanFactory#createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
AbstractAutowireCapableBeanFactory#doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
AbstractAutowireCapableBeanFactory#populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw)
InstantiationAwareBeanPostProcessor#postProcessProperties(PropertyValues pvs, Object bean, String beanName)

5. 在初始化 bean 实例时，进行增强处理

AbstractAutowireCapableBeanFactory#createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
AbstractAutowireCapableBeanFactory#doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
AbstractAutowireCapableBeanFactory#initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
BeanPostProcessor#postProcessBeforeInitialization(Object bean, String beanName)

6. 在完成初始化 bean 实例后，进行增强处理

AbstractAutowireCapableBeanFactory#createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
AbstractAutowireCapableBeanFactory#doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
AbstractAutowireCapableBeanFactory#initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
BeanPostProcessor#postProcessAfterInitialization(Object bean, String beanName)

org.springframework.context.support.ApplicationContextAwareProcessor,
org.springframework.boot.web.servlet.context.WebApplicationContextServletContextAwareProcessor,
org.springframework.context.annotation.ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor,
org.springframework.context.support.PostProcessorRegistrationDelegate$BeanPostProcessorChecker,

org.springframework.boot.context.properties.ConfigurationPropertiesBindingPostProcessor
(proxyTargetClass=true; optimize=false; opaque=false; exposeProxy=false; frozen=false)

org.springframework.boot.web.server.WebServerFactoryCustomizerBeanPostProcessor,
org.springframework.boot.web.server.ErrorPageRegistrarBeanPostProcessor,
org.springframework.context.annotation.CommonAnnotationBeanPostProcessor,
org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor,
org.springframework.context.support.ApplicationListenerDetector

Java系列