Spring IoC 容器的扩展

时间 2020-07-07

标签 spring ioc 容器扩展栏目 Spring 繁體版

原文原文链接

前言

本系列所有基于 Spring 5.2.2.BUILD-SNAPSHOT 版本。由于 Spring 整个体系太过于庞大，因此只会进行关键部分的源码解析。html

本篇文章主要介绍 Spring IoC 容器的功能扩展。java

正文

咱们平时在使用 Spring 时，大多不会直接使用 BeanFactory，使用比较多的是 ApplicationContext；那么在 Spring 中 BeanFactory 和 ApplicationContext 有什么区别呢？git

BeanFactory 这个接口提供了高级配置的机制的管理对象，是一个基本的 IoC 的容器。
ApplicationContext 是 BeanFactory 的一个子接口，提供了 BeanFactory 的所有功能，而且在此基础上还提供了：
- 面向切面 (AOP)
- 配置元信息 (Configuration Metadata)
- 资源管理 (Resources)
- 事件 (Events)
- 国际化 (i18n)
- 注解 (Annotations)
- Environment 抽象 (Environment Abstraction)

真正的底层 IoC 容器是 BeanFactory 的实现类，ApplicationContext 中的 getBean() 其实都是委托给 DefaultListableBeanFactory 来实现。github

其中核心流程都在 AbstractApplicationContext#refresh() 方法中，咱们直接从这个方法开始。spring

容器刷新

AbstractApplicationContext#refresh

public void refresh() throws BeansException, IllegalStateException {
    // 加锁
    synchronized (this.startupShutdownMonitor) {
        // 准备刷新的上下文环境，见下文详解
        prepareRefresh();

        // 获取刷新后的beanFactory，通常都是建立一个DefaultListableBeanFactory，见下文详解
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // 使用当前上下文环境准备beanFactory，见下文详解
        prepareBeanFactory(beanFactory);

        try {
            // beanFactory的后置处理，子类实现，这也算是beanFactory的扩展点
            // AbstractRefreshableWebApplicationContext在这个方法内加入了request和session的做用域
            postProcessBeanFactory(beanFactory);

            // 调用全部BeanFactoryPostProcessors的实现类，见下文详解
            invokeBeanFactoryPostProcessors(beanFactory);

            // 注册BeanPostProcessors，见下文详解
            registerBeanPostProcessors(beanFactory);

            // 初始化消息资源，这里不作过多分析
            initMessageSource();

            // 初始化事件传播器，这里不作过多分析
            initApplicationEventMulticaster();

            // 在特殊的上下文环境中初始化指定的bean，模板方法留给子类实现
            onRefresh();

            // 注册监听器，这里不作过多分析
            registerListeners();

            // 实例化全部非延迟加载的单例bean，见下文详解
            finishBeanFactoryInitialization(beanFactory);

            // 完成上下文的刷新，调用生命周期处理器的onRefresh()而且发布上下文刷新完成事件，这里不作过多分析
            finishRefresh();
        }
        // 省略异常处理
        finally {
            // 重置缓存，例如方法、字段等
            resetCommonCaches();
        }
    }
}

上面方法就是上下文刷新的流程，其中关于消息资源和事件的处理这里就不分析了，后续可能会单独分析一下 Spring 中的事件。缓存

上下文刷新前的环境准备

AbstractApplicationContext#prepareRefresh

protected void prepareRefresh() {
    // 记录开始时间
    this.startupDate = System.currentTimeMillis();
    // 上下文关闭标识设置为 false
    this.closed.set(false);
    // 上下文激活标识设置为 true
    this.active.set(true);

    // 初始化占位符属性资源，该方法是留给子类实现的，默认什么也不作
    initPropertySources();

    // 验证须要的属性文件是否都已经放入环境中
    getEnvironment().validateRequiredProperties();

    if (this.earlyApplicationListeners == null) {
        this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
    } else {
        // 在上下文刷新前重置监听器
        this.applicationListeners.clear();
        this.applicationListeners.addAll(this.earlyApplicationListeners);
    }

    this.earlyApplicationEvents = new LinkedHashSet<>();
}

得到新的 BeanFactory

AbstractApplicationContext#obtainFreshBeanFactory

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    // 刷新 bean 工厂，见下文详解
    refreshBeanFactory(); 
    // 返回 bean 工厂，见下文详解
    return getBeanFactory(); 
}

AbstractRefreshableApplicationContext#refreshBeanFactory

protected final void refreshBeanFactory() throws BeansException {
    // 若是有beanFactory
    if (hasBeanFactory()) {
        // 销毁全部的单例bean
        destroyBeans();
        // 关闭beanFactory，也就是将beanFactory设置为null
        closeBeanFactory();
    }
    try {
        // 建立 DefaultListableBeanFactory
        DefaultListableBeanFactory beanFactory = createBeanFactory();
        // 指定序列化id
        beanFactory.setSerializationId(getId());
        // 定制beanFactory，设置相关属性
        customizeBeanFactory(beanFactory);
        // 加载beanDefinition
        loadBeanDefinitions(beanFactory);
        synchronized (this.beanFactoryMonitor) {
            // 加锁，将beanFactory赋值给全局变量
            this.beanFactory = beanFactory;
        }
    }
    // 省略异常处理...
}

AbstractRefreshableApplicationContext#getBeanFactory

public final ConfigurableListableBeanFactory getBeanFactory() {
    // 加锁
    synchronized (this.beanFactoryMonitor) {
        // 若是beanFactory为空抛出异常
        if (this.beanFactory == null) {
            throw new IllegalStateException("BeanFactory not initialized or already closed - call 'refresh' before accessing beans via the ApplicationContext");
        }
        // 返回beanFactory
        return this.beanFactory;
    }
}

对 BeanFactory 进行功能填充

AbstractApplicationContext#prepareBeanFactory

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // 设置beanFactory的classLoader为当前context的classLoader
    beanFactory.setBeanClassLoader(getClassLoader());
    // 设置beanFactory的表达式语言处理器
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    // 为beanFactory增长了一个的propertyEditor，这个主要是对bean的属性等设置管理的一个工具
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

    // 添加bean扩展，主要是对ApplicationContext新增长的Aware接口进行调用
    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);

    // 注册解决依赖，也就是说咱们能够经过依赖注入来注入如下四种类型的bean
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);

    // 将是ApplicationListener类型的bean在BeanPostProcessor的初始化后回调方法中加入到context的监听器列表中
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

    // 增长对AspectJ支持
    if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }

    // 若是beanFactory不存在名为environment的bean，添加默认的，该bean就和咱们正常声明的单例bean同样
    if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
    }
    // 若是beanFactory不存在名为systemProperties的bean，添加默认的，该bean就和咱们正常声明的单例bean同样
    if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
    }
    // 若是systemEnvironment不存在名为systemEnvironment的bean，添加默认的，该bean就和咱们正常声明的单例bean同样
    if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
    }
}

调用 BeanFactory 的处理器

AbstractApplicationContext#invokeBeanFactoryPostProcessors

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    // 实例化并调用全部已注册的BeanFactoryPostProcessor
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

    if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }
}

PostProcessorRegistryDelegate#invokeBeanFactoryPostProcessors

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

    Set<String> processedBeans = new HashSet<>();
    // 判断beanFactory是不是BeanDefinitionRegistry类型
    // 一般状况下这里的beanFactory是DefaultListableBeanFactory因此这里判断为true
    if (beanFactory instanceof BeanDefinitionRegistry) {
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        // 保存实现了BeanFactoryPostProcessor bean的集合
        List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
        // 保存实现了BeanDefinitionRegistryPostProcessor bean的集合
        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
        // 遍历beanFactoryPostProcessors
        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            // 找出是BeanDefinitionRegistryPostProcessor类型的并调用其postProcessBeanDefinitionRegistry()
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor) postProcessor;
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
                // 将BeanDefinitionRegistryPostProcessor类型的添加进registryProcessors
                registryProcessors.add(registryProcessor);
            }
            else {
                // 将BeanFactoryPostProcessor类型的添加进regularPostProcessors
                regularPostProcessors.add(postProcessor);
            }
        }

        List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

        // 获取全部BeanDefinitionRegistryPostProcessor类型的beanName
        String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        // 遍历postProcessorNames
        for (String ppName : postProcessorNames) {
            // 若是实现了PriorityOrdered接口，
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                // 初始化此bean并添加进currentRegistryProcessors
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                // 将此beanName添加到已处理的记录中
					processedBeans.add(ppName);
            }
        }
        // 排序
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        // 将全部BeanDefinitionRegistryPostProcessor类型而且实现了PriorityOrdered接口的bean添加进registryProcessors
        registryProcessors.addAll(currentRegistryProcessors);
        // 遍历调用currentRegistryProcessors中的全部BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        // 清空currentRegistryProcessors
        currentRegistryProcessors.clear();

        // 和上面的差很少只是此次是实现了Ordered接口的，而且没有处理过的
        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);
        currentRegistryProcessors.clear();

        // 和上面的差很少只是此次是全部的实现了BeanDefinitionRegistryPostProcessors的bean，而且没有处理过的
        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);
            currentRegistryProcessors.clear();
        }

        // 调用BeanFactoryPostProcessor的postProcessBeanFactory()
        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    }
    else {
        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    }

    // 获取全部BeanFactoryPostProcessor类型的beanName
    String[] postProcessorNames =
        beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    List<String> orderedPostProcessorNames = new ArrayList<>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    // 遍历postProcessorNames
    for (String ppName : postProcessorNames) {
        // 若是已经处理过，直接跳过；由于BeanDefinitionRegistryPostProcessor继承于BeanFactoryPostProcessor
        // 因此postProcessorNames也包含BeanDefinitionRegistryPostProcessor类型的bean，这里会对BeanDefinitionRegistryPostProcessor类型的bean直接跳过
        if (processedBeans.contains(ppName)) {
        }
        // 若是实现了PriorityOrdered接口，初始化该bean并添加进priorityOrderedPostProcessors
        else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        }
        // 若是实现了Ordered接口，将beanName添加进orderedPostProcessorNames
        else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        }
        // 正常的将beanName添加进nonOrderedPostProcessorNames
        else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    // 排序，而后调用BeanFactoryPostProcessors的postProcessBeanFactory()
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

    // 和上面的同样这里是实现了Ordered接口的
    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();
}

上面代码首先找出 BeanDefinitionRegistryPostProcessor 和 BeanFactoryPostProcessor 类型的 bean，而后根据其实现的排序接口，来分别进行初始化以及调用其回调方法。能够把 PriorityOrdered 理解为 超级会员，Ordered 为 普通会员，都未实现的理解为 普通用户，优先级一个比一个高。session

咱们首先看一下 BeanFactoryPostProcessor 接口的定义：app

@FunctionalInterface
public interface BeanFactoryPostProcessor {

    /**
     * 容器初始化后，bean实例化以前调用，能够在此修改BeanDefinition
     */
    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;

}

能够看出 BeanFactoryPostProcessor 接口是 Spring 初始化 BeanFactory 时对外暴露的扩展点，Spring IoC 容器容许 BeanFactoryPostProcessor 在容器实例化任何 bean 以前读取 bean 的定义，并能够修改它。工具

接下里咱们看一下 BeanDefinitionRegistryPostProcessor 接口的定义：post

public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {

    void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;

}

BeanDefinitionRegistryPostProcessor 比 BeanFactoryPostProcessor 具备更高的优先级，从上面解析的代码中就能够看出，主要用来在 BeanFactoryPostProcessor 以前注册其它 bean 的定义。

注册 Bean 的处理器

AbstractApplicationContext#registerBeanPostProcessors

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

//PostProcessorRegistrationDelegate.java
public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
   // 获取全部实现了BeanPostProcessor的beanName
   // 这里会获取到AutowiredAnnotationProcessor和CommonAnnotationProcessor后置处理器的beanName
   String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

   // 已经注册进beanFactory的数量 + 手动注册的BeanPostProcessorChecker + 实现了BeanPostProcessor还未注册的bean的数量
   int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
   beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

   // 存储实现了PriorityOrdered接口的BeanPostProcessors
   List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
   // 存储实现了MergedBeanDefinitionPostProcessor接口的BeanPostProcessors
   List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
   // 存储实现了Ordered接口的BeanPostProcessors
   List<String> orderedPostProcessorNames = new ArrayList<>();
   // 存储正常的BeanPostProcessors
   List<String> nonOrderedPostProcessorNames = new ArrayList<>();

   for (String ppName : postProcessorNames) {
       // 若是实现了BeanPostProcessor的bean实现了PriorityOrdered接口
       if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
           // 获取bean实例
           BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
           // 添加进priorityOrderedPostProcessors
           priorityOrderedPostProcessors.add(pp);
           // 若是bean也实现了MergedBeanDefinitionPostProcessor，则添加进internalPostProcessors
           if (pp instanceof MergedBeanDefinitionPostProcessor) {
               internalPostProcessors.add(pp);
           }
       }
       // 若是实现了Ordered接口，添加进orderedPostProcessorNames
       else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
           orderedPostProcessorNames.add(ppName);
       }
       // 不然添加进nonOrderedPostProcessorNames
       else {
           nonOrderedPostProcessorNames.add(ppName);
       }
   }

   // 将实现了PriorityOrdered的BeanPostProcessors先排序再注册进beanFactory
   sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

   // 将实现了Order的BeanPostProcessors先排序再注册进beanFactory
   List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
   for (String ppName : orderedPostProcessorNames) {
       BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
       orderedPostProcessors.add(pp);
       // 若是实现了MergedBeanDefinitionPostProcessor
       if (pp instanceof MergedBeanDefinitionPostProcessor) {
           // 添加进internalPostProcessors
           internalPostProcessors.add(pp);
       }
   }
   sortPostProcessors(orderedPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, orderedPostProcessors);

   // 将正常的BeanPostProcessors注册进beanFactory
   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);

   // 最后将实现MergedBeanDefinitionPostProcessor的BeanPostProcessors先排序再注册进beanFactory
   sortPostProcessors(internalPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, internalPostProcessors);

   // 这里再次添加了ApplicationListenerDetector(以前在prepareBeanFactory()已经添加过)是为了获取代理
   beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

上面代码最后的部分会把实现了 MergedBeanDefinitionPostProcessor 会在最后从新注册一遍，你们可能会认为这不就重复注册了吗，其实否则，beanFactory#addBeanPostProcessor() 会首先删除老的，再从新添加新的。

根据上面代码你们也会发现，ApplicationContext 会帮咱们自动注册实现了 BeanPostProcessors 的 bean，而使用 BeanFactory 就须要本身手动注册了。

注意：上面只是注册，真正调用是在 getBean() 的时候。

初始化非懒加载的单例 bean

AbstractApplicationContext#finishBeanFactoryInitialization

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    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));
    }

    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    }

    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
        getBean(weaverAwareName);
    }

    beanFactory.setTempClassLoader(null);

    // 冻结全部的bean定义，也就是bean定义将不被修改或任何进一步的处理
    beanFactory.freezeConfiguration();

    // 初始化非延迟的单例bean，见下文详解
    beanFactory.preInstantiateSingletons();
}

DefaultListableBeanFactory#preInstantiateSingletons

public void preInstantiateSingletons() throws BeansException {
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

    for (String beanName : beanNames) {
        // 获取合并的BeanDefinition
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        // bean不是抽象类 && bean是单例做用域 && bean不是延迟加载
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            // 若是bean的FactoryBean
            if (isFactoryBean(beanName)) {
                // 获取FactoryBean的实例，前面加了&符号
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                if (bean instanceof FactoryBean) {
                    final FactoryBean<?> factory = (FactoryBean<?>) bean;
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
((SmartFactoryBean<?>) factory)::isEagerInit, getAccessControlContext());
                    }
                    else {
                        // FactoryBean是否提早初始化
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                       ((SmartFactoryBean<?>) factory).isEagerInit());
                    }
                    // 若是是提早初始化直接调用getBean()去初始化bean
                    if (isEagerInit) {
                        getBean(beanName);
                    }
                }
            }
            // 直接调用getBean()去初始化bean
            else {
                getBean(beanName);
            }
        }
    }

    for (String beanName : beanNames) {
        // 获取上面初始化后的单例bean
        Object singletonInstance = getSingleton(beanName);
        // 若是bean实现了SmartInitializingSingleton接口，调用afterSingletonsInstantiated()
        if (singletonInstance instanceof SmartInitializingSingleton) {
            final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                    smartSingleton.afterSingletonsInstantiated();
                    return null;
                }, getAccessControlContext());
            }
            else {
                smartSingleton.afterSingletonsInstantiated();
            }
        }
    }
}

上面代码中的 getMergedLocalBeanDefinition() 在Spring IoC bean 的建立有解析过，这里再也不赘述。这里介绍一下 SmartInitializingSingleton 接口，先看下该接口的定义：

public interface SmartInitializingSingleton {

	/**
	 * 单例bean初始化完成以后调用
	 */
	void afterSingletonsInstantiated();

}

这个接口比较简单，就一个方法，而且只在 preInstantiateSingletons() 中调用了，也就是说你直接使用 BeanFactory 是不会调用该回调方法的。该接口回调方法在单例 bean 初始化完成以后调用后执行，属于 Spring Bean 生命周期的加强。

完成刷新

AbstractApplicationContext#finishRefresh

protected void finishRefresh() {
    // 清除资源缓存
    clearResourceCaches();
		
    // 为此上下文初始化生命周期处理器，见下文详解
    initLifecycleProcessor();
		
    // 首先将刷新完毕事件传播到生命周期处理器，见下详解
    getLifecycleProcessor().onRefresh();

    // 发布上下文刷新完成的事件
    publishEvent(new ContextRefreshedEvent(this));

    LiveBeansView.registerApplicationContext(this);
}

AbstractApplicationContext#initLifecycleProcessor

protected void initLifecycleProcessor() {
    // 若是当前beanFactory中含有名称为lifecycleProcessor的bean定义，初始化该bean并赋值给全局变量lifecycleProcessor
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
        this.lifecycleProcessor = beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
    } else {
        // beanFactory中没有名称为lifecycleProcessor的bean定义，建立一个DefaultLifecycleProcessor并当作单例bean注册进beanFactory
        DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
        defaultProcessor.setBeanFactory(beanFactory);
        this.lifecycleProcessor = defaultProcessor;
        beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
    }
}

DefaultLifecycleProcessor#onRefresh

public void onRefresh() {
    startBeans(true);
    this.running = true;
}

private void startBeans(boolean autoStartupOnly) {
    // 获取全部实现了Lifecycle或者SmartLifecycle的单例bean
    Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
    Map<Integer, LifecycleGroup> phases = new HashMap<>();
    // 由于onRefresh()调用时该方法时，手动设置了autoStartupOnly为false，因此这里的bean必需是SmartLifecycle类型而且isAutoStartup()返回true
    lifecycleBeans.forEach((beanName, bean) -> {
        if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
            // 获取bean的阶段值（若是没有实现Phased接口，则值为0）
            int phase = getPhase(bean);
            // 拿到存放该阶段值的LifecycleGroup，若是为空则新建一个并把当前阶段值加入其中
            LifecycleGroup group = phases.get(phase);
            if (group == null) {
                group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
                phases.put(phase, group);
            }
            group.add(beanName, bean);
        }
    });
    // 若是phases不为空，根据阶段值从小到大排序，并调用重写Lifecycle接口的start()
    if (!phases.isEmpty()) {
        List<Integer> keys = new ArrayList<>(phases.keySet());
        Collections.sort(keys);
        for (Integer key : keys) {
            phases.get(key).start();
        }
    }
}

总结

本文主要介绍了 ApplicationContext 整个加载的流程，咱们能够从新整理一下思路：

刷新前的准备，在这里会记录整个上下文启动的开始时间，将激活标识设置为 true，关闭标识设置为 false。
建立一个新的 BeanFactory，这里大多数状况下都是 DefaultListableBeanFactory。首先会检测以前有没有 BeanFactory，有的话会先销毁再从新建立，而后会加载 bean 的定义元信息。
配置 BeanFactory，设置 BeanFactory 的 classLoader、表达式语言处理器、添加了 ApplicationContext 新增长的 Aware 接口回调等。
调用 BeanFactory 的后置处理器，这也是 BeanFactory 的扩展点；上文有分析过这里再也不赘述。
注册容器内全部的 BeanPostProcessors，上文也分析过，再也不赘述；值得注意的是若是单单使用 BeanFactory 的话是不会自动注册的。
初始化消息资源，这里没有过多分析，由于对咱们整个流程几乎没什么影响。
初始化事件传播器。关于 Spring 的事件，我打算后面单独写一篇文章来介绍，这里就没有多说。
在特殊的上下文环境中初始化指定的bean，模板方法留给子类实现。
注册监听器，这也留着到 Spring 事件中一块儿介绍。
初始化全部非延迟加载的单例 bean，而且会回调实现了 SmartInitializingSingleton 接口的 afterSingletonsInstantiated()，这个接口算是 bean 生命周期的加强。
完成上下文的刷新，调用生命周期处理器的 onRefresh() 而且发布上下文刷新完成事件。

最后，我模仿 Spring 写了一个精简版，代码会持续更新。地址：https://github.com/leisurexi/tiny-spring。