SpringBoot启动流程SpringApplication准备阶段源码分析

下面就详细讲解一下“SpringBoot启动流程SpringApplication准备阶段源码分析”的完整攻略。SpringBoot启动流程可以分为准备阶段、运行阶段、关闭阶段三个阶段，而本篇主要介绍SpringApplication的准备阶段。

SpringBoot启动流程简介

SpringBoot启动流程包括如下三个阶段：

1. 准备阶段：包括ApplicationContext的初始化、Environment的初始化等。
2. 运行阶段：包括@Configuration、@SpringBootApplication加载实例化、自定义监听器的加载、加载web容器等。
3. 关闭阶段：容器的销毁、自定义销毁器的调用等。

在三个阶段中，准备阶段是SpringBoot启动的基础。其中，SpringApplication负责整个启动流程的控制。

SpringApplication准备阶段源码分析

1. run方法

SpringApplication的主要方法是run方法。当我们在Main方法中启动SpringBoot时，SpringApplication的run方法会被执行。

在这个方法中，SpringApplication会先创建一个SpringApplicationRunListeners对象，并调用它的starting方法。

public ConfigurableApplicationContext run(String... args) {
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    ConfigurableApplicationContext context = null;
    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
    configureHeadlessProperty();
    SpringApplicationRunListeners listeners = getRunListeners(args);
    listeners.starting();
    try {
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
        configureIgnoreBeanInfo(environment);
        Banner printedBanner = printBanner(environment);
        context = createApplicationContext();
        exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
                new Class[] { ConfigurableApplicationContext.class }, 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;
}

2. prepareEnvironment方法

prepareEnvironment方法是准备环境变量的过程，即将ConfigurableEnvironment对象的属性设置好，后续创建IOC容器和相关环境时需要用到。

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
        ApplicationArguments applicationArguments) {
    ConfigurableEnvironment environment = getOrCreateEnvironment();
    configureEnvironment(environment, applicationArguments.getSourceArgs());
    listeners.environmentPrepared(environment);
    if (this.addConversionService) {
        ConversionService conversionService = ApplicationConversionService.getSharedInstance();
        environment.setConversionService((ConfigurableConversionService) conversionService);
    }
    configurePropertySources(environment, applicationArguments.getSourceArgs());
    if (!this.isCustomEnvironment) {
        environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment, deduceEnvironmentClass());
    }
    ConfigurationPropertySources.attach(environment);
    return environment;
}

在这个方法中，首先使用getOrCreateEnvironment方法，获取或者创建ConfigurableEnvironment对象。然后通过方法configureEnvironment和configurePropertySources对ConfigurableEnvironment进行初始化。这些方法里面设置了一些常用的环境配置，比如设置环境的名称、激活的profiles、加载配置文件等等。最后，SpringApplication会将ConfigurableEnvironment转换成Environment对象，将其放到Environment中，以备后续使用。

3. configureHeadlessProperty方法

configureHeadlessProperty方法用于设置系统参数java.awt.headless的值，默认值为：System.getProperty("java.awt.headless", Boolean.FALSE.toString())。

private void configureHeadlessProperty() {
    System.setProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, Boolean.toString(this.headless));
}

4. configureIgnoreBeanInfo方法

configureIgnoreBeanInfo方法设置了系统参数spring.beaninfo.ignore的值，用于禁止Spring加载一些bean信息，加快Spring启动速度。

private void configureIgnoreBeanInfo(ConfigurableEnvironment environment) {
    if (this.beanInfoFactories.isEmpty()) {
        System.setProperty("spring.beaninfo.ignore", "true");
    }
    else {
        for (BeanInfoFactory beanInfoFactory : this.beanInfoFactories) {
            BeanInfoUtils.registerBeanInfo(beanInfoFactory);
        }
    }
}

5. getRunListeners方法

getRunListeners方法是获取SpringApplicationRunListeners对象的方法，这里会通过Spring Factories的方式，获取所有SpringApplicationRunListener的实现。

private SpringApplicationRunListeners getRunListeners(String[] args) {
    Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };
    return new SpringApplicationRunListeners(logger,
            getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args));
}

之后，SpringApplication会先调用SpringApplicationRunListeners的starting方法，并执行所有SpringApplicationRunListener的starting方法。

public void starting() {
    for (SpringApplicationRunListener listener : this.listeners) {
        listener.starting();
    }
}

至此，SpringApplication的准备阶段就已经完成了。接下来就是SpringApplication的运行阶段和关闭阶段。在这个过程中，SpringApplication会初始化Springboot的配置，并在ApplicationContext中启动所有的bean，为我们提供便捷的web服务。

代码示例1：SpringApplication的基本使用

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

代码示例2：多环境配置SpringApplication的使用

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(Application.class);
        app.setDefaultProperties(Collections.singletonMap("server.port", "8083"));
        app.run(args);
    }
}

以上简要地介绍了SpringBoot启动流程SpringApplication的准备阶段源码分析以及两个代码示例。希望对你有所帮助。