Spring源码解析之refresh方法

ZhaoHP
84 阅读4分钟

refresh方法

大概流程

  1. 处理占位符属性，验证属性，初始化listeners和events
  2. 获取beanFactory，对于XML配置的会在此处解析和注册BeanDefinition
  3. 对beanFactory做一些加工，添加后置处理器等
  4. 调用BeanFactoryPostProcessor，这时里面只有一个PostProcessor【ConfigurationClassPostProcessor】，用于解析和注册BeanDefinition
  5. 注册和实例化所有的BeanPostProcessor
  6. 初始化MessageSource
  7. 初始化事件广播器
  8. 子类扩展refresh，添加一些特殊的Bean
  9. 向事件广播器中注册ApplicationListener
  10. 创建单例Bean
  11. 结束refresh，发布ContextRefreshedEvent事件

完整代码

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

        /*
            处理占位符属性，验证属性，初始化listeners和events
            将active标签修改为"true"，表示已经激活
        */
        prepareRefresh();

        /*
            通知子类内部刷新beanFactory
        */
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        /*
            预处理beanFactory
        */
        prepareBeanFactory(beanFactory);

        try {
            /*
                一个空方法，由其子类自己实现。主要用于对beanFactory做一些后置处理
            */
            postProcessBeanFactory(beanFactory);

            StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
            
            /*
                执行所有的BeanFactoryPostProcessor
            */
            invokeBeanFactoryPostProcessors(beanFactory);

            /*
                注册所有的BeanPostProcessor
            */
            registerBeanPostProcessors(beanFactory);
            beanPostProcess.end();

            /*
                初始化MessageSource，项目中比较少用到
            */
            initMessageSource();

            /*
                初始化一个事件广播器
            */
            initApplicationEventMulticaster();

            /*
            	初始化其他上下文中的特殊Bean，由子类实现
            */
            onRefresh();

            /*
                注册所有的事件监听器
            */
            registerListeners();

            /*
                初始化剩余的Bean
            */
            finishBeanFactoryInitialization(beanFactory);

            /*
            	发布初始化完成事件
            */
            finishRefresh();
        }

        catch (BeansException ex) {
            if (logger.isWarnEnabled()) {
                logger.warn("Exception encountered during context initialization - " +
                        "cancelling refresh attempt: " + ex);
            }

            /*
                发生异常，销毁已创建的Bean
            */
            destroyBeans();

            /*
                重置active标签
            */
            cancelRefresh(ex);

            /*
                向上抛出异常
            */
            throw ex;
        }

        finally {
            /*
                清除各种各样的缓存
            */
            resetCommonCaches();
            contextRefresh.end();
        }
    }
}

部分方法解析

invokeBeanFactoryPostProcessors方法

本方法会先执行【BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry】后置处理器，再执行【BeanFactoryPostProcessor#postProcessBeanFactory】

public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

    Set<String> processedBeans = new HashSet<>();

    if (beanFactory instanceof BeanDefinitionRegistry registry) {

        // 省略部分不重要代码...
        /*
            获取实现了PriorityOrder接口的BeanDefinitionRegistryPostProcessor
        */
        String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        registryProcessors.addAll(currentRegistryProcessors);
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
        currentRegistryProcessors.clear();

        /*
            获取实现了Ordered接口的BeanDefinitionRegistryPostProcessor
        */
        postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
            if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        registryProcessors.addAll(currentRegistryProcessors);
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
        currentRegistryProcessors.clear();

        /*
            获取其他所有的BeanDefinitionRegistryPostProcessor
        */
        boolean reiterate = true;
        while (reiterate) {
            reiterate = false;
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
                if (!processedBeans.contains(ppName)) {
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                    reiterate = true;
                }
            }
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
            currentRegistryProcessors.clear();
        }

        /*
            BeanDefinitionRegistryPostProcessor继承了BeanFactoryPostProcessor接口
            此处是调用即实现了BeanFactoryPostProcessor的回调接口
        */
        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
    } else {
        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    }

    /*
        获取所有BeanFactoryPostProcessor的BeanName集合，并按照实现了PriorityOrdered、Ordered接口，和没实现接口放到不同的集合中
    */
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
    for (String ppName : postProcessorNames) {
        if (processedBeans.contains(ppName)) {
            // skip - already processed in first phase above
        } else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        } else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    /*
        回调实现了PriorityOrdered接口的BeanFactoryPostProcessor#postProcessBeanFactory
    */
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

    /*
        回调实现了Ordered接口的BeanFactoryPostProcessor#postProcessBeanFactory
    */
    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
    for (String postProcessorName : orderedPostProcessorNames) {
        orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

    /*
        回调其余的BeanFactoryPostProcessor#postProcessBeanFactory
    */
    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
    for (String postProcessorName : nonOrderedPostProcessorNames) {
        nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

}

registerBeanPostProcessors方法

此方法注册并初始化了BeanPostProcessor，之所以在此处初始化是因为BeanPostProcessor是干预Bean的创建过程的，所以必须在bean实例化之前就实例化所有的BeanPostProcessor

public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

    /*
        获取所有BeanPostProcessor的BeanName集合
    */
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
    
    /*
        添加BeanPostProcessorChecker（主要是当BeanPostProcessor不符合规范时记录信息）
    */
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, postProcessorNames, beanProcessorTargetCount));

    /*
        初始化BeanPostProcessor
        将实现了PriorityOrdered接口、实现了Ordered接口、未实现任何排序接口和MergedBeanDefinitionPostProcessor后置处理器的分别放到不同的集合
        最后添加到BeanFactory中
    */
    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
    List<String> orderedPostProcessorNames = new ArrayList<>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    for (String ppName : postProcessorNames) {
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            priorityOrderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        }
		else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        }
		else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
    for (String ppName : orderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        orderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);

    List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
    for (String ppName : nonOrderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        nonOrderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

    sortPostProcessors(internalPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, internalPostProcessors);

    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

initApplicationEventMulticaster

初始化一个事件多播器，如果beanFactory已经存在则使用已存在；否则新建一个SimpleApplicationEventMulticaster。

protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    /*
        如果BeanFactory已经存在【applicationEventMulticaster】，则使用已经存在的
    */    
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        this.applicationEventMulticaster = beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
        if (logger.isTraceEnabled()) {
            logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
        }
    }
    else {
        /*
            如果不存在【applicationEventMulticaster】，则新建一个SimpleApplicationEventMulticaster，并添加到beanFactory中
        */
        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
        if (logger.isTraceEnabled()) {
            logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
                         "[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
        }
    }
}

onRefresh方法

初始化其他上下文中的特殊Bean，由AbstractApplicationContext的子类实现。 内嵌的Tomcat就在这里实现，具体实现可看【ServletWebServerApplicationContext#onRefresh】

registerListeners

向事件广播器中注册所有的实现【ApplicationListener】接口的监听器，同时发布早期的ApplicationListener

protected void registerListeners() {
    // 注册静态的事件监听器
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        getApplicationEventMulticaster().addApplicationListener(listener);
    }

    /*
        获取实现了ApplicationListener的BeanName集合，并添加到事件多播器
    */
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }

    /*
        广播早期的事件。
        对于单独的Spring工程来说，此时没有事件要发布
    */
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    this.earlyApplicationEvents = null;
    if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
}

finishBeanFactoryInitialization

方法会初始化剩下的单例，非懒加载的，非抽象类的Bean。具体逻辑下篇文章讲解

finishRefresh

此方法主要是在容器refresh结束时，做一些其他的操作

protected void finishRefresh() {
    /*
        重置在Bean初始化时的各种缓存
    */
    resetCommonCaches();

    // Clear context-level resource caches (such as ASM metadata from scanning).
    clearResourceCaches();

    /*
        初始化LifecycleProcessor，如果没有则添加一个【DefaultLifecycleProcessor】
    */
    initLifecycleProcessor();

    getLifecycleProcessor().onRefresh();

    /*
        发布一个ContextRefreshedEvent事件，可通过监听此事件在容器refresh后做一些处理逻辑
    */
    publishEvent(new ContextRefreshedEvent(this));
}
avatar
文章
阅读
粉丝