springboot教程（SpringBoot究竟是如何跑起来的）

本文目录

• SpringBoot究竟是如何跑起来的
• SpringBoot是如何动起来的
• 如何创建Spring Boot应用需要注意什么

SpringBoot究竟是如何跑起来的

如果我们使用的是SpringApplication的静态run方法，那么，这个方法里面首先要创建一个SpringApplication对象实例，然后调用这个创建好的SpringApplication的实例方法。在SpringApplication实例初始化的时候，它会提前做几件事情：

根据classpath里面是否存在某个特征类（org.springframework.web.context.ConfigurableWebApplicationContext）来决定是否应该创建一个为Web应用使用的ApplicationContext类型。

使用SpringFactoriesLoader在应用的classpath中查找并加载所有可用的ApplicationContextInitializer。

使用SpringFactoriesLoader在应用的classpath中查找并加载所有可用的ApplicationListener。

推断并设置main方法的定义类。

2） SpringApplication实例初始化完成并且完成设置后，就开始执行run方法的逻辑了，方法执行伊始，首先遍历执行所有通过SpringFactoriesLoader可以查找到并加载的SpringApplicationRunListener。调用它们的started()方法，告诉这些SpringApplicationRunListener，“嘿，SpringBoot应用要开始执行咯！”。

3） 创建并配置当前Spring Boot应用将要使用的Environment（包括配置要使用的PropertySource以及Profile）。

4） 遍历调用所有SpringApplicationRunListener的environmentPrepared()的方法，告诉他们：“当前SpringBoot应用使用的Environment准备好了咯！”。

5） 如果SpringApplication的showBanner属性被设置为true，则打印banner。

6） 根据用户是否明确设置了applicationContextClass类型以及初始化阶段的推断结果，决定该为当前SpringBoot应用创建什么类型的ApplicationContext并创建完成，然后根据条件决定是否添加ShutdownHook，决定是否使用自定义的BeanNameGenerator，决定是否使用自定义的ResourceLoader，当然，最重要的，将之前准备好的Environment设置给创建好的ApplicationContext使用。

7） ApplicationContext创建好之后，SpringApplication会再次借助Spring-FactoriesLoader，查找并加载classpath中所有可用的ApplicationContext-Initializer，然后遍历调用这些ApplicationContextInitializer的initialize（applicationContext）方法来对已经创建好的ApplicationContext进行进一步的处理。

8） 遍历调用所有SpringApplicationRunListener的contextPrepared()方法。

9） 最核心的一步，将之前通过@EnableAutoConfiguration获取的所有配置以及其他形式的IoC容器配置加载到已经准备完毕的ApplicationContext。

10） 遍历调用所有SpringApplicationRunListener的contextLoaded()方法。

11） 调用ApplicationContext的refresh()方法，完成IoC容器可用的最后一道工序。

12） 查找当前ApplicationContext中是否注册有CommandLineRunner，如果有，则遍历执行它们。

13） 正常情况下，遍历执行SpringApplicationRunListener的finished()方法、（如果整个过程出现异常，则依然调用所有SpringApplicationRunListener的finished()方法，只不过这种情况下会将异常信息一并传入处理）

SpringBoot是如何动起来的

程序入口

SpringApplication.run(BeautyApplication.class, args);

执行此方法来加载整个SpringBoot的环境。

1. 从哪儿开始？

SpringApplication.java

/**

* Run the Spring application, creating and refreshing a new

* {@link ApplicationContext}.

* @param args the application arguments (usually passed from a Java main method)

* @return a running {@link ApplicationContext}

*/

public ConfigurableApplicationContext run(String... args) {

//...

}

调用SpringApplication.java 中的 run 方法，目的是加载Spring Application，同时返回 ApplicationContext。

2. 执行了什么？

2.1 计时

记录整个Spring Application的加载时间！

StopWatch stopWatch = new StopWatch();

stopWatch.start();

// ...

stopWatch.stop();

if (this.logStartupInfo) {

new StartupInfoLogger(this.mainApplicationClass)

.logStarted(getApplicationLog(), stopWatch);

}

2.2 声明

指定 java.awt.headless，默认是true 一般是在程序开始激活headless模式，告诉程序，现在你要工作在Headless mode下，就不要指望硬件帮忙了，你得自力更生，依靠系统的计算能力模拟出这些特性来。

private void configureHeadlessProperty() {

System.setProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, System.getProperty(

SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, Boolean.toString(this.headless)));

}

2.4 配置监听并发布应用启动事件

SpringApplicationRunListener 负责加载 ApplicationListener事件。

SpringApplicationRunListeners listeners = getRunListeners(args);

// 开始

listeners.starting();

// 处理所有 property sources 配置和 profiles 配置，准备环境，分为标准 Servlet 环境和标准环境

ConfigurableEnvironment environment = prepareEnvironment(listeners,applicationArguments);

// 准备应用上下文

prepareContext(context, environment, listeners, applicationArguments,printedBanner);

// 完成

listeners.started(context);

// 异常

handleRunFailure(context, ex, exceptionReporters, listeners);

// 执行

listeners.running(context);

getRunListeners 中根据 type = SpringApplicationRunListener.class 去拿到了所有的 Listener 并根据优先级排序。

对应的就是 META-INF/spring.factories 文件中的 org.springframework.boot.SpringApplicationRunListener=org.springframework.boot.context.event.EventPublishingRunListener

private 《T》 Collection《T》 getSpringFactoriesInstances(Class《T》 type,

Class《?》 parameterTypes, Object... args) {

ClassLoader classLoader = Thread.currentThread().getContextClassLoader();

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

}

复制代码

在 ApplicationListener 中 , 可以针对任何一个阶段插入处理代码。

public interface SpringApplicationRunListener {

/**

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

* early initialization.

*/

void starting();

/**

* Called once the environment has been prepared, but before the

* {@link ApplicationContext} has been created.

* @param environment the environment

*/

void environmentPrepared(ConfigurableEnvironment environment);

/**

* Called once the {@link ApplicationContext} has been created and prepared, but

* before sources have been loaded.

* @param context the application context

*/

void contextPrepared(ConfigurableApplicationContext context);

/**

* Called once the application context has been loaded but before it has been

* refreshed.

* @param context the application context

*/

void contextLoaded(ConfigurableApplicationContext context);

/**

* The context has been refreshed and the application has started but

* {@link CommandLineRunner CommandLineRunners} and {@link ApplicationRunner

* ApplicationRunners} have not been called.

* @param context the application context.

* @since 2.0.0

*/

void started(ConfigurableApplicationContext context);

/**

* 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.

* @param context the application context.

* @since 2.0.0

*/

void running(ConfigurableApplicationContext context);

/**

* Called when a failure occurs when running the application.

* @param context the application context or {@code null} if a failure occurred before

* the context was created

* @param exception the failure

* @since 2.0.0

*/

void failed(ConfigurableApplicationContext context, Throwable exception);

}

3. 每个阶段执行的内容

3.1 listeners.starting();

在加载Spring Application之前执行，所有资源和环境未被加载。

3.2 prepareEnvironment(listeners, applicationArguments);

创建 ConfigurableEnvironment； 将配置的环境绑定到Spring Application中；

private ConfigurableEnvironment prepareEnvironment(

SpringApplicationRunListeners listeners,

ApplicationArguments applicationArguments) {

// Create and configure the environment

ConfigurableEnvironment environment = getOrCreateEnvironment();

configureEnvironment(environment, applicationArguments.getSourceArgs());

listeners.environmentPrepared(environment);

bindToSpringApplication(environment);

if (this.webApplicationType == WebApplicationType.NONE) {

environment = new EnvironmentConverter(getClassLoader())

.convertToStandardEnvironmentIfNecessary(environment);

}

ConfigurationPropertySources.attach(environment);

return environment;

}

3.3 prepareContext

配置忽略的Bean；

private void configureIgnoreBeanInfo(ConfigurableEnvironment environment) {

if (System.getProperty(

CachedIntrospectionResults.IGNORE_BEANINFO_PROPERTY_NAME) == null) {

Boolean ignore = environment.getProperty("spring.beaninfo.ignore",

Boolean.class, Boolean.TRUE);

System.setProperty(CachedIntrospectionResults.IGNORE_BEANINFO_PROPERTY_NAME,

ignore.toString());

}

}

打印日志-加载的资源

Banner printedBanner = printBanner(environment);

根据不同的WebApplicationType创建Context

context = createApplicationContext();

3.4 refreshContext

支持定制刷新

/**

* Register a shutdown hook with the JVM runtime, closing this context

* on JVM shutdown unless it has already been closed at that time.

* 《p》This method can be called multiple times. Only one shutdown hook

* (at max) will be registered for each context instance.

* @see java.lang.Runtime#addShutdownHook

* @see #close()

*/

void registerShutdownHook();

3.5 afterRefresh

刷新后的实现方法暂未实现

/**

* Called after the context has been refreshed.

* @param context the application context

* @param args the application arguments

*/

protected void afterRefresh(ConfigurableApplicationContext context,

ApplicationArguments args) {

}

3.6 listeners.started(context);

到此为止， Spring Application的环境和资源都加载完毕了； 发布应用上下文启动完成事件； 执行所有 Runner 运行器 - 执行所有 ApplicationRunner 和 CommandLineRunner 这两种运行器

// 启动

callRunners(context, applicationArguments);

3.7 listeners.running(context);

触发所有 SpringApplicationRunListener 监听器的 running 事件方法

希望对你有帮助

如何创建Spring Boot应用需要注意什么

创建 Spring Boot 应用其实很简单，添加基础依赖包，有以下两种方式

1. 继承spring-boot-starter-parent项目

《parent》

《groupId》

org.springframework.boot

《/groupId》

《artifactId》

spring-boot-starter-parent

《/artifactId》

《version》

1.5.6.RELEASE

《/version》

《/parent》

2. 导入spring-boot-dependencies项目依赖

《dependencyManagement》

《dependencies》

《dependency》

《groupId》

org.springframework.boot

《/groupId》

《artifactId》

spring-boot-dependencies

《/artifactId》

《version》

1.5.6.RELEASE

《/version》

《type》

pom

《/type》

《scope》

import

《/scope》

《/dependency》

《/dependencyManagement》

或者去 https://start.spring.io/ 快速生成，祝你好运????