从入门到放弃SpringBoot启动源码分析

前言

上一篇文章我们简单聊了MySQL的数据库连接过程，写完之后自己读了一遍，感觉分析得还不够透。很多细节其实并没有真正捋清楚，所以这次干脆从Springboot的源码入手，重新从头走一遍。

main 入口分析

package com.springboot.demo;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.scheduling.annotation.EnableScheduling;

@MapperScan("com.springboot.demo.repository.dao")
@SpringBootApplication
@EnableScheduling
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

一个最简单的Springboot项目，启动类里就一行代码。别小看这一行，背后藏着一整套路。我们就从这行开始拆。

SpringApplication::SpringApplication

public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
    this.resourceLoader = resourceLoader;
    Assert.notNull(primarySources, "PrimarySources must not be null");
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    this.mainApplicationClass = deduceMainApplicationClass();
}

构造方法的主要工作就是初始化一堆成员变量：参数列表、应用类型、监听器等等。注意这里的 WebApplicationType.deduceFromClasspath()，它会根据classpath下有没有某些类来判断是web环境还是非web环境。

getSpringFactoriesInstances

private  Collection getSpringFactoriesInstances(Class type,
        Class[] parameterTypes, Object... args) {
    ClassLoader classLoader = getClassLoader();
    // Use names and ensure unique to protect against duplicates
    Set names = new LinkedHashSet<>(
            SpringFactoriesLoader.loadFactoryNames(type, classLoader));
    List instances = createSpringFactoriesInstances(type, parameterTypes,
            classLoader, args, names);
    AnnotationAwareOrderComparator.sort(instances);
    return instances;
}

这个方法说白了就是根据传入的type，从 META-INF/spring.factories 里捞出一堆配置类名，然后一一实例化。过程中还做了去重和排序，挺严谨。

loadFactoryNames 负责读文件，createSpringFactoriesInstances 负责校验类型（必须是parameterTypes的子类）并通过反射创建实例。

SpringApplication::run

/**
 * Run the Spring application, creating and refreshing a new
 * {@link ApplicationContext}.
 * @param args the application arguments (usually passed from a Ja va main method)
 * @return a running {@link ApplicationContext}
 */
public ConfigurableApplicationContext run(String... args) {
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    ConfigurableApplicationContext context = null;
    Collection 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;
}

整个启动流程都在这个 run 方法里了。下面我们拆开看每一步。

StopWatch

一个计时器，先记下启动的时间点，最后用来算耗时。

变量初始化

各种临时变量的准备工作，后面会一步步用上。

configureHeadlessProperty

设置系统属性 ja va.awt.headless 为 true。说白了就是告诉操作系统：这个服务端程序不需要显示器、鼠标、键盘这些外设，如果代码里用到了图形资源，自己模拟就好了。

getRunListeners

从 spring.factories 中加载并实例化所有 SpringApplicationRunListener，这些监听器负责在启动的不同阶段广播事件。

prepareEnvironment

配置环境：加载配置文件、系统变量、命令行参数等，然后通过监听器广播环境准备完毕的事件。

printBanner

打印启动时那个标志性的横幅。

createApplicationContext

根据 webApplicationType 创建对应的 Spring 上下文实例。

exceptionReporters

初始化异常报告器，一旦启动过程中间出异常，这些报告器会负责输出友好信息。

prepareContext

private void prepareContext(ConfigurableApplicationContext context,
        ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
        ApplicationArguments applicationArguments, Banner printedBanner) {
    context.setEnvironment(environment);
    postProcessApplicationContext(context);
    applyInitializers(context);
    listeners.contextPrepared(context);
    if (this.logStartupInfo) {
        logStartupInfo(context.getParent() == null);
        logStartupProfileInfo(context);
    }
    // Add boot specific singleton beans
    ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
    beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
    if (printedBanner != null) {
        beanFactory.registerSingleton("springBootBanner", printedBanner);
    }
    if (beanFactory instanceof DefaultListableBeanFactory) {
        ((DefaultListableBeanFactory) beanFactory)
                .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
    }
    // Load the sources
    Set