Spring初始化容器与创建bean的过程

Spring容器的创建以及级初始化过程

通过使用AnnotationConfigApplicationContext这个类来创建一个bean容器，我们从这个类进去看看，Spring怎么给我们来创建对象的

Spring容器的refresh（）【创建刷新】

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

       1）initPropertySources();初始化一些属性设置，留给子类来初始化信息，在子类自定义个性化的属性设置方式

       2）getEnviornment().validateRequiredProperties();检验属性的合法

       3）earlyApplicationEvents=new LinkedHashSet<Application>();保存容器中的一些时间，由事件派发器发送事件

2、obtainFreshBeanFactory();获取BeanFactory;

      1）refreshBeanFactory();刷新【创建】BeanFacory

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

             设置id

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

      3）将创建的BeanFactory【DefaultListenerBeanFactory】返回

3、prepareBeanFactory(beanFactory)；BeanFactory的预备工作（Beanfactory进行一些设置）

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

      2）添加部分BeanFactoryProcessor

      3）设置忽略自动装配的接口EnvironmentAware、

     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、invokeBeanFactoryPostProcessor(beanFactory);执行BeanFactoryPostProcessor

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

     两个接口：BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor

     1）、按优先级执行Bean一些Processor

6、registerBeanPostProcessors（beanFactory）;注册BeanPostProcessor（Bean的后置处理器）【interceptor】

     不同接口类型的BeanProcessor，在Bean创建后的执行时机是不一样的

     获取一些Processor并执行

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

     1）获取BeanFactory

     2）看容器中是否有id为messageSource的，类型是MessageSource的组件

     3）创建MessageSource注册在容器中

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.preInstantiatteSingletons()；初始化后剩下的单实例bean

                  1）获取bean容器中的所有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>()

                                      3、缓存中获取不到、开始Bean的创建对象流程

                                       4、标记当前bean已经被创建（多线程）

                                       5、获取Bean的定义信息

                                       6、获取当前Bean依赖的其他Bean；如果有按照getBean()把依赖的Bean先创建出来

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

                                                  1）createBean(beanName,mbd,args);

                                                   2）Object bean=resolveBeforeInstantiation(beanName,mbdToUse)，让Bean

                                                           【InstantiationAwareBeanPostProcessor】：提前执行

                                                            先触发：postProcessorBeforeInstantiation();

                                                             如果有返回值：触发postProcessorAfterInitiazation()；让BeanPostProcessor先拦截返回代理对象

                                                    3）如果前面的InstantiationAwareBeanPostProcessor没有返回代理对象，调用4）

                                                     4）Object  beanInstance=doCreateBean(beanName，mbdToUse，args)；创建Bean

                                                                1）创建Bean实例；createBeanInstance(beanName，mbd，args)

                                                                       利用工程方法或者对象的构造器创建出Bean实例  

                                                                2）、applyMergedBeanDefinitionPostProcessor(mbd，beanType，beanName)；

                                                                          调用MergedBeanDefinitionPostProcessor的bdp.postProcessorMergedBeanDefinition(mbd，beanType，beanName)；

                                                               3）  【Bean属性赋值】populateBean(beanName,mbd,instanceWapper) ；

                                                                        1）拿到InstantiationAwareBeanPostProcessor后置处理器，postProcessorInstantiation()；

                                                                          postProcessorAfterINstantiation()；

                                                                        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）【执行后置处理器初始化之前】applyBeanPostProcessorBeforeINitialization（wrappedBean,bean）

                                                                                      BeanPostProcessor.postProcessorBeforeInitialization（）；

                                                                             3）【执行初始化方法】invokeInitMethods(beanName，wrappedBean，mbd)；

                                                                                       1）是否是InitializingBean接口的实现，执行接口规定的初始化

                                                                                        2）是否自定义初始化方法

                                                                               4）【执行后置处理器初始化之后】applyBeanPostProcessorAfterInitialization

                                                                                        BeanPostProcessor.postProcessorAfterINitialization（）

                                                                     5）注册Bean的销毁方法

                                                              5）将创建的Bean添加到缓存中singleonObjects

                                                      ioc容器就是这些Map，很多Map里面保存了单实例Bean，环境信息

                                              所有Bean的都利用getBean创建完成后

                                                     检查所有的Bean是否是SmartInitializingSingleton接口的，如果是，就执行afterSingletonInstantiated()

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

          1)、initLifecycleProcessor()；初始化和生命周期有关的后置处理器；lifecycleProcessor

                 默认从容器中找是否有lifecycleProcessor的组件【LifecycleProcessor】；如果没有new DefaultlifecycleProcessor

                加入到容器

                 写一LifecycleProcessor的实现类，可以在BeanFactory

                   void onRefresh()

                   void onClose()

            2)、getLifecycleProcessor().onRefresh()；

                    拿到前面定义的生命周期处理器（BeanFactory）;回调onRefresh();

            3）publishEvent(new ContextRefreshEvent(this))；发布容器刷新完成事件

            4）iveBeanView.registerApplicationContext(this)

 

=================总结====================

       1）spring容器在启动的时候，先会保存所有注册进来的Bean的定义信息

               1）xml注册bean；<bean>

                2）注解注册Bean；@Service、@Component、@Bean、XXX

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

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

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

         3）后置处理器；

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

                         AutowiredAnnotationBeanPostProcessor：处理自动注入

                         AnnotationAwareAspectJAutoProxyCreator：来做AOP功能

                         增强的功能注解

                         AsyncAnnotationBeanPostProcessor

          4）事件驱动模型；

              ApplicationListener：事件监听

               ApplicationEventMulticaster事件派发