一. 前言

Spring源码系列——容器的启动过程(一)中,我们解析了构造方法.
Spring源码系列——容器的启动过程(二)中,我们解析了注册方法.
本篇文章,分析最后一个方法refresh()!

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
    this();
    register(componentClasses);
    // 3.刷新整个容器
    refresh();
}

二. refresh()方法解析

构造方法中, 前面两步已经做了很多事情了, 但这些事情都是准备工作. 比起refresh()而言, 还是小巫见大巫. 在refresh()方法中,包含着各后置处理的作用 / 调用时机; Bean的诞生过程; 循环依赖如何解决以及Spring的其他组件使用等. 接下来迎接风暴!

// refresh()本身是一个聚合方法, 具体的功能都委托给了各个子方法.
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // 1.在刷新容器之前,做一些基础的处理. 不难
        prepareRefresh();

        // 2. 获取刷新后的beanFactory.注意:这里并不是要把当前的beanFactory全部刷新,只是刷新部分数据.不然之前的准备工作岂不是白做了. 不难
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// 3. 准备BeanFactory. 重要!!!
        prepareBeanFactory(beanFactory);

        try {
            // 4. 空方法 Spring后版本可能会用
            postProcessBeanFactory(beanFactory);
			
            // 5. 调用后置处理器 重要!!!
            invokeBeanFactoryPostProcessors(beanFactory);

            // 6. 注册后置处理的Bean到容器当中 重要!!!
            registerBeanPostProcessors(beanFactory);

            // 7. 初始化MessageSource并将其bean注入到容器中
            initMessageSource();

            // 8. 初始化事件多播器并将其bean注入到容器中
            initApplicationEventMulticaster();

            // 9. 在特定上下文子类中初始化其他特殊bean. 当前是空方法, Spring后续版本可能会用
            onRefresh();

            // 10. 注册监听器到容器中
            registerListeners();

            // 11. 实例化所有剩余的bean(非延迟)到容器中 重要!!!
            finishBeanFactoryInitialization(beanFactory);

            // 12. 最后, 发布容器刷新完成事件
            finishRefresh();
        }

        catch (BeansException ex) {
           // 异常情况下, 销毁容器中所有的bean
            destroyBeans();
            cancelRefresh(ex);
            throw ex;
        }

        finally {
            // 清除一些不必要的缓存
            resetCommonCaches();
        }
    }
}

2.1 prepareRefresh()

protected void prepareRefresh() {
    // 设置激活状态,启动时间
    this.startupDate = System.currentTimeMillis();
    this.closed.set(false);
    this.active.set(true);

    // 初始化资源必要的资源. 目前是空方法. Spring后续版本可能会启用.
    initPropertySources();

    // 校验系统环境/JVM环境当中的必要参数
    getEnvironment().validateRequiredProperties();

    // 存储预刷新的ApplicationListeners. 实际上就是一个empty set
    if (this.earlyApplicationListeners == null) {
        this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
    }
    else {
        this.applicationListeners.clear();
        this.applicationListeners.addAll(this.earlyApplicationListeners);
    }

    // 允许收集早期的ApplicationEvent，一旦多播器可用，便会发布. 实际上这里也是一个empty set
    this.earlyApplicationEvents = new LinkedHashSet<>();
}

2.2 prepareBeanFactory()

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // 设置beanFactory的类加载器. 实际上,这里的类加载器和前文中所提到的类加载器是一样的.
    beanFactory.setBeanClassLoader(getClassLoader());
    // 设置beanFactory当中的表达式语言解析器. 比如@Value中的表达式就是这里设置的解析器来解析的.
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    // 设置beanFactory当中的属性编辑器.比如在配置文件中配置了一个"2020-01-01"的日期类型字符串,
    // 正常情况下,Spring无法解析为Date类型,因此可以通过自定义属性编辑器的方式来转换.这就是属性编辑器的作用.
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
	
    // 重要!!! 这里添加了一个ApplicationContextAwareProcessor到BeanFactory的BeanPostProcessors中.
    // 注意,这里只是添加到后置处理列表,并没有将其解析为beanDefinition,更没有解析为bean注入到容器当中.具体解析时机,后面会提到.
    // 到这里, BeanFactory中的BeanPostProcessors中迎来了第1个后置处理器.(注意,并没有添加到BeanDefinitionMap中)
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

	// 忽略实现了这些接口的类的解析和注入.
    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
    beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

    // 这里提前注册已解析的依赖,目的是用于自动装配使用.
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);

    // BeanPostProcessors中迎来了第2个 processor
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

    // 第一次进来显然不包含,因此不会进入if分支
    if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        // Set a temporary ClassLoader for type matching.
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }

    // 将environment实例注入到单例容器中, 到这里,容器迎来了第1个单例!
    if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
    }
    // 将systemProperties实例注入到单例容器中, 到这里,容器迎来了第2个单例!
    if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
    }
    // 将systemEnvironment实例注入到单例容器中, 到这里,容器迎来了第3个单例!
    if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
    }
}

prepareBeanFactory()方法很有意义,因为它在整个容器启动过程中,第一次添加了后置处理器到列表中,第一次添加了单例到容器中.

2.3 invokeBeanFactoryPostProcessors()

这个方法及其重要,因为它调用了后置处理器

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
	// 首先获取容器中的BeanFactoryPostProcessors. 注意这里不是获取BeanPostProcessors.
    // 因此第一次这里获取到BeanFactoryPostProcessors列表肯定是空
    // 委托给invokeBeanFactoryPostProcessors方法
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

    // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
    // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
    if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }
}

委托的方法如下(高能预警):

// 这个方法很复杂~
public static void invokeBeanFactoryPostProcessors(
        ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

    // Invoke BeanDefinitionRegistryPostProcessors first, if any.
    Set<String> processedBeans = new HashSet<>();

	// 首先,判断是不是BeanDefinitionRegistry类型, 从BeanFactoryUML类图中可以看出. 显然是的,因此进入到if分支
    if (beanFactory instanceof BeanDefinitionRegistry) {
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        // 注意, 这里会先初始化两个列表
        // 一个用于盛放BeanFactoryPostProcessor类型的后置处理器
        // 一个用于盛放BeanDefinitionRegistryPostProcessor类型的后置处理器
        // 值得注意的是, BeanDefinitionRegistryPostProcessor实际上是继承了BeanFactoryPostProcessor
        // 那么为什么这里要用两个容器分别盛放呢??? 原因在于, Spring的初始化过程中,后置处理器的执行顺序有要求. 这里我们不展开详细讨论,会专门拿一篇文章出来解说后置处理器.
        List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
        
		// 因为beanFactoryPostProcessors为空,因此for循环直接跳出.
        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                BeanDefinitionRegistryPostProcessor registryProcessor =
                        (BeanDefinitionRegistryPostProcessor) postProcessor;
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
                registryProcessors.add(registryProcessor);
            }
            else {
                regularPostProcessors.add(postProcessor);
            }
        }

		// 再初始化一个BeanDefinitionRegistryPostProcessor容器列表. 注意区别与之前的registryProcessors!
        List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

        // 首先，调用实现PriorityOrdered的BeanDefinitionRegistryPostProcessors
        // 从容器中获取BeanDefinitionRegistryPostProcessor的beanNameList,
        // 从上文中可以得知,容器中只有ConfigurationClassPostProcessor是BeanDefinitionRegistryPostProcessor类型的.
        // 因此,postProcessorNames只有1个值
        String[] postProcessorNames =
                beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
        	// ConfigurationClassPostProcessor实现了PriorityOrdered接口, 因此这里进入到if分支.
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            	// 获取BeanDefinitionRegistryPostProcessor的bean并放入到currentRegistryProcessors
                // 上文中我们得知,当前的容器中只有3个bean, 这里通过getBean方法只会,容器将会添加第4个bean.
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                // 添加到processedBeans中
                processedBeans.add(ppName);
            }
        }
        
        // 对currentRegistryProcessors进行排序.
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        // 将currentRegistryProcessors全部添加到registryProcessors中
        registryProcessors.addAll(currentRegistryProcessors);
        // 调用BeanDefinitionRegistryPostProcessor的独有方法:postProcessBeanDefinitionRegistry()
        // 从上文解析得知,实际上这里只会调用ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry()
        // 在这里面便提现了ConfigurationClassPostProcessor的价值!!! 它是通过一个parser对象解析@Configuration注解的类的.
        // 本例中, 就是解析Config.class类,而在Config.class上有@ComponentScan注解,因此会通过scanner扫描该包下的所有@Component注解的类并解析成BeanDefinition添加到BeanFactory的beanDefinitionMap中.
        // 到这里,便知道,Spring就是在这里完成了@Configuration类的解析和bean的初步扫描!
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        // 调用完成后, 将currentRegistryProcessors清空,以便后续再次使用.
        currentRegistryProcessors.clear();

        // 接下来，调用实现Ordered的BeanDefinitionRegistryPostProcessors
        // 同样的,显示获取BeanDefinitionRegistryPostProcessor的所有postProcessorNames,
        // 通过上文得知, 实际上只有1个
        postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
        	// 判断是否实现了Ordered接口. 显然ConfigurationClassPostProcessor没有实现Ordered接口,因此不会进入if分支
            if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }
        // 排序, 从上文得知, 这里会排个寂寞~~因为当前的currentRegistryProcessors为空
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        // 同样地,寂寞~~
        registryProcessors.addAll(currentRegistryProcessors);
        // 寂寞~~
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        // 再寂寞~~
        currentRegistryProcessors.clear();

        // 最后，调用所有其他BeanDefinitionRegistryPostProcessor，通过while循环保证会全部调用完
        boolean reiterate = true;
        while (reiterate) {
            reiterate = false;
            // 获取BeanDefinitionRegistryPostProcessor的所有postProcessorNames, 同样的只有1个~~
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
            	// 由于在上文中processedBeans已经添加了ConfigurationClassPostProcessor了,因此必然包含啊
                // 所以这里不会进入到if分支.
                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);
            currentRegistryProcessors.clear();
        }

        // 现在，调用到目前为止已处理的所有处理器的postProcessBeanFactory回调
        // 上文中, 都是调用的BeanDefinitionRegistryPostProcessor当中的特有的方法,
        // 这里将会调用BeanFactoryPostProcessor中的方法了.
        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    }

    else {
        // Invoke factory processors registered with the context instance.
        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    }

	// 通过以上解析, BeanDefinitionRegistryPostProcessor类型的后置处理器就执行完了.
    // 接下来,将执行BeanFactoryPostProcessor类型的后置处理器.有了上面的铺垫之后,接下来就会好受很多.
    
    // 首先,从容器中获取BeanFactoryPostProcessor类型的后置处理器名称.
    // 这里实际上会获取到2个: ConfigurationClassPostProcessor和EventListenerPostProcessor
    String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

    // 这里需要先执行实现了priority的, 再执行实现了Ordered的, 最后执行非ordered的, 因此这里是初始化了3个List
    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    List<String> orderedPostProcessorNames = new ArrayList<>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    for (String ppName : postProcessorNames) {
    	// 如果processedBeans包含了, 说明已经调用过了,不需要再执行.
        // 再我们这个场景中,
        // 很显然, ConfigurationClassPostProcessor是已经执行过了, 因此将会跳过
        // 而EventListenerPostProcessor没有执行过,因此不会跳过
        if (processedBeans.contains(ppName)) {
            // skip - already processed in first phase above
        }
        else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
        	// 如果实现了PriorityOrdered, 则添加到priorityOrderedPostProcessors中
            priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        }
        else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
        	// 如果实现了Ordered, 则添加到orderedPostProcessorNames中
            orderedPostProcessorNames.add(ppName);
        }
        else {
        	// 否则, 添加到nonOrderedPostProcessorNames
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    // 首先，调用实现PriorityOrdered的BeanFactoryPostProcessors
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

    // 接下来，调用实现Ordered的BeanFactoryPostProcessors
    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
    for (String postProcessorName : orderedPostProcessorNames) {
        orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

    // 最后，调用所有其他BeanFactoryPostProcessors
    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
    for (String postProcessorName : nonOrderedPostProcessorNames) {
        nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

    // 清空不必要的元数据缓存
    beanFactory.clearMetadataCache();
}

invokeBeanFactoryPostProcessors()方法到这里执行完毕, 初看之时, 我头皮着实麻了一下,但是静下心来梳理了以便之后, 又感叹于Spring复杂且精妙.
这个方法整体上是执行实现了BeanFactoryPostProcessor的后置处理器的. 在Spring内部中使用了BeanDefinitionRegistryPostProcessor来作为框架辅助运行, 它的执行优先级也是最高的. 整个BeanFactoryPostProcessor组件 的执行优先级如下:
最高: 实现了PriorityOrdered接口的 BeanDefinitionRegistryPostProcessor
再次: 实现了Ordered接口的 BeanDefinitionRegistryPostProcessor
再次: 普通的BeanDefinitionRegistryPostProcessor
再次: 实现了PriorityOrdered接口的 BeanFactoryPostProcessor
再次: 实现了Ordered接口的BeanFactoryPostProcessor
最低: 普通的BeanFactoryPostProcessor

在实际应用中最高优先级执行的便是实现PriorityOrdered的ConfigurationClassPostProcessor类. 因为它真的很重要,因此必须优先级最高.
知道了这个优先级之后, 我们便可以通过实现BeanFactoryPostProcessor或者BeanDefinitionRegistryPostProcessor来插足Spring的生命周期了. 当然了, BeanFactoryPostProcessor或者BeanDefinitionRegistryPostProcessor其实是Spring内部使用的, 开发人员在非特殊情况下应该避免直接使用, Spring为我们提供了优先级更低的BeanPostProcessor

讲解完BeanFactoryPostProcessor后,继续~~

2.4 registerBeanPostProcessors()

这个方法主要是注册BeanPostProcessor的.

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
	// 委托
    PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

实际上是委托给registerBeanPostProcessors()方法:

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

	// 获取当前所有的PostProcessor的名称
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    // 添加一个checker
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

    // 同样的道理, 优先级最高的是实现了PriorityOrdered, 然后是实现了Ordered,最后是普通的BeanPostProcessor.
    // 将这些注册到BeanFactory的BeanPostProcessors列表中.
    
    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);
        }
    }

    // First, register the BeanPostProcessors that implement PriorityOrdered.
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

    // Next, register the BeanPostProcessors that implement Ordered.
    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);

    // Now, register all regular BeanPostProcessors.
    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);

    // Finally, re-register all internal BeanPostProcessors.
    sortPostProcessors(internalPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, internalPostProcessors);

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

registerBeanPostProcessors()的主要目的就是注册程序当中的BeanPostProcessor到容器中,并且通过getBean方法,将这些BeanPostProcessor的bean注入到容器当中去. 而真正的调用则是在注入bean的过程中调用的.

2.5 finishBeanFactoryInitialization()

该方法将会实例化所有剩余的（非延迟初始化）单例. 也就是说, 经过了前面所有的步骤之后, 终于要开始解析并注入我们程序代码当中定义的bean了,无论是通过注解的方式还是JavaConfig的方式还是配置的方式.

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // Initialize conversion service for this context.
    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
            beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
        beanFactory.setConversionService(
                beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    }

    // Register a default embedded value resolver if no bean post-processor
    // (such as a PropertyPlaceholderConfigurer bean) registered any before:
    // at this point, primarily for resolution in annotation attribute values.
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    }

    // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
        getBean(weaverAwareName);
    }

    // Stop using the temporary ClassLoader for type matching.
    beanFactory.setTempClassLoader(null);

    // Allow for caching all bean definition metadata, not expecting further changes.
    beanFactory.freezeConfiguration();

    // 最关键的就是这个方法, 它会实例化所有剩余的（非延迟初始化）单例!!!
    beanFactory.preInstantiateSingletons();
}

2.6 finishRefresh()

该方法做一些结尾的工作, 主要是发布容器刷新成功事件.

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

    // Initialize lifecycle processor for this context.
    initLifecycleProcessor();

    // Propagate refresh to lifecycle processor first.
    getLifecycleProcessor().onRefresh();

    // 发布容器刷新成功事件
    publishEvent(new ContextRefreshedEvent(this));

    // Participate in LiveBeansView MBean, if active.
    LiveBeansView.registerApplicationContext(this);
}

2.7 refresh()小结

整个refresh过程几乎设计到了Spring core的所有东西. 比如后置处理的解析/注册/调用, bean的解析/自动装配/循环依赖等.

三. 总结

本篇文章以注解的方式将整个Spring容器启动的过程梳理了一遍, 目的是通过这个过程知道Spring容器的整个启动过程,以及这个过程涉及到哪些点,每个点的大致作用是什么, 从整体框架上做到心中有数,然后后面各个点逐个击破.从而深度掌握Spring Framework!
Stay hungry, stay foolish!