spring boot项目03：阅读启动源码

Eclipse版本：2021-03 (4.19.0)

Java：8

Spring Boot：spring-boot-starter-parent#2.5.2（对于的spring-core/context/beans的版本为 5.3.8）

项目：nothing - 非Web项目，web - Web项目

技能GET：Debug（调试，Step Into/Over/Return）

目录

概述

项目启动调试

第一步） new SpringApplication(primarySources)

第二步）.run(args)

---

概述

Spring Boot依赖于Spring Framework，而Spring Framework的核心是 Spring Core、Spring Context、Spring Beans。

Spring容器 是其中的核心，用来管理（装） Spring应用的 所有Bean及其关系，涉及到 BeanFactory、ApplicationContext 两个核心接口，其中，ApplicationContext 是 BeanFactory 的子孙接口。

ApplicationContext 接口：

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
        MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
    // ...
}

ApplicationContext 除了 Bean管理外，还有其它的功能，所以才继承了更多接口。

ApplicationContext 也有很多子孙接口及实现类，用来搭配不同的应用——非Web、Web-Servlet、Web-Reactive应用 3种（参考 WebApplicationType 枚举类）。

项目启动调试

调用静态函数 SpringApplication#run

ConfigurableApplicationContext context = SpringApplication.run(NothingApplication.class, args);

ConfigurableApplicationContext context = SpringApplication.run(WebApplication.class, args);

其下调用了：

new SpringApplication(primarySources).run(args);

分为两步：

第一步）new SpringApplication(primarySources)

第二步）.run(args)

启动完毕后，返回一个 ConfigurableApplicationContext  对象，这个对象是 ApplicationContext 接口的 子接口：

public interface ConfigurableApplicationContext extends ApplicationContext, Lifecycle, Closeable {
}

通过这个 ConfigurableApplicationContext 对象，可以获取 Spring容器中 所有Bean的信息，比如，总数、各个Bean的名称等。

非Web应用 Bean数量：
44

Web应用 Bean数量：
137

当然，ApplicationContext 在开发时还有更多用途。

下面分别介绍启动的两步对 ApplicationContext 的影响——主要是 容器中 Bean的变化。

第一步） new SpringApplication(primarySources)

添加断点：

开始调试（Debug As）：

程序停止了上面。

点击 左上角的 Step Into，进入 SpringApplication 构造函数。再次Step Into 可以进入下面的构造函数：

    @SuppressWarnings({ "unchecked", "rawtypes" })
    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();
        this.bootstrapRegistryInitializers = getBootstrapRegistryInitializersFromSpringFactories();
        setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        this.mainApplicationClass = deduceMainApplicationClass();
    }

点击Step Over可以一步一步检查执行情况：构造函数会调到基本参数设置的地方，最后才进入 构造函数 上面的函数体。

第6行 判断 应用类型，结果是 前面提到的 3种。Step Over到这一行后，可以执行 Step Into 进入查看：

    static WebApplicationType deduceFromClasspath() {
        if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
                && !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
            return WebApplicationType.REACTIVE;
        }
        for (String className : SERVLET_INDICATOR_CLASSES) {
            if (!ClassUtils.isPresent(className, null)) {
                return WebApplicationType.NONE;
            }
        }
        return WebApplicationType.SERVLET;
    }

在本文的项目中，nothing 返回的是 NONE，web返回的是 SERVLET。

项目不同，建立的 ApplicationContext 也不同，这也是上面 两个项目初始化时 容器中具有不同 Bean数量的原因。

查看完毕，可以点击Step Return直接返回。

SpringApplication 初始化最后是 设置 bootstrapRegistryInitializers、initializers、listeners，都会调用 getSpringFactoriesInstances 函数获取实例。

Step Over到最后一步时，可以查看 右边 this对象（SpringApplication对象）的各个参数的值：

上面 红框中的 initializers、listeners 是有值的——在后面的步骤中会用到，bootstrapRegistryInitializers为空：

# initializers
[org.springframework.boot.context.config.DelegatingApplicationContextInitializer@55de24cc, 
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer@dc7df28, 
org.springframework.boot.context.ContextIdApplicationContextInitializer@30f842ca, 
org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer@69c81773, 
org.springframework.boot.rsocket.context.RSocketPortInfoApplicationContextInitializer@4d14b6c2, 
org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer@7e990ed7, 
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener@c05fddc]


# listeners
[org.springframework.boot.env.EnvironmentPostProcessorApplicationListener@25df00a0, 
org.springframework.boot.context.config.AnsiOutputApplicationListener@4d15107f, 
org.springframework.boot.context.logging.LoggingApplicationListener@7b4c50bc, 
org.springframework.boot.autoconfigure.BackgroundPreinitializer@5884a914, 
org.springframework.boot.context.config.DelegatingApplicationListener@50378a4, 
org.springframework.boot.builder.ParentContextCloserApplicationListener@60f00693, 
org.springframework.boot.ClearCachesApplicationListener@79207381, 
org.springframework.boot.context.FileEncodingApplicationListener@491b9b8]

执行完毕， 即 SpringApplication 对象初始化完毕，接下来执行第二步——回到断点行时，再次执行 Step Into。

第二步）.run(args)

进入 run函数，来看看源码：

    public ConfigurableApplicationContext run(String... args) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        DefaultBootstrapContext bootstrapContext = createBootstrapContext();
        ConfigurableApplicationContext context = null; // 需要返回的 ApplicationContext对象
        configureHeadlessProperty();
        SpringApplicationRunListeners listeners = getRunListeners(args);
        listeners.starting(bootstrapContext, this.mainApplicationClass); // 开始启动
        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
            configureIgnoreBeanInfo(environment);
            Banner printedBanner = printBanner(environment); // 执行Banner输出，可以配置不输出
            context = createApplicationContext(); // 重点1：创建ApplicationContext
            context.setApplicationStartup(this.applicationStartup);
            prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner); // 重点2：执行后，将主类对象添加到 spring容器
            refreshContext(context); // 重点3：执行后更改了更多Context的属性，并添加了更多Bean！！！
            afterRefresh(context, applicationArguments);
            stopWatch.stop(); // 上下文启动完毕，下面 通知应用已启动 started
            if (this.logStartupInfo) {
                new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
            }
            listeners.started(context);
            callRunners(context, applicationArguments); // 运行 ApplicationRunner、CommandLineRunner
        }
        catch (Throwable ex) {
            handleRunFailure(context, ex, listeners);
            throw new IllegalStateException(ex);
        }

        try {
            listeners.running(context); // 通知应用已运行起来了
        }
        catch (Throwable ex) {
            handleRunFailure(context, ex, null);
            throw new IllegalStateException(ex);
        }
        return context;
    }

下面分析重点代码行。

11行： prepareEnvironment，，不同应用类型，有不同的 环境变量

    private ConfigurableEnvironment getOrCreateEnvironment() {
        if (this.environment != null) {
            return this.environment;
        }
        switch (this.webApplicationType) {
        case SERVLET:
            return new ApplicationServletEnvironment();
        case REACTIVE:
            return new ApplicationReactiveWebEnvironment();
        default:
            return new ApplicationEnvironment();
        }
    }

14行：createApplicationContext()

    protected ConfigurableApplicationContext createApplicationContext() {
        return this.applicationContextFactory.create(this.webApplicationType);
    }

这里的create函数 是 ApplicationContextFactory接口 的 DEFAULT 对象，它根据不同的 webApplicationType 来创建不同的 ApplicationContext：

注意，这里无法使用 Step Over 进入 DEFAULT 对象的执行体。

非Web应用：

    public AnnotationConfigApplicationContext() {
        StartupStep createAnnotatedBeanDefReader = this.getApplicationStartup().start("spring.context.annotated-bean-reader.create");
        this.reader = new AnnotatedBeanDefinitionReader(this);
        createAnnotatedBeanDefReader.end();
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }

Web-Sevlet应用：

    public AnnotationConfigServletWebServerApplicationContext() {
        this.reader = new AnnotatedBeanDefinitionReader(this);
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }

Web-Reactive应用：

    public AnnotationConfigReactiveWebServerApplicationContext() {
        this.reader = new AnnotatedBeanDefinitionReader(this);
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }

执行完 第14行 后，context变量不再是 null了，其下的 beanFactory对象下的 beanDefinitionNames也要 5个对象了：

这个就是 Spring容器，更多的 Bean将在 后面的步骤中装入其中。

在 非Web、Web-Servlet应用 中，上面 beanDefinitionNames的 5个元素的值是相同的，列举如下：

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
 org.springframework.context.annotation.internalAutowiredAnnotationProcessor
 org.springframework.context.annotation.internalCommonAnnotationProcessor
 org.springframework.context.event.internalEventListenerProcessor
 org.springframework.context.event.internalEventListenerFactory

16行：prepareContext 函数调用，添加主类到容器

17行：refreshContext

24行：callRunners

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

上面运行完毕，返回context，此时，项目已成功启动。

更多问题：

1、这些Bean 是怎么找到的呢？

答案在 17行 refreshContext(context) 的执行过程中，可以更进一步 调试。由于没有外部配置文件，主要是根据 主类的配置（注解：默认 或 自定义的）去查找需要的 Bean。

2、怎么改造启动过程呢——为了更好地使用？

说明，

1、Debug的确挺好用的。除了在Debug前加断点，在Debug中也可以加断点，再控制执行到自己需要的行。

2、结合Spring相关文档，阅读源码时可以收获更多。因为，文档中还提到不少 可扩展的地方，结合在一起，就可以更好地使用Spring来开发应用了。

参考资料

1、Spring 容器是什么？

2、给你一份Spring Boot核心知识清单

非常好的一篇文章！必读！

3、