一、SpringBoot是什么
SpringBoot 是依赖于 Spring 的,比起 Spring,除了拥有 Spring 的全部功能以外,SpringBoot 无需繁琐的 Xml 配置,这取决于它自身强大的自动装配功能;并且自身已嵌入Tomcat、Jetty 等 web 容器,集成了 SpringMvc,使得 SpringBoot 可以直接运行,不需要额外的容器,提供了一些大型项目中常见的非功能性特性,如嵌入式服务器、安全、指标,健康检测、外部配置等,
其实 Spring 大家都知道,Boot 是启动的意思。所以,Spring Boot 其实就是一个启动 Spring 项目的一个工具而已,总而言之,SpringBoot 是一个服务于框架的框架;也可以说 SpringBoot 是一个工具,这个工具简化了 Spring 的配置;
二、Spring Boot的核心功能
- 可独立运行的 Spring 项目:Spring Boot 可以以 Jar 包的形式独立运行
- 内嵌的 Servlet 容器:Spring Boot 可以选择内嵌 Tomcat、Jetty 或者 Undertow,无须以 war 包形式部署项目
- 简化的 Maven 配置:Spring 提供推荐的基础 POM 文件来简化 Maven 配置
- 自动配置 Spring:Spring Boot会根据项目依赖来自动配置 Spring 框架,极大地减少项目要使用的配置
- 提供生产就绪型功能:提供可以直接在生产环境中使用的功能,如性能指标、应用信息和应用健康检查
- 无代码生成和 Xml 配置:Spring Boot 不生成代码。完全不需要任何 Xml 配置即可实现 Spring 的所有配置
三、SpringBoot启动流程
SpringBoot的启动经过了一些一系列的处理,我们先看看整体过程的流程图
3.1、运行 SpringApplication.run() 方法
可以肯定的是,所有的标准的 SpringBoot 的应用程序都是从 run 方法开始的
package com.spring;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
@SpringBootApplication
public class App {
public static void main(String[] args) {
// 启动springboot
ConfigurableApplicationContext run = SpringApplication.run(App.class, args);
}
}
进入 run 方法后,会 new 一个 SpringApplication 对象,创建这个对象的构造函数做了一些准备工作,编号第 2~5 步就是构造函数里面所做的事情
/**
* Static helper that can be used to run a {@link SpringApplication} from the
* specified sources using default settings and user supplied arguments.
* @param primarySources the primary sources to load
* @param args the application arguments (usually passed from a Java main method)
* @return the running {@link ApplicationContext}
*/
public static ConfigurableApplicationContext run(Class<?>[] primarySources,
String[] args) {
return new SpringApplication(primarySources).run(args);
}
3.2、确定应用程序类型
在 SpringApplication 的构造方法内,首先会通过 WebApplicationType.deduceFromClasspath()
; 方法判断当前应用程序的容器,默认使用的是Servlet 容器,除了 Servlet 之外,还有 NONE 和 REACTIVE (响应式编程);
具体代码
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
// resourceLoader 赋值为 Null
this.resourceLoader = resourceLoader;
// primarySources不为空,继续向下执行。为空抛异常
Assert.notNull(primarySources, "PrimarySources must not be null");
// 将 SpringbootdemoApplication(启动类)赋值给 primarySources
this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
// 从 classpath 类路径推断 Web 应用类型,有三种 Web 应用类型,分别是
// NONE: 该应用程序不应作为 Web 应用程序运行,也不应启动嵌入式 Web 服务器
// SERVLET: 该应用程序应作为基于 servlet 的 Web 应用程序运行,并应启动嵌入式 servlet Web 服务器。
// REACTIVE: 该应用程序应作为响应式 Web 应用程序运行,并应启动嵌入式响应式 Web 服务器
this.webApplicationType = WebApplicationType.deduceFromClasspath();
// 初始化 bootstrapRegistryInitializers,通过 getSpringFactoriesInstances()获取工厂实例,
// 底层使用的是反射Class<?> instanceClass = ClassUtils.forName(name, classLoader)动态加载实例对象。
this.bootstrapRegistryInitializers = new ArrayList<>(
getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
// 初始化 ApplicationContextInitializer 集合
setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
// 初始化 ApplicationListener
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
// 获取 StackTraceElement 数组遍历,通过反射获取堆栈中有 main 方法的类
this.mainApplicationClass = deduceMainApplicationClass();
}
3.3、加载所有的初始化器
这里加载的初始化器是 SpringBoot 自带初始化器,从从 META-INF/spring.factories 配置文件中加载的,那么这个文件在哪呢?自带有 2 个,分别在源码的 Jar 包的 spring-boot-autoconfigure 项目 和 spring-boot 项目里面各有一个
spring.factories文件里面,看到开头是 org.springframework.context.ApplicationContextInitializer 接口就是初始化器了
我们也可以自己实现一个自定义的初始化器:实现 ApplicationContextInitializer 接口既可
MyApplicationContextInitializer.java
package com.spring.application;
import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;
/**
* 自定义的初始化器
*/
public class MyApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
@Override
public void initialize(ConfigurableApplicationContext configurableApplicationContext) {
System.out.println("我是初始化的 MyApplicationContextInitializer...");
}
}
在 resources 目录下添加 META-INF/spring.factories 配置文件,内容如下,将自定义的初始化器注册进去;
org.springframework.context.ApplicationContextInitializer=\
com.spring.application.MyApplicationContextInitializer
启动 SpringBoot 后,就可以看到控制台打印的内容了,在这里我们可以很直观的看到它的执行顺序,是在打印 banner的后面执行的;
3.4、加载所有的监听器
加载监听器也是从 META-INF/spring.factories 配置文件中加载的,与初始化不同的是,监听器加载的是实现了 ApplicationListener 接口的类
自定义监听器也跟初始化器一样,依葫芦画瓢就可以了,这里不在举例;
3.5、设置程序运行的主类
deduceMainApplicationClass(); 这个方法仅仅是找到 main 方法所在的类,为后面的扫包作准备,deduce 是推断的意思,所以准确地说,这个方法作用是推断出主方法所在的类;
3.6、开启计时器
程序运行到这里,就已经进入了 run 方法的主体了,第一步调用的 run 方法是静态方法,那个时候还没实例化 SpringApplication 对象,现在调用的 run 方法是非静态的,是需要实例化后才可以调用的,进来后首先会开启计时器,这个计时器有什么作用呢?顾名思义就使用来计时的嘛,计算 SpringBoot 启动花了多长时间;关键代码如下:
// 实例化计时器
StopWatch stopWatch = new StopWatch();
// 开始计时
stopWatch.start();
run 方法代码段截图
3.7、将 java.awt.headless 设置为 true
这里将 java.awt.headless 设置为 true,表示运行在服务器端,在没有显示器器和鼠标键盘的模式下照样可以工作,模拟输入输出设备功能。
做了这样的操作后,SpringBoot 想干什么呢?其实是想设置该应用程序,即使没有检测到显示器,也允许其启动。对于服务器来说,是不需要显示器的,所以要这样设置
方法主体如下:
private void configureHeadlessProperty() {
System.setProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, System.getProperty(
SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, Boolean.toString(this.headless)));
}
通过方法可以看到,setProperty() 方法里面又有个 getProperty();这不多此一举吗?其实 getProperty() 方法里面有2个参数, 第一个 key值,第二个是默认值,意思是通过 key 值查找属性值,如果属性值为空,则返回默认值 true;保证了一定有值的情况;
3.8、获取并启用监听器
这一步 通过监听器来实现初始化的的基本操作,这一步做了 2 件事情
- 创建所有 Spring 运行监听器并发布应用启动事件
- 启用监听器
3.9、设置应用程序参数
将执行 run 方法时传入的参数封装成一个对象
仅仅是将参数封装成对象,没啥好说的,对象的构造函数如下
public DefaultApplicationArguments(String[] args) {
Assert.notNull(args, "Args must not be null");
this.source = new Source(args);
this.args = args;
}
那么问题来了,这个参数是从哪来的呢?其实就是 main 方法里面执行静态 run 方法传入的参数
3.10、准备环境变量
准备环境变量,包含系统属性和用户配置的属性,执行的代码块在 prepareEnvironment 方法内
打了断点之后可以看到,它将 maven 和系统的环境变量都加载进来了
3.11、忽略 bean 信息
这个方法 configureIgnoreBeanInfo() 这个方法是将 spring.beaninfo.ignore 的默认值值设为 true,意思是跳过 beanInfo 的搜索,其设置默认值的原理和第 7 步一样;
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());
}
}
当然也可以在配置文件中添加以下配置来设为 false
spring.beaninfo.ignore=false
3.12、打印 banner 信息
显而易见,这个流程就是用来打印控制台那个很大的 Spring 的 Banner 的,就是下面这个东东
那他在哪里打印的呢?他在 SpringBootBanner.java 里面打印的,这个类实现了 Banner 接口,
而且 Banner 信息是直接在代码里面写死的;
有些公司喜欢自定义 Banner 信息,如果想要改成自己喜欢的图标该怎么办呢,其实很简单,只需要在 resources 目录下添加一个 banner.txt 的文件即可,txt 文件内容如下
,-----.
| |) /_ ,---. ,--,--.,--.--.
| .-. \| .-. :' ,-. || .--'
| '--' /\ --.\ '-' || |
`------' `----' `--`--'`--'
一定要添加到 resources 目录下,别加错了
只需要加一个文件即可,其他什么都不用做,然后直接启动 SpringBoot,就可以看到效果了
3.13、创建应用程序的上下文
实例化应用程序的上下文, 调用 createApplicationContext() 方法,这里就是用反射创建对象,没什么好说的;
3.14、实例化异常报告器
异常报告器是用来捕捉全局异常使用的,当 SpringBoot 应用程序在发生异常时,异常报告器会将其捕捉并做相应处理,在 spring.factories 文件里配置了默认的异常报告器
需要注意的是,这个异常报告器只会捕获启动过程抛出的异常,如果是在启动完成后,在用户请求时报错,异常报告器不会捕获请求中出现的异常
了解原理了,接下来我们自己配置一个异常报告器来玩玩;
MyExceptionReporter.java 继承 SpringBootExceptionReporter 接口
package com.spring.application;
import org.springframework.boot.SpringBootExceptionReporter;
import org.springframework.context.ConfigurableApplicationContext;
public class MyExceptionReporter implements SpringBootExceptionReporter {
private ConfigurableApplicationContext context;
// 必须要有一个有参的构造函数,否则启动会报错
MyExceptionReporter(ConfigurableApplicationContext context) {
this.context = context;
}
@Override
public boolean reportException(Throwable failure) {
System.out.println("进入异常报告器");
failure.printStackTrace();
// 返回false会打印详细springboot错误信息,返回true则只打印异常信息
return false;
}
}
在 spring.factories 文件中注册异常报告器
# Error Reporters 异常报告器
org.springframework.boot.SpringBootExceptionReporter=\
com.spring.application.MyExceptionReporter
接着我们在 application.yml 中 把端口号设置为一个很大的值,这样肯定会报错
server:
port: 80828888
启动后,控制台打印如下图
3.15、准备上下文环境
这里准备的上下文环境是为了下一步刷新做准备的,里面还做了一些额外的事情;
1、实例化单例的beanName生成器
在 postProcessApplicationContext(context); 方法里面。使用单例模式创建 了BeanNameGenerator 对象,其实就是 beanName 生成器,用来生成 bean 对象的名称
2、执行初始化方法
初始化方法有哪些呢?还记得第 3 步里面加载的初始化器嘛?其实是执行第3步加载出来的所有初始化器,实现 ApplicationContextInitializer
接口的类
3、将启动参数注册到容器中
这里将启动参数以单例的模式注册到容器中,是为了以后方便拿来使用,参数的beanName 为 :springApplicationArguments
3.16、刷新上下文
刷新上下文已经是 Spring 的范畴了,自动装配和启动 tomcat 就是在这个方法里面完成的,还有其他的 Spring 自带的机制在这里就不一一细说了
3.17、刷新上下文后置处理
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.18、结束计时器
到这一步,Springboot 其实就已经完成了,计时器会打印启动 SpringBoot 的时长
在控制台看到启动还是挺快的,不到 2 秒就启动完成了;
3.19、发布上下文准备就绪事件
告诉应用程序,我已经准备好了,可以开始工作了
执行自定义的 run 方法
这是一个扩展功能,callRunners(context, applicationArguments) 可以在启动完成后执行自定义的 run 方法;有 2 种方式可以实现:
- 实现 ApplicationRunner 接口
- 实现 CommandLineRunner 接口
接下来我们验证一把,为了方便代码可读性,我把这 2 种方式都放在同一个类里面
package com.spring.init;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
/**
* 自定义run方法的2种方式
*/
@Component
public class MyRunner implements ApplicationRunner, CommandLineRunner {
@Override
public void run(ApplicationArguments args) throws Exception {
System.out.println(" 我是自定义的run方法1,实现 ApplicationRunner 接口既可运行" );
}
@Override
public void run(String... args) throws Exception {
System.out.println(" 我是自定义的run方法2,实现 CommandLineRunner 接口既可运行" );
}
}
启动 SpringBoot 后就可以看到控制台打印的信息了
具体代码
public ConfigurableApplicationContext run(String... args) {
long startTime = System.nanoTime();
// 通过 BootstrapRegistryInitializer来initialize 默认的 DefaultBootstrapContext
DefaultBootstrapContext bootstrapContext = createBootstrapContext();
ConfigurableApplicationContext context = null;
// 配置java.awt.headless属性
configureHeadlessProperty();
// 获取 SpringApplicationRunListeners 监听器
SpringApplicationRunListeners listeners = getRunListeners(args);
// 启动 SpringApplicationRunListeners 监听,表示 SpringApplication 启动(触发ApplicationStartingEvent事件)
listeners.starting(bootstrapContext, this.mainApplicationClass);
try {
// 创建 ApplicationArguments 对象,封装了 args 参数
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
// 做相关环境准备,绑定到 SpringApplication,返回可配置环境对象ConfigurableEnvironment
ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
// 配置 spring.beaninfo.ignore,设置为 true.即跳过搜索Bean信息
configureIgnoreBeanInfo(environment);
// 控制台打印 SpringBoot 的 Banner(横幅)标志
Banner printedBanner = printBanner(environment);
// 根据WebApplicationType从ApplicationContextFactory工厂创建ConfigurableApplicationContext
context = createApplicationContext();
// 设置ConfigurableApplicationContext中的ApplicationStartup为DefaultApplicationStartup
context.setApplicationStartup(this.applicationStartup);
// 应用所有的ApplicationContextInitializer容器初始化器初始化context,触发ApplicationContextInitializedEvent事件监听,打印启动日志信息,启动Profile日志信息
// ConfigurableListableBeanFactory中注册单例Bean(springApplicationArguments),并为该BeanFactory中的部分属性赋值。
// 加载所有的source.并将Bean加载到ConfigurableApplicationContext,触发ApplicationPreparedEvent事件监听
prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
// 刷新容器(在方法中集成了Web容器具体请看 https://editor.csdn/md/?articleId=123136262)
refreshContext(context);
// 刷新容器的后置处理(空方法)
afterRefresh(context, applicationArguments);
// 启动花费的时间
Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
if (this.logStartupInfo) {
// 打印日志Started xxx in xxx seconds (JVM running for xxxx)
new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
}
// 触发 ApplicationStartedEvent 事件监听。上下文已刷新,应用程序已启动。
listeners.started(context, timeTakenToStartup);
// 调用 ApplicationRunner和CommandLineRunner
callRunners(context, applicationArguments);
}
// 处理运行时发生的异常,触发 ApplicationFailedEvent 事件监听
catch (Throwable ex) {
handleRunFailure(context, ex, listeners);
throw new IllegalStateException(ex);
}
try {
// 启动准备消耗的时间
Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
// 在 run 方法完成前立即触发 ApplicationReadyEvent事件监听,表示应用上下文已刷新,并且CommandLineRunners和ApplicationRunners已被调用。
listeners.ready(context, timeTakenToReady);
}
catch (Throwable ex) {
handleRunFailure(context, ex, null);
throw new IllegalStateException(ex);
}
return context;
}
转载请标明出处,原文地址:https://blog.csdn/weixin_41835916 如果觉得本文对您有帮助,请点击赞支持一下,您的支持是我写作最大的动力,谢谢。
更多推荐
Java面试--SpringBoot启动流程
发布评论