SpringBoot介绍SpringBoot目录 SpringBoot介绍_Spring缺点分析 SpringBoot介绍_什么是SpringBoot SpringBoot介绍_SpringBoot核心功能 SpringBoot入门_通过官网搭建项目 SpringBoot入门_通过IDEA脚手架搭建项目 SpringBoot入门_SpringBoot项目结构SpringBoot入门_通过Maven搭建项目 SpringBoot入门_编写Java代码 SpringBoot原理分析_起步依赖Spri

78 阅读 0 评论 52 点赞

我是靠谱客的博主霸气乐曲，这篇文章主要介绍SpringBoot介绍SpringBoot目录 SpringBoot介绍_Spring缺点分析 SpringBoot介绍_什么是SpringBoot SpringBoot介绍_SpringBoot核心功能 SpringBoot入门_通过官网搭建项目 SpringBoot入门_通过IDEA脚手架搭建项目 SpringBoot入门_SpringBoot项目结构SpringBoot入门_通过Maven搭建项目 SpringBoot入门_编写Java代码 SpringBoot原理分析_起步依赖Spri，现在分享给大家，希望可以做个参考。

SpringBoot目录

SpringBoot介绍_Spring缺点分析

SpringBoot介绍_什么是SpringBoot

SpringBoot介绍_SpringBoot核心功能

SpringBoot入门_通过官网搭建项目

SpringBoot入门_通过IDEA脚手架搭建项目

SpringBoot入门_SpringBoot项目结构

SpringBoot入门_通过Maven搭建项目

SpringBoot入门_编写Java代码

SpringBoot原理分析_起步依赖

查看spring-boot-starter-parent起步依赖

查看spring-boot-starter-web起步依赖

SpringBoot原理分析_自动配置

查看注解 @SpringBootApplication 的源码

查看注解 @EnableAutoConfifiguration 的源码

查看AutoConfifigurationImportSelector源码

我们 ServletWebServerFactoryAutoConfifiguration 为例来分析源码：

进入 ServerProperties 类源码如下：

SpringBoot原理分析_核心注解

YAML文件_配置文件介绍

YAML文件_自定义配置简单数据

YAML文件_自定义配置对象数据

YAML文件_自定义配置集合数据

YAML文件_读取配置文件的数据

使用@Value读取

使用@ConfigurationProperties读取

YAML文件_占位符的使用

YAML文件_配置文件存放位置及优先级

YAML文件_bootstrap配置文件

SpringBoot注册web组件_注册Servlet

SpringBoot注册web组件_注册Filter

SpringBoot注册web组件_注册Listener

SpringBoot访问静态资源_静态资源相关目录

static目录

目录结构

templates目录

SpringBoot访问静态资源_静态资源其他存放位置

SpringBoot整合JSP

Thymeleaf_Thymeleaf入门

Thymeleaf_变量输出

Thymeleaf_操作字符串

Thymeleaf_操作时间

Thymeleaf_条件判断

Thymeleaf_迭代遍历

遍历集合

使用状态变量

遍历Map

Thymeleaf_获取域中的数据

Thymeleaf_URL写法

在RESTful风格路径中添加参数

Thymeleaf_相关配置

SpringBoot热部署

SpringBoot整合MyBatis

SpringBoot参数校验_简单数据类型

SpringBoot参数校验_异常处理

SpringBoot参数校验_校验相关注解

SpringBoot参数校验_对象类型

SpringBoot指标监控_添加Actuator功能

SpringBoot指标监控_Spring Boot Admin

SpringBoot日志管理

SpringBoot项目部署_项目打包

SpringBoot项目部署_多环境配置

SpringBoot容器化部署_安装Docker环境

SpringBoot容器化部署_Dockerfile制作镜像

SpringBoot容器化部署_Maven插件制作镜像

Spring Task_定时任务

Spring Task_入门案例

Spring Task_Cron表达式

Spring Task_Cron实战案例

Spring Task_@Scheduled

Spring Task_多线程任务

SpringBoot目录

SpringBoot介绍_Spring缺点分析

Spring是一个非常优秀的轻量级框架，以IOC（控制反转）和AOP（面向切面）为思想内核，极大简化了JAVA企业级项目的开发。虽然Spring的组件代码是轻量级的，但它的配置却是重量级的。使用Spring进行项目开发需要在配置文件中写很多代码，所有这些配置都代表了开发时的损耗。

除此之外，Spring项目的依赖管理也是一件耗时耗力的事情。在环境搭建时，需要分析要导入哪些库的坐标，而且还需要分析导入与之有依赖关系的其他库的坐标，一旦选错了依赖的版本，随之而来的不兼容问题就会严重阻碍项目的开发进度。比如Spring5.0以上只能使用Junit4.12以上的版本。

总结
Spring的缺点：
1.配置过于繁琐。
2.引入的依赖过多，版本控制复杂。

SpringBoot介绍_什么是SpringBoot

SpringBoot对Spring的缺点进行改善和优化，基于约定大于配置的思想，简化了Spring的开发，所谓简化是指简化了Spring中大量的配置文件和繁琐的依赖引入。所以SpringBoot是一个服务于框架的框架，它不是对Spring功能的增强，而是提供了一种快速使用Spring框架的方式。

SpringBoot的优点：
配置简单
1.依赖引入简单
2.提供了一些大型项目的非功能特性，如嵌入式服务器，安全指标，健康监测等。

SpringBoot介绍_SpringBoot核心功能

自动配置
SpringBoot项目自动提供最优配置，同时可以修改默认值满足特定的要求。
起步依赖
SpringBoot的依赖是基于功能的，而不是普通项目的依赖是基于JAR包的。SpringBoot将完成一个功能所需要的所有坐标打包到一起，并完成了版本适配，我们在使用某功能时只需要引入一个依赖即可。

SpringBoot入门_通过官网搭建项目

接下来我们搭建一个SpringBoot项目，并引入SpringMVC的功能，
首先我们可以通过官网搭建项目：

1.访问start.spring.io
2.生成SpringBoot项目

SpringBoot版本说明：
SNAPSHOT：快照版，表示开发版本，随时可能修改；
M1（Mn）：M1是milestone的缩写，也就是里程碑版本；

RC1（RCn）：RC1是release candidates的缩写，也就是发布预览版；
Release：正式版，也可能没有任何后缀也表示正式版

SpringBoot打包类型说明：
使用SpringMVC开发的是一个web项目，但由于在SpringBoot中直接嵌入了Tomcat等
Web容器，所以在使用SpringBoot做Web开发时不需要部署War文件，只需要打成Jar
包即可。

SpringBoot入门_通过IDEA脚手架搭建项目

我们也可以在IDEA中利用脚手架工具搭建项目：
在IDEA中新建项目，项目类型为Spring Initializr，选择JDK版本
和搭建网站后点击下一步。

脚手架工具也会访问SpringBoot官网进行项目搭建，但SpringBoot官网有时访问速度较慢，我们也可以选择国内的镜像网站https://start.aliyun.com/搭建项目，阿里的脚手架镜像SpringBoot版本有些滞后。

选择项目参数后，点击下一步

选择SpringBoot版本和需要的起步依赖，点击下一步。

SpringBoot入门_SpringBoot项目结构

接下来我们分析SpringBoot的项目结构：

POM文件

SpringBoot项目必须继承spring-boot-starter-parent，即所有的SpringBoot项目都是spring-boot-starter-parent的子项目。
spring-boot-starter-parent中定义了常用配置、依赖、插件等信息，供SpringBoot项目继承使用。

复制代码

1
2
3
4
5
6
7
<parent>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-parent</artifactId>
     <version>2.7.0-M1</version>
     <relativePath/> 
<!-- lookup parentfrom repository -->
</parent>

SpringBoot项目中可以定义起步依赖，起步依赖不是以jar包为单位，而是以功能为单位

复制代码

1
2
3
4
5
6
7
8
9
10
11
<dependencies>
     <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-test</artifactId>
       <scope>test</scope>
    </dependency>
</dependencies>

spring-boot-maven-plugin插件是将项目打包成jar包的插件。
该插件打包后的SpringBoot项目无需依赖web容器，可以直接使用JDK运行

复制代码

1
2
3
4
5
6
7
8
<build>
  <plugins>
    <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
  </plugins>
</build>

启动类
启动类的作用是启动SpringBoot项目，运行启动类的main方法即可
启动SpringBoot项目。

复制代码

1
2
3
4
5
6
7
@SpringBootApplication
public class Springbootdemo2Application {
  public static void main(String[] args) {
  
        SpringApplication.run(Springbootdemo2Application.class, args);
 }
}

配置文件

由于SpringBoot极大简化了Spring配置，所以只有一个application.properties配置文件，且Spring的自动配置功能使得大部分的配置都有默认配置，该文件的功能是覆盖默认配置信息，该文件不写任何信息都可以启动项目。
启动后默认端口号为8080，我们可以覆盖该配置：

复制代码

1
server.port=8888

SpringBoot入门_通过Maven搭建项目

了解了SpringBoot结构后，我们也可以使用Maven手动搭建
SpringBoot项目：

使用Maven创建普通JAVA项目

在pom中添加项目的父工程、起步依赖、插件

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<!-- 父工程 -->
<parent>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-parent</artifactId>
     <version>2.7.0-M1</version>
</parent>
     <!-- 起步依赖 -->
<dependencies>
  <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
</dependencies>
<!-- 插件 -->
<build>
  <plugins>
    <plugin>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
  </plugins>
</build>

编写启动类

复制代码

1
2
3
4
5
6
7
8
@SpringBootApplication
public class SpringBootApp {
  public static void main(String[] args)
    {
  
     SpringApplication.run(SpringBootApp.class, args);
    }
}

编写配置文件application.properties

复制代码

1
2
3
4
5
6
#日志格式
logging.pattern.console=%d{MM/dd
HH:mm:ss.SSS} %clr(%-5level) 
---[%-15thread] %cyan(%-50logger{50}):%msg%n
#端口号
server.port=8888

运行启动类主方法，启动项目

SpringBoot入门_编写Java代码

之前搭建的SpringBoot项目已经都整合了SpringMVC，我们编写一
个控制器进行测试：

复制代码

1
2
3
4
5
6
7
8
9
@Controller
public class MyController {
      @RequestMapping("/hello")
      @ResponseBody
      public String hello(){
          System.out.println("hellospringboot!");
          return "hello springboot!";
 }
}

启动类在启动时会做注解扫描(@Controller、@Service、@Repository......)，扫描位置为同包或者子包下的注解，所以我们要在启动类同级或同级包下编写代码。

启动项目，访问http://localhost:8888/hello

SpringBoot原理分析_起步依赖

查看spring-boot-starter-parent起步依赖

按住 Ctrl 点击 pom.xml 中的 spring-boot-starter-parent ，跳转到了 spring-boot-
starter-parent 的 pom.xml ，发现 spring-boot-starter-parent 的父工程是 spring-boot-
dependencies 。

进入 spring-boot-dependencies 的 pom.xml 可以看到，一部分坐标的版本、
依赖管理、插件管理已经定义好，所以SpringBoot工程继承
spring-boot-starter-parent 后已经具备版本锁定等配置了。所以起步依赖
的作用就是进行依赖的传递。

查看spring-boot-starter-web起步依赖

按住 Ctrl 点击 pom.xml 中的 spring-boot-starter-web ，跳转到了 spring-boot-starter-
web 的 pom.xml ，从 spring-boot-starter-web 的 pom.xml 中我们可以发现， spring-
boot-starter-web 就是将web开发要使用的 spring-web 、 spring-webmvc 等坐标进
行了打包，这样我们的工程只要引入 spring-boot-starter-web 起步依赖的坐
标就可以进行web开发了，同样体现了依赖传递的作用。

SpringBoot原理分析_自动配置

查看注解 @SpringBootApplication 的源码

@SpringBootConfifiguration：等同与@Confifiguration，既标注该类是Spring的一个配置类

@EnableAutoConfifiguration：SpringBoot自动配置功能开启

查看注解 @EnableAutoConfifiguration 的源码

查看注解 @EnableAutoConfifiguration 的源码

@Import(AutoConfifigurationImportSelector.class) 导入了 AutoConfifigurationImportSelector 类

查看AutoConfifigurationImportSelector源码

查看AutoConfifigurationImportSelector源码

SpringFactoriesLoader.loadFactoryNames 方法的作用就是从 META-INF/spring.factories 文件中读取指定类对应的类名称列表

点开 spring-boot-autoconfigure 的 spring.factories 文件

有关配置类的信息如下：

上面配置文件存在大量的以 Configuration 为结尾的类名称，这些类就是存有自动配置信息的类，而 SpringApplication 在获取这些类名后再加载。

我们 ServletWebServerFactoryAutoConfifiguration 为例来分析源码：

@EnableConfifigurationProperties(ServerProperties.class) 代表加载 ServerProperties 服务器配置属性类。

进入 ServerProperties 类源码如下：

prefifix = "server" 表示SpringBoot配置文件中的前缀，SpringBoot会将配置文件中以server开始的属性映射到该类的字段中。所以配置网络端口的方式为 server.port

如果我们没有在配置文件中配置默认端口，SpringBoot就会读取默认配置，而默认配置存放在 META-INF/spring-configuration-metadata.json 中，打开 spring-boot-autoconfigure 的 spring.factories 文件

该文件中保存的就是所有默认配置信息。

SpringBoot原理分析_核心注解

@SpringBootApplication

标注是SpringBoot的启动类。此注解等同于

@SpringBootConfiguration + @EnableAutoConfiguration + @ComponentScan 。

@SpringBootConfiguration

@SpringBootConfiguration 是 @Configuration 的派生注解，跟 @Configuration 功能一致，标注这个类是一个配置类，只不过 @SpringBootConfiguration 是 Springboot的注解，而 @Configuration 是Spring的注解

@EnableAutoConfiguration

SpringBoot自动配置注解。等同于

@AutoConfigurationPackage + @Import(AutoConfigurationImportSelector.class)

@AutoConfigurationPackage

自动扫描包的注解，它会自动扫描主类所在包下所有加了注解的类（@Controller，@Service等），以及配置类（@Configuration）。

@Import({AutoConfigurationImportSelector.class})

该注解会导入 AutoConfifigurationImportSelector 类对象，该对象会从 META-INF/spring.factories 文件中读取配置类的名称列表。

@ComponentScan

该注解会扫描项目，自动装配一些项目启动需要的Bean。

YAML文件_配置文件介绍

SpringBoot项目中，大部分配置都有默认值，但如果想替换默认配置的话，就可以使用application.properties或者application.yml进行配置。

SpringBoot默认会从resources目录下加载application.properties 或application.yml文件。其中，application.properties文件是键值对类型的文件，之前一直在使用，所以我们不再对properties文件进行阐述。

https://docs.spring.io/spring-boot/docs/2.7.0-M1/reference/ htmlsingle/#application-properties.server可以查找配置文件如何覆盖SpringBoot项目的默认配置。

除了properties文件外，SpringBoot还支持YAML文件进行配置。 YAML文件的扩展名为 .yml 或 .yaml ，它的基本要求如下：

1 大小写敏感

2 使用缩进代表层级关系

3 相同的部分只出现一次

复制代码

1
2
3
4
5
6
比如使用properties文件配置tomcat端口：  server.port=8888

而使用YAML文件配置tomcat端口： 

server:
 port: 8888

YAML文件_自定义配置简单数据

除了覆盖默认配置，我们还可以在YAML文件中配置其他信息以便我们在项目中使用。配置简单数据的方式如下：

语法:

数据名: 值

示例代码：

name: baizhan

注意：value之前有一个空格

YAML文件_自定义配置对象数据

对象:

属性名1: 属性值

属性名2: 属性值

# 或者

对象: {属性名1: 属性值,属性名2: 属性值}

示例代码：

复制代码

1
2
3
4
5
6
7
8
9
# 学生1
student1:
 sex: female
 age: 10
 address: beijing


# 学生2
student2: {sex: female,age: 10,address: beijing}

属性名前面的空格个数不限，在yml语法中，相同缩进代表同一个级别，只要每个属性前的空格数一样即可。

YAML文件_自定义配置集合数据

语法

集合:

- 值1

- 值2

# 或者

集合: [值1,值2]

示例代码

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 城市
city1:
 - beijing
 - tianjin
 - shanghai
 - chongqing


city2:
[beijing,tianjin,shanghai,chongqing]


# 集合中的元素是对象
students:
 - name: baizhan
   age: 18
   score: 100
 - name: shangxuetang
   age: 28
   score: 88
 - name: chengxuyuan
   age: 38
   score: 90

注意：值与之前的 - 之间存在一个空格

YAML文件_读取配置文件的数据

使用@Value读取

我们可以通过@Value注解将配置文件中的值映射到一个Spring管理的Bean的字段上，用法如下：

配置文件

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
name: baizhan


student:
 sex: female
 age: 10
 address: beijing


city1:
 - beijing
 - tianjin
 - shanghai
 - chongqing

students:
 - name: baizhan
   age: 18
   score: 100
 - name: shangxuetang
   age: 28
   score: 88
 - name: chengxuyuan
   age: 38
   score: 90

读取配置文件数据：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@Controller
public class YmlController1 {
    @Value("${name}")
    private String name;

    @Value("${student1.age}")
    private int age;

    @Value("${city1[0]}")
    private String city1;

    @Value("${students[0].score}")
    private double score1;

    @RequestMapping("/yml1")
    @ResponseBody
    public String yml1(){
        System.out.println(name);
        System.out.println(age);
        System.out.println(city1);
        System.out.println(score1);
        return "hello springboot!";
   }
}

@Value只能映射简单数据类型，不能将yaml文件中的对象、集合映射到属性中。

使用@ConfigurationProperties读取

通过 @ConfigurationProperties(prefifix="对象") 可以将配置文件中的配置自动与实体进行映射，这样可以将yml文件中配置的对象属性直接映射到 Bean当中。

配置文件

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
user:
 id: 10001
 username: shangxuetang
 address:
   - beijing
   - tianjin
   - shanghai
   - chongqing
 grades:
   - subject: math
     score: 100
   - subject: english
     score: 90

实体类

复制代码

1
2
3
4
5
public class Grade {
    private String subject;
    private double score;
    // 省略getter/setter/tostring
}

读取配置文件

复制代码

@Controller
@ConfigurationProperties(prefix = "user")
public class YmlController2 {
    private int id;
    private String username;
    private List<String> address;
    private List<Grade> grades;
    @RequestMapping("/yml2")
    @ResponseBody
    public String yml2(){
        System.out.println(id);
        System.out.println(username);
        System.out.println(address);
        System.out.println(grades);
        return "hello springboot!";
   }
    public int getId() {
        return id;
   }
    public void setId(int id) {
        this.id = id;
}
    public String getUsername() {
        return username;
   }
    public void setUsername(String username) {
        this.username = username;
   }
    public List<String> getAddress() {
        return address;
   }
    public void setAddress(List<String> address) {
        this.address = address;
   }
    public List<Grade> getGrades() {
        return grades;
   }
    public void setGrades(List<Grade> grades) {
        this.grades = grades;
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
@Controller
@ConfigurationProperties(prefix = "user")
public class YmlController2 {
    private int id;
    private String username;
    private List<String> address;
    private List<Grade> grades;
    @RequestMapping("/yml2")
    @ResponseBody
    public String yml2(){
        System.out.println(id);
        System.out.println(username);
        System.out.println(address);
        System.out.println(grades);
        return "hello springboot!";
   }
    public int getId() {
        return id;
   }
    public void setId(int id) {
        this.id = id;
}
    public String getUsername() {
        return username;
   }
    public void setUsername(String username) {
        this.username = username;
   }
    public List<String> getAddress() {
        return address;
   }
    public void setAddress(List<String> address) {
        this.address = address;
   }
    public List<Grade> getGrades() {
        return grades;
   }
    public void setGrades(List<Grade> grades) {
        this.grades = grades;
   }
}

YAML文件_占位符的使用

YAML文件中可以使用 ${} 占位符，它有两个作用：

使用配置文件中的值

编写配置文件

复制代码

1
2
3
4
server:
 port: 8888
myconfig:
 myport: ${server.port}

读取配置文件

复制代码

1
2
3
4
5
6
7
8
9
10
11
@Controller
public class YmlController3 {
    @Value("${myconfig.myport}")
    private int port;
    @RequestMapping("/yml3")
    @ResponseBody
    public String yml3(){
        System.out.println(port);
        return "hello springboot!";
   }
}

使用框架提供的方法

SpringBoot框架提供了一些生成随机数的方法可以在yml文件中使用：

用法如下：

复制代码

1
2
3
# 随机生成tomcat端口
server:
 port: ${random.int(1024,9999)}

YAML文件_配置文件存放位置及优先级

配置文件有如下存放位置：

项目根目录下
项目根目录下的/config子目录中
项目的resources目录中
项目的resources下的/config子目录中

这些目录下都可以存放两类配置文件，分别是 application.yml 和 application.properties ，这些配置文件的优先级从高到低依次为：

项目根目录下的/config子目录中

config/application.properties
config/application.yml

项目根目录下

application.properties
application.yml

项目的resources下的/config子目录中

resources/config/application.properties
resources/config/application.yml

项目的resources目录中

resources/application.properties
resources/application.yml

优先级高的文件会覆盖优先级低的文件中的配置

YAML文件_bootstrap配置文件

SpringBoot中有两种容器对象，分别是bootstrap和application， bootstrap是应用程序的父容器，bootstrap加载优先于 applicaton。bootstrap配置文件主要对bootstrap容器进行配置， application配置文件是对applicaton容器进行配置。 bootstrap配置文件也同样支持properties和yml两种格式，主要用于从外部引入Spring应用程序的配置。 bootstrap配置文件特征

boostrap由父ApplicationContext加载，比applicaton优先加载。
boostrap里面的属性不能被覆盖。

bootstrap与application的应用场景

application配置文件主要用于SpringBoot项目的自动化配置。
bootstrap配置文件有以下几个应用场景。

使用Spring Cloud Config配置中心时，需要在bootstrap配置文件中添加连接到配置中心的配置属性来加载外部配置中心的配置信息。
一些固定的不能被覆盖的属性。
一些加密/解密的场景。

SpringBoot注册web组件_注册Servlet

由于SpringBoot项目没有web.xml文件，所以无法在web.xml中注册web组件，SpringBoot有自己的方式注册web组件。

注册方式一

编写servlet

复制代码

1
2
3
4
5
6
7
@WebServlet("/first")
public class FirstServlet extends
HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response){
        System.out.println("First Servlet........");
   }
}

启动类扫描web组件

复制代码

1
2
3
4
5
6
7
8
9
10
11
@SpringBootApplication
//SpringBoot启动时扫描注册注解标注的Web组件
@ServletComponentScan
public class Springbootdemo2Application {
    public static void main(String[] args)
       {
      
          SpringApplication.run(Springbootdemo2Application.class, args);
   }
}

注册方式二

编写servlet

复制代码

1
2
3
4
5
6
public class SecondServlet extends
HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response){
        System.out.println("Second Servlet........");
   }
}

使用配置类注册servlet

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Configuration
public class ServletConfig {
    //ServletRegistrationBean可以注册
      Servlet组件，将其放入Spring容器中即可注册Servlet
    @Bean
    public ServletRegistrationBean getServletRegistrationBean(){
        // 注册Servlet组件
        ServletRegistrationBean bean = new ServletRegistrationBean(new SecondServlet());
        // 添加Servlet组件访问路径
        bean.addUrlMappings("/second");
        return bean;
   }
}

SpringBoot注册web组件_注册Filter

注册方式一

编写filter

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@WebFilter(urlPatterns = "/first")
public class FirstFilter implements Filter
{
    @Override
    public void init(FilterConfig filterConfig) throws ServletException { }
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse,FilterChain filterChain) throws IOException, ServletException {
        System.out.println("进入First Filter");
      
        filterChain.doFilter(servletRequest,servletResponse);
        System.out.println("离开First Filter");
   }
    @Override
    public void destroy() { }
}

启动类扫描web组件

复制代码

1
2
3
4
5
6
7
8
9
10
@SpringBootApplication
//SpringBoot启动时扫描注册注解标注的Web组件
@ServletComponentScan
public class Springbootdemo2Application {
    public static void main(String[] args)
  {
      
      SpringApplication.run(Springbootdemo2Appl ication.class, args);
   }
}

注册方式二

编写filter

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class SecondFilter implements
Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException { }
    
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("进入Second Filter");
      
    filterChain.doFilter(servletRequest,servletResponse);

    System.out.println("离开Second Filter");
   }
    @Override
    public void destroy() { }
}

使用配置类注册filter

复制代码

1
2
3
4
5
6
7
8
9
10
11
@Configuration
public class FilterConfig {
    @Bean
    public FilterRegistrationBean getFilterRegistrationBean(){
        // 注册filter组件
        FilterRegistrationBean bean =  new FilterRegistrationBean(new SecondFilter());
        // 添加过滤路径
        bean.addUrlPatterns("/second");
        return bean;
   }
}

SpringBoot注册web组件_注册Listener

注册方式一

编写Listener

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
@WebListener
public class FirstListener implements
ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("First ListenerInit......");
   }
    @Override
    public void contextDestroyed(ServletContextEvent sce){
   }
}

启动类扫描web组件

复制代码

1
2
3
4
5
6
7
8
9
@SpringBootApplication
//SpringBoot启动时扫描注册注解标注的Web组件
@ServletComponentScan
public class Springbootdemo2Application {
    public static void main(String[] args){       
      
     SpringApplication.run(Springbootdemo2Appl ication.class, args);
   }
}

注册方式二

编写Listener

复制代码

1
2
3
4
5
6
7
8
9
10
public class SecondListener implements
ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("Second Listener Init......");
   }
    @Override
    public void contextDestroyed(ServletContextEvent sce){
   }
}

使用配置类注册Listener

复制代码

1
2
3
4
5
6
7
8
@Configuration
public class ListenerConfig {
    @Bean
    public ServletListenerRegistrationBean getServletListenerRegistrationBean(){
        ServletListenerRegistrationBean bean = new ServletListenerRegistrationBean(new SecondListener());
        return bean;
   }
}

SpringBoot访问静态资源_静态资源相关目录

SpringBoot项目中没有WebApp目录，只有src目录。在 src/main/resources 下面有 static 和 templates 两个文件夹。SpringBoot默认在 static 目录中存放静态资源，而 templates 中放动态页面。

static目录

SpringBoot通过 /resources/static 目录访问静态资源，在 resources/static 中编写html页面：

复制代码

1
2
3
4
5
6
7
8
9
10
11
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>测试html</title>
</head>
<body>
   <h1>我的HTML</h1>
   <img src="/img/img.png">
</body>
</html>

目录结构

templates目录

在SpringBoot中不推荐使用JSP作为动态页面，而是默认使用 Thymeleaf编写动态页面。templates目录是存放Thymeleaf页面的目录，稍后我们讲解Thymeleaf技术。

SpringBoot访问静态资源_静态资源其他存放位置

除了 /resources/static 目录，SpringBoot还会扫描以下位置的静态资源：

/resources/META‐INF/resources/

/resources/resources/

/resources/public/

我们还可以在配置文件自定义静态资源位置

在SpringBoot配置文件进行自定义静态资源位置配置

复制代码

1
2
3
4
5
spring:
 web:
   resources:
     static-locations:
classpath:/suibian/,classpath:/static/

注意：

1 该配置会覆盖默认静态资源位置，如果还想使用之前的静态资源位置，还需要配置在后面。

2 SpringBoot2.5之前的配置方式为： spring.resources.static-locations

SpringBoot整合JSP

在SpringBoot中不推荐使用JSP作为动态页面，我们要想使用JSP编写动态页面，需要手动添加webapp目录。

由于SpringBoot自带tomcat无法解析JSP，需要在pom文件添加 JSP引擎

复制代码

1
2
3
4
5
<!--添加jsp引擎，SpringBoot内置的Tomcat不能解析JSP-->
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embedjasper</artifactId>
</dependency>

创建webapp目录，编写JSP文件

复制代码

1
2
3
4
5
6
7
8
9
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>Title</title>
  </head>
  <body>
    <h1>Hello JSP</h1>
  </body>
</html>

将webapp标记为web目录

修改配置文件，配置视图解析器

复制代码

1
2
3
4
5
6
7
8
9
10
spring:
 mvc:
   view:
     prefix: /WEB-INF/jsp/
     suffix: .jsp
logging:
 pattern:
   console: "%d{MM/dd HH:mm:ss.SSS}
%clr(%-5level) --- [%-15thread]
%cyan(%-50logger{50}):%msg%n"

创建Controller

复制代码

1
2
3
4
5
6
7
8
@Controller
public class PageController {
    // 页面跳转
    @GetMapping("/{page}")
    public String showPage(@PathVariable String page){
        return page;
   }
}

启动项目，访问http://localhost:8080/myJsp

Thymeleaf_Thymeleaf入门

Thymeleaf是一款用于渲染XML/HTML5内容的模板引擎，类似 JSP。它可以轻易的与SpringMVC等Web框架进行集成作为Web应用的模板引擎。在SpringBoot中推荐使用Thymeleaf编写动态页面。 Thymeleaf最大的特点是能够直接在浏览器中打开并正确显示模板页面，而不需要启动整个Web应用。 Thymeleaf在有网络和无网络的环境下皆可运行，它即可以让美工在浏览器查看页面的静态效果，也可以让程序员在服务器查看带数据的动态页面效果。没有数据时，Thymeleaf的模板可以静态地运行；当有数据返回到页面时，Thymeleaf标签会动态地替换掉静态内容，使页面动态显示。

1 创建Springboot项目

2 引入SpringMVC和Thymeleaf起步依赖

复制代码

1
2
3
4
5
6
7
8
9
<!--添加Thymeleaf起步依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
 </dependency>
 <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

3 创建视图index.html

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
<!DOCTYPE html>
<!-- 引入thymeleaf命名空间，方便使用thymeleaf属性 -->
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>thymeleaf入门</title>
</head>
<body>
   <!-- 静态页面显示程序员，动态页面使用后端传来的msg数据代替 -->
   <!-- thymeleaf支持el表达式 -->
   <h2 th:text="${msg}">程序员</h2>
</body>
</html>

4. template中的html文件不能直接访问，需要编写Controller跳转到页面中

复制代码

1
2
3
4
5
6
7
8
9
@Controller
public class PageController {
    // 页面跳转
    @GetMapping("/show")
    public String showPage(Model model){
        model.addAttribute("msg","Hello Thymeleaf");
        return "index";
   }
}

5.进行springboot配置

#日志格式

logging.pattern.console=%d{HH:mm:ss.SSS} %clr(%-5level) --- [%-15thread] %cyan(%-50logger{50}):%msg%n

6.启动项目，访问http://localhost:8080/show及静态页面

Thymeleaf_变量输出

1.准备模型数据

复制代码

1
2
3
4
5
@GetMapping("/show")
public String showPage(Model model){
    model.addAttribute("msg","Hello Thymeleaf");
    return "index";
}

2.在视图展示model中的值

复制代码

1
2
3
<span th:text="${msg}"></span>
<hr/>
<input th:value="${msg}">

Thymeleaf_操作字符串

Thymeleaf提供了一些内置对象可以操作数据，内置对象可直接在模板中使用，这些对象是以#引用的，操作字符串的内置对象为 strings。

使用方式：

复制代码

1
2
3
4
5
<span th:text="${#strings.isEmpty(msg)}"></span>
<hr/>
<span th:text="${#strings.contains(msg,'s')}"></span>
<hr/>
<span th:text="${#strings.length(msg)}"></span>

Thymeleaf_操作时间

操作时间的内置对象为dates

方法	说明
${#dates.format(key)}	格式化日期，默认的以浏览器默认语言为格式化标准
${#dates.format(key,'yyyy/MM/dd')}	按照自定义的格式做日期转换
${#dates.year(key)}	取年
${#dates.month(key)}	取月
${#dates.day(key)}	取日

1.准备数据

复制代码

1
model.addAttribute("date",new Date(130,01,01));

2.使用内置对象操作时间

复制代码

1
2
3
4
5
6
7
<span th:text="${#dates.format(date)}"></span>
<hr/>
<span th:text="${#dates.format(date,'yyyy/MM/dd')}"></span>
<hr/>
<span th:text="${#dates.year(date)}"></span>
<span th:text="${#dates.month(date)}"></span>
<span th:text="${#dates.day(date)}"></span>

Thymeleaf_条件判断

1.准备数据

复制代码

1
model.addAttribute("sex","女");

2.进行条件判断

复制代码

1
2
3
4
5
6
7
8
9
<div>
    <span th:if="${sex} == '男'">
       性别：男
    </span>
    <span th:if="${sex} == '女'">
       性别：女
    </span>
</div>

1.准备数据

复制代码

1
model.addAttribute("id","12");

2.进行条件判断

复制代码

1
2
3
4
5
6
7
<div th:switch="${id}">
    <span th:case="1">ID为1</span>
    <span th:case="2">ID为2</span>
    <span th:case="3">ID为3</span>
    <span th:case="*">ID为*</span>
</div>

Thymeleaf_迭代遍历

遍历集合

1.编写实体类

复制代码

1
2
3
4
5
6
7
public class Users {
    private String id;
    private String name;
    private int age;
    // 省略getter/setter/构造方法
}

2.准备数据

复制代码

1
2
3
4
5
6
List<Users> users = new ArrayList<>();
users.add(new Users("1","sxt",23));
users.add(new Users("2","baizhan",22));
users.add(new Users("3","admin",25));
model.addAttribute("users",users);

3.在页面中展示数据

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
<table border="1" width="50%">
    <tr>
        <th>ID</th>
        <th>Name</th>
        <th>Age</th>
    </tr>
    <!-- 遍历集合的每一项起名为user -->
    <tr th:each="user : ${users}">
        <td th:text="${user.id}"></td>
        <td th:text="${user.name}"></td>
        <td th:text="${user.age}"></td>
    </tr>
</table>

使用状态变量

thymeleaf将遍历的状态变量封装到一个对象中，通过该对象的属性可以获取状态变量：

使用状态变量

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
<!--冒号前的第一个对象是遍历出的对象，第二个对象是封装状态变量的对象-->
<tr th:each="user,status : ${users}">
    <td th:text="${user.id}"></td>
    <td th:text="${user.name}"></td>
    <td th:text="${user.age}"></td>
    <td th:text="${status.index}"></td>
    <td th:text="${status.count}"></td>
    <td th:text="${status.size}"></td>
    <td th:text="${status.odd}"></td>
    <td th:text="${status.even}"></td>
    <td th:text="${status.first}"></td>
    <td th:text="${status.last}"></td>
</tr>

遍历Map

1.准备数据

复制代码

1
2
3
4
5
6
7
8
Map<String,Users> map = new HashMap<>();
map.put("user1",new
Users("1","shangxuetang",23));
map.put("user2",new
Users("2","baizhan",22));
map.put("user3",new
Users("3","admin",25));
model.addAttribute("map",map);

2.遍历map

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<table border="1" width="50%">
    <tr>
        <th>ID</th>
        <th>Name</th>
        <th>Age</th>
        <th>Key</th>
    </tr>
    <!-- 遍历出的是一个键值对对象，key获取键，value获取值 -->
    <tr th:each="m : ${map}">
        <td th:text="${m.value.id}"></td>
        <td th:text="${m.value.name}"></td>
        <td th:text="${m.value.age}"></td>
        <td th:text="${m.key}"></td>
    </tr>
</table>

Thymeleaf_获取域中的数据

thymeleaf也可以获取request，session，application域中的数据，方法如下：

1.准备数据

复制代码

1
2
3
4
request.setAttribute("req","HttpServletRequest");
session.setAttribute("ses","HttpSession");
session.getServletContext().setAttribute("app","application");

2.获取域数据

复制代码

1
2
3
4
5
6
7
8
request1: <span th:text="${#request.getAttribute('req')}"/>
request2:<span th:text="${#httpServletRequest.getAttribute('req')}"/>
<hr/>
session1: <span th:text="${session.ses}"/>
session2: <span th:text="${#httpSession.getAttribute('ses')}"/>
<hr/>
application1: <span th:text="${application.app}"/>
application2:<span th:text="${#servletContext.getAttribute('app')}"/>

Thymeleaf_URL写法

在Thymeleaf中路径的写法为 @{路径}

复制代码

1
<a th:href="@{http://www.baidu.com}">百度</a>

在路径中添加参数

1. 准备数据

复制代码

1
2
model.addAttribute("id","100");
model.addAttribute("name","bzcxy");

2.准备跳转后访问的Controller

复制代码

1
2
3
4
5
6
@GetMapping("/show2")
@ResponseBody
public String show2(String id,String name)
{
    return id+":"+name;
}

3.在URL中添加参数

复制代码

1
2
3
4
5
<a th:href="@{show2?id=1&name=sxt}">静态参数一</a>
<a th:href="@{show2(id=2,name=bz)}">静态参数二</a>
<a th:href="@{'show2?id='+${id}+'&name='+${name}}">动态参数一</a>
<a th:href="@{show2(id=${id},name=${name})}">动态参数二</a>

在RESTful风格路径中添加参数

1.准备跳转后访问的Controller

复制代码

1
2
3
4
5
6
7
@GetMapping("/show3/{id}/{name}")
@ResponseBody
public String show3(@PathVariable String
id,@PathVariable String name){
    return id+":"+name;
}

2.在URL中添加参数

复制代码

1
<a th:href="@{/show3/{id}/{name} (id=${id},name=${name})}">restful格式传递参数方式</a>

Thymeleaf_相关配置

在Springboot配置文件中可以进行Thymeleaf相关配置

复制代码

1
2
3
4
5
6
7
8
spring:
 thymeleaf:
   prefix: classpath:/templates/
   suffix: .html
   encoding: UTF-8
   cache: false
   servlet:
     content-type: text/html

SpringBoot热部署

热部署，就是在应用正在运行的时候升级软件，却不需要重新启动应用。即修改完代码后不需要重启项目即可生效。在SpringBoot 中，可以使用DevTools工具实现热部署

1.添加DevTools依赖

复制代码

1
2
3
4
5
6
<!-- 热部署工具 -->
<dependency>  
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-bootdevtools</artifactId>
    <optional>true</optional>
</dependency>

2.在idea中设置自动编译

3.在Idea设置自动运行快捷键 Ctrl+Shift+Alt+/ 后点击 Registry ，勾选 complier.automake.allow.when.app.running

SpringBoot整合MyBatis

Spring整合MyBatis时需要进行大量配置，而SpringBoot整合 MyBatis则可以简化很多配置：

1.准备数据库数据

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
CREATE DATABASE `student`;
USE `student`;
DROP TABLE IF EXISTS `student`;
CREATE TABLE `student` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `sex` varchar(10) DEFAULT NULL,
  `address` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT
CHARSET=utf8;
insert  into
`student`(`id`,`name`,`sex`,`address`)
values (1,'程序员','男','北京'),(2,'北京','女','北京');

创建SpringBoot项目，添加MyBatis起步依赖和Mysql驱动依赖

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<dependency>  
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starterweb</artifactId>
</dependency>
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-bootstarter</artifactId>
    <version>2.2.1</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connectorjava</artifactId>
    <scope>runtime</scope>
</dependency>
<dependency> 
<groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-startertest</artifactId>
    <scope>test</scope>
</dependency>

3.编写实体类

复制代码

1
2
3
4
5
6
7
8
public class Student {
    private int id;
    private String name;
    private String sex;
    private String address;
    
    // 省略构造方法/getter/setter/tostring
}

4.编写Mapper接口

复制代码

1
2
3
4
@Mapper
public interface StudentMapper {
    List<Student> findAll();
}

5.编写Mapper映射文件

复制代码

1
2
3
4
5
6
7
8
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper  namespace="com.itbaizhan.springbootmybatis.mapper.StudentMapper">
    <select id="findAll" resultType="student">
       select * from student
    </select>
</mapper>

6.编写配置文件

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 数据源
spring:
 datasource:
   driver-class-name: com.mysql.cj.jdbc.Driver
   url: jdbc:mysql:///student?serverTimezone=UTC
   username: root
   password: root
   # mybatis配置
mybatis:
  # 映射文件位置
 mapper-locations: com/itbaizhan/springbootmybatis/mapper/*Mapper.xml
  # 别名
 type-aliases-package: com.itbaizhan.springbootmybatis.domain
  
#日志格式
logging:
 pattern:
 console: '%d{HH:mm:ss.SSS}
%clr(%-5level) --- [%-15thread]
%cyan(%-50logger{50}):%msg%n'

7. 编写测试类

复制代码

1
2
3
4
5
6
7
8
9
10
11
// 测试类注解，可以在运行测试代码时加载Spring容器
@SpringBootTest
public class StudentMapperTest {
    @Autowired
    private StudentMapper studentMapper;
    @Test
    public void testFindAll(){
        List<Student> all = studentMapper.findAll();
        all.forEach(System.out::println);
   }
}

SpringBoot参数校验_简单数据类型

SpringBoot自带了validation工具可以从后端对前端传来的参数进行校验，用法如下：

1.引入 validation 起步依赖

复制代码

1
2
3
4
5
<!-- 参数校验 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-startervalidation</artifactId>
</dependency>

2.编写Controller

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
// 该控制器开启参数校验
@Validated
@Controller
public class TestController {
    @RequestMapping("/t1")
    @ResponseBody
    // 在参数前加校验注解，该注解的意思是字符串参数不能为null
    public String t1(@NotBlank String username){
        System.out.println(username);
        return "请求成功！";
   }
}

3.访问http://localhost:8080/t1，发现当没有传来参数时，会抛出 ConstraintViolationException 异常。

4.在校验参数的注解中添加 message 属性，可以替换异常信息。

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
// 该控制器开启参数校验
@Validated
@Controller
public class TestController {
    @RequestMapping("/t1")
    @ResponseBody
    // 在参数前加校验注解，该注解的意思是字符串参数不能为null
    public String t1(@NotBlank(message = "用户名不能为空") String username){
        System.out.println(username);
        return "请求成功！";
   }
}

SpringBoot参数校验_异常处理

当抛出 ConstraintViolationException 异常后，我们可以使用SpringMVC的异常处理器，也可以使用SpringBoot自带的异常处理机制。当程序出现了异常，SpringBoot会使用自带的 BasicErrorController 对象处理异常。该处理器会默认跳转到/resources/templates/error.html 页面。

编写异常页面：

复制代码

1
2
3
4
5
6
7
8
9
10
11
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>错误页面</title>
</head>
<body>
   <h1>服务器开小差了！</h1>
</body>
</html>

SpringBoot参数校验_校验相关注解

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
@RequestMapping("/t2")
@ResponseBody
public String t2(
        @NotBlank @Length(min = 1, max = 5) String username,
        @NotNull @Min(0) @Max(150) Integer age,
        @NotEmpty @RequestParam List<String> address,
        @NotBlank @Email String email) {
    System.out.println(username);
    System.out.println(age);
    System.out.println(address);
    System.out.println(email);
    return "请求成功！";
}

SpringBoot参数校验_对象类型

SpringBoot也可以校验对象参数中的每个属性，

用法如下： 1 添加实体类

复制代码

1
2
3
4
5
6
7
public class Student {
    @NotNull(message = "id不能为空")
    private Integer id;
    @NotBlank(message = "姓名不能为空")
    private String name;
    // 省略getter/setter/tostring
}

2.编写控制器

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Controller
public class TestController2 {
    @RequestMapping("/t3")
    @ResponseBody
    // 校验的对象参数前添加@Validated，并将异常信息封装到BindingResult对象中
    public String t3(@Validated Student  student,BindingResult result) {
        // 判断是否有参数异常
        if (result.hasErrors()) {
            // 所有参数异常
            List<ObjectError> list =  result.getAllErrors();
             // 遍历参数异常，输出异常信息
            for (ObjectError err : list) {
                FieldError fieldError = (FieldError) err;
              
            System.out.println(fieldError.getDefaultMessage());
           }
            return "参数异常";
       }
        System.out.println(student);
        return "请求成功！";
   }
}

SpringBoot指标监控_添加Actuator功能

Spring Boot Actuator可以帮助程序员监控和管理SpringBoot应用，比如健康检查、内存使用情况统计、线程使用情况统计等。我们在SpringBoot项目中添加Actuator功能，即可使用Actuator监控项目，用法如下：

1.在被监控的项目中添加Actuator起步依赖

复制代码

1
2
3
4
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

2.编写配置文件

复制代码

1
2
#开启所有监控端点
management.endpoints.web.exposure.include= *

3.访问项目：http://localhost:8080/actuator

通过URL可以调用actuator的功能：

SpringBoot指标监控_Spring Boot Admin

Actuator使用JSON格式展示了大量指标数据，不利于我们查看，我们可以使用可视化工具Spring Boot Admin查看actuator生成指标数据。Spring Boot Admin是一个独立的项目，我们需要创建并运行该项目。

创建Spring Boot Admin服务端项目

1.创建SpringBoot项目，添加SpringMVC和Spring Boot Admin服务端起步依赖

复制代码

1
2
3
4
5
6
7
8
<dependency>  
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>de.codecentric</groupId>
    <artifactId>spring-boot-admin-starter-server</artifactId>
</dependency>

2.修改配置文件

复制代码

1
2
3
4
5
6
# 端口号
server.port=9090
#日志格式
logging.pattern.console=%d{HH:mm:ss.SSS}
%clr(%-5level) --- [%-15thread]
%cyan(%-50logger{50}):%msg%n

3.修改启动类

复制代码

1
2
3
4
5
6
7
8
9
10
@SpringBootApplication
@EnableAdminServer //开启Spring Boot Admin
服务端
public class MyadminApplication {
    public static void main(String[] args)
     {
      
      SpringApplication.run(MyadminApplication.class, args);
     }
}

连接Spring Boot Admin项目在被监控的项目中连接Spring Boot Admin项目，才能使用Spring Boot Admin查看指标数据。

1.被监控项目添加Spring Boot Admin客户端起步依赖

复制代码

1
2
3
4
5
6
<dependency>
    <groupId>de.codecentric</groupId>
    <artifactId>spring-boot-admin-starter-client</artifactId>
    <version>2.6.0</version>
</dependency>

2.修改配置文件

复制代码

1
2
3
#Spring boot admin访问地址
spring.boot.admin.client.url=http://localhost:9090

3.此时Spring Boot Admin即可连接被监控的项目

SpringBoot日志管理

SpringBoot默认使用Logback组件作为日志管理。Logback是log4j 创始人设计的一个开源日志组件。在SpringBoot项目中我们不需要额外的添加Logback的依赖，因为在 spring-boot-parent 中已经包含了 Logback的依赖。

1.在 /resources 下添加Logback配置文件logback.xml

复制代码

<?xml version="1.0" encoding="UTF-8" ?>
<configuration>
    
    <property name="LOG_HOME" value="${catalina.base}/logs/"></property>
    
    
    <appender name="Stdout"  class="ch.qos.logback.core.ConsoleAppender">
        
        <layout class="ch.qos.logback.classic.PatternLayout">
            
            <pattern>%d{MM-dd HH:mm:ss.SSS} [%thread] %-5level%logger{50} - %msg%n
            </pattern>
        </layout>
    </appender>
    
    
    <appender name="RollingFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBas edRollingPolicy">
            
<FileNamePattern>${LOG_HOME}/server.%d{yy 99-MM-dd}.log</FileNamePattern>
            <MaxHistory>30</MaxHistory>
        </rollingPolicy>
        <layout class="ch.qos.logback.classic.PatternLayout">
            
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n
            </pattern>
        </layout>
        
        <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
          
<MaxFileSize>10MB</MaxFileSize>
        </triggeringPolicy>
    </appender>
    
    <root level="info">
        <appender-ref ref="Stdout"></appender-ref>
        <appender-ref ref="RollingFile"></appender-ref>
    </root>
</configuration>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
<?xml version="1.0" encoding="UTF-8" ?>
<configuration>
    <!--定义日志文件的存储地址-->
    <property name="LOG_HOME" value="${catalina.base}/logs/"/>
    
    <!-- 控制台输出 -->
    <appender name="Stdout"  class="ch.qos.logback.core.ConsoleAppender">
        <!-- 日志输出编码 -->
        <layout class="ch.qos.logback.classic.PatternLayout">
            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
            <pattern>%d{MM-dd HH:mm:ss.SSS} [%thread] %-5level%logger{50} - %msg%n
            </pattern>
        </layout>
    </appender>
    
    <!-- 按照每天生成日志文件 -->
    <appender name="RollingFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBas edRollingPolicy">
            <!--日志文件输出的文件名-->
<FileNamePattern>${LOG_HOME}/server.%d{yy 99-MM-dd}.log</FileNamePattern>
            <MaxHistory>30</MaxHistory>
        </rollingPolicy>
        <layout class="ch.qos.logback.classic.PatternLayout">
            <!--格式化输出：%d表示时间，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n
            </pattern>
        </layout>
        <!--日志文件最大的大小-->
        <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
          
<MaxFileSize>10MB</MaxFileSize>
        </triggeringPolicy>
    </appender>
    <!-- 日志输出级别 -->
    <root level="info">
        <appender-ref ref="Stdout"/>
        <appender-ref ref="RollingFile"/>
    </root>
</configuration>

注：Logback配置文件名为logback-test.xml或 logback.xml，如果classpath下没有这两个文件，LogBack 会自动进行最小化配置。

2.在代码中打印日志

复制代码

1
2
3
4
5
6
7
8
9
10
@Controller
public class LogbackController {
    private final static Logger logger = LoggerFactory.getLogger(LogbackController.class);
    @RequestMapping("/printLog")
    @ResponseBody
    public String showInfo(){
        logger.info("记录日志");
        return "Hello Logback";
   }
}

3.如果日志过多，可以屏蔽一些包的日志，在配置文件中配置

复制代码

1
2
#屏蔽org包中的日志输出
logging.level.org=off

补充：Log4j2安全漏洞在2021年12月，Log4j2爆出了极其严重的安全漏洞，攻击者可以让记录的日志包含指定字符串，从而执行任意程序。很多大型网站，如百度等都是此次Log4j漏洞的受害者，很多互联网企业连夜做了应急措施。 Log4j2.0到2.14.1全部存在此漏洞，危害范围极其广泛， Log4j2.15.0-rc1中修复了这个 bug。

因Log4j2漏洞的反复无常，导致某些公司已经切换到Logback 来记录日志，但在Log4j2漏洞爆出后，Logback也爆出漏洞：在Logback1.2.7及之前的版本中，具有编辑配置文件权限的攻击者可以制作恶意配置，允许从LDAP服务器加载、执行任意代码。解决方案为将Logback升级到安全版本： Logback1.2.9+ SpringBoot2.6.2以上的Logback版本已经升到了1.2.9，Log4j2 的版本也升到了2.17.0，所以我们使用SpringBoot2.6.2以上版本无需担心Log4j2和Logback安全漏洞。

SpringBoot项目部署_项目打包

SpringBoot项目是依赖于Maven构建的，但打包时如果只依赖 Maven打包工具则会打包不完整，我们还需要在SpringBoot项目中引入SpringBoot打包插件：

复制代码

1
2
3
4
5
6
7
8
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-mavenplugin</artifactId>
        </plugin>
    </plugins>
</build>

此时再使用Maven插件打包：

打包后jar包解压目录如下：

可以看到该目录少了BOOT-INF，打包是不完整的，也无法运行jar 包

运行jar包：

1 进入jar包所在目录，使用cmd打开命令行窗口

2 输入命令：

复制代码

1
java -jar jar包名

SpringBoot项目部署_多环境配置

在真实开发中，在不同环境下运行项目往往会进行不同的配置，比如开发环境使用的是开发数据库，测试环境使用的是测试数据库，生产环境使用的是生产数据库。SpringBoot支持不同环境下使用不同的配置文件，用法如下：

配置文件名：

application-环境名.properties/yml

如：

1 application-dev.properties/yml 开发环境配置文件
复制代码# 开发环境端口号为8080 server: port: 8080
1
2
3
# 开发环境端口号为8080
server:
 port: 8080
2 application-test.properties/yml 测试环境配置文件
复制代码# 测试环境端口号为8081 server: port: 8081
1
2
3
# 测试环境端口号为8081
server:
 port: 8081
3 application-prod.properties/yml 生产环境配置文件
复制代码# 生产环境端口号为80 server: port: 80
1
2
3
# 生产环境端口号为80
server:
 port: 80

运行jar包时选择环境：

java -jar jar包名 --spring.profiles.active=环境名

SpringBoot容器化部署_安装Docker环境

为了节约资源，在生产环境中我们更多的是使用Docker容器部署 SpringBoot应用，首先我们准备Docker环境：

1 准备一台centos7系统的虚拟机，连接虚拟机。

2 关闭虚拟机防火墙
复制代码# 关闭运行的防火墙 systemctl stop firewalld.service # 禁止防火墙自启动 systemctl disable firewalld.service
1
2
3
4
# 关闭运行的防火墙
systemctl stop firewalld.service
# 禁止防火墙自启动
systemctl disable firewalld.service
3. 安装Docker
复制代码# 安装Docker yum -y install docker # 启动docker systemctl start docker
1
2
3
4
# 安装Docker
yum -y install docker
# 启动docker
systemctl start docker

SpringBoot容器化部署_Dockerfile制作镜像

由于在SpringBoot中嵌入了Web容器，所以在制作SpringBoot项目的镜像时无需依赖Web容器，基于JDK制作镜像即可，接下来我们使用Dockerfile制作镜像：

1.进入opt目录
复制代码cd /opt
1
cd /opt
2 使用rz命令将项目Jar包上传至虚拟机

3 编写DockerFile
复制代码cat <<EOF > Dockerfile # 基于JDK11 FROM openjdk:11 # 作者 MAINTAINER itbaizhan # 拷贝到容器opt目录 ADD springbootdemo7-0.0.1-SNAPSHOT.jar /opt #保留端口 EXPOSE 8080 # 启动容器后执行的命令 CMD java -jar /opt/springbootdemo7-0.0.1- SNAPSHOT.jar --spring.profiles.active=dev EOF
1
2
3
4
5
6
7
8
9
10
11
12
13
14
cat <<EOF > Dockerfile
# 基于JDK11
FROM openjdk:11
# 作者
MAINTAINER itbaizhan
# 拷贝到容器opt目录
ADD springbootdemo7-0.0.1-SNAPSHOT.jar
/opt
#保留端口
EXPOSE 8080
# 启动容器后执行的命令
CMD java -jar /opt/springbootdemo7-0.0.1-
SNAPSHOT.jar --spring.profiles.active=dev
EOF
4.构建镜像
复制代码 docker build -t springbootdocker .
1
2
 docker build -t springbootdocker .
5.查看所有的镜像，出现springbootdocker代表镜像构建成功
复制代码docker images
1
docker images
6.使用镜像启动容器
复制代码docker run -d -p 8080:8080 springbootdocker
1
2
docker run -d -p 8080:8080
springbootdocker
7.访问ip地址:8080/printLog查看是否启动成功

SpringBoot容器化部署_Maven插件制作镜像

除了DockerFile，我们还可以使用Maven插件制作镜像。使用方法如下：

1.开启远程docker服务
复制代码# 修改docker配置文件 vim /lib/systemd/system/docker.service # 在ExecStart=后添加配置，远程访问docker的端口为2375 ExecStart=/usr/bin/dockerd-current -H tcp://0.0.0.0:2375 -H unix://var/run/docker.sock --add-runtime dockerrunc=/usr/libexec/docker/docker-runccurrent --default-runtime=docker-runc --exec-opt native.cgroupdriver=systemd --userland-proxypath=/usr/libexec/docker/docker-proxycurrent --initpath=/usr/libexec/docker/docker-initcurrent --seccompprofile=/etc/docker/seccomp.json $OPTIONS $DOCKER_STORAGE_OPTIONS $DOCKER_NETWORK_OPTIONS $ADD_REGISTRY $BLOCK_REGISTRY $INSECURE_REGISTRY $REGISTRIES # 重启docker systemctl daemon-reload systemctl restart docker
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 修改docker配置文件
vim /lib/systemd/system/docker.service
# 在ExecStart=后添加配置，远程访问docker的端口
为2375
ExecStart=/usr/bin/dockerd-current -H
tcp://0.0.0.0:2375 -H
unix://var/run/docker.sock 
          --add-runtime dockerrunc=/usr/libexec/docker/docker-runccurrent 
          --default-runtime=docker-runc 
          --exec-opt
          native.cgroupdriver=systemd 
          --userland-proxypath=/usr/libexec/docker/docker-proxycurrent 
          --initpath=/usr/libexec/docker/docker-initcurrent 
          --seccompprofile=/etc/docker/seccomp.json 
          $OPTIONS 
          $DOCKER_STORAGE_OPTIONS 
          $DOCKER_NETWORK_OPTIONS 
          $ADD_REGISTRY 
          $BLOCK_REGISTRY 
          $INSECURE_REGISTRY 
          $REGISTRIES
# 重启docker
systemctl daemon-reload
systemctl restart docker
2.在项目的pom文件中添加 docker-maven-plugin 插件
复制代码 <plugin> <groupId>com.spotify</groupId> <artifactId>docker-mavenplugin</artifactId> <version>1.2.2</version> <configuration>  <dockerHost>http://192.168.25.101:2375</dockerHost>  <baseImage>openjdk:11</baseImage>  <maintainer>itbaizhan</maintainer> <resources> <resource>  <targetPath>/</targetPath>  <directory>${project.build.directory} </directory>  <include>${project.build.finalName}.jar</include> </resource> </resources> <workdir>/</workdir> <entryPoint>["java", "-jar","${project.build.finalName}.jar","--spring.profiles.active=dev"]</entryPoint> <forceTags>true</forceTags>  <imageName>${project.artifactId} </imageName>  <imageTags> <imageTag>${project.version} </imageTag> </imageTags> </configuration> </plugin>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

<plugin>
    <groupId>com.spotify</groupId>
    <artifactId>docker-mavenplugin</artifactId>
    <version>1.2.2</version>
    <configuration>
        
    <dockerHost>http://192.168.25.101:2375</dockerHost>
        
        <baseImage>openjdk:11</baseImage>
        
        <maintainer>itbaizhan</maintainer>
        <resources>
            <resource>
                
                <targetPath>/</targetPath>
                
              
                <directory>${project.build.directory}
                </directory>
                
              
                <include>${project.build.finalName}.jar</include>
            </resource>
        </resources>
        <workdir>/</workdir>
        <entryPoint>["java", "-jar","${project.build.finalName}.jar","--spring.profiles.active=dev"]</entryPoint>
        <forceTags>true</forceTags>
        
        <imageName>${project.artifactId}
        </imageName>
        
        <imageTags>
            <imageTag>${project.version}
        </imageTag>
        </imageTags>
    </configuration>
</plugin>
3.使用maven的package命令给项目打包

4.使用maven的docker插件制作镜像

5.查看所有的镜像，出现springbootdemo7代表镜像构建成功
复制代码docker images
1
2
docker images
6.使用镜像启动容器
复制代码docker run -d -p 8081:8080 springbootdemo7:0.0.1-SNAPSHOT
1
2
docker run -d -p 8081:8080
springbootdemo7:0.0.1-SNAPSHOT

Spring Task_定时任务

定时任务即系统在特定时间执行一段代码，它的场景应用非常广泛：

1 购买游戏的月卡会员后，系统每天给会员发放游戏资源。

2 管理系统定时生成报表。

3 定时清理系统垃圾。

4 ......

定时任务的实现主要有以下几种方式：

1. Java自带的java.util.Timer类，这个类允许调度一个java.util.TimerTask任务。使用这种方式可以让程序按照某一个频度执行，但不能在指定时间运行。一般用的较少。

2 Quartz。这是一个功能比较强大的的调度器，可以让程序在指定时间执行，也可以按照某一个频度执行，配置起来稍显复杂。

3 Spring3.0以后自带Spring Task，可以将它看成一个轻量级的Quartz，使用起来比 Quartz简单许多，在课程中我们使用Spring Task实现定时任务

Spring Task_入门案例

1.创建SpringBoot项目，在启动类开启定时任务。

复制代码

1
2
3
4
5
6
7
8
9
@SpringBootApplication
@EnableScheduling
public class Springbootdemo8Application {
    public static void main(String[] args)
   {
      
       SpringApplication.run(Springbootdemo8Application.class, args);
   }
}

2.编写定时任务类

复制代码

1
2
3
4
5
6
7
8
9
@Component
public class MyTask {
    // 定时任务方法，每秒执行一次
    @Scheduled(cron="* * * * * *")
    public void task1() {
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
        System.out.println(sdf.format(new Date()));
   }
}

3.启动项目，定时任务方法按照配置定时执行。

Spring Task_Cron表达式

Spring Task依靠Cron表达式配置定时规则。Cron表达式是一个字符串，分为6或7个域，每一个域代表一个含义，以空格隔开。有如下两种语法格式：

1.Seconds Minutes Hours DayofMonth Month DayofWeek Year

2 Seconds Minutes Hours DayofMonth Month DayofWeek

Spring Task_Cron实战案例

Spring Task_@Scheduled

@Scheduled写在方法上方，指定该方法定时执行。常用参数如下：

cron：cron表达式，定义方法执行的时间规则。

fixedDelay：任务立即执行，之后每隔多久执行一次，单位是毫秒，上一次任务结束后计算下次执行的时间。

复制代码

1
2
3
4
5
6
7
8
// 立即执行，任务结束后每5秒执行一次
@Scheduled(fixedDelay=5000)
public void task1() throws
InterruptedException {
    SimpleDateFormat sdf = new  SimpleDateFormat("HH:mm:ss");
    Thread.sleep(1000);
    System.out.println(sdf.format(new Date()));
}

fixedRate：任务立即执行，之后每隔多久执行一次，单位是毫秒，上一次任务开始后计算下次执行的时间。

复制代码

1
2
3
4
5
6
7
8
// 立即执行，之后每5秒执行一次
@Scheduled(fixedRate=5000)
public void task2() throws
InterruptedException {
    SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
    Thread.sleep(1000);
    System.out.println(sdf.format(new Date()));
}

initialDelay：项目启动后不马上执行定时器，根据initialDelay 的值延时执行。

复制代码

1
2
3
4
5
6
7
8
9
// 项目启动3秒后执行，之后每5秒执行一次。
@Scheduled(fixedRate=5000,initialDelay =
3000)
public void task3() throws
InterruptedException {
    SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
    Thread.sleep(1000);
    System.out.println(sdf.format(new Date()));
}

Spring Task_多线程任务

Spring Task定时器默认是单线程的，如果项目中使用多个定时器，使用一个线程会造成效率低下。代码如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
@Scheduled(cron="* * * * * *")
private void task1() throws
InterruptedException {
  
System.out.println(Thread.currentThread().getId()+"线程执行任务1");
    Thread.sleep(5000);
}
@Scheduled(cron="* * * * * *")
private void task2() {
  
System.out.println(Thread.currentThread().getId()+"线程执行任务2");
}

任务1较浪费时间，会阻塞任务2的运行。此时我们可以给Spring Task配置线程池。

最后

以上就是霸气乐曲最近收集整理的关于SpringBoot介绍SpringBoot目录 SpringBoot介绍_Spring缺点分析 SpringBoot介绍_什么是SpringBoot SpringBoot介绍_SpringBoot核心功能 SpringBoot入门_通过官网搭建项目 SpringBoot入门_通过IDEA脚手架搭建项目 SpringBoot入门_SpringBoot项目结构SpringBoot入门_通过Maven搭建项目 SpringBoot入门_编写Java代码 SpringBoot原理分析_起步依赖Spri的全部内容，更多相关SpringBoot介绍SpringBoot目录 SpringBoot介绍_Spring缺点分析 SpringBoot介绍_什么是SpringBoot SpringBoot介绍_SpringBoot核心功能 SpringBoot入门_通过官网搭建项目 SpringBoot入门_通过IDEA脚手架搭建项目 SpringBoot入门_SpringBoot项目结构SpringBoot入门_通过Maven搭建项目 SpringBoot入门_编写Java代码 SpringBoot原理分析_起步依赖Spri内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：Spring全家桶
浏览次数：78 次浏览
发布日期：2023-10-16 11:36:27
本文链接：https://www.kaopuke.com/article/k-p-k_13_u_23_o_26_f0_14__23_g0.html

SpringBoot介绍SpringBoot目录 SpringBoot介绍_Spring缺点分析 SpringBoot介绍_什么是SpringBoot SpringBoot介绍_SpringBoot核心功能 SpringBoot入门_通过官网搭建项目 SpringBoot入门_通过IDEA脚手架搭建项目 SpringBoot入门_SpringBoot项目结构SpringBoot入门_通过Maven搭建项目 SpringBoot入门_编写Java代码 SpringBoot原理分析_起步依赖Spri

SpringBoot目录

SpringBoot介绍_Spring缺点分析

SpringBoot介绍_什么是SpringBoot

SpringBoot介绍_SpringBoot核心功能

SpringBoot入门_通过官网搭建项目

SpringBoot入门_通过IDEA脚手架搭建项目

SpringBoot入门_SpringBoot项目结构

SpringBoot入门_通过Maven搭建项目

SpringBoot入门_编写Java代码

SpringBoot原理分析_起步依赖

查看spring-boot-starter-parent起步依赖

查看spring-boot-starter-web起步依赖

SpringBoot原理分析_自动配置

查看注解 @SpringBootApplication 的源码

查看注解 @EnableAutoConfifiguration 的源码

查看AutoConfifigurationImportSelector源码

我们 ServletWebServerFactoryAutoConfifiguration 为例来分析源码：

进入 ServerProperties 类源码如下：

SpringBoot原理分析_核心注解

YAML文件_配置文件介绍

YAML文件_自定义配置简单数据

YAML文件_自定义配置对象数据

YAML文件_自定义配置集合数据

YAML文件_读取配置文件的数据

使用@Value读取

使用@ConfigurationProperties读取

YAML文件_占位符的使用

YAML文件_配置文件存放位置及优先级

YAML文件_bootstrap配置文件

SpringBoot注册web组件_注册Servlet

SpringBoot注册web组件_注册Filter

SpringBoot注册web组件_注册Listener

SpringBoot访问静态资源_静态资源相关目录

static目录

目录结构

templates目录

SpringBoot访问静态资源_静态资源其他存放位置

SpringBoot整合JSP

Thymeleaf_Thymeleaf入门

Thymeleaf_变量输出

Thymeleaf_操作字符串

Thymeleaf_操作时间

Thymeleaf_条件判断

Thymeleaf_迭代遍历

遍历集合

使用状态变量

遍历Map

Thymeleaf_获取域中的数据

Thymeleaf_URL写法

在RESTful风格路径中添加参数

Thymeleaf_相关配置

SpringBoot热部署

SpringBoot整合MyBatis

SpringBoot参数校验_简单数据类型

SpringBoot参数校验_异常处理

SpringBoot参数校验_校验相关注解

SpringBoot参数校验_对象类型

SpringBoot指标监控_添加Actuator功能

SpringBoot指标监控_Spring Boot Admin

SpringBoot日志管理

SpringBoot项目部署_项目打包

SpringBoot项目部署_多环境配置

SpringBoot容器化部署_安装Docker环境

SpringBoot容器化部署_Dockerfile制作镜像

SpringBoot容器化部署_Maven插件制作镜像

Spring Task_定时任务

Spring Task_入门案例

Spring Task_Cron表达式

Spring Task_Cron实战案例

Spring Task_@Scheduled

Spring Task_多线程任务

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

微信扫一扫：分享

发表评论取消回复