1.AbstractApplicationContext#refresh主流程

    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            // 刷新容器 预准备工作
            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory.
            // 获取一个全新的BeanFactory接口实例
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            // 预处理bf.
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                // 空方法，留给子类实现，用于注册一些 beanFactoryPostProcessor
                postProcessBeanFactory(beanFactory);

                // Invoke factory processors registered as beans in the context.
                // 查找 并 执行 bfpp 后处理器
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                // 注册后处理器
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                initMessageSource();

                // Initialize event multicaster for this context.
                // 初始化事件传播器。
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                // 留给子类去实现的，在这个方法内，你可以硬编码提供一些组件，
                // 比如说 提供了一些Listeners
                onRefresh();

                // Check for listener beans and register them.
                // 注册通过配置提供的Listener，这些监听器 最终都会注册到 Multicaster内。
                registerListeners();

                // Instantiate all remaining (non-lazy-init) singletons.
                // 实例化非懒加载状态的单实例。
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                // 完成刷新 后做的一些事情，主要是启动生命周期对象。
                finishRefresh();
            }

2.AbstractApplicationContext#prepareRefresh

    protected void prepareRefresh() {
        // Switch to active.
        //设置容器启动时间
        this.startupDate = System.currentTimeMillis();
        this.closed.set(false);
        this.active.set(true);

        if (logger.isDebugEnabled()) {
            if (logger.isTraceEnabled()) {
                logger.trace("Refreshing " + this);
            }
            else {
                logger.debug("Refreshing " + getDisplayName());
            }
        }

        // Initialize any placeholder property sources in the context environment.
        // 留给子类扩展
        initPropertySources();

        // Validate that all properties marked as required are resolvable:
        // see ConfigurablePropertyResolver#setRequiredProperties
        // 校验必须有的环境变量
        getEnvironment().validateRequiredProperties();

        // Store pre-refresh ApplicationListeners...
        if (this.earlyApplicationListeners == null) {
            this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
        }
        else {
            // Reset local application listeners to pre-refresh state.
            this.applicationListeners.clear();
            this.applicationListeners.addAll(this.earlyApplicationListeners);
        }

        // Allow for the collection of early ApplicationEvents,
        // to be published once the multicaster is available...
        this.earlyApplicationEvents = new LinkedHashSet<>();
    }

示例：

public class Main {
    public static void main(String[] args) {
        ApplicationContext ac =
                new MyClassPathXmlApplicationContext("spring-required-properties-test.xml");
    }

}

public class MyClassPathXmlApplicationContext extends ClassPathXmlApplicationContext {
    public MyClassPathXmlApplicationContext(String... configLocations) {
        super(configLocations);
    }

    /**
     * 重写AbstractApplicationContext.initPropertySources() 方法
     * 在此指定需要验证非空的环境变量
     */
    @Override
    protected void initPropertySources() {
        getEnvironment().setRequiredProperties("LG_HOME");
    }
}

如果必需的属性没有设置，就会报错：

Exception in thread "main" org.springframework.core.env.MissingRequiredPropertiesException: The following properties were declared as required but could not be resolved: [LG_HOME]
    at org.springframework.core.env.AbstractPropertyResolver.validateRequiredProperties(AbstractPropertyResolver.java:145)
    at org.springframework.core.env.AbstractEnvironment.validateRequiredProperties(AbstractEnvironment.java:519)
    at org.springframework.context.support.AbstractApplicationContext.prepareRefresh(AbstractApplicationContext.java:605)
    at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:520)
    at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:144)
    at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:95)
    at com.wz.spring.requiredProperties.MyClassPathXmlApplicationContext.<init>(MyClassPathXmlApplicationContext.java:8)
    at com.wz.spring.requiredProperties.Main.main(Main.java:8)

FAILURE: Build failed with an exception.

3.AbstractApplicationContext#obtainFreshBeanFactory

    protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        refreshBeanFactory();
        return getBeanFactory();
    }

    protected final void refreshBeanFactory() throws BeansException {
        // 条件成立：说明当前applicationContext内部拥有一个beanFactory接口实例，
        // 咱们需要将该beanFactory实例完全释放掉。
        if (hasBeanFactory()) {
            // 销毁原beanFactory内部的实例的流程。
            destroyBeans();
            closeBeanFactory();
        }
        try {
            DefaultListableBeanFactory beanFactory = createBeanFactory();
            beanFactory.setSerializationId(getId());
            customizeBeanFactory(beanFactory);
            // 加载bd信息，这一步完成之后，所有的配置信息（bd）就注册到 bf内了。
            loadBeanDefinitions(beanFactory);
            // 保留引用。
            this.beanFactory = beanFactory;
        }
        catch (IOException ex) {
            throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
        }
    }

3.1 重点分析一下bean的销毁逻辑

    protected void destroyBeans() {
        // 销毁原beanFactory内部的单实例。
        getBeanFactory().destroySingletons();
    }

    public void destroySingletons() {
        super.destroySingletons();
        updateManualSingletonNames(Set::clear, set -> !set.isEmpty());
        clearByTypeCache();
    }

    public void destroySingletons() {
        if (logger.isTraceEnabled()) {
            logger.trace("Destroying singletons in " + this);
        }
        synchronized (this.singletonObjects) {
            // 设置该属性，表示当前beanFactory状态转变为了销毁状态。
            this.singletonsCurrentlyInDestruction = true;
        }

        // disposable ？ 创建单实例时，会检查当前单实例类型
        // 是否实现了DisposableBean接口，如果实现了该接口，
        // 对应，容器销毁时，需要执行该bean.destroy() 方法。
        String[] disposableBeanNames;
        synchronized (this.disposableBeans) {
            disposableBeanNames = StringUtils.toStringArray(this.disposableBeans.keySet());
        }
        for (int i = disposableBeanNames.length - 1; i >= 0; i--) {
            destroySingleton(disposableBeanNames[i]);
        }

        this.containedBeanMap.clear();
        this.dependentBeanMap.clear();
        this.dependenciesForBeanMap.clear();

        clearSingletonCache();
    }

    public void destroySingleton(String beanName) {
        // Remove a registered singleton of the given name, if any.
        // 清空3级缓存 + registeredSingletons 里面 对应当前beanName的数据。
        removeSingleton(beanName);

        // Destroy the corresponding DisposableBean instance.
        DisposableBean disposableBean;
        synchronized (this.disposableBeans) {
            // 注册时会向 disposableBeans 内部存放 实现了  DisposableBean 接口的 bean
            disposableBean = (DisposableBean) this.disposableBeans.remove(beanName);
        }
        destroyBean(beanName, disposableBean);
    }

    protected void destroyBean(String beanName, @Nullable DisposableBean bean) {
        // Trigger destruction of dependent beans first...
        Set<String> dependencies;
        // dependentBeanMap ？ 保存的是依赖当前 bean 的其它bean信息。
        //比如说：b/c/d 这三个bean依赖了a，那么dependentBeanMap 内部 就应该有这样一个数据：
        //{key:a, value: {b,c,d}}
        synchronized (this.dependentBeanMap) {
            // Within full synchronization in order to guarantee a disconnected Set
            dependencies = this.dependentBeanMap.remove(beanName);
        }
        if (dependencies != null) {
            if (logger.isTraceEnabled()) {
                logger.trace("Retrieved dependent beans for bean '" + beanName + "': " + dependencies);
            }
            // 因为依赖对象要被回收了，所以 依赖当前bean的其它对象，
            // 都要执行destroySingleton逻辑。
            for (String dependentBeanName : dependencies) {
                destroySingleton(dependentBeanName);
            }
        }

        // Actually destroy the bean now...
        if (bean != null) {
            try {
                //执行当前bean的销毁方法。
                bean.destroy();
            }
            catch (Throwable ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Destruction of bean with name '" + beanName + "' threw an exception", ex);
                }
            }
        }

        // Trigger destruction of contained beans...
        Set<String> containedBeans;
        synchronized (this.containedBeanMap) {
            // Within full synchronization in order to guarantee a disconnected Set
            containedBeans = this.containedBeanMap.remove(beanName);
        }
        if (containedBeans != null) {
            for (String containedBeanName : containedBeans) {
                destroySingleton(containedBeanName);
            }
        }

        // Remove destroyed bean from other beans' dependencies.
        synchronized (this.dependentBeanMap) {
            for (Iterator<Map.Entry<String, Set<String>>> it = this.dependentBeanMap.entrySet().iterator(); it.hasNext();) {
                Map.Entry<String, Set<String>> entry = it.next();
                Set<String> dependenciesToClean = entry.getValue();
                dependenciesToClean.remove(beanName);
                if (dependenciesToClean.isEmpty()) {
                    it.remove();
                }
            }
        }

        // Remove destroyed bean's prepared dependency information.
        // 比如说a 它依赖了 w,x ，那么对应dependenciesForBeanMap 就应该有：
        // {a, {w,x}}
        this.dependenciesForBeanMap.remove(beanName);
    }

4.AbstractApplicationContext#prepareBeanFactory

    protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // Tell the internal bean factory to use the context's class loader etc.
        // 给当前bf设置一个类加载器，用于加载bd的class信息。
        beanFactory.setBeanClassLoader(getClassLoader());
        // Spring EL 表达式，这个表达式谁解析？ 
        // StandardBeanExpressionResolver .  #{object.a}
        beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
        //BeanWrapper 本身就是属性编辑器注册中心，
        // 属性编辑器作用于beanWrapper内部管理的真实bean 注入 字段值时，
        //当某个字段对应的类型 在 BeanWrapper内 有对应的 属性编辑器，
        // 那么对应类型的字段值 就由该属性编辑器 代理写入。
        beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

        // Configure the bean factory with context callbacks.
        // 添加后处理器，该后处理器 主要用于向bean内部注入一些 框架级别的实例，
        // 比如说：环境变量、ApplicationContext
        beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
        //忽略指定类型的依赖。
        //意思就是说，bean内部有这些类型的字段的话，这些字段 不参与 依赖注入。
        // 统一放在上面的ApplicationContextAwareProcessor里面处理
        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 interface not registered as resolvable type in a plain factory.
        // MessageSource registered (and found for autowiring) as a bean.
        beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
        beanFactory.registerResolvableDependency(ResourceLoader.class, this);
        beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
        beanFactory.registerResolvableDependency(ApplicationContext.class, this);

        // Register early post-processor for detecting inner beans as ApplicationListeners.
        // 该后处理器 将配置的监听者 注册到 ac中。
        beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

        // Detect a LoadTimeWeaver and prepare for weaving, if found.
        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()));
        }

        // Register default environment beans.
        if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
            beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
        }
        if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
            beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
        }
        if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
            beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
        }
    }

4.1 属性编辑器

属性编辑器：属性注入进Bean实例之前，可以通过属性编辑器操作一下。

public class DatePropertyEditorRegistrar implements PropertyEditorRegistrar {
    @Override
    public void registerCustomEditors(PropertyEditorRegistry registry) {
        registry.registerCustomEditor(Date.class, new DatePropertyEditor());
    }
}


public class DatePropertyEditor extends PropertyEditorSupport {
    private String format = "yyyy-MM-dd";

    public void setFormat(String format) {
        this.format = format;
    }

    public void setAsText(String arg0) {
        System.out.println("arg0：" + arg0);
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        try {
            Date d = sdf.parse(arg0);
            this.setValue(d);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="student" class="com.wz.spring.fieldEditor.Student">
        <property name="name" value="zhangsan"/>
        <property name="birthday" value="2000-01-01"/>
    </bean>

    <!-- 自定义属性编辑器 -->
    <bean class = "org.springframework.beans.factory.config.CustomEditorConfigurer">
        <property name="propertyEditorRegistrars">
            <list>
                <bean class="com.wz.spring.fieldEditor.DatePropertyEditorRegistrar"/>
            </list>
        </property>
    </bean>
</beans>

4.2 ApplicationListenerDetector

    @Override
    public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
        if (ApplicationListener.class.isAssignableFrom(beanType)) {
            this.singletonNames.put(beanName, beanDefinition.isSingleton());
        }
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        return bean;
    }


    /**
     * 判断当前创建出来的bean实例 是否是 实现了 ApplicationListener 接口的 实例，如果是，
     * 当前bean就是一个 事件监听器 对象，需要把监听者注册到 ac 中。
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (bean instanceof ApplicationListener) {
            // potentially not detected as a listener by getBeanNamesForType retrieval
            Boolean flag = this.singletonNames.get(beanName);
            if (Boolean.TRUE.equals(flag)) {
                // singleton bean (top-level or inner): register on the fly
                this.applicationContext.addApplicationListener((ApplicationListener<?>) bean);
            }
            else if (Boolean.FALSE.equals(flag)) {
                if (logger.isWarnEnabled() && !this.applicationContext.containsBean(beanName)) {
                    // inner bean with other scope - can't reliably process events
                    logger.warn("Inner bean '" + beanName + "' implements ApplicationListener interface " +
                            "but is not reachable for event multicasting by its containing ApplicationContext " +
                            "because it does not have singleton scope. Only top-level listener beans are allowed " +
                            "to be of non-singleton scope.");
                }
                this.singletonNames.remove(beanName);
            }
        }
        return bean;
    }

5.AbstractApplicationContext#invokeBeanFactoryPostProcessors

    protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        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.
        // 存储已经执行过的bfpp beanName
        Set<String> processedBeans = new HashSet<>();

        // 条件成立：说明当前bf是bd注册中心。bd全部注册到bf内。
        if (beanFactory instanceof BeanDefinitionRegistry) {
            // 将bf 转换成 bdRegistry。
            BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
            // 规整的 普通的 PostProcessor集合。
            List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
            // 存储 BeanDefinitionRegistryPostProcessor 集合。
            // BeanDefinitionRegistryPostProcessor 这种类型的容器后处理器 
            // 可以再向容器内 手动硬编码注册一些bd。
            List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

            // 处理ApplicationContext上面 硬编码注册的一些 bfpp 处理器。
            for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
                if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                    BeanDefinitionRegistryPostProcessor registryProcessor =
                            (BeanDefinitionRegistryPostProcessor) postProcessor;
                    // 这里调用 可以向 bf 内部再次注册一些 bd信息。
                    registryProcessor.postProcessBeanDefinitionRegistry(registry);
                    registryProcessors.add(registryProcessor);
                }
                else {
                    //因为当前postProcessor非registry类型，
                    // 即当前postProcessor是个普通的。就加入到普通集合，后续会统一执行一些方法。
                    regularPostProcessors.add(postProcessor);
                }
            }

            // Do not initialize FactoryBeans here: We need to leave all regular beans
            // uninitialized to let the bean factory post-processors apply to them!
            // Separate between BeanDefinitionRegistryPostProcessors that implement
            // PriorityOrdered, Ordered, and the rest.
            // 临时的，当前阶段的 registry后处理器集合。
            List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

            // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
            //使用bf获取BeanDefinitionRegistryPostProcessor类型的全部beanName
            String[] postProcessorNames =
                    beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            //处理每个beanName，每个beanName其实都是
            // BeanDefinitionRegistryPostProcessor。
            for (String ppName : postProcessorNames) {
                // 判断对应的bean是否实现了 主排序接口PriorityOrdered ，
                // 如果实现了，就让该 bdrpp 添加到 currentRegistryProcessors。
                if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    // 因为接下来马上就是要执行 bfrpp 的 registry 相关接口方法，
                    // 所以将beanName添加到processedBeans 表示已执行。
                    processedBeans.add(ppName);
                }
            }
            //排序，根据order值进行 升序排序。
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            //添加到registry类型后处理器集合内。
            registryProcessors.addAll(currentRegistryProcessors);
            // 调用每个bdrpp的postProcessBeanDefinitionRegistry 方法，
            // 向bf内注册bd信息。
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            // 清空集合。
            currentRegistryProcessors.clear();

            // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
                //!processedBeans.contains(ppName)  确保每个bdrpp只执行一次 注册 bd的逻辑。
                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();

            // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
            // 控制while是否需要再次循环，因为循环内就是查找并执行
            // bdrpp后处理器的registry相关的接口方法。
            // 接口方法执行之后 会向bf 内注册 bd，再次注册的bd 
            // 也有可能是 bdrpp 类型，所以，需要该变量控制while循环。
            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();
            }

            // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
            invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
            // 执行硬编码提供的【beanFactoryPostProcessor】接口实现类的 
            // postProcessBeanFactory() 方法。
            invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
        }

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

        //上面的代码处理了：硬编码提供的bfpp 和 bdrpp 这两种类型的bfpp。
        //还有普通的bfpp需要处理。

        // Do not initialize FactoryBeans here: We need to leave all regular beans
        // uninitialized to let the bean factory post-processors apply to them!
        // 获取容器内注册的bfpp类型的 beanName 数组集合。
        String[] postProcessorNames =
                beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

        // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
        // Ordered, and the rest.
        List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
        List<String> orderedPostProcessorNames = new ArrayList<>();
        List<String> nonOrderedPostProcessorNames = new ArrayList<>();
        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);
            }
        }

        // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
        sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

        // Next, invoke the BeanFactoryPostProcessors that implement 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);

        // Finally, invoke all other BeanFactoryPostProcessors.
        List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
        for (String postProcessorName : nonOrderedPostProcessorNames) {
            nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
        }
        invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

        // Clear cached merged bean definitions since the post-processors might have
        // modified the original metadata, e.g. replacing placeholders in values...
        beanFactory.clearMetadataCache();
    }

6.AbstractApplicationContext#initApplicationEventMulticaster

    protected void initApplicationEventMulticaster() {
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        // 条件成立：说明用户自定义了事件传播器。 
        // 咱们可以实现ApplicationEventMulticaster接口，
        // 写一款自己的事件传播器，通过bean的方式提供给Spring。
        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 {
            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() + "]");
            }
        }
    }

7.AbstractApplicationContext#registerListeners

    protected void registerListeners() {
        // Register statically specified listeners first.
        // 注册硬编码提供的监听器。
        for (ApplicationListener<?> listener : getApplicationListeners()) {
            getApplicationEventMulticaster().addApplicationListener(listener);
        }

        // Do not initialize FactoryBeans here: We need to leave all regular beans
        // uninitialized to let post-processors apply to them!
        // 注册通过配置提供的Listener。
        // 用户可以通过beanDefinition的方式 提供 Listener。
        String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
        for (String listenerBeanName : listenerBeanNames) {
            getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
        }

        // Publish early application events now that we finally have a multicaster...
        Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
        this.earlyApplicationEvents = null;
        if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
            for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
                getApplicationEventMulticaster().multicastEvent(earlyEvent);
            }
        }
    }

8.AbstractApplicationContext#finishBeanFactoryInitialization

    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.
        // 冻结配置信息，冻结bd信息。 冻结之后，就无法再向bf内注册bd。
        beanFactory.freezeConfiguration();

        // Instantiate all remaining (non-lazy-init) singletons.
        // 预初始化非懒加载状态的单实例。
        beanFactory.preInstantiateSingletons();
    }

    public void preInstantiateSingletons() throws BeansException {
        if (logger.isTraceEnabled()) {
            logger.trace("Pre-instantiating singletons in " + this);
        }

        // Iterate over a copy to allow for init methods which in turn register new bean definitions.
        // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
        List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

        // Trigger initialization of all non-lazy singleton beans...
        for (String beanName : beanNames) {
            // 获取bd信息。
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            // 条件成立：说明bd是非抽象 且 是单实例 且 非懒加载，就需要预先实例化出来。
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                //当前beanDefinition对应的class可能是 普通的，也可能是 FactoryBean。
                //条件成立：说明当前bd的class是FactoryBean
                if (isFactoryBean(beanName)) {
                    // 获取FactoryBean实例本身。
                    Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                    if (bean instanceof FactoryBean) {
                        FactoryBean<?> factory = (FactoryBean<?>) bean;
                        boolean isEagerInit;
                        if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                            isEagerInit = AccessController.doPrivileged(
                                    (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
                                    getAccessControlContext());
                        }
                        else {
                            // 控制FactoryBean内部管理的真实bean，在refresh阶段 是否也初始化。
                            isEagerInit = (factory instanceof SmartFactoryBean &&
                                    ((SmartFactoryBean<?>) factory).isEagerInit());
                        }
                        // 需要初始化FactoryBean管理的Bean
                        if (isEagerInit) {
                            getBean(beanName);
                        }
                    }
                }
                else {
                    getBean(beanName);
                }
            }

9.AbstractApplicationContext#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();

        // Publish the final event.
        publishEvent(new ContextRefreshedEvent(this));

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

9.1 initLifecycleProcessor()

    protected void initLifecycleProcessor() {
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        // 条件成立：说明用户自定义了 生命周期处理器。
        if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
            this.lifecycleProcessor =
                    beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
            if (logger.isTraceEnabled()) {
                logger.trace("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
            }
        }
        else {
            // Spring 默认提供的生命周期处理器。
            DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
            defaultProcessor.setBeanFactory(beanFactory);
            this.lifecycleProcessor = defaultProcessor;
            // 将生命周期处理器 注册到 bf的一级缓存内。
            beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
            if (logger.isTraceEnabled()) {
                logger.trace("No '" + LIFECYCLE_PROCESSOR_BEAN_NAME + "' bean, using " +
                        "[" + this.lifecycleProcessor.getClass().getSimpleName() + "]");
            }
        }
    }

9.2 DefaultLifecycleProcessor#onRefresh

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

    /**
     * autoStartupOnly ？
     * true：表示只启动 SmartLifecycle 生命周期对象，并且启动 SmartLifecycle对象它的autoStartup是true。
     *       不会启动 普通的 lifecycle 生命周期对象。
     *
     * false：全部启动。
     */
    private void startBeans(boolean autoStartupOnly) {
        // 获取到所有实现了 Lifecycle接口的对象，
        // 包装到map内，key是beanName,value 是 lifecycle对象。
        Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
        // 因为生命周期对象 可能依赖其它生命周期对象的执行结果，
        // 所以需要执行顺序，靠什么实现呢？
        // 靠 phase 数值，phase 越低的 lifecycle 越先执行 start 方法。
        Map<Integer, LifecycleGroup> phases = new HashMap<>();
        lifecycleBeans.forEach((beanName, bean) -> {
            // true：表示只启动 SmartLifecycle 生命周期对象，
            // 并且启动 SmartLifecycle对象它的autoStartup是true。
            // false ：全部启动。
            if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
                // 获取当前lifecycle对象的 执行排序值。
                int phase = getPhase(bean);
                // LifecycleGroup 内部存储的都是 phase 值一致的 lifecycle。
                LifecycleGroup group = phases.get(phase);
                if (group == null) {
                    group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
                    phases.put(phase, group);
                }
                // 将当前lifecycle添加到 当前phase值一致的 group 内。
                group.add(beanName, bean);
            }
        });
        //执行到这里，lifecycle就按照phase分完组了
        if (!phases.isEmpty()) {
            List<Integer> keys = new ArrayList<>(phases.keySet());
            //从小到大的一个排序。
            Collections.sort(keys);
            for (Integer key : keys) {
                //执行 lifecycleGroup.start() 启动分组内的lifecycle。
                phases.get(key).start();
            }
        }
    }

DefaultLifecycleProcessor.LifecycleGroup#start

        public void start() {
            if (this.members.isEmpty()) {
                return;
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Starting beans in phase " + this.phase);
            }
            //排序..
            Collections.sort(this.members);


            for (LifecycleGroupMember member : this.members) {
                doStart(this.lifecycleBeans, member.name, this.autoStartupOnly);
            }

        }

    private void doStart(Map<String, ? extends Lifecycle> lifecycleBeans, String beanName, boolean autoStartupOnly) {
        // 确保lifecycle只被启动一次。 在一个分组内 被启动了，
        // 其它分组内，就看不到该lifecycle了。
        Lifecycle bean = lifecycleBeans.remove(beanName);
        if (bean != null && bean != this) {
            // 获取当前即将要被启动的lifecycle所依赖的其它beanName
            String[] dependenciesForBean = getBeanFactory().getDependenciesForBean(beanName);
            // 先启动当前lifecycle所依赖的lifecycle。
            for (String dependency : dependenciesForBean) {
                doStart(lifecycleBeans, dependency, autoStartupOnly);
            }
            // true：表示只启动 SmartLifecycle 生命周期对象，
            //   并且启动 SmartLifecycle对象它的autoStartup是true。
            // false ：全部启动。
            if (!bean.isRunning() &&
                    (!autoStartupOnly || !(bean instanceof SmartLifecycle) || ((SmartLifecycle) bean).isAutoStartup())) {
                if (logger.isTraceEnabled()) {
                    logger.trace("Starting bean '" + beanName + "' of type [" + bean.getClass().getName() + "]");
                }
                try {
                    //启动当前lifecycle。
                    bean.start();
                }
                catch (Throwable ex) {
                    throw new ApplicationContextException("Failed to start bean '" + beanName + "'", ex);
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Successfully started bean '" + beanName + "'");
                }
            }
        }
    }

9.3 DefaultLifecycleProcessor#stop

    public void stop() {
        stopBeans();
        this.running = false;
    }

    private void stopBeans() {
        // 获取到所有实现了 Lifecycle接口的对象，
        // 包装到map内，key是beanName,value 是 lifecycle对象。
        Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
        // 因为生命周期对象 可能依赖其它生命周期对象的执行结果，
        // 所以需要执行顺序，靠什么实现呢？
        // 靠 phase 数值，phase 越低的 lifecycle 越晚执行 stop 方法。
        Map<Integer, LifecycleGroup> phases = new HashMap<>();
        lifecycleBeans.forEach((beanName, bean) -> {
            int shutdownPhase = getPhase(bean);
            LifecycleGroup group = phases.get(shutdownPhase);
            if (group == null) {
                group = new LifecycleGroup(shutdownPhase, this.timeoutPerShutdownPhase, lifecycleBeans, false);
                phases.put(shutdownPhase, group);
            }
            group.add(beanName, bean);
        });
        if (!phases.isEmpty()) {
            List<Integer> keys = new ArrayList<>(phases.keySet());
            //降序 ，lifecycle 最先启动的，最晚关闭；最晚启动，最先关闭。
            keys.sort(Collections.reverseOrder());
            for (Integer key : keys) {
                phases.get(key).stop();
            }
        }
    }

DefaultLifecycleProcessor.LifecycleGroup#stop

        public void stop() {
            if (this.members.isEmpty()) {
                return;
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Stopping beans in phase " + this.phase);
            }
            this.members.sort(Collections.reverseOrder());

            // 创建了latch，并且设置latch内部的值为  当前分组内 smartLifecycle的数量。
            CountDownLatch latch = new CountDownLatch(this.smartMemberCount);

            // 保存当前正在处于 关闭ing 的 smartLifecycle beanName。
            Set<String> countDownBeanNames = Collections.synchronizedSet(new LinkedHashSet<>());

            // bf 全部的lifecycle BeanNames
            Set<String> lifecycleBeanNames = new HashSet<>(this.lifecycleBeans.keySet());

            // 处理本分组内的需要关闭的 lifecycle。
            for (LifecycleGroupMember member : this.members) {

                if (lifecycleBeanNames.contains(member.name)) {

                    doStop(this.lifecycleBeans, member.name, latch, countDownBeanNames);
                }
                else if (member.bean instanceof SmartLifecycle) {
                    // Already removed: must have been a dependent bean from another phase
                    latch.countDown();
                }
            }


            try {
                // 关闭分组lifecycle的主线程，会在这里等待，等待latch 归0，或者超时。   30s.
                latch.await(this.timeout, TimeUnit.MILLISECONDS);

                if (latch.getCount() > 0 && !countDownBeanNames.isEmpty() && logger.isInfoEnabled()) {
                    logger.info("Failed to shut down " + countDownBeanNames.size() + " bean" +
                            (countDownBeanNames.size() > 1 ? "s" : "") + " with phase value " +
                            this.phase + " within timeout of " + this.timeout + "ms: " + countDownBeanNames);
                }
            }
            catch (InterruptedException ex) {
                Thread.currentThread().interrupt();
            }
        }
    }

    private void doStop(Map<String, ? extends Lifecycle> lifecycleBeans, final String beanName,
            final CountDownLatch latch, final Set<String> countDownBeanNames) {

        Lifecycle bean = lifecycleBeans.remove(beanName);
        if (bean != null) {
            // 依赖当前lifecycle的其它对象 beanName.
            String[] dependentBeans = getBeanFactory().getDependentBeans(beanName);
            // 因为当前lifecycle即将要关闭了，所以那些依赖了 
            // 当前lifecycle的bean，如果也是lifecycle对象的话，也要先于当前对象关闭。
            for (String dependentBean : dependentBeans) {
                doStop(lifecycleBeans, dependentBean, latch, countDownBeanNames);
            }
            try {
                if (bean.isRunning()) {
                    if (bean instanceof SmartLifecycle) {
                        if (logger.isTraceEnabled()) {
                            logger.trace("Asking bean '" + beanName + "' of type [" +
                                    bean.getClass().getName() + "] to stop");
                        }
                        // 将当前SmartLifecycle beanName 添加到 
                        // countDownBeanNames 集合内，该集合表示正在关闭的 smartLifecycle。
                        countDownBeanNames.add(beanName);
                        // Smartlifecycle 可以传递一个Callback ，
                        // 理论上可以支持异步关闭 生命周期 对象了。
                        ((SmartLifecycle) bean).stop(() -> {
                            latch.countDown();
                            countDownBeanNames.remove(beanName);
                            if (logger.isDebugEnabled()) {
                                logger.debug("Bean '" + beanName + "' completed its stop procedure");
                            }
                        });
                    }
                    else {
                        // 普通的lifecycle 对象，直接调用 lifecycle.stop() 
                        if (logger.isTraceEnabled()) {
                            logger.trace("Stopping bean '" + beanName + "' of type [" +
                                    bean.getClass().getName() + "]");
                        }
                        bean.stop();
                        if (logger.isDebugEnabled()) {
                            logger.debug("Successfully stopped bean '" + beanName + "'");
                        }
                    }
                }
                else if (bean instanceof SmartLifecycle) {
                    // Don't wait for beans that aren't running...
                    latch.countDown();
                }
            }
            catch (Throwable ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Failed to stop bean '" + beanName + "'", ex);
                }
            }
        }
    }