Spring容器深度解析：初始化与后置处理器详解-优快云博客

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

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

   1）、initPropertySources()初始化一些属性设置;子类自定义个性化的属性设置方法；
   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）、设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxx；
 4）、注册可以解析的自动装配；我们能直接在任何组件中自动注入：
       BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
 5）、添加BeanPostProcessor【ApplicationListenerDetector】
 6）、添加编译时的AspectJ；
 7）、给BeanFactory中注册一些能用的组件；
    environment【ConfigurableEnvironment】、
    systemProperties【Map<String, Object>】、
    systemEnvironment【Map<String, Object>】

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

   1）、子类通过重写这个方法来在BeanFactory创建并预准备完成以后做进一步的设置
======================以上是BeanFactory的创建及预准备工作==================================

5、invokeBeanFactoryPostProcessors(beanFactory);执行BeanFactoryPostProcessor的方法；

   BeanFactoryPostProcessor：BeanFactory的后置处理器。在BeanFactory标准初始化之后执行的；
   两个接口：BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor
   1）、执行BeanFactoryPostProcessor的方法；
      先执行BeanDefinitionRegistryPostProcessor
      1）、获取所有的BeanDefinitionRegistryPostProcessor；
      2）、看先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor、
         postProcessor.postProcessBeanDefinitionRegistry(registry)
      3）、在执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor；
         postProcessor.postProcessBeanDefinitionRegistry(registry)
      4）、最后执行没有实现任何优先级或者是顺序接口的BeanDefinitionRegistryPostProcessors；
         postProcessor.postProcessBeanDefinitionRegistry(registry)
         
      再执行BeanFactoryPostProcessor的方法
      1）、获取所有的BeanFactoryPostProcessor
      2）、看先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor、
         postProcessor.postProcessBeanFactory()
      3）、在执行实现了Ordered顺序接口的BeanFactoryPostProcessor；
         postProcessor.postProcessBeanFactory()
      4）、最后执行没有实现任何优先级或者是顺序接口的BeanFactoryPostProcessor；
         postProcessor.postProcessBeanFactory()

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

      不同接口类型的BeanPostProcessor；在Bean创建前后的执行时机是不一样的
      BeanPostProcessor、
      DestructionAwareBeanPostProcessor、
      InstantiationAwareBeanPostProcessor、
      SmartInstantiationAwareBeanPostProcessor、
      MergedBeanDefinitionPostProcessor【internalPostProcessors】、
      
      1）、获取所有的 BeanPostProcessor;后置处理器都默认可以通过PriorityOrdered、Ordered接口来执行优先级
      2）、先注册PriorityOrdered优先级接口的BeanPostProcessor；
         把每一个BeanPostProcessor；添加到BeanFactory中
         beanFactory.addBeanPostProcessor(postProcessor);
      3）、再注册Ordered接口的
      4）、最后注册没有实现任何优先级接口的
      5）、最终注册MergedBeanDefinitionPostProcessor；
      6）、注册一个ApplicationListenerDetector；来在Bean创建完成后检查是否是ApplicationListener，如果是
         applicationContext.addApplicationListener((ApplicationListener<?>) bean);

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

      1）、获取BeanFactory
      2）、看容器中是否有id为messageSource的，类型是MessageSource的组件
         如果有赋值给messageSource，如果没有自己创建一个DelegatingMessageSource；
            MessageSource：取出国际化配置文件中的某个key的值；能按照区域信息获取；
      3）、把创建好的MessageSource注册在容器中，以后获取国际化配置文件的值的时候，可以自动注入MessageSource；
         beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);   
         MessageSource.getMessage(String code, Object[] args, String defaultMessage, Locale locale);

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

      1）、获取BeanFactory
      2）、从BeanFactory中获取applicationEventMulticaster的ApplicationEventMulticaster；
      3）、如果上一步没有配置；创建一个SimpleApplicationEventMulticaster
      4）、将创建的ApplicationEventMulticaster添加到BeanFactory中，以后其他组件直接自动注入

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

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

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

      1、从容器中拿到所有的ApplicationListener
      2、将每个监听器添加到事件派发器中；
         getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
      3、派发之前步骤产生的事件；

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

   1、beanFactory.preInstantiateSingletons();初始化后剩下的单实例bean
      1）、获取容器中的所有Bean，依次进行初始化和创建对象
      2）、获取Bean的定义信息；RootBeanDefinition
      3）、Bean不是抽象的，是单实例的，是懒加载；
         1）、判断是否是FactoryBean；是否是实现FactoryBean接口的Bean；
         2）、不是工厂Bean。利用getBean(beanName);创建对象
            0、getBean(beanName)； ioc.getBean();
            1、doGetBean(name, null, null, false);
            2、先获取缓存中保存的单实例Bean。如果能获取到说明这个Bean之前被创建过（所有创建过的单实例Bean都会被缓存起来）
               从private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);获取的
            3、缓存中获取不到，开始Bean的创建对象流程；
            4、标记当前bean已经被创建
            5、获取Bean的定义信息；
            6、【获取当前Bean依赖的其他Bean;如果有按照getBean()把依赖的Bean先创建出来；】
            7、启动单实例Bean的创建流程；
               1）、createBean(beanName, mbd, args);
               2）、Object bean = resolveBeforeInstantiation(beanName, mbdToUse);让BeanPostProcessor先拦截返回代理对象；
                  【InstantiationAwareBeanPostProcessor】：提前执行；
                  先触发：postProcessBeforeInstantiation()；
                  如果有返回值：触发postProcessAfterInitialization()；
               3）、如果前面的InstantiationAwareBeanPostProcessor没有返回代理对象；调用4）
               4）、Object beanInstance = doCreateBean(beanName, mbdToUse, args);创建Bean
                   1）、【创建Bean实例】；createBeanInstance(beanName, mbd, args);
                     利用工厂方法或者对象的构造器创建出Bean实例；
                   2）、applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                     调用MergedBeanDefinitionPostProcessor的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, bean);执行xxxAware接口的方法
                        BeanNameAware\BeanClassLoaderAware\BeanFactoryAware
                     2）、【执行后置处理器初始化之前】applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
                        BeanPostProcessor.postProcessBeforeInitialization（）;
                    3 ）、【执行初始化方法】invokeInitMethods(beanName, wrappedBean, mbd);
                        1）、是否是InitializingBean接口的实现；执行接口规定的初始化；
                        2）、是否自定义初始化方法；
                     4）、【执行后置处理器初始化之后】applyBeanPostProcessorsAfterInitialization
                        BeanPostProcessor.postProcessAfterInitialization()；
                   5）、注册Bean的销毁方法；
               5）、将创建的Bean添加到缓存中singletonObjects；
            ioc容器就是这些Map；很多的Map里面保存了单实例Bean，环境信息。。。。；
      所有Bean都利用getBean创建完成以后；
         检查所有的Bean是否是SmartInitializingSingleton接口的；如果是；就执行afterSingletonsInstantiated()；

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

      1）、initLifecycleProcessor();初始化和生命周期有关的后置处理器；LifecycleProcessor
         默认从容器中找是否有lifecycleProcessor的组件【LifecycleProcessor】；如果没有new DefaultLifecycleProcessor();
         加入到容器；
         
         写一个LifecycleProcessor的实现类，可以在BeanFactory
            void onRefresh();
            void onClose();    
      2）、    getLifecycleProcessor().onRefresh();
         拿到前面定义的生命周期处理器（BeanFactory）；回调onRefresh()；
      3）、publishEvent(new ContextRefreshedEvent(this));发布容器刷新完成事件；
      4）、liveBeansView.registerApplicationContext(this);

总结

   1）、Spring容器在启动的时候，先会保存所有注册进来的Bean的定义信息；
      1）、xml注册bean；<bean>
      2）、注解注册Bean；@Service、@Component、@Bean、xxx
   2）、Spring容器会合适的时机创建这些Bean
      1）、用到这个bean的时候；利用getBean创建bean；创建好以后保存在容器中；
      2）、统一创建剩下所有的bean的时候；finishBeanFactoryInitialization()；
   3）、后置处理器；BeanPostProcessor
      1）、每一个bean创建完成，都会使用各种后置处理器进行处理；来增强bean的功能；
         AutowiredAnnotationBeanPostProcessor:处理自动注入
         AnnotationAwareAspectJAutoProxyCreator:来做AOP功能；
         xxx....
         增强的功能注解：
         AsyncAnnotationBeanPostProcessor
         ....
   4）、事件驱动模型；
      ApplicationListener；事件监听；
      ApplicationEventMulticaster；事件派发：

二、BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor以及BeanPostProcessor

1、BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor以及BeanPostProcessor都属于Spring的后置处理器，可以实现它们以达到动态注册bean定义，动态修改bean定义，以及动态修改bean。

2、BeanDefinitionRegistryPostProcessor继承接口BeanFactoryPostProcessor，该接口新增postProcessBeanDefinitionRegistry方法，方法参数是BeanDefinitionRegistry对象，BeanDefinitionRegistry对象是bean定义的保存中心。

众所周知BeanDefinitionRegistry是用于beanDefinition注册、修改的。那么此方法在就可以在spring standard initialization后去修改一个beanDefinition、或者新增一个。这个类有个巨屌的实现类ConfigurationClassPostProcessor，这个类将处理configuration的类中以下注解：@Import、@PropertySource、@ComponentScan、@ImportResource、@Bean methods等。将这些注解涉及到的BeanDifinition注册到BeanDefinitionRegistry中。对ConfigurationClassPostProcessor加载兴趣的查看可以看下此链接；

3、BeanFactoryPostProcessor是一个接口，它允许自定义修改应用程序上下文的bean定义，在基于bean factory上调整上下文的bean属性值。

BeanFactoryPostProcessor可以与bean交互并修改bean定义，但从不使用bean实例。这个接口支持修改容器内的beanDefinition对象，也可以直接注册bean对象，在标准的beanDefinition注册之后以及预实例化bean对象之前postProcessBeanFactory方法，也是在实例化之前调用，也是读取bean定义并作出修改，比如属性修改，这个类spring也有一个巨牛的实现类PropertyPlaceholderConfigurer，这类的描述如下：将配置文件中的值注入到我们的代码中！！如数据源信息等。 BeanFactoryPostProcessor：BeanFactory级别的处理，是针对整个Bean的工厂进行处理

4、BeanPostProcessor也是一个接口，它允许动态修改应用程序上下文的bean，这时候bean已经实例化成功。 BeanPostProcessor：bean级别的处理，针对某个具体的bean进行处理

BeanPostProcessor子类比较多，有4个拓展接口，共11个方法，这个11方法描述如下：

1、BeanPostProcessors是在实例化后，初始化方法执行前、后分别执行2个方法(这里的初始化方法是init-method或者实现了InitializingBean的afterPropertiesSet方法，一般这个玩意用于读取缓存文件，初始化信息等操作)。通过这个类我们可以轻松的自定义受spring管理的bean，就是可以对bean为所欲为！

2、InstantiationAwareBeanPostProcessor拓展了BeanPostProcessors接口，这个接口也是非常的牛掰，可以在实例化Bean前（调用postProcessBeforeInstantiation方法）、后(postProcessAfterInstantiation)提供扩展的回调接口。
postProcessBeforeInstantiation这个返回值可以用来代替原本该生成的目标对象的实例(比如代理对象)。如果该方法的返回值代替原本该生成的目标对象，后续只有postProcessAfterInitialization方法会调用然后就直接返回了。不会在进行后续操作(可以看下AbstractAutoProxyCreator AOP代理实现）。这个类还是有一个方法：postProcessPropertyValues，这个方法是bean实例化后填充属性的时候使用，
3.SmartInstantiationAwareBeanPostProcessor又拓展了InstantiationAwareBeanPostProcessor接口，主要是供spring内部使用
4. MergedBeanDefinitionPostProcessor，也是实例化后执行，主要将那些元数据缓存起来以提供后续的postProcessPropertyValues输入注入时获取。
5. DestructionAwareBeanPostProcessor，是对象销毁的前置回调。

5、三者执行顺序：BeanDefinitionRegistryPostProcessor优先于BeanFactoryPostProcessor执行，BeanFactoryPostProcessor优先于BeanPostProcessor执行。

三、Bean生命周期

参考spring源码注释 
1、BeanNameAware's setBeanName
2、BeanClassLoaderAware's setBeanClassLoader
3、BeanFactoryAware's setBeanFactory
4、EnvironmentAware's setEnvironment
5、EmbeddedValueResolverAware's setEmbeddedValueResolver
6、ResourceLoaderAware's setResourceLoader (only applicable when running in an application context)
7、ApplicationEventPublisherAware's setApplicationEventPublisher (only applicable when running in an application context)
8、MessageSourceAware's setMessageSource (only applicable when running in an application context)
9、ApplicationContextAware's setApplicationContext (only applicable when running in an application context)
10、ServletContextAware's setServletContext (only applicable when running in a web application context)
11、postProcessBeforeInitialization methods of BeanPostProcessors
12、InitializingBean's afterPropertiesSet
13、a custom init-method definition
14、postProcessAfterInitialization methods of BeanPostProcessors 


/**
* bean的生命周期：
*         bean创建---初始化----销毁的过程
* 容器管理bean的生命周期；
* 我们可以自定义初始化和销毁方法；容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法
*
* 构造（对象创建）
*         单实例：在容器启动的时候创建对象
*         多实例：在每次获取的时候创建对象\
*
* BeanPostProcessor.postProcessBeforeInitialization
* 初始化：
*         对象创建完成，并赋值好，调用初始化方法。。。
* BeanPostProcessor.postProcessAfterInitialization
* 销毁：
*         单实例：容器关闭的时候
*         多实例：容器不会管理这个bean；容器不会调用销毁方法；
*
*
* 遍历得到容器中所有的BeanPostProcessor；挨个执行beforeInitialization，
* 一但返回null，跳出for循环，不会执行后面的BeanPostProcessor.postProcessorsBeforeInitialization
*
* BeanPostProcessor原理
* populateBean(beanName, mbd, instanceWrapper);给bean进行属性赋值
* initializeBean
* {
* applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
* invokeInitMethods(beanName, wrappedBean, mbd);执行自定义初始化
* applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
*}
*
*
*
* 1）、指定初始化和销毁方法；
*         通过@Bean指定init-method和destroy-method；
* 2）、通过让Bean实现InitializingBean（定义初始化逻辑），
*                 DisposableBean（定义销毁逻辑）;
* 3）、可以使用JSR250；
*         @PostConstruct：在bean创建完成并且属性赋值完成；来执行初始化方法
*         @PreDestroy：在容器销毁bean之前通知我们进行清理工作
* 4）、BeanPostProcessor【interface】：bean的后置处理器；
*         在bean初始化前后进行一些处理工作；
*         postProcessBeforeInitialization:在初始化之前工作
*         postProcessAfterInitialization:在初始化之后工作
*
* Spring底层对 BeanPostProcessor 的使用；
*         bean赋值，注入其他组件，@Autowired，生命周期注解功能，@Async,xxx BeanPostProcessor;
*
*
*/

扩展原理

/**
* 扩展原理：
* BeanPostProcessor：bean后置处理器，bean创建对象初始化前后进行拦截工作的
*
* 1、BeanFactoryPostProcessor：beanFactory的后置处理器；
*         在BeanFactory标准初始化之后调用，来定制和修改BeanFactory的内容；
*         所有的bean定义已经保存加载到beanFactory，但是bean的实例还未创建
*
*
* BeanFactoryPostProcessor原理:
* 1)、ioc容器创建对象
* 2)、invokeBeanFactoryPostProcessors(beanFactory);
*         如何找到所有的BeanFactoryPostProcessor并执行他们的方法；
*             1）、直接在BeanFactory中找到所有类型是BeanFactoryPostProcessor的组件，并执行他们的方法
*             2）、在初始化创建其他组件前面执行
*
* 2、BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor
*         postProcessBeanDefinitionRegistry();
*         在所有bean定义信息将要被加载，bean实例还未创建的；
*
*         优先于BeanFactoryPostProcessor执行；
*         利用BeanDefinitionRegistryPostProcessor给容器中再额外添加一些组件；
*
*     原理：
*         1）、ioc创建对象
*         2）、refresh()-》invokeBeanFactoryPostProcessors(beanFactory);
*         3）、从容器中获取到所有的BeanDefinitionRegistryPostProcessor组件。
*             1、依次触发所有的postProcessBeanDefinitionRegistry()方法
*             2、再来触发postProcessBeanFactory()方法BeanFactoryPostProcessor；
*
*         4）、再来从容器中找到BeanFactoryPostProcessor组件；然后依次触发postProcessBeanFactory()方法
*     
* 3、ApplicationListener：监听容器中发布的事件。事件驱动模型开发；
*       public interface ApplicationListener<E extends ApplicationEvent>
*         监听 ApplicationEvent 及其下面的子事件；
*
*      步骤：
*         1）、写一个监听器（ApplicationListener实现类）来监听某个事件（ApplicationEvent及其子类）
*             @EventListener;
*             原理：使用EventListenerMethodProcessor处理器来解析方法上的@EventListener；
*
*         2）、把监听器加入到容器；
*         3）、只要容器中有相关事件的发布，我们就能监听到这个事件；
*                 ContextRefreshedEvent：容器刷新完成（所有bean都完全创建）会发布这个事件；
*                 ContextClosedEvent：关闭容器会发布这个事件；
*         4）、发布一个事件：
*                 applicationContext.publishEvent()；
*     
*  原理：
*      ContextRefreshedEvent、IOCTest_Ext$1[source=我发布的时间]、ContextClosedEvent；
*  1）、ContextRefreshedEvent事件：
*      1）、容器创建对象：refresh()；
*      2）、finishRefresh();容器刷新完成会发布ContextRefreshedEvent事件
*  2）、自己发布事件；
*  3）、容器关闭会发布ContextClosedEvent；
*  
*  【事件发布流程】：
*      3）、publishEvent(new ContextRefreshedEvent(this));
*              1）、获取事件的多播器（派发器）：getApplicationEventMulticaster()
*              2）、multicastEvent派发事件：
*              3）、获取到所有的ApplicationListener；
*                  for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
*                  1）、如果有Executor，可以支持使用Executor进行异步派发；
*                      Executor executor = getTaskExecutor();
*                  2）、否则，同步的方式直接执行listener方法；invokeListener(listener, event);
*                   拿到listener回调onApplicationEvent方法；
*  
*  【事件多播器（派发器）】
*      1）、容器创建对象：refresh();
*      2）、initApplicationEventMulticaster();初始化ApplicationEventMulticaster；
*          1）、先去容器中找有没有id=“applicationEventMulticaster”的组件；
*          2）、如果没有this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
*              并且加入到容器中，我们就可以在其他组件要派发事件，自动注入这个applicationEventMulticaster；
*  
*  【容器中有哪些监听器】
*      1）、容器创建对象：refresh();
*      2）、registerListeners();
*          从容器中拿到所有的监听器，把他们注册到applicationEventMulticaster中；
*          String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
*          //将listener注册到ApplicationEventMulticaster中
*          getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
*          
*   SmartInitializingSingleton 原理：->afterSingletonsInstantiated();
*           1）、ioc容器创建对象并refresh()；
*           2）、finishBeanFactoryInitialization(beanFactory);初始化剩下的单实例bean；
*               1）、先创建所有的单实例bean；getBean();
*               2）、获取所有创建好的单实例bean，判断是否是SmartInitializingSingleton类型的；
*                   如果是就调用afterSingletonsInstantiated();
*         
*
*
*/