SpringBoot 的启动流程

深藏阁楼爱情的钟 2024-03-23 17:01 51阅读 0赞

SpringBoot 是一个基于 Spring 框架的快速开发框架，旨在简化 Spring 应用程序的开发和部署。在本文中，我们将深入分析 SpringBoot 启动过程的源代码，并提供必要的解释和说明。

### SpringBoot启动过程简介 ###

SpringBoot应用程序的启动过程可以分为以下几个步骤：

1.  加载应用程序上下文
2.  扫描应用程序中的所有组件
3.  自动配置应用程序环境
4.  启动嵌入式Web服务器

在下面的章节中，我们将逐一分析这些步骤的源代码。

### 加载应用程序上下文 ###

SpringBoot 应用程序的上下文是一个包含所有应用程序组件的容器。在启动过程中，SpringBoot 会加载并初始化这个容器。

这个步骤的源代码在`SpringApplication`类中。具体来说，`SpringApplication`类的`run`方法是这个过程的入口点。在这个方法中，Spring Boot会通过调用`createApplicationContext`方法来创建应用程序上下文。

下面是`createApplicationContext`方法的源代码：

protected ConfigurableApplicationContext createApplicationContext() {
        Class<?> contextClass = this.applicationContextClass;
        if (contextClass == null) {
            try {
                switch (this.webApplicationType) {
                    case SERVLET:
                        contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);
                        break;
                    case REACTIVE:
                        contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
                        break;
                    default:
                        contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
                }
            }
            catch (ClassNotFoundException ex) {
                throw new IllegalStateException(
                        "Unable to create a default ApplicationContext, " +
                        "please specify an ApplicationContextClass", ex);
            }
        }
        return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
    }
    复制代码

在这个方法中，SpringBoot 会根据应用程序类型（Servlet或Reactive）选择合适的上下文类。然后，它会使用 Java 反射机制来实例化这个类并返回一个可配置的应用程序上下文对象。

### 扫描应用程序中的所有组件 ###

在上一步中，SpringBoot创建了应用程序上下文。在这一步中，SpringBoot会扫描应用程序中的所有组件并将它们注册到应用程序上下文中。

这个步骤的源代码在`SpringApplication`类中的`scan`方法中。具体来说，在这个方法中，SpringBoot 会创建一个`SpringBootBeanDefinitionScanner`对象，并使用它来扫描应用程序中的所有组件。

下面是`scan`方法的源代码：

private void scan(String... basePackages) {
        if (ObjectUtils.isEmpty(basePackages)) {
            return;
        }
        ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(
                this.includeFilters, this.excludeFilters, this.resourceLoader);
        scanner.setResourceLoader(this.resourceLoader);
        scanner.setEnvironment(this.environment);
        scanner.setIncludeAnnotationConfig(this.useAnnotatedConfig);
        scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
            @Override
            protected boolean matchClassName(String className) {
                return getExcludeClassNames().contains(className);
            }
        });
        for (String basePackage : basePackages) {
            scanner.findCandidateComponents(basePackage).forEach(this.componentDefinitions::add);
        }
    }
    复制代码

在这个方法中，SpringBoot 会创建一个`ClassPathScanningCandidateComponentProvider`对象，并使用它来扫描应用程序中的所有组件。这个对象会扫描指定包路径下的所有类，并将它们转换为 Spring 的 Bean 定义。这些 Bean 定义将被注册到应用程序上下文中。

### 自动配置应用程序环境 ###

在上一步中，SpringBoot将应用程序中的所有组件注册到应用程序上下文中。在这一步中，SpringBoot将自动配置应用程序环境，包括配置数据源、事务管理器、JPA等。

这个步骤的源代码在`SpringApplication`类中的`configureEnvironment`方法中。在这个方法中，Spring Boot会创建一个`SpringApplicationRunListeners`对象，并使用它来配置应用程序环境。

下面是`configureEnvironment`方法的源代码：

private void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
        if (this.addCommandLineProperties) {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            environment.getPropertySources().addLast(new CommandLinePropertySource(applicationArguments));
        }
        this.listeners.environmentPrepared(environment);
        if (this.logStartupInfo) {
            this.logStartupInfo(environment);
        }
        ConfigurationPropertySources.attach(environment);
        Binder.get(environment).bind(ConfigurationPropertyName.EMPTY, Bindable.ofInstance(this.sources));
        if (!this.isCustomEnvironment) {
            EnvironmentConverter.configureEnvironment(environment, this.deduceEnvironmentClass());
        }
        this.listeners.environmentPrepared(environment);
    }
    复制代码

在这个方法中，SpringBoot 会创建一个`ApplicationArguments`对象，并将其转换为一个命令行属性源。然后，它会调用`listeners`中的`environmentPrepared`方法来通知应用程序环境已经准备好了。随后，SpringBoot 会绑定属性源到应用程序环境中，并调用`listeners`中的`environmentPrepared`方法来通知应用程序环境已经准备好了。

### 启动嵌入式Web服务器 ###

在上一步中，SpringBoot 将应用程序环境自动配置完成。在这一步中，SpringBoot 将启动嵌入式Web服务器，以便应用程序能够提供 Web 服务。

这个步骤的源代码在`SpringApplication`类中的`run`方法中。具体来说，在这个方法中，SpringBoot 会根据应用程序类型（Servlet或Reactive）选择合适的嵌入式Web服务器，并使用它来启动应用程序。

下面是`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;
    }
    复制代码

在这个方法中，SpringBoot 会使用一个`StopWatch`对象来计算应用程序启动时间。然后，它会调用`listeners`中的`starting`方法来通知应用程序即将启动。接着，SpringBoot 会准备应用程序环境，并使用它来创建应用程序上下文。随后，SpringBoot 会调用`listeners`中的`started`方法来通知应用程序已经启动。最后，SpringBoot 会调用`callRunners`方法来运行所有的`CommandLineRunner`和`ApplicationRunner`组件。

### 总结 ###

在本文中，我们深入分析了 SpringBoot 应用程序的启动过程的源代码。我们了解了 SpringBoot 如何加载应用程序上下文、扫描应用程序中的所有组件、自动配置应用程序环境以及启动嵌入式Web服务器。这些步骤的源代码展示了 SpringBoot 如何简化应用程序的开发和部署。