spring源码解析

spring容器的refresh()  【创建刷新】
1、prepareRefresh(); 刷新前的预处理
  1.initPropertySources(); 初始化一些属性设置，子类自定义个性化的属性设置方法
  2.getEnvironment().validateRequiredProperties();检验属性的合法性
  3.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>(); 保存容器的一些早期的事件
2、ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();  获取 beanFactory
  1.refreshBeanFactory(); 刷新工厂
      创建this.beanFactory = new DefaultListableBeanFactory(); 并设置id
  2. getBeanFactory();返回GenericApplicationContext创建的BeanFactory对象
  3. 将创建的工厂DefaultListableBeanFactory 返回
3、prepareBeanFactory(beanFactory); BeanFactory的预准备工作(对BeanFactory进行一些设置)
   1.设置 BeanFactory的 类加载器，支持表达式解析器
   2.添加部分BeanPostProcessor 后置处理器 ApplicationContextAwareProcessor
   3.设置忽略的自动装配的接口 EnvironmentAware 、EmbeddedValueResolverAware 等等
   4.注册可以解析的自动装配 BeanFactory  ResourceLoader  ApplicationEventPublisher ApplicationContext
   5.添加部分BeanPostProcessor 后置处理器 ApplicationListenerDetector
   6.添加编译时的aspect 支持
   7.给容器中注入一些能用的组件 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 方法：
      1.获取所有的 BeanDefinitionRegistryPostProcessor
      2.看优先级排序 PriorityOrdered --  Ordered -- 最后执行所有 invokeBeanDefinitionRegistryPostProcessors-->postProcessor.postProcessBeanDefinitionRegistry(registry);
      3.然后获取所有的 BeanFactoryPostProcessor  执行优先级同2 invokeBeanFactoryPostProcessors-->postProcessor.postProcessBeanFactory(beanFactory);

6、registerBeanPostProcessors(beanFactory); 注册bean的后置处理器
   不同接口类型的BeanPostProcessor 在bean创建前后的执行时机是不一样的
   BeanPostProcessor
   DestructionAwareBeanPostProcessor
   InstantiationAwareBeanPostProcessor
   MergedBeanDefinitionPostProcessor
   SmartInstantiationAwareBeanPostProcessor

   1.获取所有的BeanPostProcessor；后置处理器都默认有 优先级 PriorityOrdered --  Ordered
   2.先注册PriorityOrdered 优先级接口的BeanPostProcessor
     把每个BeanPostProcessor添加到BeanFactory中  registerBeanPostProcessors --> beanFactory.addBeanPostProcessor(postProcessor);
   3.再注册   Ordered
   4.后注册 没有实现任何接口的
   5.最终注册MergedBeanDefinitionPostProcessor
   6.最终注册一个ApplicationListenerDetector 来在bean创建完成后检查是否是ApplicationListener，如果是的话执行
     applicationContext.addApplicationListener((ApplicationListener<?>) bean);

7、initMessageSource();   初始化MessageSource组件 （做国际化功能；消息绑定，消息解析）
   1.beanFactory = getBeanFactory();
   2.判断是否有id为messageSource类型为MessageSource的组件
     如果有赋值给messageSource 如果没有创建DelegatingMessageSource
     MessageSource：取出国际化配置文件中某个key的值，能按照区域信息获取
     beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource); 注入到容器中

8、initApplicationEventMulticaster(); 初始化事件派发器，在注册监听时会使用
    1.beanFactory = getBeanFactory();
    2.从BeanFactory中获取ApplicationEventMulticaster
    3.如果没有配置，就创建一个 SimpleApplicationEventMulticaster
    4.将创建的ApplicationEventMulticaster 添加到BeanFactory中，以后其他组件直接自动注入

9、onRefresh(); 空壳方法 -- 子类可以去实现，在容器刷新的时候可以自定义逻辑，web场景下会使用
   1.子类重写，在容器刷新的时候可自定义逻辑

10、registerListeners(); 将项目里所有的ApplicationListener注册到容器中
    1.getApplicationListeners() 从容器中获取所有的ApplicationListener
    2.将每个监听器添加到派发器中
    getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);

11、finishBeanFactoryInitialization(beanFactory); 初始化所有的剩下的单实例bean
    1.beanFactory.preInstantiateSingletons();
      1.拿到所有的bean的定义信息名称，依次进行初始化
      2.获取bean的 RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
      3.判断是否是abstract，singleton lazy
        1.判断是否是FactoryBean，是否实现FactoryBean接口的bean
        2.不是工厂bean，利用getBean(beanName); 创建对象
           --doGetBean(beanName)
             1.getSingleton(beanName) 先获取缓存中保存的单实例bean，如果获取到说明这个bean之前创建过==三级缓存
                singletonObjects
             2.缓存中获取不到，开始Bean的创建：
             3.markBeanAsCreated(beanName); 标记已经创建
             4.获取bean定义信息getMergedLocalBeanDefinition(beanName);
             5.获取当前bean依赖的其他bean==>mbd.getDependsOn();如果有，使用getBean(dep); 把依赖的bean先创建出来
             6.启动单实例bean的创建：
               createBean(beanName, mbd, args);
               1.resolveBeforeInstantiation(beanName, mbdToUse);如果bean配置了实例化的后置处理器 则返回对应的代理对象
                 【InstantiationAwareBeanPostProcessors】：提前执行：
                    触发：bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                    如果bean不为空则 触发 bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
               2.【doCreate】如果InstantiationAwareBeanPostProcessors没有返回对象，则调用
                  Object beanInstance = doCreateBean(beanName, mbdToUse, args);
                  1>instanceWrapper = createBeanInstance(beanName, mbd, args);
                    利用工厂方法或者构造器创建bean实例
                  2>applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); 调用【MergedBeanDefinitionPostProcessor】
                     的方法bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
                  3>populateBean(beanName, mbd, instanceWrapper);  属性赋值
                     赋值之前,遍历所有的后置处理器
                     A: 如果【InstantiationAwareBeanPostProcessor】 则postProcessAfterInstantiation
                     B: 如果【InstantiationAwareBeanPostProcessor】 则postProcessPropertyValues
                     C:applyPropertyValues 为属性赋值
                  4> bean初始化：exposedObject = initializeBean(beanName, exposedObject, mbd);
                     A:invokeAwareMethods(beanName, bean); 执行aware接口的方法
                     B:wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); --执行所有后置处理器的before方法
                       processor.postProcessBeforeInitialization(result, beanName);
                     C:invokeInitMethods(beanName, wrappedBean, mbd); 初始化方法
                       是否是InitializingBean接口的实现，执行接口规定的初始化
                       是否是自定义初始化方法
                     D:wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); --执行后置处理器的after方法
                   5>  Object earlySingletonReference = getSingleton(beanName, false); 获取初始化的bean
                   6> 注册bean的销毁方法registerDisposableBeanIfNecessary(beanName, bean, mbd);
                3.DefaultSingletonBeanRegistry#getSingleton.addSingleton(beanName, singletonObject); 将创建的bean添加到singletonObjects

        3.所有bean都利用getBean()创建完成后:
         检查所有的bean是否是SmartInitializingSingleton,如果是的话执行smartSingleton.afterSingletonsInstantiated();


12、finishRefresh();完成BeanFactory的初始化创建工作：
    1.initLifecycleProcessor(); 初始化和生命周期有关的后置处理器LifecycleProcessor
    写一个LifecycleProcessor实现类，可以在BeanFactory 的 onRefresh() 和 onClose() 调用
    2.getLifecycleProcessor().onRefresh(); 拿到定义的生命周期处理器 回调onRefresh方法
    3.publishEvent(new ContextRefreshedEvent(this));发布容器刷新完成事件 
    4.LiveBeansView.registerApplicationContext(this);