spring5.x源码解析（ioc的流程总结）

容器的初始化过程

先做了预处理以及解析工作，然后从refresh方法开始

public void refresh() throws BeansException, IllegalStateException {
        Object var1 = this.startupShutdownMonitor;
    synchronized(this.startupShutdownMonitor) {
        this.prepareRefresh();
        ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
        this.prepareBeanFactory(beanFactory);

        try {
            this.postProcessBeanFactory(beanFactory);
            this.invokeBeanFactoryPostProcessors(beanFactory);
            this.registerBeanPostProcessors(beanFactory);
            this.initMessageSource();
            this.initApplicationEventMulticaster();
            this.onRefresh();
            this.registerListeners();
            this.finishBeanFactoryInitialization(beanFactory);
            this.finishRefresh();
        } catch (BeansException var9) {
            if (this.logger.isWarnEnabled()) {
                this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
            }

            this.destroyBeans();
            this.cancelRefresh(var9);
            throw var9;
        } finally {
            this.resetCommonCaches();
        }

    }
}

1. 首先prepareRefresh方法，是做了容器刷新前的预处理
   1） initPropertySources(),空方法，主要是子类做一些个性化属性设置
   2）this.getEnvironment().validateRequiredProperties();校验属性的合法性
   3）this.earlyApplicationEvents = new LinkedHashSet();保存容器中早期的一些事件
2. this.obtainFreshBeanFactory() 获取bean工厂
   1）this.refreshBeanFactory(); 刷新（创建）bean工厂
   a)创建了一个DefaultListableBeanFactory对象
   b) 并为他设置了一个序列化的id
   2）this.getBeanFactory(); 获取bean工厂,获取刚刚GenericApplicationContext类创建的bean工厂
   3）返回这个beanFactory
3. this.prepareBeanFactory(beanFactory); beanFactory的预准备工作，为刚创建好的beanFactory设置一些属性
   1）设置beanFactory的类加载器、支持表达式解析器。。
   2）支持部份BeanPostProcessor(ApplicationContextAwareProcessor)
   3）设置忽略的自动装配接口EnvironmentAware、EmbeddedValueResolverAware、ResourceLoaderAware。。。。
   4）注册可以解析的自动装配BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext，使我们能在任何
   组件中用@Autowired注解拿到这些基础类
   5）添加后置处理器 ApplicationListenerDetector
   6）添加一些容器启动时的默认组件
4. this.postProcessBeanFactory(beanFactory);准备工作完成后的后置处理工作，空方法
   1）子类通过重写这个方法来在beanFactory创建并预准备完成后做进一步的设置
   以上是beanFactory的创建和预准备工作==================
5. this.invokeBeanFactoryPostProcessors(beanFactory);执行BeanFactory的后置处理器
   有两个接口BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor
   1）执行 PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors());
   a）获取所有的BeanDefinitionRegistryPostProcessor
   b）排序
   c）先执行实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
   再执行实现了Ordered接口的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
   最后执行没有实现任何优先级或者顺序接口的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
   -------------------------------------------
   d）获取所有的BeanFactoryPostProcessor
   e）排序
   f）先执行实现了PriorityOrdered接口的BeanFactoryPostProcessor的postProcessBeanFactory方法
   再执行实现了Ordered接口的BeanFactoryPostProcessor的postProcessBeanFactory方法
   最后执行没有实现任何优先级或者顺序接口的BeanFactoryPostProcessor的postProcessBeanFactory方法
6. this.registerBeanPostProcessors(beanFactory); 注册bean的后置处理器，用来拦截bean的创建过程的
   BeanPostProcessor、
   DestructionAwareBeanPostProcessor、
   InstantiationAwareBeanPostProcessor、
   SmartInstantiationAwareBeanPostProcessor、
   MergedBeanDefinitionPostProcessor【internalPostProcessor】
   不同的BeanPostProcessor执行时机不一样
   1）获取所有的beanPostProcessor，并且按优先级（PriorityOrdered）和顺序（Ordered）排序和整理
   a）先注册实现了PriorityOrdered接口的BeanPostProcessor（把每一个BeanPostProcessor添加到BeanFactory中）
   b）再注册实现了Ordered接口的
   c）再注册没有实现上面两个接口的
   d）最后注册MergedBeanDefinitionPostProcessor。
   registerBeanPostProcessors(beanFactory, (List)internalPostProcessors);
   e）最终注册ApplicationListenerDetector（在bean创建完成后检测是否是ApplicationListener，如果是，就把这个bean放在容器中保存
7. this.initMessageSource();做国际化工作、消息绑定、消息解析
   1）获取beanFactory
   2）看容器中是否有id为messageSource，类型为MessageSource的组件
   a）如果有，赋值给messageSource属性
   b）如果没有，创建一个默认的messageSource叫做DelegatingMessageSource，并注册到容器中
   MessageSource作用：能按照区域信息取出国际化配置文件中的key
8. this.initApplicationEventMulticaster();初始化事件派发器
   1） 获取beanFactory
   2） 从beanFactory获取applicationEventMulticaster
   a）判断容器中是否有，如果有，直接获取
   b）如果没有自己创建一个默认的SimpleApplicationEventMulticaster并且加入到容器中
9. this.onRefresh(); 空方法，留给子类重写onRefresh方法
10. this.registerListeners(); 将所有的监听器注册进容器中
    1）从容器中拿到所有的ApplicationListener组件
    2）将所有的ApplicationListener加入到ApplicationEventMulticaster事件派发器中
    3）派发之前产生的事件this.getApplicationEventMulticaster().multicastEvent(earlyEvent);
11. this.finishBeanFactoryInitialization(beanFactory);初始化所有剩下的单实例bean
    1）beanFactory.preInstantiateSingletons();主要看这个方法，初始化剩下的单实例bean
    a）拿到所有的bean的名称信息：List beanNames = new ArrayList(this.beanDefinitionNames);
    b）通过名称拿到所有的bean的定义信息RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName)
    c）判断bean的定义信息，如果不是抽象的、是单实例的、不是懒加载的
    1）判断是不是factoryBean（实现了FactoryBean接口的bean）
    a）如果是，就会调用factoryBean接口的getObject方法来生成bean
    b）如果不是调用getBean(beanName)方法创建对象
    1）getBean(beanName)调用doGetBean(name, null, null, false);
    a）doGetBean方法先调用getSingleton(beanName);获取之前被创建过的单实例bean
    b）如果拿到了就返回这个bean，如果没拿到就开始bean的创建流程
    1）markBeanAsCreated(beanName)，先标记这个bean，表示他已经被创建了防止多线程情况下创建同一个bean
    2）RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName)，通过beanName拿到bean的定义信息
    3）checkMergedBeanDefinition，检查如果当前bean是抽象的bean，抛出异常
    4）获取当前bean的@DependsOn注解属性，如果当前bean有dependsOn，则先创建所依赖的bean
    5）判断当前bean是否是单例的if (mbd.isSingleton())，如果是，则调用createBean(beanName, mbd, args)来创建bean
    a）先获取bean的定义信息RootBeanDefinition mbdToUse = mbd
    b）resolveBeanClass(mbd, beanName);解析bean的类型
    c）prepareMethodOverrides处理重写的方法
    d）resolveBeforeInstantiation(beanName, mbdToUse)。给BeanPostProcessors一个机会创建代理对象，
    执行的是InstantiationAwareBeanPostProcessor这个后置处理器
    1）先触发InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation方法
    2）如果返回的对象不为null就触发postProcessAfterInitialization方法
    3）返回这个bean
    e）如果上面返回的bean不为空，就直接返回
    f）如果为null就调用doCreateBean(beanName, mbdToUse, args)，用来创建bean
    1）instanceWrapper = createBeanInstance(beanName, mbd, args);先是创建bean的实例，放在一个包装对象中
    利用工厂方法或者构造方法创建bean实例
    2）applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);允许后置处理器来修改bean的定义
    执行的是MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition方法
    3）boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
    isSingletonCurrentlyInCreation(beanName));进行循环引用的判断
    4）populateBean(beanName, mbd, instanceWrapper) 给bean的属性赋值
    a）赋值之前先调用InstantiationAwareBeanPostProcessor后置处理器，执行postProcessAfterInstantiation方法
    b）拿到InstantiationAwareBeanPostProcessor后置处理器，执行postProcessPropertyValues方法
    c）applyPropertyValues(beanName, mbd, bw, pvs)，利用setter等方法，执行属性赋值操作
    5）initializeBean(beanName, exposedObject, mbd)；bean的初始化
    a）invokeAwareMethods(beanName, bean)；xxxAware接口的执行
    实现了BeanNameAware、BeanClassLoaderAware、BeanFactoryAware的接口，此时会进行回调
    b）调用实现了BeanPostProcessor接口的postProcessBeforeInitialization方法(此时加
    了@PostConstruct注解的方法会在这里执行)
    c）invokeInitMethods(beanName, wrappedBean, mbd);
    调用在@Bean注解中加了initMethod属性的方法，或者实现了InitializingBean接口的afterPropertiesSet方法
    d）执行BeanPostProcessor的postProcessAfterInitialization方法
    6）registerDisposableBeanIfNecessary(beanName, bean, mbd);注册bean的销毁方法，
    实现了DisposableBean接口的destroy方法
    6）将产生的单实例bean加入到Map singletonObjects中，而这个singletonObjects保存了所有的单实例bean，
    以后要拿对象时就是从这个map中拿
    c）所有bean都通过getBean方法创建完成后，判断所有的bean中有没有实现了SmartInitializingSingleton接口的，
    如果有，则调用它的afterSingletonsInstantiated方法
12. this.finishRefresh();完成容器的刷新
    1）this.initLifecycleProcessor();初始化和生命周期有关的后置处理器
    a）默认从容器找是否有LifecycleProcessor的组件，
    如果有就会在容器启动时调用他的onRefresh方法，在容器关闭时调用他的onClose方法
    b）如果没有就创建一个默认的DefaultLifecycleProcessor，并加入到容器中
    2）拿到this.getLifecycleProcessor()上面生成的LifecycleProcessor组件，调用他的onRefresh();
    3）this.publishEvent((ApplicationEvent)(new ContextRefreshedEvent(this)));发布容器刷新完成的事件