spring源码-ioc容器周期

Spring容器的refresh 创建刷新：

 

1-prepareRefresh刷新前的预处理：

initPropertySources 初始化一些属性配置，原来是空的，子类自定义的属性设置方法

getEnvironment().validateRequiredProperties();检验属性的合法性

this.earlyApplicationEvents = new LinkedHashSet<>();保存容器中的一些早期的事件

2-obtainFreshBeanFactory();获取BeanFactory

refreshBeanFactory(); 刷新BeanFactory;（在GenericApplicationContext类里面）
    创建了this.beanFactory = new DefaultListableBeanFactory();
    设置idthis.beanFactory.setSerializationId(getId());

getBeanFactory()返回刚才GenericApplicationContext构造器创建的BeanFactory对象
将创建的的BeanFactory[DefaultListableBeanFactory]返回

3-prepareBeanFactory(beanFactory); BeanFactory的预备工作，BeanFactory进行一些设置

1设置BeanFactory类的类加载器，支持表达式解析器。。。。。

2beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));添加部分的BeanPostProcessor

3设置忽略的自动装配的接口(就是不能通过实现接口进行加载)，包括EnvironmentAware EmbeddedValueResolverAware

4beanFactory.registerResolvableDependency
注册可以解析的自动装配(就是通过autowire) 包括BeanFactory ResourceLoader  ApplicationEventPublisher

5添加BeanPostProcessor(ApplicationListenerDetector)

6添加编译时的AspetJ

7给BeanFactory能用的组件
     environment【ConfigurableEnvironment】
    systemProperties  【Map<String, Object>】
    systemEnvironment【Map<String, Object>】

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

子类通过重写该方法来BeanFactory创建并准备以后坐进一步的设置

###############################上面就是BeanFactory的创建几与准备工作

5-invokeBeanFactoryPostProcessors(beanFactory);执行BeanFactoryPostProcessor

　　BeanFactoryPostProcessor  BeanFactory后置处理器，在BeanFactory标准初始化之后执行

　　两个接口：BeanFactoryPostProcessor   BeanDefinitionRegistryPostProcessor子接口

1-执行BeanFactoryPostProcessor的方法：
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
    先执行这个后置处理器BeanDefinitionRegistryPostProcessor
    1-获取所有的BeanDefinitionRegistryPostProcessor
    2-看优先级排序，先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor
        执行后置处理器方法postProcessor.postProcessBeanDefinitionRegistry
    3-在执行实现了Ordered.class顺序接口的BeanDefinitionRegistryPostProcessor
         postProcessor.postProcessBeanDefinitionRegistry(registry);
    4-最后执行没有实现优先级或者顺序接口的BeanDefinitionRegistryPostProcessor

再执行BeanFactoryPostProcessor的方法
 其实流程和上面那个处理器一样

6-registerBeanPostProcessors(beanFactory);注册BeanPostProcessors,Bean的后置处理器，拦截Bean创建的过程

1-获取所有的BeanPostProcessor
    不同类型的BeanPostProcessor，在Bean创建前后的执行时机是不一样的
    DestructionAwareBeanPostProcessor【存放位置】
    InstantiationAwareBeanPostProcessor，【存放位置】
    SmartInstantiationAwareBeanPostProcessor，【存放位置】
    MergedBeanDefinitionPostProcessor【存放位置internalPostProcessors】
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

(后置处理器都有优先级)

2-注册PriorityOrderd优先级接口的BeanPostProcessor：
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
        实际上就是将每一个BeanPostProcessor，添加到BeanFactory中
        beanFactory.addBeanPostProcessor(postProcessor);    

3-在注册Oreder接口的
4-最后注册么有实现任何接口的
5-最终注册的是MergedBeanDefinitionPostProcessor类型的
6-最后最后注册ApplicationListenerDetector：来创建Bean完成后检查是否是ApplicationListener，如果是的化就进行下面带#号的语句
        beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));

######this.applicationContext.addApplicationListener((ApplicationListener<?>) bean);

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

1-获取BeanFactory:
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();

2-看容器中是否包含id为 messageSource组件
    如果有就赋值给该类的属性
        this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
      如果没有新建一个DelegatingMessageSource dms = new DelegatingMessageSource();
        MessageSource 取出国际化配置文件中的某个key的值，能按照区域信息获取

3-把创建好的MessageSource注册在容器中，以后获取国际化配置文件的值的时候，自动注入MessageSource即刻
    beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
    String getMessage(String code, @Nullable Object[] args, @Nullable String defaultMessage, Locale locale);

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

1-获取BeanFactory
2-从BeanFactory中获取ApplicationEventMulticaster  
 beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);

3-如果上一步没有配置，创建一个SimpleApplicationEventMulticaster
    SimpleApplicationEventMulticaster simpleApplicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);

4-将创建的ApplicationEventMulticaster   添加到BeanFactory中，以后可以自动注入
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);

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

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

10-registerListeners();给容器中将所有项目里面的ApplicationListener注册进来

1-从容器中拿到ApplicationListener
    getApplicationListeners()
2-将每个监听器，提娜佳到事件派发起
    getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);

3-派发之前步骤产生的事件：
        getApplicationEventMulticaster().multicastEvent(earlyEvent);

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

1-beanFactory.preInstantiateSingletons();初始化剩下的单实例Bean
    1-获取容器中所有的Bean,依次进行初始化和创建对象
        beanNames = new ArrayList<>(this.beanDefinitionNames);
    2-获取Bean的定义信息：RootBeanDefinition
    3-如果bean不是抽象的额，是单实例的，是懒加载：
        1-判断是否是FactoryBean，是否是实现FactoryBean接口的Bean,如果是工厂bean就会用工厂的getObject来创建对象
        2-如果不是直接利用getBean(beanName)创建对象
            getBean(beanName)怎么做：
                1-调用doGetBean
                2-先获取缓存中的单实例bean,如果能够获取到，Bean是之前被创建的（所有被创建锅的Bean都会被缓存起来）
                    Object sharedInstance = getSingleton(beanName);
                3-获取不到，开始创建对象流程：
                4-标记当前bean已经被创建markBeanAsCreated(beanName);
                5-获取Bean的定义信息RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                6-获取当前Bean依赖的信息：String[] dependsOn = mbd.getDependsOn();并通过getBean创建出来
                7-启动单实例Bean的创建过程if (mbd.isSingleton())
                    1-createBean(beanName, mbd, args)
                     2-让BeanPostProcess进行拦截执行
                        Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
                        执行的类型是：InstantiationAwareBeanPostProcessor类型
                        触发Object result = bp.postProcessBeforeInstantiation(beanClass, beanName);
                        如果有放回值，执行 processor.postProcessAfterInitialization(result, beanName);

                        3-如果前面InstantiationAwareBeanPostProcessor没有返回代理对象
                        执行：Object beanInstance = doCreateBean(beanName, mbdToUse, args);

执行doCreateBean的流程

通过bean构造器创建Bean
instanceWrapper = createBeanInstance(beanName, mbd, args);

applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
调用MergedBeanDefinitionPostProcessor的方法：
processor.postProcessMergedBeanDefinition(mbd, beanType, beanName);

位Bean属性赋值populateBean(beanName, mbd, instanceWrapper);
　　赋值之前
　　1-拿到InstantiationAwareBeanPostProcessor 后置处理器：
　　　　执行bp.postProcessAfterInstantiation
　　2-在其拿到InstantiationAwareBeanPostProcessor 后置处理器
　　　　执行bp.postProcessPropertyValues
　　3-应用Bean属性的值，为属性利用setter方法进行赋值现在才开始赋值applyPropertyValues(beanName, mbd, bw, pvs);

Bean初始化
　　initializeBean(beanName, exposedObject, mbd);
　　1-invokeAwareMethods(beanName, bean);执行Aware接口的方法。
　　　　BeanNameAware 
　　　　BeanClassLoaderAware
　　　　BeanFactoryAware

　　2-执行后置处理器初始化之前的方法：BeanPostProcessor

　　　wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
　　　　调用processor.postProcessBeforeInitialization(result, beanName);
　　3-执行初始化方法：InitializingBean
　　　　1-判断是否是InitializingBean接口，执行规定的初始化方法：
　　　　2-判断是否自定义初始化方法
　　4-执行后置处理器初始化
　　　　wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
　　　　　　BeanPostProcessor.postProcessAfterInitialization
注册Bean的销毁方法：
　　registerDisposableBeanIfNecessary(beanName, bean, mbd);

最后是将Bean添加到缓存当中的singletonObjects

备注：IOC容器就是这些Map,很多Map里面保存了单实例Bean，环境信息等

DefaultListableBeanFactory

所有Bean都利用getBean完成之后：
    检查所有的Bean是否是SmartInitializingSingleton接口的，如果是，
    就执行smartSingleton.afterSingletonsInstantiated();

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

初始化和生命周期有关的后置处理器initLifecycleProcessor();LifecycleProcessor
    写一个LifecycleProcessor的实现类，可以在BeanFactory两个阶段
        void onRefresh()  void onClose()
    如果没有自定义生命周期，则容器会新建一个 new DefaultLifecycleProcessor();并注册到容器当中去：
 beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);

拿到前面的生命周期，回调onRefresh()方法，getLifecycleProcessor().onRefresh();

发布容器刷新完成事件publishEvent(new ContextRefreshedEvent(this));

LiveBeansView.registerApplicationContext(this);

spring容器总结

1-Spring容器在启动的时候，贤惠保存所有注册进来的Bean定义信息

　　1-1xml注册bean<bean>

　　1-2注解注册Bean @Service @Component

2-Spring容器会合适的时机创建那就这些Bean

　　2-1用到这个Bean的时候，利用getBean创建Bean,并保存到容器中

　　2-2统一创建所有剩下的Bean,finishBeanFactoryInitialization

3-后置处理器：

　　3-1每个Bean的创建完成，都会使用各种后置处理器进行处理，来增强bean的功能

　　　　AutowiredAnnotationBeanPostProcessor 处理自动注入

　　　　AnnotationAwareAspectJAutoProxyCreator 做AOP功能

　　　　增强的功能注解，都是通过后置处理器来完成的

　　　　AsyncAnnotationBeanPostProcessor

4-事件驱动模型：

　　ApplicationListener：事件监听

　　ApplicationEventMulticaster事件派发