1 @SpringBootApplication
2 public class Application {
3     public static void main(String[] args) {
4         SpringApplication.run(Application.class, args);
5     }
6 }

public ConfigurableApplicationContext run(String... args) {

    // 任务执行计时监听器
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    ConfigurableApplicationContext context = null;
    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
    // 设置系统java.awt.headless属性，确定是否开启headless模式(默认开启headless模式)
    configureHeadlessProperty();
    // SpringApplication run方法的监听器，通过 SpringFactoriesLoader 加载
    SpringApplicationRunListeners listeners = getRunListeners(args);
    // 启动监听器
    listeners.starting();
    try {

        // 创建 SpringBoot 默认启动参数
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        // 用于设置活动和默认配置文件以及操作基础属性源的工具，即配置启动环境
        ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
        // 配置对不存在的BeanInfo类的重复 ClassLoader 访问
        configureIgnoreBeanInfo(environment);
        // 打印LOGO
        Banner printedBanner = printBanner(environment);
        // 创建合适的 ApplicationContext
        context = createApplicationContext();
        // SpringBoot 启动错误的回调接口，通过 SpringFactoriesLoader 加载
        exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
                new Class[] { ConfigurableApplicationContext.class }, context);
        // 准备 Spring 上下文
        // 在这个方法中，主要完成了以下几件事：
        //  1、设置SpringBoot的环境配置(Environment)
        //  2、注册Spring Bean名称的序列化器BeanNameGenerator，并设置资源加载器ResourceLoader
        //  3、加载ApplicationContextInitializer初始化器，并进行初始化
        //  4、统一将上面的Environment、BeanNameGenerator、ResourceLoader使用默认的Bean注册器进行注册
        prepareContext(context, environment, listeners, applicationArguments, printedBanner);
        // 注册销毁上下文的钩子
        // 刷新 Spring 上下文
        refreshContext(context);
        // 刷新后处理
        afterRefresh(context, applicationArguments);
        // 停止计时监听器
        stopWatch.stop();
        if (this.logStartupInfo) {
            // 打印计时器日志
            new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
        }
        // 上下文已刷新且应用程序已启动
        listeners.started(context);
        // 运行 ApplicationRunner 和 CommandLineRunner 的实现类
        // 二者区别在于入参不同
        callRunners(context, applicationArguments);
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, exceptionReporters, listeners);
        throw new IllegalStateException(ex);
    }

    try {
        // 发布事件以指示应用程序已准备好上下文环境为请求提供服务
        listeners.running(context);
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, exceptionReporters, null);
        throw new IllegalStateException(ex);
    }
    return context;
}

@Override
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // 准备此上下文以进行刷新。
        prepareRefresh();

        // 解析所有 Spring 配置文件,
        // 将所有 Spring 配置文件中的 bean 定义封装成 BeanDefinition，
        // 加载到 BeanFactory 中
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // 配置 beanFactory 的标准上下文特征，
        // 例如上下文的 ClassLoader、后置处理器等
        prepareBeanFactory(beanFactory);

        try {
            // 允许在上下文子类中对 BeanFactory 进行后续处理，
            // 默认实现为空，留给子类实现。
            postProcessBeanFactory(beanFactory);

            // 实例化和调用所有 BeanFactoryPostProcessor
            // BeanFactoryPostProcessor 接口是 Spring 初始化 BeanFactory 时对外暴露的扩展点，
            // Spring IoC 容器允许 BeanFactoryPostProcessor 在容器实例化任何 bean 之前读取 bean 的定义，并可以修改它。
            invokeBeanFactoryPostProcessors(beanFactory);

            // 注册拦截 BeanPostProcessor，
            // 将所有实现了 BeanPostProcessor 接口的类加载到 BeanFactory 中。
            // BeanFactoryPostProcessor 是针对 BeanFactory 的扩展，
            // 主要用在 bean 实例化之前，读取 bean 的定义，并可以修改它。
            registerBeanPostProcessors(beanFactory);

            // 初始化此上下文的消息源。 
            initMessageSource();

            // 为此上下文初始化应用的事件广播器 ApplicationEventMulticaster
            initApplicationEventMulticaster();

            // 初始化特定上下文子类中的其他特殊bean ，默认实现为空。
            onRefresh();

            // 检查监听器bean并注册它们。 
            registerListeners();

            // 实例化所有剩余的（非懒加载）单例。 
            finishBeanFactoryInitialization(beanFactory);

            // 最后一步：发布相应的事件。 
            // 完成此上下文的刷新，主要是推送上下文刷新完毕事件（ContextRefreshedEvent ）到监听器。
            finishRefresh();
        }

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

            // 销毁已创建的单例以避免闲置资源（清理不被引用的 Bean）。 
            destroyBeans();

            // 重置“active”标志。 
            cancelRefresh(ex);

            // 将异常传播到调用方。 
            throw ex;
        }

        finally {
            // 重置Spring核心中的常见内省缓存，因为我们
            // 可能不再需要单例bean的元数据了。。。
            resetCommonCaches();
        }
    }
}

protected List<AutoConfigurationImportFilter> getAutoConfigurationImportFilters() {
        return SpringFactoriesLoader.loadFactories(AutoConfigurationImportFilter.class, this.beanClassLoader);
    }

public static <T> List<T> loadFactories(Class<T> factoryType, @Nullable ClassLoader classLoader) {
    Assert.notNull(factoryType, "‘factoryType‘ must not be null");
    ClassLoader classLoaderToUse = classLoader;
    if (classLoaderToUse == null) {
        classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
    }
    // 加载配置文件 META-INF/spring.factories，获取自动配置的类路径，即加载 Resource 资源
    List<String> factoryImplementationNames = loadFactoryNames(factoryType, classLoaderToUse);
    if (logger.isTraceEnabled()) {
        logger.trace("Loaded [" + factoryType.getName() + "] names: " + factoryImplementationNames);
    }
    List<T> result = new ArrayList<>(factoryImplementationNames.size());
    for (String factoryImplementationName : factoryImplementationNames) {
        // 通过反射初始化 Bean factory
        result.add(instantiateFactory(factoryImplementationName, factoryType, classLoaderToUse));
    }
    AnnotationAwareOrderComparator.sort(result);
    return result;
}