Spring容器的的refresh()

/ Spring技术笔记 / 0 条评论 / 271浏览

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

refresh()源码

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

        // 刷新前的预处理
        prepareRefresh();

        // 获取BeanFactory
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // BeanFactory的预处理工作,对BeanFactory进行一些赋值设置
        prepareBeanFactory(beanFactory);

        try {
            // BeanFactory准备工作完成后进行的后置处理工作
            postProcessBeanFactory(beanFactory);
            
            StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
            // 注册BeanFactory的后置处理器,执行BeanFactoryPostProcessor方法
            invokeBeanFactoryPostProcessors(beanFactory);

            // 注册Bean的后置处理器,用于拦截Bean的整个创建过程
            registerBeanPostProcessors(beanFactory);
            beanPostProcess.end();

            // 初始化MessageSource组件(做国际化功能,消息绑定,消息解析)
            initMessageSource();

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

            // 留给子容器(子类)重写,在刷新上下文时自定义逻辑
            onRefresh();

            // 将项目中所有的ApplicationListener注册到容器中
            registerListeners();

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

            // 完成BeanFactory的初始化创建工作,IOC容器就创建完成
            finishRefresh();
    }
}

BeanFactory的创建及预准备工作

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

  1. initPropertySources(); 初始化一些属性设置(空),子类可实现后自定义个性化的属性设置方法
  2. getEnvironment().validateRequiredProperties(); 校验属性的合法等
  3. this.earlyApplicationEvents = new LinkedHashSet<>(); 保存容器中的一些早期的事件

2. obtainFreshBeanFactory(); 获取BeanFactory

  1. refreshBeanFactory(); 刷新【创建】BeanFactory对象
    1. 创建一个bean工厂
    public GenericApplicationContext() {
        this.beanFactory = new DefaultListableBeanFactory();
    }
2. 设置id
  1. getBeanFactory(); 返回刚才GenericApplicationContext创建的BeanFactory对象
  2. 将创建的BeanFactory【DefaultListableBeanFactory】返回

3. prepareBeanFactory(beanFactory); BeanFactory的预处理工作,对BeanFactory进行一些赋值设置

  1. 设置BeanFactory的类加载器、支持表达式解析器...
  2. 添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
  3. 设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、ResourceLoaderAware、、ApplicationEventPublisherAware、MessageSourceAware、ApplicationContextAware、ApplicationStartupAware
  4. 注册可以解析的自动装配,使我们能够在任何组件中自动注入(@Autowired)。BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
  5. 添加部分BeanPostProcessor【ApplicationListenerDetector】
  6. 添加编译时的AspectJ
  7. 给BeanFactory注册一些能用的组件
    1. environment ConfigurableEnvironment
    2. systemProperties Map<String, Object>
    3. systemEnvironment Map<String, Object>
    4. applicationStartup ApplicationStartup

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

  1. 子类可以重写此方法在BeanFactory创建并预准备完成以后做进一步的设置。

BeanFactory后面的流程

5. invokeBeanFactoryPostProcessors(beanFactory); 注册BeanFactory的后置处理器,执行BeanFactoryPostProcessor方法

源代码位于:PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors()

BeanFactoryPostProcessor:

  1. BeanFactory的后置处理器
  2. 在BeanFactory标准初始化之后执行
  3. 拥有两个接口
    1. BeanFactoryPostProcessor
    2. BeanDefinitionRegistryPostProcessor

执行BeanFactoryPostProcessor方法

子接口[BeanDefinitionRegistryPostProcessor]具有最高优先级,其次再执行BeanFactoryPostProcessor的方法

先执行BeanDefinitionRegistryPostProcessor的方法

  1. 获取所有的BeanDefinitionRegistryPostProcessor
  2. 先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor
    1. postProcessor.postProcessBeanDefinitionRegistry(registry);
  3. 再执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor
    1. postProcessor.postProcessBeanDefinitionRegistry(registry);
  4. 最后执行没有实现任何优先级或顺序接口的BeanDefinitionRegistryPostProcessor
    1. postProcessor.postProcessBeanDefinitionRegistry(registry);

再执行BeanFactoryPostProcessor的方法

  1. 获取所有的BeanFactoryPostProcessor
  2. 先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor
    1. postProcessor.postProcessBeanFactory(beanFactory);
  3. 再执行实现了Ordered顺序接口的BeanFactoryPostProcessor
    1. postProcessor.postProcessBeanFactory(beanFactory);
  4. 最后执行没有实现任何优先级或顺序接口的BeanFactoryPostProcessor
    1. postProcessor.postProcessBeanFactory(beanFactory);

6. registerBeanPostProcessors(beanFactory); 注册Bean的后置处理器,用于拦截Bean的整个创建过程

源代码位于:PostProcessorRegistrationDelegate#registerBeanPostProcessors()

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

  1. BeanPostProcessor
  2. DestructionAwareBeanPostProcessor
  3. InstantiationAwareBeanPostProcessor
  4. SmartInstantiationAwareBeanPostProcessor
  5. MergedBeanDefinitionPostProcessor【internalPostProcessors】

执行过程

  1. 获取所有的BeanPostProcessor;后置处理器都默认可以通过PriorityOrdered、Ordered接口来实现优先级排序
  2. 先注册PriorityOrdered优先级排序接口的BeanPostProcessor 把每一个BeanPostProcessor都添加到BeanFactory中
private static void registerBeanPostProcessors(
        ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {

    if (beanFactory instanceof AbstractBeanFactory) {
        // Bulk addition is more efficient against our CopyOnWriteArrayList there
        ((AbstractBeanFactory) beanFactory).addBeanPostProcessors(postProcessors);
    }
    else {
        for (BeanPostProcessor postProcessor : postProcessors) {
            beanFactory.addBeanPostProcessor(postProcessor);
        }
    }
}
  1. 再注册Ordered接口的
  2. 再注册没有实现任何优先级接口的
  3. 最后注册MergedBeanDefinitionPostProcessor【internalPostProcessors】
  4. 最终注册一个ApplicationListenerDetector;再Bean创建完后检查是否是ApplicationListener,如果是则将其注册到上下文中 applicationContext.addApplicationListener((ApplicationListener<?>) bean);

7. initMessageSource();初始化MessageSource组件(做国际化功能,消息绑定,消息解析)

MessageSource按照区域,取出国际化配置文件中的某个key的值

  1. getBeanFactory();获取BeanFactory
  2. 判断容器中是否有id=messageSource的组件,类型=MessageSource
    1. 如果有,赋值给变量messageSource
    2. 如果没有,自己创建一个DelegatingMessageSource
  3. 把创建好的MessageSource注册到容器中,后续可依赖注入 beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);

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

  1. 获取BeanFactory
  2. 从BeanFactory中获取ApplicationEventMulticaster的ApplicationEventMulticaster
  3. 将创建的ApplicationEventMulticaster添加到BeanFactory中,后续可依赖注入

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

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

10. registerListeners();将项目中所有的ApplicationListener注册到容器中

  1. 从applicationListeners属性中拿到之前步骤中所有的ApplicationListener,注册到事件派发器中
  2. 从容器中拿到所有的ApplicationListener,注册到事件派发器中 getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
  3. 派发(调用)之前步骤产生的事件 getApplicationEventMulticaster().multicastEvent(earlyEvent);

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

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

11.1.1 获取容器中的所有bean,依次进行初始化和创建对象

List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
for (String beanName : beanNames) {

11.1.2 获取bean的定义信息RootBeanDefinition

RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);

11.1.3 Bean不是抽象的,是单实例的,不是懒加载的

!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()

11.1.3.1 判断是否是FactoryBean,是否是实现FactoryBean接口的bean
  1. 如果是,则利用FactoryBean接口的FactoryBean#getObject获取对象
  2. 如果不是,利用getBean(beanName)创建对象 0. getBean(beanName) -> 与ApplicationContext#getBean一致
    1. doGetBean(name, null, null, false);
    2. 先获取缓存中保存的单实例bean,如果能获取到,说明之前被创建过。(所有创建过的单实例Bean都会被缓存起来)
    3. getSingleton(beanName, true); private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
    4. 缓存中获取不到,开始创建对象流程
    5. 标记当前bean已被创建 markBeanAsCreated(beanName);
    6. 获取Bean的定义信息 RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
    7. 获取当前Bean依赖的其他bean,如果有按照getBean()把依赖的Bean先创建出来
    String[] dependsOn = mbd.getDependsOn();
        if (dependsOn != null) {
            for (String dep : dependsOn) {
                ...
                registerDependentBean(dep, beanName);
                getBean(dep);
                ...
            }
        }
    
    1. 启动单实例Bean的创建流程 mbd.isSingleton()
      1. getSingleton(String beanName, ObjectFactory<?> singletonFactory)
      2. createBean(beanName, mbd, args);
      3. resolveBeforeInstantiation(beanName, mbdToUse); 让BeanPostProcessor先提前拦截返回Bean代理对象 【InstantiationAwareBeanPostProcessor】: 提前执行 先触发:Object result = bp.postProcessBeforeInstantiation(beanClass, beanName); 如果有返回值,再触发:processor.postProcessAfterInitialization(result, beanName);
      4. Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        1. 【创建Bean实例】:createBeanInstance(beanName, mbd, args); 利用工厂方法或者对象的构造器创建出Bean实例
        2. applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); 调用【MergedBeanDefinitionPostProcessor】的processor.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, wrappedBean, mbd);执行XXX_Aware接口为Aware属性赋值 BeanNameAware/BeanClassLoaderAware/BeanFactoryAware
          2. 【执行后置处理器初始化之前】applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); processor.postProcessBeforeInitialization(result, beanName);
          3. 【执行初始化方法】invokeInitMethods(beanName, wrappedBean, mbd);
            1. 是否是InitializingBean接口的实现,执行接口规定的初始化方法
            2. 是否有自定义初始化方法 String initMethodName = mbd.getInitMethodName();
          4. 【执行后置处理器初始化之后的方法】applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); processor.postProcessAfterInitialization(result, beanName);
        5. 【注册bean的销毁方法】registerDisposableBeanIfNecessary(beanName, bean, mbd); 实现DisposableBean接口
      5. 将创建的bean添加到缓存DefaultSingletonBeanRegistry#addSingleton

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

  1. clearResourceCaches(); 清除上下文级别的资源缓存

  2. initLifecycleProcessor();初始化和生命周期有关的后置处理器:LifecycleProcessor

    1. 默认从容器中找是否存在名为lifecycleProcessor的组件[LifecycleProcessor],如果没有就创建new DefaultLifecycleProcessor();,然后加入到容器中
    2. 自定义实现LifecycleProcessor接口,可以接收到两个回调
      1. void onRefresh(); - 上下文刷新的通知
      2. void onClose(); - 上下文关闭的通知
  3. getLifecycleProcessor().onRefresh(); 拿到刚才获取的生命周期处理器,回调onRefresh()事件

  4. publishEvent(new ContextRefreshedEvent(this)); - 发布容器刷新完成事件

总结

  1. 在Spring启动时,先会保存所有注册进来的Bean定义信息
    1. xml注册
    2. @Bean、@Component...
  2. Spring会在适当的时候创建对应的Bean
    1. 用到这个bean的时候,利用getBean创建
    2. 启动时统一创建剩下的所有Bean,finishBeanFactoryInitialization(beanFactory)
  3. 后置处理器 BeanPostProcessor
    1. 每一个Bean创建完成后,都会使用各种后置处理器增强Bean的功能
      1. AutowiredAnnotationBeanPostProcessor: 处理自动注入
      2. AsyncAnnotationBeanPostProcessor: 处理异步
      3. AnnotationAwareAspectJAutoProxyCreator: 处理AOP
  4. 事件驱动模型
    1. ApplicationListener:事件监听
    2. AnnotationAwareAspectJAutoProxyCreator:事件派发器