源码分析SpringBoot启动

时间 2019-11-07

原文原文链接

遇到一个问题，须要从yml文件中读取数据初始化到static的类中。搜索须要实现ApplicationRunner，并在其实现类中把值读出来再set进去。因而乎就想探究一下SpringBoot启动中都干了什么。

引子

就像引用中说的，用到了ApplicationRunner类给静态class赋yml中的值。代码先量一下，是这样：web

@Data
@Component
@EnableConfigurationProperties(MyApplicationRunner.class)
@ConfigurationProperties(prefix = "flow")
public class MyApplicationRunner implements ApplicationRunner {

    private String name;
    private int age;
    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("ApplicationRunner...start...");
        MyProperties.setAge(age);
        MyProperties.setName(name);
        System.out.println("ApplicationRunner...end...");
    }
}

public class  MyProperties {
    private static String name;
    private static int age;
    public static String getName() {
        return name;
    }
    public static void setName(String name) {
        MyProperties.name = name;
    }
    public static int getAge() {
        return age;
    }
    public static void setAge(int age) {
        MyProperties.age = age;
    }
}

从SpringApplication开始

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

这是一个SpringBoot启动入口，整个项目环境搭建和启动都是从这里开始的。咱们就从SpringApplication.run()点进去看一下，Spring Boot启动的时候都作了什么。点进去run看一下。spring

public static ConfigurableApplicationContext run(Class<?> primarySource,
        String... args) {
    return run(new Class<?>[] { primarySource }, args);
}

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

首先通过了两个方法，立刻就要进入关键了。SpringApplication(primarySources).run(args)，这句话作了两件事，首先初始化SpringApplication，而后进行开启run。首先看一下初始化作了什么。app

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();
}

首先读取资源文件Resource,而后读取FlowApplication这个类信息（就是primarySources），而后从classPath中肯定是什么类型的项目，看一眼WebApplicationType这里面有三种类型：less

public enum WebApplicationType {
    NONE, //不是web项目
    SERVLET,//是web项目
    REACTIVE;//2.0以后新加的，响应式项目
    ...
}

回到SpringApplication接着看，肯定好项目类型以后，初始化一些信息setInitializers()，getSpringFactoriesInstances()看一下都进行了什么初始化：ide

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

首先获得ClassLoader，这个里面记录了全部项目package的信息、全部calss的信息啊什么什么的，而后初始化各类instances，在排个序，ruturn之。post

再回到SpringApplication，接着是设置监听器setListeners()。this

而后设置main方法，mainApplicationClass()，点进deduceMainApplicationClass()看一看：spa

private Class<?> deduceMainApplicationClass() {
    try {
        StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
        for (StackTraceElement stackTraceElement : stackTrace) {
            if ("main".equals(stackTraceElement.getMethodName())) {
                return Class.forName(stackTraceElement.getClassName());
            }
        }
    }
    catch (ClassNotFoundException ex) {
        // Swallow and continue
    }
    return null;
}

从方法栈stackTrace中，不断读取方法，经过名称，当读到“main”方法的时候，得到这个类实例，return出去。日志

到这里，全部初始化工做结束了，也找到了Main方法，ruturn给run()方法，进行后续项目的项目启动。code

准备好，开始run吧

先上代码：

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;
}

首先开启一个计时器，记录下此次启动时间，我们项目开启 XXXms statred 就是这么计算来的。
而后是一堆声明，知道listeners.starting()，这个starting()，我看了一下源码注释

Called immediately when the run method has first started. Can be used for very
early initialization.

早早初始化，是为了后面使用，看到后面还有一个方法listeners.started()

Called immediately before the run method finishes, when the application context has been refreshed and all {@link CommandLineRunner CommandLineRunners} and {@link ApplicationRunner ApplicationRunners} have been called.

这会儿应该才是真正的开启完毕，值得一提的是，这里终于看到了引子中的ApplicationRunner这个类了，莫名的有点小激动呢。

咱们继续进入try，接下来是读取一些参数applicationArguments，而后进行listener和environment的一些绑定。而后打印出Banner图，printBanner(),这个方法里面能够看到把environment，也存入Banner里面了，应该是为了方便打印，若是有日志模式，也打印到日志里面，因此，项目启动的打印日志里面记录了不少东西。

private Banner printBanner(ConfigurableEnvironment environment) {
    if (this.bannerMode == Banner.Mode.OFF) {
        return null;
    }
    ResourceLoader resourceLoader = (this.resourceLoader != null)
            ? this.resourceLoader : new DefaultResourceLoader(getClassLoader());
    SpringApplicationBannerPrinter bannerPrinter = new SpringApplicationBannerPrinter(
            resourceLoader, this.banner);
    if (this.bannerMode == Mode.LOG) {
        return bannerPrinter.print(environment, this.mainApplicationClass, logger);
    }
    return bannerPrinter.print(environment, this.mainApplicationClass, System.out);
}

接着生成上下文环境 context = createApplicationContext();还记着webApplicationType三种类型吗，这边是根据webApplicationType类型生成不一样的上下文环境类的。

接着开启 exceptionReporters，用来支持启动时的报错。

接着就要准备往上下文中set各类东西了，看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<Object> sources = getAllSources();
    Assert.notEmpty(sources, "Sources must not be empty");
    load(context, sources.toArray(new Object[0]));
    listeners.contextLoaded(context);
}

首先把环境environment放进去，而后把resource信息也放进去，再让全部的listeners知道上下文环境。 这个时候，上下文已经读取yml文件了 因此这会儿引子中yml建立的参数，上下文读到了配置信息，又有点小激动了！接着看，向beanFactory注册单例bean：一个参数bean，一个Bannerbean。

prepareContext() 这个方法大概先这样，而后回到run方法中，看看项目启动还干了什么。

refreshContext(context) 接着要刷新上下问环境了，这个比较重要，也比较复杂，今天只看个大概，有机会另外写一篇博客，说说里面的东西，这里面主要是有个refresh()方法。看注释可知，这里面进行了Bean工厂的建立，激活各类BeanFactory处理器，注册BeanPostProcessor，初始化上下文环境，国际化处理，初始化上下文事件广播器，将全部bean的监听器注册到广播器（这样就能够作到Spring解耦后Bean的通信了吧）

总之，Bean的初始化咱们已经作好了，他们直接也能够很好的通信。

接着回到run方法，
afterRefresh(context, applicationArguments); 这方法里面没有任何东西，网上查了一下，说这里是个拓展点，有机会研究下。

接着stopWatch.stop();启动就算完成了，由于这边启动时间结束了。
我正要失落的发现没找到咱们引子中说到的ApplicationRunner这个类,就在下面看到了最后一个方法，必须贴出来源码：
callRunners(context, applicationArguments)，固然这个方法前面还有listeners.started().

private void callRunners(ApplicationContext context, ApplicationArguments args) {
    List<Object> runners = new ArrayList<>();
    runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
    runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
    AnnotationAwareOrderComparator.sort(runners);
    for (Object runner : new LinkedHashSet<>(runners)) {
        if (runner instanceof ApplicationRunner) {
            callRunner((ApplicationRunner) runner, args);
        }
        if (runner instanceof CommandLineRunner) {
            callRunner((CommandLineRunner) runner, args);
        }
    }
}

看到没，这会就执行了ApplicationRunner 方法（至于CommandLineRunner，和ApplicationRunner相似，只是参数类型不一样，这边不作过多区分先）。因此能够说ApplicationRunner不是启动的一部分，不记录进入SpringBoot启动时间内，这也好理解啊，你本身初始化数据的时间凭什么算到我SpringBoot身上，你要初始化的时候作了个费时操做，回头又说我SpringBoot辣鸡，那我不是亏得慌...

最后run下这个，listeners.running(context);这会儿用户自定义的事情也会被调用了。

ok，结束了。

小结

今天只是大概看了下SpringBoot启动过程。有不少细节，好比refresh()都值得再仔细研究一下。SpringBoot之因此好用，就是帮助咱们作了不少配置，省去不少细节（不得不说各类stater真实让咱们傻瓜式使用了不少东西），可是一样定位bug或者经过项目声明周期搞点事情的时候会无从下手。因此，看看SpringBoot源码仍是听有必要的。