一、Spring启动关键步骤
- Spring内部BeanPostProcessor
二、Spring启动过程
三、invokeBeanFactoryPostProcessors执行过程补充
- 执行BeanFactoryPostProcessor
- Lifecycle的使用

一、Spring启动关键步骤

1.构造BeanFactory（默认：DefaultListableBeanFactory）。
2.解析配置类，生成BeanDefinition，并注册到步骤1中的BeanFactory。

  1. 解析@ComponentScan，此时就会完成扫描
  2. 解析@Import
  3. 解析@Bean

3.初始化MessageSource对象，ApplicationContext支持国际化。
4.初始化ApplicationEventMulticaster对象，ApplicationContext还支持事件机制。
5.把用户定义的ApplicationListener对象添加到ApplicationContext中，Spring启动完成后发布事件。
6.创建非懒加载的单例Bean对象，并存在BeanFactory的单例池中。
7.调用Lifecycle Bean的start()方法。
8.发布ContextRefreshedEvent事件。

Spring内部BeanPostProcessor

  1. 注册默认的BeanPostProcessor对象，到BeanFactory中
     1. AutowiredAnnotationBeanPostProcessor：处理@Autowired、@Value
     2. CommonAnnotationBeanPostProcessor：处理@Resource、@PostConstruct、@PreDestroy
     3. ApplicationContextAwareProcessor：处理ApplicationContextAware等回调
  2. 查找外部用户自定义的BeanPostProcessor对象（类型为BeanPostProcessor的Bean对象），并添加到BeanFactory中

二、Spring启动过程

Annotation方式IOC启动流程

在调用AnnotationConfigApplicationContext的构造方法之前，会调用父类GenericApplicationContext的无参构造方法，会构造一个BeanFactory，为DefaultListableBeanFactory。
构造AnnotatedBeanDefinitionReader（主要作用添加一些基础的PostProcessor，同时可以通过reader进行BeanDefinition的注册），同时对BeanFactory进行设置和添加PostProcessor（后置处理器）
1. 设置dependencyComparator：AnnotationAwareOrderComparator，它是一个Comparator，是用来进行排序的，会获取某个对象上的Order注解或者通过实现Ordered接口所定义的值进行排序，在日常开发中可以利用这个类来进行排序。
2. 设置autowireCandidateResolver：ContextAnnotationAutowireCandidateResolver，用来解析某个Bean能不能进行自动注入，比如某个Bean的autowireCandidate属性是否等于true
3. 向BeanFactory中添加ConfigurationClassPostProcessor对应的BeanDefinition，它是一个BeanDefinitionRegistryPostProcessor，并且实现了PriorityOrdered接口
4. 向BeanFactory中添加AutowiredAnnotationBeanPostProcessor对应的BeanDefinition，它是一个InstantiationAwareBeanPostProcessorAdapter，MergedBeanDefinitionPostProcessor
5. 向BeanFactory中添加CommonAnnotationBeanPostProcessor对应的BeanDefinition，它是一个InstantiationAwareBeanPostProcessor，InitDestroyAnnotationBeanPostProcessor
6. 向BeanFactory中添加EventListenerMethodProcessor对应的BeanDefinition，它是一个BeanFactoryPostProcessor，SmartInitializingSingleton
7. 向BeanFactory中添加DefaultEventListenerFactory对应的BeanDefinition，它是一个EventListenerFactory
构造ClassPathBeanDefinitionScanner（主要作用可以用来扫描得到并注册BeanDefinition），同时进行设置：
1. 设置this.includeFilters = AnnotationTypeFilter(@Component注解)
2. 设置environment
3. 设置resourceLoader
利用reader注册配置类（例如：AppConfig）为BeanDefinition，类型为AnnotatedGenericBeanDefinition
接下来就是调用refresh方法
prepareRefresh()：
1. 记录启动时间
2. 可以允许子容器（即AbstractApplicationContext实现类）设置一些内容到Environment中
3. 验证Environment中是否已经包括必须要的属性
obtainFreshBeanFactory()：进行BeanFactory的refresh，在这里会去调用子类的refreshBeanFactory方法，具体子类是怎么刷新的得看子类，然后再调用子类的getBeanFactory方法，重新得到一个BeanFactory
prepareBeanFactory(beanFactory)：
1. 设置beanFactory的类加载器
2. 设置表达式解析器：StandardBeanExpressionResolver，用来解析Spring中的表达式
3. 添加默认类型转化器，PropertyEditorRegistrar：ResourceEditorRegistrar，PropertyEditor类型转化器注册器，用来注册一些默认的PropertyEditor
4. 添加一个Bean的后置处理器：ApplicationContextAwareProcessor，是一个BeanPostProcessor，用来执行EnvironmentAware、ApplicationEventPublisherAware等回调方法
5. 添加ignoredDependencyInterface：向此属性中添加一些接口，如果某个类实现了这个接口，并且这个类中的某些set方法在接口中也存在，那么set方法在自动注入的时候是不会执行的，比如EnvironmentAware这个接口，如果某个类实现了这个接口，那么就必须实现它的setEnvironment方法，而这是一个set方法，和Spring中的autowire是冲突的，那么Spring在自动注入时是不会调用setEnvironment方法的，而是等到回调Aware接口时再来调用（注意，这个功能仅限于xml的autowire，@Autowired注解是忽略这个属性的）
  1. EnvironmentAware
  2. EmbeddedValueResolverAware
  3. ResourceLoaderAware
  4. ApplicationEventPublisherAware
  5. MessageSourceAware
  6. ApplicationContextAware
  7. 另外其实在构造BeanFactory的时候就已经提前添加了另外三个：
  8. BeanNameAware
  9. BeanClassLoaderAware
  10. BeanFactoryAware
6. 添加resolvableDependencies：在byType进行依赖注入时，会先从这个属性中根据类型找bean
  1. BeanFactory.class：当前BeanFactory对象
  2. ResourceLoader.class：当前ApplicationContext对象
  3. ApplicationEventPublisher.class：当前ApplicationContext对象
  4. ApplicationContext.class：当前ApplicationContext对象
7. 添加一个Bean的后置处理器：ApplicationListenerDetector，是一个BeanPostProcessor，用来判断某个Bean是不是ApplicationListener，如果是，则把这个Bean添加到ApplicationContext中去，注意一个ApplicationListener只能是单例的
8. 添加一个Bean的后置处理器：LoadTimeWeaverAwareProcessor，是一个BeanPostProcessor，用来判断某个Bean是不是实现了LoadTimeWeaverAware接口，如果实现了则把ApplicationContext中的loadTimeWeaver回调setLoadTimeWeaver方法设置给该Bean。
9. 添加一些单例bean到单例池：
  1. “environment”：Environment对象
  2. “systemProperties”：System.getProperties()返回的Map对象
  3. “systemEnvironment”：System.getenv()返回的Map对象
postProcessBeanFactory(beanFactory) ：提供给AbstractApplicationContext的子类进行扩展，具体的子类，可以继续向BeanFactory中再添加一些东西
invokeBeanFactoryPostProcessors(beanFactory)：实例化（所有）并执行（所有）BeanFactoryPostProcessor
1. 在BeanFactory中（至少）会存在一个BeanFactoryPostProcessor：ConfigurationClassPostProcessor，它也是一个BeanDefinitionRegistryPostProcessor
2. 第一阶段
3. 从BeanFactory中找到类型为BeanDefinitionRegistryPostProcessor的beanName，即ConfigurationClassPostProcessor，然后调用BeanFactory的getBean方法得到实例对象
4. 执行ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry()方法:
  1. 解析AppConfig类
  2. 扫描得到BeanDefinition并注册
  3. 解析@Import，@Bean等注解得到BeanDefinition并注册
  4. 详细的看另外的笔记，专门分析了ConfigurationClassPostProcessor是如何工作的
  5. 在这里，我们只需要知道在这一步会去得到BeanDefinition，而这些BeanDefinition中可能存在BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor，所以执行完ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry()方法后，还需要继续执行其他BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法
5. 执行其他BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法
6. 执行所有BeanDefinitionRegistryPostProcessor的postProcessBeanFactory()方法
7. 第二阶段（ConfigurationClassPostProcessor完成扫描后，后续可以获得开发者自定义的BeanDefinitionRegistryPostProcessor）
8. 从BeanFactory中找到类型为BeanFactoryPostProcessor的beanName，而这些BeanFactoryPostProcessor包括了上面的BeanDefinitionRegistryPostProcessor
9. 执行还没有执行过的BeanFactoryPostProcessor的postProcessBeanFactory()方法
到此，所有的BeanFactoryPostProcessor的逻辑都执行完了，主要做的事情就是得到BeanDefinition并注册到BeanFactory中
registerBeanPostProcessors(beanFactory)：因为上面的步骤完成了扫描，这个过程中程序员可能自己定义了一些BeanPostProcessor，在这一步就会把BeanFactory中所有的BeanPostProcessor找出来并实例化（实例化前后、初始化前后会使用），并添加到BeanFactory中去（属性beanPostProcessors），最后再重新添加一个ApplicationListenerDetector对象（之前其实就添加了过，这里把ApplicationListenerDetector【用户识别事件监听的实现类】移动到最后）
initMessageSource()：如果BeanFactory中存在一个叫做”messageSource“的BeanDefinition，则会把这个Bean对象创建出来，并赋值给ApplicationContext的messageSource属性，让ApplicationContext拥有国际化的功能
initApplicationEventMulticaster()：如果BeanFactory中存在一个叫做”applicationEventMulticaster“的BeanDefinition，那么就会把这个Bean对象创建出来并赋值给ApplicationContext的applicationEventMulticaster属性，让ApplicationContext拥有事件发布的功能
onRefresh()：提供给AbstractApplicationContext的子类进行扩展，没用
registerListeners()：从BeanFactory中获取ApplicationListener类型的beanName，然后添加到ApplicationContext中的事件广播器applicationEventMulticaster中去，到这一步因为FactoryBean还没有调用getObject()方法生成Bean对象，所以这里要在根据类型找一下ApplicationListener，记录一下对应的beanName
finishBeanFactoryInitialization(beanFactory)：完成BeanFactory的初始化，主要就是实例化非懒加载的单例Bean。
finishRefresh()：BeanFactory的初始化完后，就到了Spring启动的最后一步了
设置ApplicationContext的lifecycleProcessor，默认情况下设置的是DefaultLifecycleProcessor
调用lifecycleProcessor的onRefresh()方法，如果是DefaultLifecycleProcessor，会获取所有类型为Lifecycle的Bean对象，然后调用它的start()方法，这就是ApplicationContext的生命周期扩展机制
发布ContextRefreshedEvent事件。

处理监听事件的BeanPostProcessor
ApplicationListenerDetector
在初始化后步骤，识别继承ApplicationListener接口的监听器实现。
EventListenerMethodProcessor
用户识别使用@EventListener注解的监听器实现。

继承了SmartInitializingSingleton（在完成所有非懒加载的bean创建后，调用afterSingletonsInstantiated遍历所有实例化的对象，找到被@EventListener注解标记的方法，并包装成为监听器实例）
SimpleApplicationEventMulticaster
事件发布器

三、invokeBeanFactoryPostProcessors执行过程补充

执行BeanFactoryPostProcessor

执行（开发者自己）通过ApplicationContext添加进来的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法
执行BeanFactory中实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法
执行BeanFactory中实现了Ordered接口的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法
执行BeanFactory中其他的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法
执行上面所有的BeanDefinitionRegistryPostProcessor的postProcessBeanFactory()方法
执行（开发者自己）通过ApplicationContext添加进来的BeanFactoryPostProcessor的postProcessBeanFactory()方法
执行BeanFactory中实现了PriorityOrdered接口的BeanFactoryPostProcessor的postProcessBeanFactory()方法
执行BeanFactory中实现了Ordered接口的BeanFactoryPostProcessor的postProcessBeanFactory()方法

执行BeanFactory中其他的BeanFactoryPostProcessor的postProcessBeanFactory()方法

Lifecycle的使用

org.springframework.context.support.AbstractApplicationContext#finishRefresh方法调用Lifecycle接口
org.springframework.context.support.DefaultLifecycleProcessor#onRefresh

@Component
public class SelfLifecycle implements SmartLifecycle {
 private boolean isRunning = false;
 @Override
 public void start() {
     System.out.println("启动");
     isRunning = true;
 }
 @Override
 public void stop() {
     // 要触发stop()，要调用context.close()，或者注册关闭钩子（context.registerShutdownHook();）
     System.out.println("停止");
     isRunning = false;
 }
 @Override
 public boolean isRunning() {
     return isRunning;
 }
}

开源框架学习笔记