SpringBoot详解 - 技术培训资料

烂番茄1024

已于 2023-07-18 13:31:49 修改

阅读量89

点赞数

于 2023-07-18 13:28:16 首次发布

本文链接：https://blog.csdn.net/wlgyvetoal/article/details/131784896

版权

Java 同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

SpringBoot

2 篇文章 0 订阅

订阅专栏

【金山文档】 SpringBoot详解 - 技术培训资料
https://kdocs.cn/l/cjxzIYSpQ48R

SpringBoot详解 - 技术培训资料

讲师：王良
日期： 2023-07-17

=========== 前言 ==============

示例代码仓库：

培训中所使用的示例代码仓库：https://gitee.com/wangliang181230/spring-boot-demo.git

SpringBoot版本：

此次培训，选取SpringBoot 2.7.13 版本，为大家讲解相关知识，不同版本间，会存在一些差异，请大家自己在实际开发过程中去发现。

========== 入门篇 ==============

第一章构建SpringBoot应用

1.1.使用maven构建一个SpringBoot Web应用

注：Maven 培训资料 https://kdocs.cn/l/cf7c074Q1Lvs

1.1.1.添加 `pom.xml` 文件：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.7.13</version>
      <relativePath/>
   </parent>

   <groupId>cn.wangliang181230.boot</groupId>
   <artifactId>web-application</artifactId>
   <version>1.0-SNAPSHOT</version>
   <packaging>jar</packaging><!-- 默认值为jar，可以省略 -->

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
   </dependencies>

   <build>
      <finalName>${project.artifactId}</finalName>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
</project>

1.1.2.添加 `XxxWebApplication.java` 类：

package cn.wangliang181230.boot.web;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class XxxWebApplication {

   public static void main(String[] args) throws Exception {
      SpringApplication.run(XxxWebApplication.class, args);
   }

}

1.1.3.添加 `application.yml` 配置文件：

spring:
  application:
    name: xxxxxx

server:
  port: 8080 # 端口号：未配置时，默认为：8080

# web应用类型配置：
## 该配置可选值：
###      NONE : 非web应用
###   SERVLET : 传统的web应用（默认值）
###  REACTIVE : 响应式编程的web应用
spring.main.web-application-type: servlet
## 低版本springboot中使用的配置项，高版本中已经废弃
##   可选值只有 true|false ，因为低版本还不支持 reactive，后来支持了，所以就废弃了此配置，改用上面那个配置。
#spring.main.web-environment: true

1.1.4.开发一个接口 `MyRestController`：

package cn.wangliang181230.boot.web.restcontroller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyRestController {

   @GetMapping("/test")
   public String test() {
      System.out.println("test: " + System.currentTimeMillis());
      return "test";
   }

}

1.2.使用maven构建一个SpringBoot 非Web应用

1.2.1.添加 `pom.xml` 文件：

与Web应用不同的是，spring-boot-starter-web替换为spring-boot-starter

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.7.13</version>
      <relativePath/>
   </parent>

   <groupId>cn.wangliang181230.boot</groupId>
   <artifactId>task-application</artifactId>
   <version>1.0-SNAPSHOT</version>
   <packaging>jar</packaging><!-- 默认值为jar，可以省略 -->

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
      </dependency>
   </dependencies>

   <build>
      <finalName>${project.artifactId}</finalName>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
</project>

1.2.2.添加 `XxxApplication.java` 类：

如果是定时任务来处理应用，则需要启用 @EnableScheduling ：

package cn.wangliang181230.boot.web;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@EnableScheduling
public class XxxApplication {

   public static void main(String[] args) throws Exception {
      SpringApplication.run(XxxApplication.class, args);
   }

}

1.2.3.添加 `application.yml` 配置文件：

非Web应用，不需要配置端口号 server.port

spring:
  application:
    name: xxx

# web应用类型配置：
## 该配置可选值：
##      NONE : 非web应用
##   SERVLET : 传统的web应用（默认值）
##  REACTIVE : 响应式编程的web应用
spring.main.web-application-type: none
## 低版本springboot中使用的配置项，高版本中已经废弃
##   可选值只有 true|false ，因为低版本还不支持 reactive，后来支持了，所以就废弃了此配置，改用上面那个配置。
#spring.main.web-environment: false

#定时任务相关配置
spring.task.scheduling:
  pool:
    size: 10 #定时任务线程池大小，默认只有1个线程，同一时间，只能执行一个定时任务

1.2.4.开发一个定时任务 `MyTask`：

package cn.wangliang181230.boot.unweb.task;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.text.SimpleDateFormat;
import java.util.Date;

@Component
public class MyTask {

   private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");


   /**
    * 每5秒执行一次
    * 每运行一次，消耗1个线程，直到一次运行结束，释放线程。
    */
   @Scheduled(cron = "0/5 * * * * ?")
   public void task1() throws InterruptedException {
      System.out.println(Thread.currentThread().getId() + "\t" + sdf.format(new Date()) + ": task1: start");
      Thread.sleep(10 * 1000);
      System.out.println(Thread.currentThread().getId() + "\t" + sdf.format(new Date()) + ": task1: end");
   }

   /**
    * 距上次运行结束，间隔5秒后再执行一次
    * 每运行一次，消耗1个线程，直到一次运行结束，释放线程。
    * 注意：会存在线程池耗尽的风险。
    */
   @Scheduled(fixedRate = 1000 * 5)
   public void task2() throws InterruptedException {
      System.out.println(Thread.currentThread().getId() + "\t" + sdf.format(new Date()) + ": task2: start");
      Thread.sleep(10 * 1000);
      System.out.println(Thread.currentThread().getId() + "\t" + sdf.format(new Date()) + ": task2: end");
   }

   /**
    * 距上次运行结束，间隔5秒后再执行一次
    * 同一时间，最多只会有一个任务正在运行，最多消耗1个线程
    */
   @Scheduled(fixedDelay = 1000 * 5)
   public void task3() throws InterruptedException {
      System.out.println(Thread.currentThread().getId() + "\t\t" + sdf.format(new Date()) + ": task3: start");
      Thread.sleep(10 * 1000);
      System.out.println(Thread.currentThread().getId() + "\t\t" + sdf.format(new Date()) + ": task3: end");
   }

}

第二章打包并运行

2.1.打包成jar包，并使用java命令直接运行：

1）在pom.xml中，配置 <packaging>jar</packaging> ；
2）添加插件配置：

<build>
   <finalName>${project.artifactId}</finalName>
   <plugins>
      <plugin>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
   </plugins>
</build>

3）再使用 mvn clean package 命令，进行打包jar；
4）在 target/ 目录下，找到 xxxxx.jar 文件；
5）使用 java -jar xxxxx.jar 命令，直接运行jar包，即可启动springboot应用。

2.2.打包成war包，放到web容器（如：tomcat）中运行：

1）前提条件：必须是一个Web应用；
2）在pom.xml中，配置 <packaging>war</packaging> ；
3）将 tomcat 相关依赖的scope设置为provided：

<dependencies>
   <dependency>
      <groupId>org.apache.tomcat.embed</groupId>
      <artifactId>tomcat-embed-jasper</artifactId>
      <scope>provided</scope>
   </dependency>
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-tomcat</artifactId>
      <scope>provided</scope>
   </dependency>
</dependencies>

4）关于 /META-INF/web.xml 的说明：
a.可以在 resources/ 资源目录下，添加 WEB-INF/web.xml；（自行学习web.xml相关知识）
b.也可以忽略该配置文件：

<build>
   <plugins>
      <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-war-plugin</artifactId>
         <configuration>
            <!-- 没有 `WEB-INF/web.xml` 配置文件时，也不报错。 -->
            <failOnMissingWebXml>false</failOnMissingWebXml>
         </configuration>
      </plugin>
   </plugins>
</build>

5）修改 XxxWebApplication 类，继承
org.springframework.boot.web.servlet.support.SpringBootServletInitializer 类，并重写 configure 方法：

package cn.wangliang181230.boot.web;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

@SpringBootApplication
public class XxxWebApplication
      extends SpringBootServletInitializer // for war
{
   // for jar
   public static void main(String[] args) throws Exception {
      SpringApplication.run(XxxWebApplication.class, args);
   }


   // for war
   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
      return builder.sources(XxxWebApplication.class);
   }

}

6）再使用 mvn clean package 命令，进行打包war；
7）安装 tomcat，并配置其环境变量；（自行学习tomcat相关知识）
8）将打包好的war包，复制到tomcat的 webapps/ 目录下；
9）启动tomcat bin/startup.bat ，它会自动解压缩war包，并运行；
10）测试：http://localhost:8080/web-application/test，正常响应内容，说明部署成功。
11）可以进入tomcat的管理界面：http://localhost:8080/manager
2.3.打包成native-image，直接运行：

注：参考我的个人博客：https://wangliang1024.cn/blog/#/native-image/

第三章内置Web容器

3.1.其他Web容器

SpringBoot的Web应用，内置了Web容器。默认情况下，使用的是Tomcat。
同时，还支持以下几种Web容器：

3.1.1.Jetty

Jetty 是一个高性能、轻量级的 Java Web 容器，它提供了高度可配置的插件系统，使得开发者可以轻松地扩展和定制应用程序。
使用方法：排除tomcat依赖，引用jetty依赖：

<dependencies>
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
      <exclusions>
         <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
         </exclusion>
      </exclusions>
   </dependency>
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-jetty</artifactId>
   </dependency>
</dependencies>

3.1.2.Undertow

Undertow 是一个高性能、可扩展的 Java Web 容器，它使用少量的内存和 CPU 资源，提供了出色的性能和可扩展性。
使用方法：排除tomcat依赖，引用undertow依赖：

<dependencies>
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
      <exclusions>
         <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
         </exclusion>
      </exclusions>
   </dependency>
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-undertow</artifactId>
   </dependency>
</dependencies>

3.2.各Web容器的配置：

注：此次培训暂不讲解，网上资料很多，可以自行学习。

3.2.1.Tomcat

3.2.2.Jetty

3.2.3.Undertow

========== 进阶篇 ==============

第四章 SpringBoot应用的生命周期、事件及应用

4.1.SpringBoot应用的生命周期各阶段详解

SpringBoot应用的生命周期，分为以下几个阶段：
注：相关代码见 SpringApplication.run(String... args) 方法。

4.1.1.初始化阶段：

1）创建SpringApplication实例，并初始化；
2）加载Spring应用运行监听器：
从所有 META-INF/spring.factories 配置文件中，读取所有 org.springframework.boot.SpringApplicationRunListener；
目前，SpringBoot 只提供了一个 org.springframework.boot.context.event.EventPublishingRunListener，用于发布生命周期中的各事件，供扩展使用；
3）创建 SpringApplicationRunListeners 实例：
该实例，用于管理所有 SpringApplicationRunListener；
4）加载事件监听器：
从所有 META-INF/spring.factories 配置文件中，读取所有 org.springframework.context.ApplicationListener，用于监听 EventPublishingRunListener 发布的事件；
5）发布事件：1.应用开始-ApplicationStartingEvent 。

4.1.2.环境准备阶段（重要）：

1）创建 ConfigurableEnvironment 实例，并初始化；
2）发布事件：2.环境已准备-ApplicationEnvironmentPreparedEvent；
3）将名为 defaultProperties 的配置源，移到末尾，使其优先级最低。

4.1.3.休闲阶段：打印 SpringBoot的Banner图：

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::               (v2.7.13)

可以使用以下配置控制Banner的显示：

#高版本使用，可选值：console（默认）、log、off
spring.main.banner-mode: console
#低版本使用，可选值：true（默认）、false
spring.main.show-banner: true

spring.banner:
  location: classpath:my-spring-boot-banner.txt # 自定义banner内容
  charset: UTF-8 # 自定义内容字符集

4.1.4.上下文准备阶段：

1）根据应用类型，创建上下文实例，并初始化：ConfigurableApplicationContext
2）发布事件：3.上下文已初始化-ApplicationContextInitializedEvent
3）发布事件：4.应用已准备-ApplicationPreparedEvent

4.1.5.启动阶段（重要）：

1）读取配置文件中配置的自动装配类：

SpringBoot-2.x版本：
从所有 META-INF/spring.factories 配置文件中，读取所有 org.springframework.boot.autoconfigure.EnableAutoConfiguration所配置的所有自动装配类；

SpringBoot-3.x版本：
从所有 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 配置文件中，读取所有的自动装配类。

注意：2.7.x版本为过度版本，两种都支持。

2）扫描启动类所在包下的所有Bean；

3）分析需要加载的Bean、加载顺序、依赖关系；

4）优先加载特殊Bean：

a.Bean工厂处理器：
b.BeanPostProcessor（Bean处理器）：前置、后置处理器；

5）加载所有需要的Bean：

a.实例化
b.前置处理器
c.初始化
d.依赖注入
e.后置处理器
f.执行 @PostConstruct 标注的方法
g.其他待补充…

6）启动Web容器：

如果是Web应用，则会启动内置的Web容器，
并发布事件：Web容器已初始化事件-ServletWebServerInitializedEvent。

7）发布事件：5.上下文已刷新-`ContextRefreshedEvent`

8）发布事件：6.应用已启动-`ApplicationStartedEvent`

4.1.6.运行阶段：

1）运行所有Runner:

运行所有实现了ApplicationRunner 或 CommandLineRunner 接口的Bean的 run() 方法，执行顺序通过order值及类名排序。

2）发布事件：7.应用已准备就绪-`ApplicationReadyEvent`

应用已准备好可以接收请求时，会发布此事件。

4.1.7.结束阶段：

1）优雅关机：有超时时间；

2）销毁所有Bean：

执行所有实现了 DisposableBean 接口的 bean 的 destroy() 方法；

3）关闭上下文：`ConfigurableApplicationContext`

4）发布事件：8.上下文已关闭-`ContextClosedEvent`

4.1.8.异常处理阶段：

1）发布事件：9.应用启动失败-ApplicationFailedEvent

4.2.SpringBoot应用的事件详解

SpringBoot自身，也添加了一些ApplicationListener，下面事件中，主要针对其中的两个（LoggingApplicationListener、EnvironmentPostProcessorApplicationListener）进行讲解：

4.2.1.应用开始-`ApplicationStartingEvent`

1）LoggingApplicationListener：(1)
创建 LoggingSystem 实例，并初始化。

4.2.2.环境已准备-`ApplicationEnvironmentPreparedEvent`

1）EnvironmentPostProcessorApplicationListener:
从所有 META-INF/spring.factories 配置文件中，读取所有 org.springframework.boot.env.EnvironmentPostProcessor，并执行，将环境信息全部加载完。
2）LoggingApplicationListener：(2)
根据配置重载LoggingSystem

4.2.3.上下文已初始化-`ApplicationContextInitializedEvent`

1）暂无

4.2.4.应用已准备-`ApplicationPreparedEvent`

1）LoggingApplicationListener：(3)
将LoggingSystem、LoggerGroups、Lifecycle注册到Spring容器中。

4.2.5.上下文已刷新-`ContextRefreshedEvent`

1）暂无

4.2.6.应用已启动-`ApplicationStartedEvent`

1）暂无

4.2.7.应用已准备-`ApplicationReadyEvent`

1）暂无

4.2.8.上下文已关闭-`ContextClosedEvent`

1）LoggingApplicationListener：(4)
清理LoggingSystem。

4.2.9.应用启动失败-`ApplicationFailedEvent`

1）LoggingApplicationListener：(5)
清理LoggingSystem。

4.3.SpringBoot应用的各阶段各事件的一些应用场景

4.3.1.环境准备阶段的一些应用：

1）从配置中心读取配置：示例代码中编写一个简易的配置中心功能，用于演示配置中心的基本原理。
2）公司统一修改三方组件配置默认值；
3）添加一些用于简化其他配置的自定义配置；
4）其他待补充…

4.3.2.辅助分析应用启动耗时:

当SpringBoot应用启动非常耗时时，我们可以通过应用监听器（ApplicationListener）将每个事件的时间记录下来，通过计算各事件之间的时差，还找出耗时的点。

4.3.3.其他待补充…

第五章 SpringBoot部分常用功能的原理与应用

5.1.环境与配置（Environment、Properties）

5.1.1.可配置的环境：`ConfigurableEnvironment`

用于管理应用的所有配置源，通过环境后置处理器，进行配置源添加。

5.1.2.配置源：`PropertySource<?>`

由ConfigurableEnvironment统一管理，并根据配置源的优先级，获取配置值。

5.1.3.环境后置处理器：`EnvironmentPostProcessor`

5.1.3.1.SpringBoot提供的环境后置处理器：

1）RandomValuePropertySourceEnvironmentPostProcessor：
添加随机值函数式数据源到环境中。
2）SystemEnvironmentPropertySourceEnvironmentPostProcessor：
读取System.getProperties()，优先级比yaml配置文件高。
3）ConfigDataEnvironmentPostProcessor：
读取yaml配置文件。
4）其他还有很多，这里就不一一讲解，大家有兴趣，可以自己去学习。

5.1.4.函数式配置源：

5.1.4.1.SpringBoot提供的函数式配置源

1）RandomValuePropertySource：
支持int、long、uuid随机生成。
配置方式如：
${random.int}：随机生成一个整数，可以是负整数、0、正整数。
${random.int(5)}：随机生成一个大于等于0，小于5的整数。
${random.int[5,10]}：随机生成一个大于等于5，小于10的整数。
${random.long}：随机生成一个整数，可以是负整数、0、正整数。
${random.long(5)}：随机生成一个大于等于0，小于5的整数。
${random.long[5,10]}：随机生成一个大于等于5，小于10的整数。
${random.uuid}: 随机生成36位UUID

5.1.4.2.自定义开发函数式配置源：

具体代码，见示例代码：MyFunctionPropertySource

5.1.5.配置源加载器：`PropertySourceLoader`

用来扩展配置文件类型。

5.1.6.配置：`XxxProperties`

5.1.6.1.`@ConfigurationProperties`：

标记一个类为Properties类，并配置该配置类的配置前缀。

5.1.6.2.`@EnableConfigurationProperties`：

将一个标记了 @ConfigurationProperties 注解的类，注册为SpringBean。

5.1.6.3.各类型配置值的配置方式：

1）基本类型：
其中boolean类型的配置，可选配置值为：true或on、false或off。
其他类型都比较简单，就不仔细讲解。
2）数组或列表类型：
用逗号分隔，或通过每行一个横杆的方式。
3）Map类型：

注：具体配置方式见示例代码。

5.1.7.配置格式：

在SpringBoot中，配置的键的格式类似 xxx.yyy.zzz.aaaa-bbbb 这样的用逗号分隔开来的字符串来表示，达到分组的目的。
需要注意的是，在高版本SpringBoot中，@ConfiguratioinProperties注解中，不允许使用驼峰格式，只允许使用横杆格式。

5.1.8.配置文件：

在springboot中，默认会加载几个目录下的配置文件：
1）classpath:/application.(yml|yaml|properties)
2）classpath:/application- ${activeProfile}.(yml|yaml|properties) 3）classpath:/config/application.(yml|yaml|properties) 4）classpath:/config/application-$ {activeProfile}.(yml|yaml|properties)

5.1.9.配置提示功能：

配置提示功能，是springboot插件的功能，该插件会读取所有/META-INF/spring-configuration-metadata.json 文件，用于配置提示功能。

自动生成spring-configuration-metadata.json的依赖：

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-configuration-processor</artifactId>
   <optional>true</optional>
</dependency>

该依赖通过注解处理器实现，在代码编译阶段，读取所有 @ConfigurationProperties注解及其标注的配置类，生成metadata文件，最后，再读取 additional-spring-configuration-metadata.json 文件，将其增量内容合并进去，就完成了。

5.2.自动装配（AutoConfiguration）

5.2.1.自动装配原理：

自动装配分为两部分组成：

5.2.1.1.自动装配类：

SpringBoot-2.x版本：
从所有 META-INF/spring.factories 配置文件中，读取所有 org.springframework.boot.autoconfigure.EnableAutoConfiguration所配置的所有自动装配类；

SpringBoot-3.x版本：
从所有 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 配置文件中，读取所有的自动装配类。

注意：2.7.x版本为过度版本，两种都支持。

5.2.1.2.启动类所在包下的所有Bean：

启动类所在包下的所有Bean，也会自动加载，与自动装配类是所配置的Bean一起，在应用启动阶段被加载。

5.2.2.条件装配详解：`@Conditional`注解与 `Condition` 接口：

SpringBoot的条件装配，都是通过 @Conditional(XxxCondition.class)注解，来标注各个自动装配类及各个Bean，指定一个或多个Condition接口的实现类。
在应用启动阶段，分析Bean时，通过运行指定的Condition接口实现类的matches方法，来判断Bean是否需要加载该Bean。

5.2.3.SpringBoot提供的 `@ConditionalOnXxx` 注解：

5.2.3.1.`@ConditionalOnClass`：类存在条件

5.2.3.2.`@ConditionalOnMissingClass`：类不存在条件

5.2.3.3.`@ConditionalOnBean`：Bean存在条件

5.2.3.4.`@ConditionalOnMissingBean`：Bean不存在条件

5.2.3.5.`@ConditionalOnProperty`：配置条件

5.2.3.6.`@ConditionalOnExpression`：表达式

5.2.3.7.`@ConditionalOnSingleCandidate`：单例条件

5.2.3.8.`@ConditionalOnWebApplication`：Web应用条件

5.2.3.9.`@ConditionalOnNotWebApplication`：非Web应用条件

5.2.3.10.`@ConditionalOnWarDeployment`：war运行条件

5.2.3.11.`@ConditionalOnNotWarDeployment`：非war运行条件

5.2.3.12.`@ConditionalOnResource`：资源文件条件

5.2.3.13.`@ConditionalOnCloudPlatform`：平台条件

5.2.3.14.`@ConditionalOnJava`：Java版本条件

5.2.3.15.`@ConditionalOnJndi`：JNDI资源条件

5.2.4.自定义开发 `@ConditionalOnXxx` 和 `Condition`接口实现类

大家自己尝试去开发看看，这里就不详细介绍了。

5.3.SpringBoot中的对相同功能的Bean的执行顺序控制

@Order 注解、@AutoConfigureOrder 注解、Ordered接口、PriorityOrdered接口：

第六章 SpringBoot依赖讲解

6.1.依赖和插件清单（BOM）：`spring-boot-dependencies`

内容待补充，先现场培训讲解…

6.2.父项目：`spring-boot-starter-parent`

内容待补充，先现场培训讲解…

6.3.各组件起步依赖：`spring-boot-starter-xxx`

内容待补充，先现场培训讲解…

第七章 Spring6和SpringBoot3新特性说明

7.1.最低要求Java17

7.2.内置Tomcat版本升级：10.x，基于Jakarta EE标准。

7.3.Javax 替换为 Jakarta

7.4.全面支持GraalVM的`Native Image`

7.5.其他更新内容见官方资料

第八章其他还有很多内容未讲到，以后再补充…

以上内容是SpringBoot项目中最为常用的

烂番茄1024

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
SpringBoot详解 - 技术培训资料

SpringBoot详解：生命周期、事件、各种监听器、可配置环境、配置源、环境后置处理器、自动装配、条件装配等等的原理讲解。
复制链接

扫一扫

专栏目录

SpringBoot详解 - 技术培训资料

SpringBoot详解 - 技术培训资料

=========== 前言 ==============

示例代码仓库：

SpringBoot版本：

========== 入门篇 ==============

第一章 构建SpringBoot应用

1.1.使用maven构建一个SpringBoot Web应用

1.1.1.添加 pom.xml 文件：

1.1.2.添加 XxxWebApplication.java 类：

1.1.3.添加 application.yml 配置文件：

1.1.4.开发一个接口 MyRestController：

1.2.使用maven构建一个SpringBoot 非Web应用

1.2.1.添加 pom.xml 文件：

1.2.2.添加 XxxApplication.java 类：

1.2.3.添加 application.yml 配置文件：

1.2.4.开发一个定时任务 MyTask：

第二章 打包并运行

2.1.打包成jar包，并使用java命令直接运行：

2.2.打包成war包，放到web容器（如：tomcat）中运行：

第三章 内置Web容器

3.1.其他Web容器

3.1.1.Jetty

3.1.2.Undertow

3.2.各Web容器的配置：

3.2.1.Tomcat

3.2.2.Jetty

3.2.3.Undertow

========== 进阶篇 ==============

第四章 SpringBoot应用的生命周期、事件及应用

4.1.SpringBoot应用的生命周期各阶段详解

4.1.1.初始化阶段：

4.1.2.环境准备阶段（重要）：

4.1.3.休闲阶段：打印 SpringBoot的Banner图：

4.1.4.上下文准备阶段：

4.1.5.启动阶段（重要）：

1）读取配置文件中配置的自动装配类：

2）扫描启动类所在包下的所有Bean；

3）分析需要加载的Bean、加载顺序、依赖关系；

4）优先加载特殊Bean：

5）加载所有需要的Bean：

6）启动Web容器：

7）发布事件：5.上下文已刷新-ContextRefreshedEvent

8）发布事件：6.应用已启动-ApplicationStartedEvent

4.1.6.运行阶段：

1）运行所有Runner:

2）发布事件：7.应用已准备就绪-ApplicationReadyEvent

4.1.7.结束阶段：

1）优雅关机：有超时时间；

2）销毁所有Bean：

3）关闭上下文：ConfigurableApplicationContext

4）发布事件：8.上下文已关闭-ContextClosedEvent

4.1.8.异常处理阶段：

4.2.SpringBoot应用的事件详解

4.2.1.应用开始-ApplicationStartingEvent

4.2.2.环境已准备-ApplicationEnvironmentPreparedEvent

4.2.3.上下文已初始化-ApplicationContextInitializedEvent

4.2.4.应用已准备-ApplicationPreparedEvent

4.2.5.上下文已刷新-ContextRefreshedEvent

4.2.6.应用已启动-ApplicationStartedEvent

4.2.7.应用已准备-ApplicationReadyEvent

4.2.8.上下文已关闭-ContextClosedEvent

4.2.9.应用启动失败-ApplicationFailedEvent

4.3.SpringBoot应用的各阶段各事件的一些应用场景

4.3.1.环境准备阶段的一些应用：

4.3.2.辅助分析应用启动耗时:

4.3.3.其他待补充…

第五章 SpringBoot部分常用功能的原理与应用

5.1.环境与配置（Environment、Properties）

5.1.1.可配置的环境：ConfigurableEnvironment

5.1.2.配置源：PropertySource<?>

5.1.3.环境后置处理器：EnvironmentPostProcessor

5.1.3.1.SpringBoot提供的环境后置处理器：

5.1.4.函数式配置源：

5.1.4.1.SpringBoot提供的函数式配置源

5.1.4.2.自定义开发函数式配置源：

5.1.5.配置源加载器：PropertySourceLoader

5.1.6.配置：XxxProperties

5.1.6.1.@ConfigurationProperties：

5.1.6.2.@EnableConfigurationProperties：

第一章构建SpringBoot应用

1.1.1.添加 `pom.xml` 文件：

1.1.2.添加 `XxxWebApplication.java` 类：

1.1.3.添加 `application.yml` 配置文件：

1.1.4.开发一个接口 `MyRestController`：

1.2.1.添加 `pom.xml` 文件：

1.2.2.添加 `XxxApplication.java` 类：

1.2.3.添加 `application.yml` 配置文件：

1.2.4.开发一个定时任务 `MyTask`：

第二章打包并运行

第三章内置Web容器

7）发布事件：5.上下文已刷新-`ContextRefreshedEvent`

8）发布事件：6.应用已启动-`ApplicationStartedEvent`

2）发布事件：7.应用已准备就绪-`ApplicationReadyEvent`

3）关闭上下文：`ConfigurableApplicationContext`

4）发布事件：8.上下文已关闭-`ContextClosedEvent`

4.2.1.应用开始-`ApplicationStartingEvent`

4.2.2.环境已准备-`ApplicationEnvironmentPreparedEvent`

4.2.3.上下文已初始化-`ApplicationContextInitializedEvent`

4.2.4.应用已准备-`ApplicationPreparedEvent`

4.2.5.上下文已刷新-`ContextRefreshedEvent`

4.2.6.应用已启动-`ApplicationStartedEvent`

4.2.7.应用已准备-`ApplicationReadyEvent`

4.2.8.上下文已关闭-`ContextClosedEvent`

4.2.9.应用启动失败-`ApplicationFailedEvent`

5.1.1.可配置的环境：`ConfigurableEnvironment`

5.1.2.配置源：`PropertySource<?>`

5.1.3.环境后置处理器：`EnvironmentPostProcessor`

5.1.5.配置源加载器：`PropertySourceLoader`

5.1.6.配置：`XxxProperties`

5.1.6.1.`@ConfigurationProperties`：

5.1.6.2.`@EnableConfigurationProperties`：

5.2.2.条件装配详解：`@Conditional`注解与 `Condition` 接口：

5.2.3.SpringBoot提供的 `@ConditionalOnXxx` 注解：

5.2.3.1.`@ConditionalOnClass`：类存在条件

5.2.3.2.`@ConditionalOnMissingClass`：类不存在条件

5.2.3.3.`@ConditionalOnBean`：Bean存在条件

5.2.3.4.`@ConditionalOnMissingBean`：Bean不存在条件

5.2.3.5.`@ConditionalOnProperty`：配置条件

5.2.3.6.`@ConditionalOnExpression`：表达式

5.2.3.7.`@ConditionalOnSingleCandidate`：单例条件

5.2.3.8.`@ConditionalOnWebApplication`：Web应用条件

5.2.3.9.`@ConditionalOnNotWebApplication`：非Web应用条件

5.2.3.10.`@ConditionalOnWarDeployment`：war运行条件

5.2.3.11.`@ConditionalOnNotWarDeployment`：非war运行条件

5.2.3.12.`@ConditionalOnResource`：资源文件条件

5.2.3.13.`@ConditionalOnCloudPlatform`：平台条件

5.2.3.14.`@ConditionalOnJava`：Java版本条件

5.2.3.15.`@ConditionalOnJndi`：JNDI资源条件

5.2.4.自定义开发 `@ConditionalOnXxx` 和 `Condition`接口实现类

6.1.依赖和插件清单（BOM）：`spring-boot-dependencies`

6.2.父项目：`spring-boot-starter-parent`

6.3.各组件起步依赖：`spring-boot-starter-xxx`

7.4.全面支持GraalVM的`Native Image`

第八章其他还有很多内容未讲到，以后再补充…