Spring Boot 的启动过程，表面上看只是一个 SpringApplication.run() 的调用，但背后藏着一条高度结构化的执行链路。很多开发者只把它当黑盒用，遇到问题却不知道从哪下手。下面这张图概括了整体流程，而核心逻辑全写在 SpringApplication 这个类里——我们直接看源码，比看任何文档都实在。

先看最经典的入口：一个 @SpringBootApplication 注解的类，配合 SpringApplication.run()。实际上 run 方法内部会先创建一个 SpringApplication 实例，再调用它的 run 方法。就是这么一层包装，把初始化、环境准备、容器创建、监听器触发等等全部串联起来。

@SpringBootApplication
public class Application {
    public static void main(String[] args){
        SpringApplication.run(Application.class, args);
    }
}

public class SpringApplication {
    public static ConfigurableApplicationContext run(Class[] primarySources,
            String[] args) {
        return new SpringApplication(primarySources).run(args);
    }

    public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
        //资源加载器
        this.resourceLoader = resourceLoader;
        this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
        //推断出要创建的容器类型
        this.webApplicationType = deduceWebApplicationType();
        //实例化所有的ApplicationContextInitializer
        setInitializers((Collection) getSpringFactoriesInstances(
                ApplicationContextInitializer.class));
        //实例化所有的ApplicationListener
        setListeners((Collection) getSpringFactoriesInstances(
                ApplicationListener.class));
        this.mainApplicationClass = deduceMainApplicationClass();
    }

    public ConfigurableApplicationContext run(String... args) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        ConfigurableApplicationContext context = null;
        Collection exceptionReporters = new ArrayList<>();
        configureHeadlessProperty();

        //把SpringApplication的启动过程分成的很多阶段，每个阶段都有相应的事件抛出,
        //然后会有一些监听器监听整个启动过程。
        SpringApplicationRunListeners listeners = getRunListeners(args);
        listeners.starting();

        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);

            //准备环境，并将配置文件中的配置加载到environment中
            ConfigurableEnvironment environment = prepareEnvironment(listeners,
                    applicationArguments);
            configureIgnoreBeanInfo(environment);
            Banner printedBanner = printBanner(environment);

            //创建applicationContext
            context = createApplicationContext();

            exceptionReporters = getSpringFactoriesInstances(
                    SpringBootExceptionReporter.class,
                    new Class[] { ConfigurableApplicationContext.class }, context);

            //准备context
            prepareContext(context, environment, listeners, applicationArguments,
                    printedBanner);

            //创建相关的对象，并注册到容器中
            refreshContext(context);
            afterRefresh(context, applicationArguments);

            stopWatch.stop();
            if (this.logStartupInfo) {
                new StartupInfoLogger(this.mainApplicationClass)
                        .logStarted(getApplicationLog(), stopWatch);
            }

            listeners.started(context);
            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;
    }

    private ConfigurableEnvironment prepareEnvironment(
            SpringApplicationRunListeners listeners,
            ApplicationArguments applicationArguments) {
        // Create and configure the environment
        //创建一个可配置的environment对象，所有的配置都会放在这个对象中
        ConfigurableEnvironment environment = getOrCreateEnvironment();

        //默认配置设置到environment,配置profile
        configureEnvironment(environment, applicationArguments.getSourceArgs());

        //事件监听，其中ConfigFileApplicationListener将配置文件里面的配置都加载到environment中
        listeners.environmentPrepared(environment);
        bindToSpringApplication(environment);

        if (this.webApplicationType == WebApplicationType.NONE) {
            environment = new EnvironmentConverter(getClassLoader())
                    .convertToStandardEnvironmentIfNecessary(environment);
        }
        ConfigurationPropertySources.attach(environment);
        return environment;
    }

    protected void configureEnvironment(ConfigurableEnvironment environment,
            String[] args) {
        //把设置的默认的配置和命令行配置加到environment中
        configurePropertySources(environment, args);
        //配置profile到environment中
        configureProfiles(environment, args);
    }

    private void prepareContext(ConfigurableApplicationContext context,
            ConfigurableEnvironment environment,
            SpringApplicationRunListeners listeners,
            ApplicationArguments applicationArguments, Banner printedBanner) {
        context.setEnvironment(environment);
        postProcessApplicationContext(context);

        //调用ApplicationContextInitializer的initialize()方法
        applyInitializers(context);

        listeners.contextPrepared(context);
        if (this.logStartupInfo) {
            logStartupInfo(context.getParent() == null);
            logStartupProfileInfo(context);
        }

        // Add boot specific singleton beans
        context.getBeanFactory().registerSingleton("springApplicationArguments",
                applicationArguments);
        if (printedBanner != null) {
            context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
        }

        // Load the sources
        Set