Spring扩展原理

一、BeanFactoryPostProcessor

        是beanFactory后置处理器。在BeanFactory标准初始化之后调用，所有的bean定义已经保存加载到beanfactory，但是bean的实例还未创建。

        工作原理：通过invokeBeanFactoryPostProcessor（beanFactory）方法。

                1.在BeanFactory中找到所有类型是BeanFactoryPostProcessor的组件，并执行他们的方法。

                2.在初始化创建其他组件前面执行。

二、BeanDefinitionRegistryPostProcessor

        是BeanFactoryPostProcessor的子接口；

        在所有bean定义信息将要加载，bean实例还未创建的时候；

        优先BeanFactoryPostProcessor执行；

        利用BeanDefinitionRegistryPostProcessor给容器中再额外添加一些组件；

        工作原理：

                1.在refresh（）中调用invokeBeanFactoryPostProcessor(beanFactory)方法;

                2.从容器中获取所有的BeanDefinitionRegistryPostProcessor组件，

                        1）、依次触发所有postProcessorBeanDefinitionRegistry（）方法；

                        2）、再来触发postProcessBeanFactory（）方法BeanFactoryPostProcessor；

        beanDefinitionRegistry 里面保存了每一个bean的定义信息。BeanFactory就是按照他的信息内容创建bean实例。优先于BeanFactoryPostProcessor执行。

三、ApplicationListener

        监听容器中发布的事件。完成事件驱动模型开发。

        步骤：1.写一个监听器来监听某个事件（ApplicationEvent及其子类)、或者使用@EventListener注解

                   2.把监听器加入到容器;

                   3.只要容器中有相关事件的发布,我们就能监听到这个事件。

                   4.发布一个事件：

                        applicationContext.publicEvent();

        【事件的发布流程】

                1.获取事件的多播器（派发器）：getApplicationEventMulticaster（）

                2.multicastEvent派发事件；

                3.获取到所有的ApplicationListener；判断是否支持Executor进行异步派发；

                        否则，同步的方式直接执行listener方法；invokeListener（listener，event）；

                        拿到listener回调onApplicationEvent方法；

四、SmartInitializingSingleton

        1.ioc容器创建对象并refresh（）

        2.finishBeanFactoryInitialization（beanFactory）;

                1).先创建所有的单实例bean, getBean();

                2).获取所有创建好的单实例bean,判断是否是SmartInitilizingSingleton类型的;

                        如果是就调用afterSingletonsInstantiated();

五、Spring容器创建过程

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

                1) initPropertySource() 初始化一些属性设置;子类自定义个性化的属性设置方法;

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

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

        2.obtainFreshBeanFactory();获取BeanFactory;

                1) refreshBeanFactory(); 刷新【创建】BeanFactory；

                        创建了一个this.beanFactory = new DefaultListableBeanFactory();

                        设置id;                

                2) getBeanFactory(); 返回刚才GenericApplicationContext创建的BeanFactory对象;

                3) 将创建的BeanFactory【DefaultListableBeanFactory】返回;

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

                1) 设置BeanFactory的类加载器、支持表达式解析器等

                2) 添加部分BeanPostProcessor【ApplicationContextAwareProcessor】

                3) 设置忽略的自动装配的接口

                4) 注册可以解析自动装配的接口

                5) 添加BeanPostProcessor

                6) 添加编译时的AspectJ

                7) 给BeanFactory中注册一些能用的组件

                        environment、systemProperties、systemEnvironment

        4.postProcessBeanFactory（beanFactory）;BeanFactory准备工作完成后进行的后置处理工作；

                1) 子类通过重写这个方法来在BeanFactory创建并预准备完成以后做进一步的设置;

======================以上BeanFactory的创建及预准备工作=======================

        5.invokeBeanFactoryPostProcessors(beanFactory); 执行BeanFactoryPostProcessor;

                BeanFactoryPostProcessor: BeanFactory 的后置处理器,在BeanFactory标准初始化后执行的;

                两个接口:BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor

                1) 执行BeanFactoryPostProcessor的方法,先判断是否实现 BeanDefinitionRegistry；

                        如果是,先执行BeanDefinitionRegistryPostProcessor；

                        1) 获取所有的BeanDefinitionRegistryPostProcessor;

                        2) 先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor;

                        3) 再执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor;

                        4) 最后执行没有实现任何优先级或者是顺序接口的BeanDefinitionRegistryPostProcessor

                2) 再执行BeanFactoryPostProcessor的方法

                        1) 获取所有的BeanFactoryPostProcessor

                        2) 先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor;

                        3) 再执行实现了Ordered顺序接口的BeanFactoryPostProcessor;

                        4) 最后执行没有实现任何优先级或者是顺序接口的BeanFactoryPostProcessor

        6.registerBeanPostProcessors(beanFactory);注册BeanPostProcessor（Bean的后置处理器）【intercept bean creation】

                        1） 获取所有的BeanPostProcessor；后置处理器默认都可以通过PriorityOrdered、Ordered接口来执行优先级

                        2）先注册PriorityOrdered优先级接口的BeanPostProcessor

                                把每一个BeanPostProcessor添加到BeanFactory中

                        3）再注册Ordered接口的

                        4）最后注册没有实现任何优先级接口的

                        5）最终注册MergedBeanDefinitionPostProcessor

                        6）注册一个ApplicationListenerDetector；来在Bean创建完成后检查是否是ApplicationListener，如果是就把ApplicationListener放在容器中：

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

                1） 获取BeanFactory

                2）看容器中是否有MessageSource组件，没有则自己创建一个。

                        MessageSource： 取出国际化配置文件中的某个key值，能按照区域信息获取；

                3）把创建好的MessageSource注册在容器中，以后获取国际化配置文件的值时，可以自动注入MessageSource

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

                1）获取BeanFactory

                2）从BeanFactory中获取applicationEventMulticaster的ApplicationEventMulticaster

                3）如果上一步没有配置，则获取一个SimpleApplicationEventMulticaster(beanFactory)；简单的事件派发器

                4）将创建的ApplicationEventMulticaster添加到BeanFactory中，以后其他组件直接自动注入

        8.onRefresh();留给子类容器

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

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

                        1) 从容器中拿到所有的ApplicationListener

                        2) 将每个监听器添加到事件派发器中

                        3) 派发之前步骤产生的事件

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

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

                        1)获取容器中的所有Bean,依次进行初始化和创建对象。

                        2)获取Bean的定义信息；RootBeanDefinition

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

                                1）是否是FactoryBean：是否是实现FactoryBean接口的Bean

                                2）如果不是，用getBean创建对象。

                                        0、getBean（beanName）；ico.getBean();

                                        1、doGetBean(name,null,null,false);

                                        2、先获取缓存中保存的单实例Bean。如果能获取到说明这个Bean之前被创建过（所有创建过的单实例Bean都会被缓存起来）

                                        3、如果缓存拿不到，开始Bean的创建对象流程

                                        4、标记信息已被创建

                                        5、获取Bean的定义信息

                                        6、获取该Bean的依赖信息，如果有依赖，按照getBean()把依赖的Bean先创建出来。

                                        7、启动单实例的创建流程

                                                ①

                                                ②：【创建Bean实例】 调用createBeanInstance(beanName,mdb,args);方法，利用工厂方法或者对象的构造器创建出Bean实例；

                                                ③：【Bean属性赋值】populateBean；先拿到InstantiationAwareBeanPostProcessor后置处理器，依次调用postProcessAfterInstantiation()和postProcessPropertyValues()方法。最后调用applyPropertyValues()方法为属性赋值。

                                                ④：【Bean初始化】initializeBean();

                                                        调用初始化之前的后置处理器——》执行初始化方法（判断是否实现InitializingBean接口或者自定义初始化方法）——》执行初始化之后的后置处理器

                                                ⑤：注册Bean销毁方法

                                3）将创建的单实例Bean添加到缓存中singletonObjects；（是一个Map，IOC容器是很多的Map）

总结

        1.Spring容器再启动的时候，先回保存所有注册进来的Bean的定义信息；

                1）、xml注册Bean

                2）、注解注册Bean

        2.Spring容器会合适的时机创建这些Bean

                1）、用到这个bean的时候；利用getBean创建bean；创建好以后保存在容器中。

                2）、统一创建剩下所有的bean的时候；finishBeanFactoryInitialization()

        3.后置处理器；

                1）、每一个bean创建完成，都会使用各种后置处理器进行处理；来增强bean的功能。

                        AutowiredAnnotationBeanPostProcessor：处理自动注入

                        AnnotationAwareAspectJAutoProxyCreator：来做AOP功能

        4.事件驱动模型：

                ApplicationListener：事件监听

                ApplicationEventMulticaster; 事件派发