Spring加载过程

刷新前的预处理：PrepareRefresh()

  • initPropertySources()初始化一些属性设置
  • getEnvironment().validateRequiredProperties(); 检验属性的合法等
  • earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>; 保存容器中的一些早期事件

获取BeanFactory：obtainFreshBeanFactory();

  • refreshBeanFactory(); 刷新【创建】BeanFactory
  • getBeanFactory(); 返回刚才GenericApplicationContext创建的BeanFactory对象
  • 将创建的BeanFactory对象【DefaultListableBeanFactory】返回

BeanFactory的预备准备工作（BeanFactory进行一些设置）：prepareBeanFactory(beanFactory);

  • 设置BeanFactory的类加载器、支持表达式解析器
  • 添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
  • 设置忽略的自动装配的接口 EnvironmentAware、EmbeddedValueResolverAware。。。
  • 注册可以解析的自动装配，我们能直接在任何组件中自动注入：BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
  • 添加BeanPostProcessor,【ApplicationListenerDetector】
  • 添加编译时的AspectJ支持
  • 给BeanFactory中注册一些能用的组件：environment【ConfigurableEnvironment】、SystemProperties【Map<String, Object>】、　　 systemEnvironment【Map<String, Object>】

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

  • 子类通过这个方法在BeanFactory创建并预准备完成后做的进一步设置

以上是BeanFactory的创建和预准备工作

执行BeanFactoryPostProcessor：invokeBeanFactoryPostProcessor(beanFactory);

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

两个接口：BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor

  • 执行BeanFactoryPostProcessor的方法：
    • 先执行BeanDefinitionRegistryPostProcessor
      • 获取所有的BeanDefinitionRegistryPostProcessor
      • 先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor
        • 执行方法postProcessor.postProcessBeanDefinitionRegistry(registry)
      • 再执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor
        • 执行方法postProcessor.postProcessBeanDefinitionRegistry(registry)
      • 最后执行没有实现任何优先级或者是顺序接口的BeanDefinitionRegistryPostProcessor
        • 执行方法postProcessor.postProcessBeanDefinitionRegistry(registry)
    • 再执行BeanFactoryPostProcessor的方法
      • 获取所有的BeanFactoryPostProcessor
      • 先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor
        • 执行方法postProcessor.postProcessBeanFactory(registry)
      • 再执行实现了Ordered顺序接口的BeanFactoryPostProcessor
        • 执行方法postProcessor.postProcessBeanFactory(registry)
      • 最后执行没有实现任何优先级或者是顺序接口的BeanFactoryPostProcessor
        • 执行方法postProcessor.postProcessBeanFactory(registry)

注册BeanPostProcessor（Bean的后置处理器）：registerBeanPostProcessor(beanFactory);

不同接口类型的BeanPostProcessor：在Bean创建前后的执行时机是不一样的

  • BeanPostProcessor
  • DestructionAwareBeanPostProcessor
  • InstantiationAwareBeanPostProcessor
  • SmartInstantiationAwareBeanPostProcessor
  • MergedBeanDefinitionPostProcessor

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

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

把每一个BeanPostProcessor添加到BeanFactory中

beanFactory.addBeanPostProcessor(postProcessor)

3) 再注册Ordered优先级接口的BeanPostProcessor

4) 然后再注册没有任何优先级接口的BeanPostProcessor

5) 最终注册MergedBeanDefinitionPostProcessor

6) 注册一个ApplicationListenerDetector：再Bean创建完成后检查是否是ApplicationListener，如果是则执行

applicationContext.addApplicationListener((ApplicationListener<?>) bean)

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

1) 获取BeanFactory

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

如果有就赋值给messageSource，如果没有就自己创建一个DelegatingMessageSource;

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

3) 把创建好的messageSource注册到容器中，以后获取国际化配置文件的时候，可以自动注入MessageSource ，然后可以再调用它的getMessage方法beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource)

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

1) 获取BeanFactory

2) 从BeanFactory中获取applicationEventMulticaster的ApplicationEventMulticaster

3) 如果上一步没有配置，那就会自己创建一个SimpleApplicationEventMulticaster，然后将创建的ApplicationEventMulticaster 组件添加到BeanFactory中，以后其他组件可以直接注入

留给子容器(子类)：onRefresh();

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

将项目中所有ApplicationListener注册进容器中：registerListeners();

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

2) 将每个监听器添加到事件派发器中getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName)

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

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

  • beanFactory.preInstantiateSingletons();初始化所有剩下的单实例Bean
    • 获取容器中的所有bean, 依次进行初始化和创建对象
    • 获取Bean的定义信息；RootBeanDefinition
    • Bean不是抽象的，是单实例的，且不是懒加载的，
      • 判断是不是FactoryBean；是否是实现FactoryBean接口的Bean
      • 如果不是FactoryBean；使用getBean(beanName)创建对象
        • getBean(beanName) -> ioc.getBean();
        • doGetBean(name, null, null, false)
        • 先获取缓存中保存的单实例Bean。如果能获取到，说明这个Bean之前被创建过（所有创建过的单实例Bean 都会被缓存起来）从singletonObjects中获取
        • 缓存中获取不到，开始Bean的创建对象流程；
        • 标记当前Bean已经被创建
        • 获取Bean的定义信息
        • 获取当前Bean依赖的其它Bean；如果有，还是按照getBean()把依赖的Bean先创建出来
        • 启动单实例Bean的创建流程
          • createBean(beanName, mbd, args);
          • Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            • 让BeanPostProcessor先拦截返回代理对象；
            • InstantiationAwareBeanPostProcessor提前执行
            • 先触发：postProcessBeforeInstantiation();
            • 如果有返回值；再触发postProcessAfterInstantiation()
          • 如果前面的InstantiationAwareBeanPostProcessor 没有返回代理对象；调用Object beanInstance = doCreateBean(beanName, mbdToUse, args)创建Bean
            • 创建Bean实例，createBeanInstance(beanName, mbd, args)利用工厂方法或者对象的构造器创建出Bean实例
            • applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName) 调用MergedBeanDefinitionPostProcessor``的postProcessMergedBeanDefinition(mbd, beanType, beanName)
            • 给Bean属性赋值，调用populateBean(beanName, mbd, instanceWrapper)
              • 赋值之前：
                • 拿到InstantiationAwareBeanPostProcessor后置处理器
                  • 执行postProcessAfterInstantiation()
                • 拿到InstantiationAwareBeanPostProcessor后置处理器
                  • 执行postProcessPropertyValues()
                • 应用Bean属性的值：为属性利用setter方法进行赋值（反射）
                  • applyPropertyValues(beanName, mbd, bw, pvs)
            • 初始化Bean；initializeBean(beanName, exposedObject, mbd);
              • 执行Aware接口方法：invokeAwareMethods(beanName, bean);执行xxxAware接口的方法
                • BeanNameAware、BeanClassLoaderAware、BeanFactoryAware
              • 执行后置处理器初始化之前：applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName)
                • BeanPostProcessor.postProcessBeforeInitialization()
              • 执行初始化方法：invokeInitMethods(beanName, wrappedBean, mbd)
                • 是否是InitializingBean接口的实现：执行接口规定的初始化
                • 是否自定义初始化方法
              • 执行后置处理器初始化之后：applyBeanPostProcessorsAfterInitialization
                • BeanPostProcessor.postProcessAfterInitialization()
              • 注册Bean的销毁方法
            • 将创建的Bean添加到缓存中 - singletonObjects（Map对象）

IOC容器就是这些Map；很多的Map里保存了单实例Bean，环境信息、、、

所有Bean都利用getBean创建完成以后；再来检查所有Bean是否是SmartInitializingSingleton接口的实现类，

如果是，就执行afterSingletonsInstantiated();

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

  • initLifecycleProcessor(); 初始化和生命周期相关的后置处理器；LifecycleProcessor
    • 默认从容器中找是否有lifecycleProcessor的组件(LifecycleProcessor)
    • 如果没有，创建/使用默认的生命周期组件new DefaultLifecycleProcessor();再加入到容器中；
    • 写一个LifecycleProcessor的实现类，可以在BeanFactory的下面两个方法刷新和关闭前后进行拦截调用
      • onRefresh()
      • onClose()
  • getLifecycleProcessor().onRefresh();
    • 拿到前面定义的生命周期处理器（BeanFactory）；回调.onRefresh();
  • publishEvent(new ContextRefreshedEvent(this)); 发布容器刷新完成时间；
  • liveBeansView.registerApplicationContext();

总结

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

results matching ""

    No results matching ""