Spring容器的的refresh()【创建刷新】

refresh()源码

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

        // 刷新前的预处理
        prepareRefresh();

        // 获取BeanFactory
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // BeanFactory的预处理工作，对BeanFactory进行一些赋值设置
        prepareBeanFactory(beanFactory);

        try {
            // BeanFactory准备工作完成后进行的后置处理工作
            postProcessBeanFactory(beanFactory);
            
            StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
            // 注册BeanFactory的后置处理器，执行BeanFactoryPostProcessor方法
            invokeBeanFactoryPostProcessors(beanFactory);

            // 注册Bean的后置处理器，用于拦截Bean的整个创建过程
            registerBeanPostProcessors(beanFactory);
            beanPostProcess.end();

            // 初始化MessageSource组件（做国际化功能，消息绑定，消息解析）
            initMessageSource();

            // 初始化事件派发器
            initApplicationEventMulticaster();

            // 留给子容器（子类）重写，在刷新上下文时自定义逻辑
            onRefresh();

            // 将项目中所有的ApplicationListener注册到容器中
            registerListeners();

            // 初始化所有剩下的单实例bean
            finishBeanFactoryInitialization(beanFactory);

            // 完成BeanFactory的初始化创建工作，IOC容器就创建完成
            finishRefresh();
    }
}

BeanFactory的创建及预准备工作

1. prepareRefresh(); 刷新前的预处理

initPropertySources(); 初始化一些属性设置（空），子类可实现后自定义个性化的属性设置方法
getEnvironment().validateRequiredProperties(); 校验属性的合法等
this.earlyApplicationEvents = new LinkedHashSet<>(); 保存容器中的一些早期的事件

2. obtainFreshBeanFactory(); 获取BeanFactory

refreshBeanFactory(); 刷新【创建】BeanFactory对象
1. 创建一个bean工厂

    public GenericApplicationContext() {
        this.beanFactory = new DefaultListableBeanFactory();
    }

2. 设置id

getBeanFactory(); 返回刚才GenericApplicationContext创建的BeanFactory对象
将创建的BeanFactory【DefaultListableBeanFactory】返回

3. prepareBeanFactory(beanFactory); BeanFactory的预处理工作，对BeanFactory进行一些赋值设置

设置BeanFactory的类加载器、支持表达式解析器...
添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、ResourceLoaderAware、、ApplicationEventPublisherAware、MessageSourceAware、ApplicationContextAware、ApplicationStartupAware
注册可以解析的自动装配，使我们能够在任何组件中自动注入(@Autowired)。BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
添加部分BeanPostProcessor【ApplicationListenerDetector】
添加编译时的AspectJ
给BeanFactory注册一些能用的组件
1. environment ConfigurableEnvironment
2. systemProperties Map<String, Object>
3. systemEnvironment Map<String, Object>
4. applicationStartup ApplicationStartup

4. postProcessBeanFactory(beanFactory); BeanFactory准备工作完成后进行的后置处理工作

子类可以重写此方法在BeanFactory创建并预准备完成以后做进一步的设置。

BeanFactory后面的流程

5. invokeBeanFactoryPostProcessors(beanFactory); 注册BeanFactory的后置处理器，执行BeanFactoryPostProcessor方法

源代码位于：PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors()

BeanFactoryPostProcessor:

BeanFactory的后置处理器
在BeanFactory标准初始化之后执行
拥有两个接口
1. BeanFactoryPostProcessor
2. BeanDefinitionRegistryPostProcessor

执行BeanFactoryPostProcessor方法

子接口[BeanDefinitionRegistryPostProcessor]具有最高优先级，其次再执行BeanFactoryPostProcessor的方法

先执行BeanDefinitionRegistryPostProcessor的方法

获取所有的BeanDefinitionRegistryPostProcessor
先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor
1. postProcessor.postProcessBeanDefinitionRegistry(registry);
再执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor
1. postProcessor.postProcessBeanDefinitionRegistry(registry);
最后执行没有实现任何优先级或顺序接口的BeanDefinitionRegistryPostProcessor
1. postProcessor.postProcessBeanDefinitionRegistry(registry);

再执行BeanFactoryPostProcessor的方法

获取所有的BeanFactoryPostProcessor
先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor
1. postProcessor.postProcessBeanFactory(beanFactory);
再执行实现了Ordered顺序接口的BeanFactoryPostProcessor
1. postProcessor.postProcessBeanFactory(beanFactory);
最后执行没有实现任何优先级或顺序接口的BeanFactoryPostProcessor
1. postProcessor.postProcessBeanFactory(beanFactory);

6. registerBeanPostProcessors(beanFactory); 注册Bean的后置处理器，用于拦截Bean的整个创建过程

源代码位于：PostProcessorRegistrationDelegate#registerBeanPostProcessors()

不同接口类型的BeanPostProcessor，在Bean创建前后的执行时机是不一样的

BeanPostProcessor
DestructionAwareBeanPostProcessor
InstantiationAwareBeanPostProcessor
SmartInstantiationAwareBeanPostProcessor
MergedBeanDefinitionPostProcessor【internalPostProcessors】

执行过程

获取所有的BeanPostProcessor；后置处理器都默认可以通过PriorityOrdered、Ordered接口来实现优先级排序
先注册PriorityOrdered优先级排序接口的BeanPostProcessor
把每一个BeanPostProcessor都添加到BeanFactory中

private static void registerBeanPostProcessors(
        ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {

    if (beanFactory instanceof AbstractBeanFactory) {
        // Bulk addition is more efficient against our CopyOnWriteArrayList there
        ((AbstractBeanFactory) beanFactory).addBeanPostProcessors(postProcessors);
    }
    else {
        for (BeanPostProcessor postProcessor : postProcessors) {
            beanFactory.addBeanPostProcessor(postProcessor);
        }
    }
}

再注册Ordered接口的
再注册没有实现任何优先级接口的
最后注册MergedBeanDefinitionPostProcessor【internalPostProcessors】
最终注册一个ApplicationListenerDetector；再Bean创建完后检查是否是ApplicationListener，如果是则将其注册到上下文中
applicationContext.addApplicationListener((ApplicationListener<?>) bean);

7. initMessageSource();初始化MessageSource组件（做国际化功能，消息绑定，消息解析）

MessageSource按照区域，取出国际化配置文件中的某个key的值

getBeanFactory();获取BeanFactory
判断容器中是否有id=messageSource的组件，类型=MessageSource
1. 如果有，赋值给变量messageSource
2. 如果没有，自己创建一个DelegatingMessageSource
把创建好的MessageSource注册到容器中，后续可依赖注入
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);

8. initApplicationEventMulticaster();初始化事件派发器

获取BeanFactory
从BeanFactory中获取ApplicationEventMulticaster的ApplicationEventMulticaster
将创建的ApplicationEventMulticaster添加到BeanFactory中，后续可依赖注入

9. onRefresh(); 留给子容器（子类）

子类重写这个方法，在容器刷新的时候可以自定义逻辑；

10. registerListeners();将项目中所有的ApplicationListener注册到容器中

从applicationListeners属性中拿到之前步骤中所有的ApplicationListener，注册到事件派发器中
从容器中拿到所有的ApplicationListener，注册到事件派发器中
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
派发（调用）之前步骤产生的事件
getApplicationEventMulticaster().multicastEvent(earlyEvent);

11. finishBeanFactoryInitialization(beanFactory); 初始化所有剩下的单实例bean

11.1 beanFactory.preInstantiateSingletons(); - 初始化剩下的单实例bean

11.1.1 获取容器中的所有bean，依次进行初始化和创建对象

List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
for (String beanName : beanNames) {

11.1.2 获取bean的定义信息RootBeanDefinition

RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);

11.1.3 Bean不是抽象的，是单实例的，不是懒加载的

!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()

11.1.3.1 判断是否是FactoryBean，是否是实现FactoryBean接口的bean

如果是，则利用FactoryBean接口的FactoryBean#getObject获取对象
如果不是，利用getBean(beanName)创建对象
0. getBean(beanName) -> 与ApplicationContext#getBean一致
1. doGetBean(name, null, null, false);
2. 先获取缓存中保存的单实例bean，如果能获取到，说明之前被创建过。（所有创建过的单实例Bean都会被缓存起来）
3. getSingleton(beanName, true);
  private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
4. 缓存中获取不到，开始创建对象流程
5. 标记当前bean已被创建 markBeanAsCreated(beanName);
6. 获取Bean的定义信息
  RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
7. 【获取当前Bean依赖的其他bean，如果有按照getBean()把依赖的Bean先创建出来】
```
String[] dependsOn = mbd.getDependsOn();
    if (dependsOn != null) {
        for (String dep : dependsOn) {
            ...
            registerDependentBean(dep, beanName);
            getBean(dep);
            ...
        }
    }
```
1. 启动单实例Bean的创建流程 mbd.isSingleton()
  1. getSingleton(String beanName, ObjectFactory<?> singletonFactory)
  2. createBean(beanName, mbd, args);
  3. resolveBeforeInstantiation(beanName, mbdToUse); 让BeanPostProcessor先提前拦截返回Bean代理对象
    【InstantiationAwareBeanPostProcessor】: 提前执行
    先触发：Object result = bp.postProcessBeforeInstantiation(beanClass, beanName);
    如果有返回值，再触发：processor.postProcessAfterInitialization(result, beanName);
  4. Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    1. 【创建Bean实例】：createBeanInstance(beanName, mbd, args);
      利用工厂方法或者对象的构造器创建出Bean实例
    2. applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
      调用【MergedBeanDefinitionPostProcessor】的processor.postProcessMergedBeanDefinition(mbd, beanType, beanName);
    3. 【bean属性赋值】populateBean(beanName, mbd, instanceWrapper);
      赋值之前：
      1. 拿到InstantiationAwareBeanPostProcessor后置处理器
        执行postProcessAfterInstantiation方法
      2. 拿到InstantiationAwareBeanPostProcessor后置处理器
        执行postProcessPropertyValues方法
        =赋值之前=
      3. 应用bean属性的值，利用setter为属性赋值
        applyPropertyValues(beanName, mbd, bw, pvs);
    4. 【Bean初始化】initializeBean(beanName, exposedObject, mbd);
      1. 【执行Aware接口方法】invokeAwareMethods(beanName, wrappedBean, mbd);执行XXX_Aware接口为Aware属性赋值
        BeanNameAware/BeanClassLoaderAware/BeanFactoryAware
      2. 【执行后置处理器初始化之前】applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        processor.postProcessBeforeInitialization(result, beanName);
      3. 【执行初始化方法】invokeInitMethods(beanName, wrappedBean, mbd);
        
        是否是InitializingBean接口的实现，执行接口规定的初始化方法
        
        是否有自定义初始化方法 String initMethodName = mbd.getInitMethodName();
      4. 【执行后置处理器初始化之后的方法】applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        processor.postProcessAfterInitialization(result, beanName);
```
5. 【注册bean的销毁方法】registerDisposableBeanIfNecessary(beanName, bean, mbd); 实现`DisposableBean`接口
```
  5. 将创建的bean添加到缓存DefaultSingletonBeanRegistry#addSingleton中

12. finishRefresh();完成BeanFactory的初始化创建工作，IOC容器就创建完成

clearResourceCaches(); 清除上下文级别的资源缓存
initLifecycleProcessor();初始化和生命周期有关的后置处理器：LifecycleProcessor
1. 默认从容器中找是否存在名为lifecycleProcessor的组件[LifecycleProcessor]，如果没有就创建new DefaultLifecycleProcessor();，然后加入到容器中
2. 自定义实现LifecycleProcessor接口，可以接收到两个回调
  1. void onRefresh(); - 上下文刷新的通知
  2. void onClose(); - 上下文关闭的通知
getLifecycleProcessor().onRefresh(); 拿到刚才获取的生命周期处理器，回调onRefresh()事件
publishEvent(new ContextRefreshedEvent(this)); - 发布容器刷新完成事件

总结

在Spring启动时，先会保存所有注册进来的Bean定义信息
1. xml注册
2. @Bean、@Component...
Spring会在适当的时候创建对应的Bean
1. 用到这个bean的时候，利用getBean创建
2. 启动时统一创建剩下的所有Bean，finishBeanFactoryInitialization(beanFactory)
后置处理器 BeanPostProcessor
1. 每一个Bean创建完成后，都会使用各种后置处理器增强Bean的功能
  1. AutowiredAnnotationBeanPostProcessor: 处理自动注入
  2. AsyncAnnotationBeanPostProcessor: 处理异步
  3. AnnotationAwareAspectJAutoProxyCreator: 处理AOP
事件驱动模型
1. ApplicationListener：事件监听
2. AnnotationAwareAspectJAutoProxyCreator：事件派发器