SpringBoot 面试题总结 （JavaGuide）
SpringBoot 面试题总结 （JavaGuide）
用 JavaGuide 复习 SpringBoot 时，找到一些面试题，没有答案，自己花了一天时间在网上找资料总结了一些，有些答案的来源比较杂忘了没有标注，望见谅。
SpringBoot 面试题总结 （JavaGuide）
- SpringBoot 面试题总结 （JavaGuide）
-
-
- 1. 简单介绍一下 Spring?有啥缺点？
-
- （一）重量级框架
- （二）集成复杂
- （三）配置复杂
- （四）构建和部署复杂
- 2.为什么要有 SpringBoot?
- 3. 说出使用 Spring Boot 的主要优点
-
- ①良好的基因
- ②简化依赖
- ③简化配置
- ④简化部署
- ⑤简化监控
- 4. 什么是 Spring Boot Starters?
- 5. Spring Boot 支持哪些内嵌 Servlet 容器？
-
- 三种嵌入式servlet容器：tomcat(默认), jetty, undertow
- 6. 如何在 Spring Boot 应用程序中使用 Jetty 而不是 Tomcat?
- 7. 介绍⼀下@SpringBootApplication 注解
-
- 【1】@SpringBootConfiguration
- 【2】@EnableAutoConfiguration
- 【3】@ComponentScan
- 8. Spring Boot 的自动配置是如何实现的?
- 9. 开发 RESTful Web 服务常用的注解有哪些？
- 10. Spirng Boot 常用的两种配置文件
- 11. 什么是 YAML？YAML 配置的优势在哪里?
- 12. Spring Boot 常用的读取配置文件的方法有哪些？
-
- 1、@Value方式获取
- 2、@ConfigurationProperties方式获取（强烈推荐）
- 3、Environment对象获取
- 4、@PropertySource方式获取
- 5、原生方式获取：加载配置文件，getProperty( )
- 13. Spring Boot 加载配置文件的优先级了解么？
-
- 1. 项目内部配置文件
- 2. 外部配置加载顺序
- 14. 常用的 Bean 映射工具有哪些？
- 15. Spring Boot 如何监控系统实际运行状况？
-
- Actuator（ HTTP 端点 ）
- JMX
- 16. Spring Boot 如何做请求参数校验？
-
- 第一步，引入依赖
- 第二步，定义要参数校验的实体类
- 还可以自定义参数校验
- 17. 如何使用Spring Boot 实现全局异常处理？
-
- @ControllerAdvice 注解和 @ExceptionHandler 注解
- 18. Spring Boot 中如何实现定时任务 ?
-
- @Scheduled
- Quartz
-
1. 简单介绍一下 Spring?有啥缺点？
（一）重量级框架
我们看到 Spring 架构图时会发现 Spring 里面包含有很多其他组件，比如数据访问、MVC、事务管理、面向切点、WebSocket 功能等，因此这么复杂的组件集中到一起就会提高初学者的学习成本。还有一方面随着你的服务越多，那么 Spring 的启动就会变得越慢。
（二）集成复杂
比如我们想要使用 MyBatis 或者 MongoDB的时候，我们要做很多工作不管使用配置方式也好还是使用注解方式。
（三）配置复杂
在使用 Spring 的时候，我们更多可能是选择 XML 进行配置，但目前这种配置方式已不在流行。
（四）构建和部署复杂
启动 Spring 的 IOC 容器，是完全要依赖于第三方的 web 服务器。自身不能启动的。
2.为什么要有 SpringBoot?
分开来看Spring Boot 是由 Spring 和 Boot 构成，Spring 即 Spring 框架，换句话而言，Spring Boot 是基于 Spring框架进行构建，Boot 就是 BootStrap（牵引），就是以 Spring作为基础的牵引程序。
Spring Boot 就是一个快速创建单个的、生产级别的基于Spring 的应用。而且是尽量使用少的依赖和少的配置完成。
从本质上来说，Spring Boot就是Spring，它做了哪些没有它你也会去做的Spring Bean的配置。
3. 说出使用 Spring Boot 的主要优点
①良好的基因
因为SpringBoot是伴随着Spring 4.0而生的，boot是引导的意思，也就是它的作用其实就是在于帮助开发者快速的搭建Spring框架，因此SpringBoot继承了Spring优秀的基因，在Spring中开发更为方便快捷。
②简化依赖
比如我们要创建一个 web 项目，使用 Spring 的朋友都知道，在使用 Spring 的时候，需要在 pom 文件中添加多个依赖，而 Spring Boot 则会帮助开发着快速启动一个 web 容器，在 Spring Boot 中，我们只需要在 pom 文件中添加如下一个 starter-web 依赖即可。
③简化配置
Spring 虽然使Java EE轻量级框架，但由于其繁琐的配置，一度被人认为是“配置地狱”。各种XML、Annotation配置会让人眼花缭乱，而且配置多的话，如果出错了也很难找出原因。Spring Boot更多的是采用 Java Config 的方式，对 Spring 进行配置。
部署配置方面，原来 Spring 有多个 xml 和 properties配置，在 Spring Boot 中只需要个 application.yml即可。
④简化部署
在使用 Spring 时，项目部署时需要我们在服务器上部署 tomcat，然后把项目打成 war 包扔到 tomcat里，在使用 Spring Boot 后，我们不需要在服务器上去部署 tomcat，因为 Spring Boot 内嵌了 tomcat，我们只需要将项目打成 jar 包，使用 java -jar xxx.jar一键式启动项目。
另外，也降低对运行环境的基本要求，环境变量中有JDK即可
⑤简化监控
我们可以引入 spring-boot-start-actuator 依赖，直接使用 REST 方式来获取进程的运行期性能参数，从而达到监控的目的，比较方便。但是 Spring Boot 只是个微框架，没有提供相应的服务发现与注册的配套功能，没有外围监控集成方案，没有外围安全管理方案，所以在微服务架构中，还需要 Spring Cloud 来配合一起使用。
4. 什么是 Spring Boot Starters?
starter是SpringBoot中的一个新发明，它有效的降低了项目开发过程的复杂程度，对于简化开发操作有着非常好的效果。 starter是一种对依赖的synthesize（合成）
-
starter的理念：starter会把所有用到的依赖都给包含进来，避免了开发者自己去引入依赖所带来的麻烦。需要注意的是不同的starter是为了解决不同的依赖，所以它们内部的实现可能会有很大的差异，
-
starter的实现：虽然不同的starter实现起来各有差异，但是他们基本上都会使用到两个相同的内容：ConfigurationProperties和AutoConfiguration。因为Spring Boot坚信“约定大于配置”这一理念，所以我们使用ConfigurationProperties来保存我们的配置，并且这些配置都可以有一个默认值，即在我们没有主动覆写原始配置的情况下，默认值就会生效，这在很多情况下是非常有用的。除此之外，starter的ConfigurationProperties还使得所有的配置属性被聚集到一个文件中（一般在resources目录下的application.properties），这样我们就告别了Spring项目中XML地狱。
starter的整体逻辑：
总结： Starters可以理解为启动器，它包含了一系列可以集成到应用里面的依赖包，可以一站式集成Spring及其他技术，而不需要到处找示例代码和依赖包。 starter其实是把这一些繁琐的配置操作交给了自己，而把简单交给了用户。除了帮助用户去除了繁琐的构建操作，在“约定大于配置”的理念下，ConfigurationProperties还帮助用户减少了无谓的配置操作。并且因为 application.properties 文件的存在，即使需要自定义配置，所有的配置也只需要在一个文件中进行，使用起来非常方便。
5. Spring Boot 支持哪些内嵌 Servlet 容器？
三种嵌入式servlet容器：tomcat(默认), jetty, undertow
使用starter即可方便嵌入，默认情况下，嵌入服务器的访问端口为8080。
Servlets、Filters & Listeners
这些组件可以同组件扫描注册，即把他们定义为Spring Bean。
默认情况下，如果只有一个servlet，则把它映射到 / ；如果有多个servlet，则加上bean name作为前缀然后映射到 /*
容器初始化
如果你需要执行容器初始化，可以通过实现注册一个org.springframework.web.WebApplicationInitializer Bean。这个接口只有一个方法onStartup，这个方法可以访问ServletContext。
当使用嵌入式容器时，可以通过@ServeltComponentScan启用@WebServlet，@WebFilter和@WebListener注解。
6. 如何在 Spring Boot 应用程序中使用 Jetty 而不是 Tomcat?
spring-boot-starter-web模块默认是使用 tomcat 作为内嵌容器，如果我们想要切换为jetty，只需要添加 jetty 的依赖即可，如：
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-jettyartifactId>
dependency>
7. 介绍⼀下@SpringBootApplication 注解
放置在Springboot启动类上，表明该类是开启Springboot容器的入口，它是一个复合注解。里面包含了包扫描，自动注入，配置注入的功能
【1】@SpringBootConfiguration
它表示的是该类会作为Springboot的一个配置类，进入该注解，发现里面包含@Configuration注解，@Configuration注解是Spring里面的注解，在Spring里，它表示该类也是一个配置类。进入@Configuration注解，我们发现他是被@Component所修饰的，所以该配置类也是一个组件。
【2】@EnableAutoConfiguration
它表示开启自动配置功能。进入@EnableAutoConfiguration中，发现它仍然是一个组合注解.
1、@AutoConfigurationPackage表示自动注入包:主要作用就是将@SpringBootApplication修饰的类的同包，子孙包下的所有组件都扫描到Spring容器中。
2、@Import({AutoConfigurationImportSelector.class})
表示根据上述所说@Import的作用是导入组件，导入自动配置选择器的组件。 将指定的值导入到Spring容器中，帮我们进行自动配置的功能。
【3】@ComponentScan
用来将指定包(如果未指定就是将当前类所在包及其子孙包)加入SpringIOC的包扫描，本质上等于配置
8. Spring Boot 的自动配置是如何实现的?
同上一题
自动装配就是自动去把第三方组件的 Bean 装载到 IOC 容器里面，不需要开发人员再去写Bean相关的一个配置，在SpringBoot应用里面只需要在启动类上加上@SpringBootApplication注解就可以去实现自动装配。
9. 开发 RESTful Web 服务常用的注解有哪些？
restful风格，就是一种面向资源服务的API设计方式，它不是规范，不是标准，它一种设计模式。核心在于，当你设计一个系统的时候，资源是第一位的考虑，你首先从资源的角度进行系统的拆分、设计，而不是像以往一样以操作为角度来进行设计 。
Restful风格最大的特点为：资源、统一接口、URI和无状态。
这种风格设计的软件，可以更简洁，更有层次，更易于实现缓存等机制
1、@GetMapping
@RequestMapping(method = RequestMethod.GET)的简写
作用：对应查询，表明是一个查询URL映射2、@PostMapping
@RequestMapping(method = RequestMethod.POST)的简写
作用：对应增加，表明是一个增加URL映射3、@PutMapping
@RequestMapping(method = RequestMethod.PUT)的简写
作用：对应更新，表明是一个更新URL映射4、@DeleteMapping
@RequestMapping(method = RequestMethod.DELETE)的简写
作用：对应删除，表明是一个删除URL映射5、@PatchMapping
Patch方式是对put方式的一种补充;
put方式是可以更新.但是更新的是整体.patch是对局部更新;仅仅使用一个url，用请求方式去区分增删改查，降低了url的复杂度，并且更加的统一和规范。
@PathVariable 用于修饰方法传入参数，表示该参数值从请求路径中获取
@RequestMapping(“h2/{a}/{b}”) /{a}/{b}：表示要传入的参数值，在请求url中用斜线/分隔多个参数。
//RESTful:http://localhost:8080/h2/1/11
@RequestMapping("h2/{a}/{b}")
public String test2(@PathVariable int a, @PathVariable int b)
10. Spirng Boot 常用的两种配置文件
SpringBoot支持 properties 和 yml 两种配置方式，两种格式的功能类似，都可以完成项目的配置信息。但是properties的优先级要高于yml，而yml文件采用树状结构，直观上更加一目了然
11. 什么是 YAML？YAML 配置的优势在哪里?
YAML是一种便于人类理解的序列化结构语言，通常同于属性的配置，在配置过程中有着良好的结构规则，与properties相比不易混淆，并且可以配置一些较为复杂的属性。
优点：
YAML有自己的结构，在具体配置过程中需遵守规则，便于程序员理解；
YAML中有配置的顺序性，在某些场合下，配置的顺序很重要；
YAML中支持数组，可以配置基本数据对象，也可以配置对象；
相较于properties，YAML的配置更加简洁。
12. Spring Boot 常用的读取配置文件的方法有哪些？
1、@Value方式获取
@Value("${value.request.url}")
private String url;
2、@ConfigurationProperties方式获取（强烈推荐）
为了更契合java的面向对象，我们采用自动配置的方式映射配置文件属性，配置完成后直接当做java对象即可使用。
@Data
@Component
@ConfigurationProperties(value = "app")
public class AppProperties {}
@ConfigurationProperties(value = “app”)表示的配置文件里属性的前缀都是app开头- 配置类上记得加
@Data和@Component注解（或者在启动类上加上@EnableConfigurationProperties(value = AppProperties.class)） - 如果有内部类对象，记得加上
@Data，不然无法映射数据 - .properties 类型文件映射规则，短横线(-)后面的首个字母会变成大写，同时注意有内部类时的写法
使用方法也很简单，直接使用spring的注解
@Autowired引入即可
@Autowired
private AppProperties appProperties;
3、Environment对象获取
使用很简单，直接使用spring的注解@Autowired引入即可
@Autowired
private Environment environment;
注意：
Environment 是org.springframework.core.env.Environment
使用Environment对象获取配置文件的值，最好使用带默认值的方法：getProperty(“配置项key”,“默认值”)，避免null值
使用Environment对象还可以获取到一些系统的启动信息，当然如果配置项过多也会有维护管理方面的问题
4、@PropertySource方式获取
有时候我们会有一些特殊意义的配置，会单独用一个配置文件存储，比如数据库配置连接参数
@Data
@Component
@ConfigurationProperties(prefix = "csdn")
@PropertySource(value = "classpath:alian.properties", encoding = "UTF-8", ignoreResourceNotFound = true)
public class ALianProperties {}
注意：
@ConfigurationProperties(value = “csdn”)表示配置文件里属性的前缀都是csdn开头@PropertySource中value属性表示指定配置文件的路径，encoding属性表示指定的是读取配置文件时的编码，记得和文件alian.properties的编码保持一致，ignoreResourceNotFound属性值为true时没找到指定配置文件的时候不报错- 配置类上记得加上
@Component注解 - .yml 格式不支持@PlaceSource注解导入配置
使用方法也很简单，直接使用spring的注解@Autowired引入即可
@Autowired
private ALianProperties ALianProperties;
5、原生方式获取：加载配置文件，getProperty( )
Properties props = new Properties();
try {
InputStreamReader inputStreamReader = new InputStreamReader(Objects.requireNonNull(this.getClass().getClassLoader().getResourceAsStream("load.properties")), StandardCharsets.UTF_8);
props.load(inputStreamReader);
} catch (IOException e1) {
e1.printStackTrace();
}
System.out.println("LoadProperties测试获取的功能名称：" + props.getProperty("function.name"));
System.out.println("LoadProperties测试获取的功能描述：" + props.getProperty("function.desp"));
原文链接：Spring Boot读取配置文件常用方式
13. Spring Boot 加载配置文件的优先级了解么？
1. 项目内部配置文件
spring boot 启动会扫描以下位置的 application.properties 或者 application.yml 文件作为Spring boot的默认配置文件
–file:./config/
–file:./
–classpath:/config/
–classpath:/
- 项目根目录下的/config目录下的配置文件。
- 项目根目录下的配置文件。
- 项目类路径（resources）下的/config目录下的配置文件。
- 项目类路径（resources）下的配置文件。
以上是按照优先级从高到低的顺序，所有位置的文件都会被加载，高优先级配置内容会覆盖低优先级配置内容。 同一目录下，.properties文件优先于.yml文件加载
SpringBoot会从这四个位置全部加载主配置文件，如果高优先级中配置文件属性与低优先级配置文件不冲突的属性，则会共同存在—互补配置。
2. 外部配置加载顺序
SpringBoot也可以从以下位置加载配置：优先级从高到低；高优先级的配置覆盖低优先级的配置，所有的配置会形成互补配置。
1.命令行参数
- 所有的配置都可以在命令行上进行指定；
- 多个配置用空格分开； –配置项=值
java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --server.port=8087 --server.context-path=/abc
2.来自java:comp/env的JNDI属性
3.Java系统属性（System.getProperties()）
4.操作系统环境变量
5.RandomValuePropertySource配置的random.*属性值
6.jar包外部的application-{profile}.properties或application.yml(带spring.profile)配置文件
7.jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件
8.jar包外部的application.properties或application.yml(不带spring.profile)配置文件
9.jar包内部的application.properties或application.yml(不带spring.profile)配置文件
10.@Configuration注解类上的@PropertySource
11.通过SpringApplication.setDefaultProperties指定的默认属性
14. 常用的 Bean 映射工具有哪些？
1. Dozer
Dozer 是一个映射框架，它使用递归将数据从一个对象复制到另一个对象。框架不仅能够在 bean 之间复制属性，还能够在不同类型之间自动转换。
2. Orika
Orika 是一个 bean 到 bean 的映射框架，它递归地将数据从一个对象复制到另一个对象。
Orika 的工作原理与 Dozer 相似。两者之间的主要区别是 Orika 使用字节码生成。这允许以最小的开销生成更快的映射器。
3. MapStruct
MapStruct 是一个自动生成 bean mapper 类的代码生成器。MapStruct 还能够在不同的数据类型之间进行转换。
4. ModelMapper
ModelMapper 是一个旨在简化对象映射的框架，它根据约定确定对象之间的映射方式。它提供了类型安全的和重构安全的 API。
5. JMapper
JMapper 是一个映射框架，旨在提供易于使用的、高性能的 Java bean 之间的映射。该框架旨在使用注释和关系映射应用 DRY 原则。该框架允许不同的配置方式:基于注释、XML 或基于 api。
参考链接： 5种常见Bean映射工具的性能比对
15. Spring Boot 如何监控系统实际运行状况？
Actuator（ HTTP 端点 ）
-
Spring Boot的Actuator提供了运行状态的监控的功能，Actuator的监控数据可以通过REST、远程shell（1.5之后的版本弃用）和
JMX方式获得。 Actuator模块提供了众多HTTP接口端点（Endpoint），来提供应用程序运行时的内部状态信息。 -
只需要在pom.xml文件中加入依赖。
-
Spring Boot Actuator提供了非常丰富的监控接口，可以通过这些接口了解应用程序运行时的内部状况。Actuator也支持用户自定义添加端点，可以根据实际应用，定义一些比较关心的指标，在运行期进行监控。
JMX
-
JMX 全称为 Java Management Extensions，即 Java 管理扩展。它提供了对 Java 应用程序和 JVM 的监控管理。
-
通过 JMX 我们可以监控服务器中各种资源的使用情况以及线程，内存和 CPU 等使用情况。
打开 jdk 下提供的工具 jConsole
16. Spring Boot 如何做请求参数校验？
接口开发中，为了防止非法参数对业务造成影响，经常需要对接口的参数做校验，例如登录的时候需要校验用户名密码是否为空，创建用户的时候需要校验邮件、手机号码格式是否准确 。
Validator 专门用来进行接口参数校验，例如常见的必填校验，email格式校验，用户名必须位于6到12之间 等等…
第一步，引入依赖
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-validationartifactId>
dependency>
第二步，定义要参数校验的实体类
@Data
public class ValidVO {
private String id;
@Length(min = 6,max = 12,message = "appId长度必须位于6到12之间")
private String appId;
@NotBlank(message = "名字为必填项")
private String name;
@Email(message = "请填写正确的邮箱地址")
private String email;
private String sex;
@NotEmpty(message = "级别不能为空")
private String level;
}
我们在需要验证的参数上加上了@Valid注解，如果验证失败，它将抛出异常。
一定一定不要忘记在类上加上 @Validated 注解了，这个参数可以告诉 Spring 去校验方法参数。
@RestController
@RequestMapping("/api")
@Validated
public class ValidVOController {
@GetMapping("/validvo/{id}")
public ResponseEntity<Integer> getValidVO (@Valid @PathVariable("appid") @Max(value = 5,message = "超过 id 的范围了") Integer appid) {
return ResponseEntity.ok().body(appid);
}
}
常见的约束注解如下：
| 注解 | 功能 |
|---|---|
| @AssertFalse | 可以为null,如果不为null的话必须为false |
| @AssertTrue | 可以为null,如果不为null的话必须为true |
| @DecimalMax | 设置不能超过最大值 |
| @DecimalMin | 设置不能超过最小值 |
| @Digits | 设置必须是数字且数字整数的位数和小数的位数必须在指定范围内 |
| @Future | 日期必须在当前日期的未来 |
| @Past | 日期必须在当前日期的过去 |
| @Max | 最大不得超过此最大值 |
| @Min | 最大不得小于此最小值 |
| @NotNull | 不能为null，可以是空 |
| @Null | 必须为null |
| @Pattern | 必须满足指定的正则表达式 |
| @Size | 集合、数组、map等的size()值必须在指定范围内 |
| 必须是email格式 | |
| @Length | 长度必须在指定范围内 |
| @NotBlank | 字符串不能为null,字符串trim()后也不能等于“” |
| @NotEmpty | 不能为null，集合、数组、map等size()不能为0；字符串trim()后可以等于“” |
| @Range | 值必须在指定范围内 |
| @URL | 必须是一个URL |
还可以自定义参数校验
虽然 Spring Validation 提供的注解基本上够用，但是面对复杂的定义，我们还是需要自己定义相关注解来实现自动校验。
参考链接： SpringBoot 如何进行参数校验，老鸟们都这么玩的！-阿里云开发者社区 (aliyun.com)
17. 如何使用Spring Boot 实现全局异常处理？
默认下，SpringBoot提供了一个 /error 映射，当我们系统发生异常，直接转到 /error 。原始错误页面很简陋，用户体验很不友好。如果想要显示给定状态码的自定义HTML错误页，可以将文件添加到error文件夹。错误页面可以是静态HTML(即添加到任何静态资源文件夹下)，也可以使用模板构建。
@ControllerAdvice 注解和 @ExceptionHandler 注解
-
@ControllerAdvice：这是一个增强的 Controller， 用于定义全局异常处理类作用在所有的@Controller类型的接口上。
使用这个 Controller ，可以实现三个方面的功能：
全局异常处理
全局数据绑定
全局数据预处理灵活使用这三个功能，可以帮助我们简化很多工作，需要注意的是，这是SpringMVC提供的功能，在SpringBoot中可以直接使用。
-
@ExceptionHandler： 用于声明处理异常的方法，统一处理某一类异常，从而能够减少代码重复率和复杂度。
@ControllerAdvice
public class GlobalExceptionHandler {
private Logger logger = LoggerFactory.getLogger(this.getClass());
/**
* 全局异常处理
*/
@ExceptionHandler(Exception.class)
@ResponseBody
public ReturnMsg handleException(HttpServletRequest request, Exception e) {
// 请求状态
HttpStatus status = getStatus(request);
// 返回错误信息：失败代码、失败信息、具体代码、具体信息
return new ReturnMsg(MsgUtil.MSG_ERROR, "发生异常", String.valueOf(status.value()), status.getReasonPhrase());
}
/**
* 自定义异常处理
*/
@ExceptionHandler(value = MyException.class)
@ResponseBody
public ReturnMsg myErrorHandler(MyException myException) {
// 返回错误信息：失败代码、失败信息、具体代码、具体信息
return new ReturnMsg(MsgUtil.MSG_ERROR, "发生异常", String.valueOf(myException.getStatus()), myException.getReason());
}
}
参考链接： 实现全局异常处理
18. Spring Boot 中如何实现定时任务 ?
定时任务实现的几种方式：
Timer：这是java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行。一般用的较少。
ScheduledExecutorService：也jdk自带的一个类；是基于线程池设计的定时任务类,每个调度任务都会分配到线程池中的一个线程去执行,也就是说,任务是并发执行,互不影响。
Spring Task：Spring3.0以后自带的task，可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多。
Quartz：这是一个功能比较强大的的调度器，可以让你的程序在指定时间执行，也可以按照某一个频度执行，配置起来稍显复杂。
以上参考链接： Spring Boot 实现定时任务的 4 种方式
在 Spring + SpringMVC 环境中，一般来说，要实现定时任务，我们有两中方案，一种是使用 Spring 自带的定时任务处理器 @Scheduled 注解，另一种就是使用第三方框架 Quartz ，Spring Boot 源自 Spring+SpringMVC ，因此天然具备这两个 Spring 中的定时任务实现策略，当然也支持 Quartz。
@Scheduled
使用 @Scheduled 非常容易，直接创建一个 Spring Boot 项目，并且添加 web 依赖 spring-boot-starter-web，项目创建成功后，添加 @EnableScheduling 注解，开启定时任务：
@SpringBootApplication
@EnableScheduling
public class ScheduledApplication {
public static void main(String[] args) {
SpringApplication.run(ScheduledApplication.class, args);
}
}
接下来配置定时任务：
@Scheduled(fixedRate = 2000)
public void fixedRate() {
System.out.println("fixedRate>>>"+new Date());
}
@Scheduled(fixedDelay = 2000)
public void fixedDelay() {
System.out.println("fixedDelay>>>"+new Date());
}
@Scheduled(initialDelay = 2000,fixedDelay = 2000)
public void initialDelay() {
System.out.println("initialDelay>>>"+new Date());
}
- 首先使用
@Scheduled注解开启一个定时任务。 fixedRate表示任务执行之间的时间间隔，具体是指两次任务的开始时间间隔，即第二次任务开始时，第一次任务可能还没结束。fixedDelay表示任务执行之间的时间间隔，具体是指本次任务结束到下次任务开始之间的时间间隔。initialDelay表示首次任务启动的延迟时间。- 所有时间的单位都是毫秒。
上面这是一个基本用法，除了这几个基本属性之外，@Scheduled 注解也支持 cron 表达式，使用 cron 表达式，可以非常丰富的描述定时任务的时间。cron 表达式格式如下（最下面有详细链接）：
[秒] [分] [小时] [日] [月] [周] [年]
例如，在 @Scheduled 注解中来一个简单的 cron 表达式，每隔5秒触发一次，如下：
@Scheduled(cron = "0/5 * * * * *")
public void cron() {
System.out.println(new Date());
}
Quartz
一般在项目中，除非定时任务涉及到的业务实在是太简单，使用 @Scheduled 注解来解决定时任务，否则大部分情况可能都是使用 Quartz 来做定时任务。
在 Spring Boot 中使用 Quartz ，只需要在创建项目时，添加 Quartz 依赖即可。
项目创建完成后，也需要添加开启定时任务的注解：
@SpringBootApplication
@EnableScheduling
public class QuartzApplication {
public static void main(String[] args) {
SpringApplication.run(QuartzApplication.class, args);
}
}
Quartz 在使用过程中，有两个关键概念，一个是JobDetail（要做的事情），另一个是触发器（什么时候做），
- 要定义 JobDetail，需要先定义 Job
第一种方式，直接定义一个Bean：
关于这种定义方式说两点：
- 首先将这个 Job 注册到 Spring 容器中。
- 这种定义方式有一个缺陷，就是无法传参。
第二种定义方式，则是继承 QuartzJobBean 并实现默认的方法
- Job 有了之后，接下来创建类，配置 JobDetail 和 Trigger 触发器，
参考链接： Spring Boot 中实现定时任务的两种方式