springIOC容器加载全过程

spring加载配置文件后会调用refresh()方法：

springIoc的创建全过程refresh()方法

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

    1)、initPropertySources()初始化一些属性配置，子类继承实现个性化        
    2)、getEnvironment().validateRequiredProperties()；检验属性的合法性

2.obtainFreshBeanFactory() 获取BeanFactory；

    1)、refreshBeanFactory()刷新BeanFactory；
        创建一个this.beanFactory = new DefaultListableBeanFactory();
        设置id；
3.prepareBeanFactory(beanFactory);beanFactory的预准备工作
    1)、设置BeanFactory的类加载器，表达式解析器....
    2)、添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
    3)、设置忽略的自动装配的接口ResourceLoaderAware、EnvironmentAware、xxx
    4)、注册可以解析的自动装配：我们能直接在任何组件中自动注入：
        BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
    5)、添加编译时的AspectJ；
    6)、给beanFactory中注册一些能用的组件，
        environment
        SystemProperties
        SystemEnvironment
4.postProcessBeanFactory(beanFactory);BeanFactory准备工作完成后进行的后置处理工作；
    1).子类通过重写这个方法在BeanFactory创建并预准备完成后做进一步的设置
=======================以上是beanFactory的创建于预准备工作===========================================
5.invokeBeanFactoryPostProcessors(beanFactory);执行BeanFactoryPostProcessor的方法；
    BeanFactoryPostProcessor：BeanFactory的后置处理器，在beanFactory标准初始化之后执行的；
    两个接口BeanFactoryPostProcessor，BeanDefinitionRegistryPostProcessor
    1).执行invokeBeanFactoryPostProcessors的方法
              先执行BeanDefinitionRegistryPostProcessor
        （1）.先执行实现了PriorityOrderd优先级接口的BeanDefinitionRegistryPostProcessor。
            postProcessor.postProcessBeanDefinitionRegistry（registry）；
        （2）.再执行实现order接口的XXXXXX（registry）
        （3）.最后执行普通的beanDefinitionRegistryPostProcessor（registry）
             再执行BeanFactoryPostProcessor
        （1）.先执行实现了PriorityOrderd优先级接口的BeanFactoryPostProcessor.
            postProcessor.postProcessBeanFactory（beanFactory）；
        （2）.再执行实现order接口的XXXXXX（beanFactory）
        （3）.最后执行普通的beanFactoryPostProcessor（beanFactory）
6.registerBeanPostProcessors(beanFactory);注册BeanPostProcessor【拦截bean的创建过程】
    不同接口类型的BeanPostProcessor；在bean创建前后的执行时机不一样
    BeanPostProcessor、DextructionAwareBeanPostProcessor、InstantiationAwareBeanPostProcessor
    SmartInstantiationAwareBeanPostProcessor、MergedBeanDefinitionPostProcessor
    1）.获取所有的BeanPostProcessor；后置处理器都默认可以有PriorityOrdered、Ordered接口优先级
    2）.先注册PriorityOrdered优先级接口的BeanPostProcessor；
        把每一个BeanPostProcessor添加到beanFactory中
        registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors){
            beanFactory.addBeanPostProcessor(postProcessor);
        }
    3）.再注册实现ordered接口的
    4）.最后注册没有实现任何接口的
    5）.最终注册InternalPostProcess
    6）.注册一个ApplicationListenerDetector
7.initMessageSource()；初始化MessageSource(做国际化功能：消息绑定，消息解析)组件
    1).获取BeanFactory
    2).容器中是否有id为messageSource，类型为MessageSource的组件
        如果有赋值给messageSource，如果没有自己创建一个DelegatingMessageSource；
        MessageSource：取出国际化配置文件中的某个key的值；能按照区域信息获取
    3).把创建好的MessageSource注册在容器中，以后获取国际化配合文件值的时候可以自动注入MessageSource
8.initApplicationEventMulticaster（）；初始化事件派发器
    1).获取BeanFactory
    2).获取applicationEventMulticaster；
    3).若容器中没有则创建一个SimpleApplicationEventMulticaster(beanFactory);并添加到BeanFactory
9.onRefresh();留给子类重写onRefresh(）在容器刷新的时候自定义逻辑；
10.registerListeners();给容器中将项目里面所有的ApplicationListener注册进来；
    1).从容器中拿到所有的ApplicationListener()
    2).将每个监听器添加到事件派发器中
        getApplicationEventMulticaster().addApplicationListener(listener);
11.finishBeanFactoryInitialization（beanFactory）初始化剩下的所有单实例bean
    1).beanFactory.preInstantiateSingletons();初始化后剩下的单实例bean
    2).获取所有的beandefinition，依次进行初始化和创建对象********到这步才给开始给容器中注册自己定义的bean信息
    3).beandefinition不是抽象的，是单实例的，不是懒加载的
        （1）判断是否是FactoryBean：是否是实现FactoryBean接口的Bean；
        （2）如果不是工厂Bean，利用getBean(beanName)创建对象，        
            0.getBean（beanName）：ioc.getBean(Name);
            1.doGetBean(beanName,null,null,false);
            2.先获取缓存中保存的单实例bean，如果能获取说明这个bean之前被创建过
            3.缓存中获取不到，开始Bean的创建对象流程
            4.标记当前bean已经被创建
            5.获取bean的定义信息  RootBeanDefinition mdb = getMergerLocalBeanDefintion(beanName);
            6.获取当前Bean依赖的其他Bean;String[] dependsOn = mbd.getDependsOn();如果有就继续调用getBean(beanName)获取；
            7.如果当前的bean是单实例的,调用方法创建一个bean 每一个bean都有自己的Factory；
                sharedInstance = getSingle(BeanName，new ObjectFactory<Object>(){
                        @Override
                    public Object getObject() throws BeansException{
                        try{
                            return create(beanName,mdb,args);//这才是真正创建bean的步骤
                            }
                        }
                });
                createBean( beanName,mdb,args);{
                Object bean = resolveBeforeInstantiation(BeanName,mbdToUse);让beanPostProcessor先提前拦截返回代理对象
                InstantiationAwareBeanPostProcessor该处理器就是在bean创建之前拦截bean，springAop的AnnotationAwareAspectJAutoProxyCreator就是这种对象
                    先触发该处理器的postProcessBeforeInstantiation();如果有返回值：触发postProcessAfterInitialization();
                如果resolveBeforeInstantiation没有返回代理对象，那么就创建bean；
                    doCreateBean(beanName,mdbToUse,args);创建bean
                        1）创建bean实例：createBeanInstance（BeanName,mdb,args);
                            利用工厂方法反射创建bean实例**********这个地方真真正正创建出来了bean*******
                        2）applyMergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition（mdb，beanType，beanName）；
                        
                        3）populateBean（beanName,mdb,instanceWrapper）;对bean的属性赋值
                            赋值之前
                            1、拿到InstantiationAwareBeanPostProcessor后置处理器postProcessBeforeInstantiation()；
                            2、拿到InstantiationAwareBeanPostProcessor后置处理器postProcessPropertyValues();
                            3、应用bean属性的值,为属性利用setter方法赋值：applyPropertyValues(beanName,mdb,bw,pvs);
                        4)Bean的初始化 initializeBean(beanName, exposedObject, mbd);
                            1、invokeAwareMethods(beanName, bean);bean实现了BeanNameAware接口、BeanClassLoaderAware、BeanFactoryAware接口会触发接口中方法                    
                            2、【执行后置处理器初始化之前的方法】applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
                            BeanPostProcessor.postProcessBeforeInitialization()%所以之前定义bean的初始化的方法可以实现bean的后置处理器的接口里面的方法，自定义初始化。
                            3、执行当前bean自己的初始化方法invokeInitMethods(beanName,wrappedBean,mdb)。
                                1.是否是InitializingBean接口实现的
                                2.是否自定义初始化方法。
                            4、执行后置处理器初始化之后的方法applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);                    
                                   BeanPostProcessor.postProcessAfterInitialization()
                
                        5）注册销毁方法
                把bean添加到单例缓存池singletonObjects中
            ioc容器就是这些map：单实例bean、环境信息。
                      }********************************doCreateBean(）执行完毕后才真正的创建了bean                            
    检查所有的Bean是否是SmartInitializingSingleton接口的方法，如果是就执行afterSingletonsInstantiated()方法；
12.finishRefresh(）完成所有过程IOC容器刷新完成
    1）.initLifecycleProcessor();初始化和生命周期有关的后置处理器LifecycleProcessor如果没有这个组件，就新建一个DefaultLifecycleProcessor
        这个接口的实现类，可以在BeanFactory的onRefresh（）和onClose（）执行
    2）.拿到前面定义的生命周期处理器；回调onRefresh方法
    3）.publishEvent(new ContextRefreshedEvent(this));发布容器刷新完成事件
    4）.LiveBeansView.registerApplicationContext(this);

GG;