SpringBoot详解教程

「爱情、让人受尽委屈。」 2024-04-28 13:24 40阅读 0赞

> 本文是鄙人早期学习的记录，存在部分不足的问题，可以私信或留言讨论，文档将一步步翻修

## SpringBoot学习笔记 ##

> 文章写得比较详细，所以很长（105336 字数），可以参考目录

### 文章目录  SpringBoot学习笔记  @\[toc\]  一、 Spring Boot 入门  预：必须掌握的技术：  1. Spring Boot 简介  学前bb  解决的问题  优点  缺点  2.微服务  What are Microservices?  单体应用  微服务  3.环境准备  Maven设置：  Idea设置  4.Spring Boot HelloWorld  4.1创建一个maven项目  4.2 创建项目结构以及启动类  5.Hello World 的探究  1)pom文件  a.父项目  b.导入的依赖  2)主程序类，主入口类  6.使用Spring Initializer快速创建Spring Boot 项目  SpringBoot学习第一步：搭建基础  流程如下  默认生成的Spring Boot 项目：  二、Spring Boot 配置  1. 配置文件  2. YAML语法  1）基本语法  2）值的写法  字面量：普通的值（数字，字符串，布尔）  对象、Map(属性和值)（键值对）  数组（List、Set)：  附：Spring Boot单元测试  3. 通过配置文件注入  1) 数据绑定到基础数据类型  2) 将数据绑定到类中 含配置文件与类绑定的方法  3) @Value 获取值和 @ConfigurationProperties获取值的比较  4) 配置文件注入值数据校验  5） @PropertySource & @ImportResource  4）Spring配置文件注入  a. @\*\*ImportResource\*\*: 导入Spring配置文件,让配置文件里面的内容生效；  b. Spring Boot 推荐给容器添加组件的方式  4.配置文件占位符  RandomValuePropertySource: 配置文件中可以使用随机数  属性配置占位符  5.Profile  1）多Profile文件  2）yml支持多文档块方式  3）激活指定Profile  6.配置文件的加载位置  7.Spring Boot 外部配置加载顺序  8.Spring Boot 自动配置原理  配置文件能写些什么？怎么写？自动配置的原理？  自动配置原理：  精髓  3.自动配置原理（细节）  1）@Conditional派生注解（Spring注解版原生的@Conditional作用）  三、Spring Boot 与日志  1、日志框架  2、SLF4j使用  1）如何在系统中使用SLF4j  2）遗留问题  3）SpringBoot日志关系  3.日志使用  1）默认配置  2）指定配置  3）切换日志框架  四、SpringBoot与Web开发  1、使用SpringBoot  2、SpringBoot对静态页面的映射规则  访问静态资源  第一种 导入的webjars  第二种"/\*\*"访问当前项目的任何资源  欢迎页配置  图标  3、模板引擎  引入thymeleaf  Thymeleaf使用&语法  语法规则  1)、th:text 改变当前元素里面的内容  2）表达式  Variable Expressions: $\{...\} 获取变量值，OGNL;  Message Expressions: \#\{...\} 获取国际化内容  Link URL Expressions: @\{...\} 定义URL链接  Fragment Expressions: ~\{...\} 插入文档  Literals（字面量）  Text operations: （文本操作）  Arithmetic operations: (数学运算)  Boolean operations: (布尔运算)  Comparisons and equality:(比较运算)  Conditional operators:(条件运算)（三元运算符也支持）  Special tokens:(特殊)  4、SpringMVC自动配置  7.1.1. Spring MVC Auto-configuration  扩展SpringMVC  全面接管SpringMVC  5、如何修改SpringBoot的默认配置  6、RestfulCRUD  1）、设置默认访问首页  2）、国际化  SprigMVC的情况  SpringBoot模式  原理  3）、登录  若登录失败，需要提升失败信息  使用MVC视图解析跳转会出现刷新重新提交表单的情况，为防止这种情况发生，我们可以使用重定向  4）、拦截器进行登录检查  为了防止他人随机访问后台管理页面，可以利用拦截器机制，做登录检查  5）、CRUD-员工列表  7、错误处理机制  1）、SpringBoot默认的错误处理机制  五、配置嵌入式Servlet容器  嵌入式Servlet容器配置  注册Servlet容器三大组件  使用其他Servlet容器  嵌入式Servlet容器自动配置原理  Spring Boot 如何自动配置servlet容器  我们对嵌入式容器配置的修改如何生效  嵌入式Servlet容器启动原理  使用外置的Servlet容器  外置的Servlet容器：外面安装Tomcat——应用war包的方式打包  六、数据访问  1、jdbc配置  配置properties  效果：  自动配置原理：  2.使用druid  Druid的简介  同时Druid不仅仅是一个数据库连接池，它包括四个部分：  Druid的功能  所以Druid可以：  配置Druid  引入stater  在配置文件进行配置  3、整合Jpa  4、整合MyBatis  MyBatis原理  一、Mybatis工作原理图  二、工作原理解析  mybatis层次图：!\[在这里插入图片描述\](https://img-blog.csdnimg.cn/20200228231938758.png?x-oss-process=image/watermark,type\_ZmFuZ3poZW5naGVpdGk,shadow\_10,text\_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw==,size\_16,color\_FFFFFF,t\_70)  配置  引入依赖  在启动类上注解——增加MapperScan注解路径执行mapper接口路径  配置文件进行配置  注解模式进行开发  七、创建SpringBootApplication  八、缓存  1、统一的缓存开发规范：J2EE——JSR107  2、配置  2、Spring缓存抽象  重要概念&缓存注解  配置环境  @Cacheable属性配置  cacheNames/value  key  SpEL表达式  keyGenerator  cacheManager  condition  unless  sync  @CachePut  @CacheEvict  key、keyGenerator与以上两个相同  condition  allEntries  beforeInvocation  @Caching  @CacheConfig  原理  运行流程  3、整合redis缓存  整合  Redis使用自制序列化器  九、Spring Boot 与消息  1、消息队列是什么以及why消息队列  1、异步：  why异步，而不是线程池？  2、解耦：  用了\*\*消息队列\*\*，耦合这个问题就迎刃而解。  那你的流程走完了，你不用管别人是否成功么？比如你下单了积分没加，优惠券没扣怎么办？  3、削峰：  解决高压访问  使用了消息队列的问题？  系统复杂性  数据一致性  可用性  技术选型（选择中间件）？  2、重要概念  1、两个重要概念  2、消息队列的两种模式  3.1 点对点模式  3.2 发布/订阅模式  3、RabbitMQ  a.简介  b.核心概念  Message  Publisher  Exchange  Queue  Binding  Connection、  Channel  Consumer  Virtual Host  Broker  c.Exchange类型  Direct  fanout  topic  d.RabbitMQ安装测试  4、RabbitMQ整合  先引入依赖（可以勾选idea项目选项快速完成）  自动配置类：  应用RabbitTemplate操作举例  监听场景@RabbitListener @EnableRabbit  AmqpAdmin的应用  十、SpringBoot与检索  十一、Spring Boot 与任务  异步任务  使用异步@Async  定时任务  开启定时任务  邮件任务  配置  引入依赖  配置文件  自动配置类  发送邮件  发送一个简单的邮件  发送一个复杂消息邮件  十二、Spring Boor与安全  SpringSecurity概述  几个类：  基础概念  开启SpringSecurity  首先引入依赖  编写安全配置类  十三、Spring Boot与分布式  1、分布式概述  Dubbo工作图  安装Zookeeper  整合Zookeeper、Dubbo、SpringBoot  1、引入依赖  2、配置dubbo  3、编写服务  4、消费者  四种架构  十四、Docker  基础  安装Docker  docker常用指令 ###

## 一、 Spring Boot 入门 ##

[Spring Boot 官方文档][Spring Boot]

### 预：必须掌握的技术： ###

*  Spring 框架的使用经验
 *  熟练使用Maven进行项目构建和依赖管理
 *  熟练使用IDEA或Eclipse

### 1. Spring Boot 简介 ###

#### 学前bb ####

大多数人应该知道神奇SSM（Spring+SpringMVC+MyBatis）三兄弟让JavaWeb的开发几乎是进入了新次元，按照官方的要求来编写代码，配置项目，项目就能稳定运行。

而SpringBoot更神奇了，人家就倡导两个字：自动（个人口胡  
SSM配置到吐的配置文件，SpringBoot就几行字，就是舒适。

> Spring Boot 来简化Spring 应用的开发，约定大于配置，去繁从简，明显提高开发效率

然后Spring Boot发展了一段时间呢，大家觉得这个啊，是真的香，拿来整[微服务][Link 1]，岂不是美滋滋  
于是你会发现大多数微服务都是Spring Boot为基础，  
（甚至Eureka的服务注册中心，就是个Spring Boot项目）

> 2020/12/10：本篇文章呢，会提到一些自动配置的原理，各位只是看个爽，这里可以选看，如果是为了学习Spring Boot，还是建议仔细品一品的！毕竟Spring Boot就是Spring+Spring MVC的无敌全自动版本，自动配置是核心。

#### 解决的问题 ####

1.  **Spring全家桶**时代
2.  Spring Boot ——》J2EE一站式解决方案
3.  Spring Cloud -> 分布式整体解决方案（Spring技术栈）

#### 优点 ####

*  快速创建独立运行的Spring项目以及与主流框架集成
 *  使用嵌入式Servlet容器，应用无需打成WAR包，直接使用Java -jar jar包名即可运行
 *  starters自动依赖与版本控制
 *  大量的自动配置，简化开发，也可以修改默认值
 *  无需配置XML，无需代码生成，开箱即用
 *  准生产环境的运行时应用监控
 *  与云计算的天然集成

#### 缺点 ####

入门快，**精通很难**

> Spring Boot是对Spring 框架的再封装，若对Spring不了解，对SpringBoot的封装机制也不会很了解，Spring Boot中许多自动配置，需要我们了解Spring的API（只有在了解Spring的API后才能更精通Spring Boot

### 2.微服务 ###

martin fowler详细介绍了微服务[Martin Fowler:microservices][Martin Fowler_microservices]

#### What are [Microservices][]? ####

微服务是一种架构风格

提倡在开发应用时，一个应用应该是一组小型服务；可以通过HTTP的方式进行互通

##### 单体应用 #####

1.  All In One ，
2.  是传统的架构，
3.  优点：开发 、部署、运维要简单，
4.  缺点：牵一发动全身，不适合大型应用
5.  在多个服务器上复制这个单体进行扩展

##### 微服务 #####

1.  一个微服务架构把每个功能元素放进一个独立的服务中
2.  通过跨域服务器分发这些服务进行扩展，只在需要时进行扩展?
3.  每一个功能元素都是一个可以替换和独立升级的软件单元
4.  详细参照微服务文档

### 3.环境准备 ###

*  Spring Boot推荐使用jdk的版本：1.7及以上
 *  maven:3.3及以上版本
 *  intellij idea
 *  Spring Boot

#### [Maven][]设置： ####

给maven的settings.xml配置文件的profiles标签添加

表明使用jdk1.8进行开发

<profile>
 	<id>jdk-1.8</id>
 	<activation>
 	<activeByDefault>true/ activeByDefault>
 	<jdk>1.8</jdk>
 </activation>
 	<properties>
 		<maven.compiler.source>1。8</maven.compiler.source>
 		<maven.compiler.target>1.8</maven.compller.target>
 		<maven.compiler.compilerverslon>1.8</maven.compiler.compllerversion>
 	</propert1es>
 </profile>
 
 
 
 
 
 
 
 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12

#### Idea设置 ####

进入设置页面 Ctrl+Alt+S

Build,Execution,Deployment–>Build Tools–>Maven

设置maven为本地的maven， 库也为本地maven库

### 4.Spring Boot HelloWorld ###

> 2020/12/20: 还是补上HelloWorld吧

首先，目前有两种流派创建Spring Boot的项目

1.  使用Spring Initializer直接轻松一键搭建（**懒批模式，在第6节，真看不动就跳6节吧**
2.  从maven项目开始一点点搭建，（**相信我，都自动化了，这个了解了解就行了**

#### 4.1创建一个maven项目 ####

<?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 https://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.2.2.RELEASE</version>
 <relativePath/> 
 </parent>
 
 <groupId>com.jiarth</groupId>
 <artifactId>jirath_blog2</artifactId>
 <version>0.4.8-GA</version>
 <name>jirath_blog2</name>
 <description>2代个人博客系统</description>
 <properties>
 <java.version>1.8</java.version>
 </properties>
 
 <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>
 <exclusions>
 <exclusion>
 <groupId>org.junit.vintage</groupId>
 <artifactId>junit-vintage-engine</artifactId>
 </exclusion>
 </exclusions>
 </dependency>
 
 </dependencies>
 
 <build>
 <plugins>
 <plugin>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-maven-plugin</artifactId>
 </plugin>
 </plugins>
 </build>

</project>

![newCodeMoreWhite.png][]

*  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
 *  42
 *  43
 *  44
 *  45
 *  46
 *  47
 *  48
 *  49
 *  50
 *  51
 *  52

#### 4.2 创建项目结构以及启动类 ####

下面的包先不用管  
java->你的包->xxxApplication.java(这是规范xxxxApplication) 就可以了  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70]

@SpringBootApplication
 public class JirathBlog2Application {
 
 public static void main(String[] args) {
 SpringApplication.run(JirathBlog2Application.class, args);
 }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9

启动，看到这个Spring Boot，你就成功了  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 1]

> 这里会有一定难度，看不懂不要慌，只不过是自动配置的原理

### 5.Hello World 的探究 ###

#### 1)pom文件 ####

##### a.父项目 #####

<parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.2.0.RELEASE</version>
 <relativePath/> 
 </parent>
 
 
 
 
 
 
 
 1 
 2 
 3 
 4 
 5 
 6

他的父项目是

<parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-dependencies</artifactId>
 <version>2.2.0.RELEASE</version>
 <relativePath>../../spring-boot-dependencies</relativePath>
 </parent>
 
 
 
 
 
 
 
 1 
 2 
 3 
 4 
 5 
 6

其中有各种依赖的版本，Spring Boot 通过此父项目真正管理Spring Boot里面的所有依赖版本（Spring Boot的依赖仲裁中心）

以后导入依赖不需要版本，（没有depenencies中依赖管理的需要自己声明版本号）

##### b.导入的依赖 #####

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

spring-boot-stater-**web**

**spring-boot-stater:Spring Boot 场景启动器**：帮我们导入了web模块正常运行的组件

Spring Boot将所有的功能都抽取出来，做成一个个的staters(启动器)，只需要在项目中引入这些启动器，相关的依赖就能自动导入

#### 2)主程序类，主入口类 ####

@SpringBootApplication
 public class CaitApplication {
 
 public static void main(String[] args) {
 SpringApplication.run(CaitApplication.class, args);
 }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8

@SpringBootApplication 核心注解，标注在某个类上说明这个类是Spring Boot的主配置类，Spring Boot 一个运行这个类的main方法来启动应用：

@Target({
        ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @SpringBootConfiguration
    @EnableAutoConfiguration
    @ComponentScan(
        excludeFilters = {
        @Filter(
        type = FilterType.CUSTOM,
        classes = {
        TypeExcludeFilter.class}
    ), @Filter(
        type = FilterType.CUSTOM,
        classes = {
        AutoConfigurationExcludeFilter.class}
    )}
    )
    @ConfigurationPropertiesScan
    public @interface SpringBootApplication {
        
    
     
     
      
     
     
      
      
      
       
     
     
      
     
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16 
       17

*  @**SpringBootConfiguration** Spring Boot 的配置类；
    
     *  标注在某个类上，表示这是一个Spring Boot 的配置类
     *  @**Configuration** 配置类上来标注这个注解；（Spring4.X）
        
         *  配置类————配置文件；
 *  @**EnableAutoConfiguration** 开启自动配置功能；
    
     *  以前我们需要配置的东西，Spring Boot 帮我们自动配置；
     *  @**EnableAutoConfiguration**告诉SpringBoot开启自动配置功能；这样自动配置才能生效
        
         *  @**AutoConfigurationPackage** : 自动配置包
         *  @\*\*Import(\{AutoConfigurationImportSelector.class\})\*\*Spring的底层注解，给容器中导入一个组件；导入的组件有AutoConfigurationImportSelector.class
        
        更多知识在 **Spring注解版**

@Target({
        ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @AutoConfigurationPackage
    @Import({
        AutoConfigurationImportSelector.class})
    public @interface EnableAutoConfiguration {
        
    
     
     
      
     
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7

接下来从底层理解：

我们进入

@Target({
        ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @Import({
        Registrar.class})
    public @interface AutoConfigurationPackage {
        
    }
    
     
     
      
     
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7

@Import既然是SpringBoot 的底层注解，那Import的是什么？我们查看Registar的内容，发现这个是一个静态类

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
 
 Registrar() {
 
 }
 public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
 AutoConfigurationPackages.register(registry, (new AutoConfigurationPackages.PackageImport(metadata)).getPackageName());
 }
 
 public Set<Object> determineImports(AnnotationMetadata metadata) {
 return Collections.singleton(new AutoConfigurationPackages.PackageImport(metadata));
 }
 }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12

![在这里插入图片描述][20200228230429605.png]

其中，这个方法registerBeanDefinitions将bean注册到容器中，我们想知道注册的到底是什么，对这行代码进行调试，

![在这里插入图片描述][20200228230445671.png]

点击运行Spring Boot，

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 2]

通过调试信息我们知道，这个注解源头在CaitApplication(Spring Boot 启动类)

我们选择getPackName()方法，鼠标右键选择计算表达

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 3]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 4]  
结果证明：导入的包为com.cait.cait，也就是启动类所在的包中所有的bean。这表明，

**@AutoConfigurationPackage的实质是注册启动类所在包中所有标记的类为Bean**

**（将主配置类所在包下以及所有子包中所有的组件扫描到Spring容器）**

那么问题来了**EnableAutoConfiguration**中也有一个Import,这个Import又是什么作用

**@Import()给容器中导入括号内组件**

点进**AutoConfigurationImportSelector.class**

*由于本人使用的Spring Boot 2.X，与1略有不同，下方为1的老师讲解*

**EnableAutoConfigurationImportSelector**:导入哪些组件的选择器?

选择debug模式，查看

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 5]

通过名字了解到是很多自动配置类(XXXAutoConfiguration)：就是给容器中导入这个场景需要的所有组件并配置好组件，使用不同的功能对应不同的配置文件

**通过配置类，免去了我们手动编写配置注入功能组件的工作！！！**

SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class,classLoader);

**Spring Boot 在启动的时候从类路径下META-INF/spring.factories中获取EnableAutoConfiguration指定的值，将这些值作为自动配置类导入到容器中，自动配置类就生效，帮我们进行自动配置工作**以前我们需要自己配置的配置类，自动配置类都帮我们完成。J2EE的整体解决方案和自动配置都在spring-boot-autoconfigure-XXXX.jar中

### 6.使用Spring Initializer快速创建Spring Boot 项目 ###

> IDE都支持Spring Boot 的快速创建项目

#### SpringBoot学习第一步：搭建基础 ####

**IDEA对SpringBoot的项目支持可以说是点击就能完成基础的搭建，方便的不得了，**

#### 流程如下 ####

1.左上角File选项，New project，选择Spring Initializr

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 6]

2.设置项目信息，Group 会自动创建Group文件夹，包含项目的代码；Artifact 的名字必须使用小写与下划线构成！！

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 7]

3.选择web项目，右上角可以选择SpringBoot 的版本，一定要使用relese版本（正式版），不要使用SNAPSHOT版本  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 8]

4.确定project的名字与位置，名字就是项目文件夹的名字

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 9]

点击finish就好啦，一个SpringBoot+Maven项目就搞定了,最后创建三个基础包，上车愉快！  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 10]

#### 默认生成的Spring Boot 项目： ####

*  主程序已经生成，我们只需要我们自己的逻辑
 *  resouces文件夹中目录结构
    
     *  static：保存所有的静态资源：js,css,images;
     *  templates:保存所有的模板页面：（Spring Boot 默认jar包嵌入式的Tomcat，默认不支持Jsp页面）；可以使用模板引擎（freemarker、thymeleaf);
     *  application.properties:Spring Boot 应用默认配置文件
     *  https://blog.csdn.net/weixin\_44494373/article/details/102779187

## 二、Spring Boot 配置 ##

[CSDN博客][CSDN]

### 1. 配置文件 ###

Spring Boot 默认使用两种配置文件

*  application.properties
 *  application.yml

> 配置文件的作用：修改Spring Boot自动配置的默认值；Spring Boot在底层自动配置好

YAML(YAML Ain’t Markup Language )语言的文本，

*  YAML A Markup Language ：是一个标记语言
 *  YAML isn’t Markup Language ： 不是一个标记语言（XML类型标记文件）

标记语言：

*  以前的标记语言大多数使用的是 XXXX.xml
 *  YAML ：以数据为中心，比json、xml等更适合做配置文件

### 2. YAML语法 ###

#### 1）基本语法 ####

K:(空格)Value 表示一对键值对（空格必备）

以\*\*空格\*\*的缩进来控制层级关系；只要是左对齐的一列数据，都是同一个层级的

server:
    	port: 8081
    	path: /hello
    
     
     
      
     
     
      
       1 
       2 
       3

属性与值也是大小写敏感的

#### 2）值的写法 ####

##### 字面量：普通的值（数字，字符串，布尔） #####

key: value (中间有空格)字面直接来写；

*  字符串默认不用加上单引号和双引号
    
     *  “”：双引号不会转义字符串里面的特殊字符；特殊字符会作为本身想表达的意思
        
         *  example: “zhangsan \\n list”：输出：zhangshan (换行) list
     *  ‘’：单引号 会转义特殊字符，特殊字符最终只是一个普通的字符串数据
        
         *  example: “zhangsan \\n list”：输出：zhangshan \\n list

##### 对象、Map(属性和值)（键值对） #####

key: value

对象还是key: value的方式

example: create a object with propertities : lastName age

friends:
    	lastName: zhangshan
    	age: 22
    
     
     
      
     
     
      
       1 
       2 
       3

行内写法：用一行表示

friends: {
        lastName: zhangshan , age: 18}
    
     
     
      
     
     
      
       1

##### 数组（List、Set)： #####

用-值表示数组中的一个元素

pets:
    	-cat
    	-dog
    	-pig
    
     
     
      
     
     
      
       1 
       2 
       3 
       4

行内写法

pets: [cat,dog,pig]
    
     
     
      
     
     
      
       1

### 附：Spring Boot单元测试 ###

可以在测试期间很方便的类似编码一样进行自动注入容器的功能

package com.cait.cait;

import org.junit.jupiter.api.Test;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest  
class CaitApplicationTests \{

@Autowired
 要进行测试的类
 @Test
 void contextLoads() {
 进行操作
 }

![newCodeMoreWhite.png][]

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19

### 3. 通过配置文件注入 ###

#### 1) 数据绑定到基础数据类型 ####

@**Value**

String LastName;

是Spring 底层的一个注解，

对应的xml

<bean class="person">
 	<property name="LastName" value="字面量/${key}/#{SpEL}"></property>
 </bean>
 
 
 
 
 
 
 
 1 
 2 
 3

用法很简单  
在一个bean里面

@Value("${配置文件Key的全路径}"
    String data;
    
     
     
      
     
     
      
       1 
       2

#### 2) 将数据绑定到类中 含配置文件与类绑定的方法 ####

**注： prefix必须全部为小写，配置的类名不能使用大写！！！！！，如 subMit是错误的！！**

首先 类 与 配置文件要对应，在类前注释 @ConfigurationProperties(prefix=“pets”)

* @ConfigurationProperties 告诉SpringBoot将本类中的所有属性和配置文件中相关属性进行绑定；
 * perfix=“pets”:配置文件中，该前缀下面的所有属性，进行一一映射
 * 若报错，点击提示，官方说明应该添加依赖
 * <dependency>
 <groupId>org.springframework.boot</groupId> 
 <artifactId>spring-boot-configuration-processor</artifactId> 
 <optional>true</optional>
 </dependency>
 
 
 
 
 
 
 
 1 
 2 
 3 
 4 
 5
 * 只有这个组件是容器中的组件，才能使用容器提供的@ConfigurationProperties功能
 * 添加@Component注解加入容器组件

总结：导入配置文件处理器，以后进行配置文件操作就有提示，类中**属性的名要对应**，类名可以不同，加入注解@ConfigurationProperties(prefix = “属性的前缀”)

<dependency>
 <groupId>org.springframework.boot</groupId> 
 <artifactId>spring-boot-configuration-processor</artifactId> 
 <optional>true</optional>
 </dependency>
 
 
 
 
 
 
 
 1 
 2 
 3 
 4 
 5

**配置文件少用中文！！！**

若输出为乱码，原因是idea使用的是utf8

打开Setting，搜索file encoding(文件编码)，选择UTF8,同时选择需要在运行时转译为ascii

*  Transparent native to ascii conversion

#### 3) @Value 获取值和 @ConfigurationProperties获取值的比较 ####

<table> 
 <thead> 
 <tr> 
 <th>类型</th> 
 <th>@ConfigurationProperties</th> 
 <th>@Value</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>功能</td> 
 <td>批量注入配置文件中的属性</td> 
 <td>一个个指定</td> 
 </tr> 
 <tr> 
 <td>松散绑定（松散语法）</td> 
 <td>supported</td> 
 <td>unsupported，要严格对应名</td> 
 </tr> 
 <tr> 
 <td>SpEL</td> 
 <td>unsupported</td> 
 <td>supported</td> 
 </tr> 
 <tr> 
 <td>JSR303</td> 
 <td>supported</td> 
 <td>unsupported</td> 
 </tr> 
 <tr> 
 <td>复杂类型封装</td> 
 <td>supported</td> 
 <td>unsupported, only simple type is permitted</td> 
 </tr> 
 </tbody> 
</table>

配置文件yml于properties他们都能获取到值

*  **如果说，我们只是在某个业务逻辑中需要获取一下文件中的某项值，使用@Value**
 *  **如果单独写了一个JavaBean来匹配配置文件中的值，使用@ConfigurationProperties**

#### 4) 配置文件注入值数据校验 ####

*  导入JSR303,在配置用的Bean上添加@Validated
 *  Bean中属性上添加判断注解
 *  @Email 就是邮箱校验
 *  @NotNull是非空注解
 *  [Spring boot @Validated注解以及配合@Valid的使用][Spring boot _Validated_Valid]
 *  [@Validated注解使用][Validated]

#### 5） @PropertySource & @ImportResource ####

*  @PropertySource:加载指定的配置文件（非默认的application.yml）
 *  参数Value指文件，**encoding指编码，也很重要！！！**

**注：@PropertySource默认只能支持properties文件！！！！，**

解决方案：[SpringBoot配置文件@PropertySource 同时支持properties文件与yaml(yml)][SpringBoot_PropertySource _properties_yaml_yml]

#### 4）Spring配置文件注入 ####

##### a. @**ImportResource**: 导入Spring配置文件,让配置文件里面的内容生效； #####

想让Spring的配置文件生效，加载进来；将@ImportResouce标注在一个类上

@ImportResource(locations= {
        "classpath:bean.xml"})
    
     
     
      
     
     
      
       1

![在这里插入图片描述][20200228230812142.png]

导入Spring配置文件：beans.xml并使其生效

##### b. Spring Boot 推荐给容器添加组件的方式 #####

*  配置类=======Spring 配置文件
 *  使用@Bean添加
 *      package com.jirath.springboot_learn.config;

import com.jirath.springboot\_learn.service.HelloService;  
import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.Configuration;

/\*\*

*  ‘@Configuratoin’ point out that current object is a Configuration Class,which used to replace the Spring Configuration file before.  
    */  
    @Configuration  
    public class MyConfig \{   
    /*\*
    
     *  add current function’s returned value to the ContextContainer,
     *  the id of the module in this ContextContainer is the name of function;
     *  @return the object which used to build a Bean  
        \*/  
        @Bean  
        public HelloService helloService()\{   
        return new HelloService();  
        \}  
        \}

![newCodeMoreWhite.png][]

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22

### 4.配置文件占位符 ###

##### RandomValuePropertySource: 配置文件中可以使用随机数 #####

r
 
 
 a
 
 
 n
 
 
 d
 
 
 o
 
 
 m
 
 
 .
 
 
 v
 
 
 a
 
 
 l
 
 
 u
 
 
 e
 
 
 
 、
 
 
 
 {random.value}、
 
 
 random.value、{random.int}、
 
 
 
 
 
 r
 
 
 a
 
 
 n
 
 
 d
 
 
 o
 
 
 m
 
 
 .
 
 
 l
 
 
 o
 
 
 n
 
 
 g
 
 
 
 、
 
 
 
 {random.long}、
 
 
 random.long、{random.int(10)}、
 
 
 
 
 
 r
 
 
 a
 
 
 n
 
 
 d
 
 
 o
 
 
 m
 
 
 .
 
 
 i
 
 
 n
 
 
 t
 
 
 [
 
 
 1024
 
 
 ,
 
 
 65536
 
 
 ]
 
 
 
 、
 
 
 
 {random.int[1024,65536]}、
 
 
 random.int[1024,65536]、{random.uuid}

##### 属性配置占位符 #####

app.name=MyApp
    app.description=${app.name} is a Spring Boot application
    
     
     
      
     
     
      
       1 
       2

*  可以在配置文件中引用前面配置过的属性（优先级前面配置过的这里都能用）
 *  $\{app.name:defultValue\}来指定找不到属性时的默认值
 *  ![在这里插入图片描述][20200228230832293.png]
 *  若引用的值不存在，SpringBoot会默认将\{\}中间的值作为value
 *  用$\{person.name:(defult)\}可以设置默认为defult

### 5.Profile ###

在开发过程中会遇到**开发和实际生产时项目的配置是不同的情况**，应对这种情况，Spring设置了Profile，

**Profile是Spring对不同环境提供不同配置功能的支持，可以通过激活、指定参数等方式快速切换环境**

#### 1）多Profile文件 ####

我们在主配置文件编写的时候，文件名可以是 application-(profile).properties/yml

**！！！注意，文件的profile必须在三个字符以内，否自无法作为配置文件！！**

默认使用application.properties的配置：

#### 2）yml支持多文档块方式 ####

spring:
    	profiles:
    		active: dev
    ---
    server:
    	port: 8081
    spring:
    	profiles: dev

—  
server:  
port: 8081  
spring:  
profiles: prod

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14

#### 3）激活指定Profile ####

*      spring.profiles.active=dev
        
           
           
            
           
           
            
             1
 *  命令行：
 *  –spring.profile.active=dev
 *  idea测试方法
 *  ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 11]
 *  打包：
    
     *  打开maven选项，Lifecycle->package
     *  ![在这里插入图片描述][20200228230947142.png]
 *  虚拟机方法：
    
     *  \-Dspring-profiles.active=dev
     *  ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 12]

### 6.配置文件的加载位置 ###

spring boot 启动会扫描以下位置的application.properties / yml 文件作为Spring Boot的默认配置文件

*  file:./config
 *  file:./
 *  以上两种是在当前项目路径下，即与src同级
 *  classpath:/config/
 *  classpath:/
 *  以上是按照优先级从高到低的顺序，所有位置的文件都会被加载，
 *  **高级优先配置内容会覆盖低级优先配置相同的内容，同时满足配置互补**
 *  我们也可以通过配置**spring.config.location**来改变**默认配置**
    
     *  项目打包好了以后，我们可以使用命令行参数的形式，启动项目的时候来指定配置文件的位置；**指定配置文件和默认加载的这些配置文件共同起作用，形成互补配置**
     *  ![image-20191109135006909][]
     *  即可以在外部改变配置

### 7.Spring Boot 外部配置加载顺序 ###

Spring Boot也可以从以下位置加载配置；优先级从高到低

[Spring Boot官方文档][Spring Boot 1]

优先加载带Profile，jar包外部的

1.  命令行参数
2.  来自java:comp/env的NDI属性
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指定的默认属性

### 8.Spring Boot 自动配置原理 ###

#### 配置文件能写些什么？怎么写？自动配置的原理？ ####

[Spring Boot官方文档关于配置文件][Spring Boot 2]

#### 自动配置原理： ####

1. Spring Boot启动的时候，加载主配置类，开启了自动配置功能@EnableAutoConfiguration，
2. @EnableAutoConfiguration的作用：
 
 * 利用EnableAutoConfigurationImportSelector给容器中导入一些组件
 * 可以查询selectImports()方法的内容；
 * Listconfigurations=getCandidateConfigurations(annotation Metadata,attributes);获取候选的配置
 
 * protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
 
 List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
 Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
 return configurations;
 }
 
 
 
 
 
 
 
 1 
 2 
 3 
 4 
 5
 * public final class SpringFactoriesLoader {
 
 public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
 private static final Log logger = LogFactory.getLog(SpringFactoriesLoader.class);
 private static final Map<ClassLoader, MultiValueMap<String, String>> cache = new ConcurrentReferenceHashMap();
 private SpringFactoriesLoader() {
 }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7

* 扫描所有jar包类路径下 META-INF/spring.factories
 * 把扫描到的这些文件的内容包装成properties对象
 * 从properties中获取到EnableAutoCongratulation.class类（类名）对应的值，然后把他们添加在容器中
 * **将类路径下 META-INF/spring.factories 里面配置的所有EnableAutoCongratulation的值加入到容器当中**
 
 位置：maven:spring-boot-autocongratulation->spring-boot-autoconfiguare-2X->META-INF->spring.factories
 
 # Auto Configure
 org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
 org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
 org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
 org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
 org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
 org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
 org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
 org.springframework.boot.autoconfigure.cloud.CloudServiceConnectorsAutoConfiguration,\
 org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
 org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
 org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
 org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
 org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveDataAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveRepositoriesAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveDataAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveRepositoriesAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveElasticsearchRepositoriesAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveRestClientAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.jdbc.JdbcRepositoriesAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.mongo.MongoReactiveDataAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.mongo.MongoReactiveRepositoriesAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.solr.SolrRepositoriesAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.redis.RedisReactiveAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.rest.RepositoryRestMvcAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration,\
 org.springframework.boot.autoconfigure.elasticsearch.jest.JestAutoConfiguration,\
 org.springframework.boot.autoconfigure.elasticsearch.rest.RestClientAutoConfiguration,\
 org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration,\
 org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration,\
 org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration,\
 org.springframework.boot.autoconfigure.h2.H2ConsoleAutoConfiguration,\
 org.springframework.boot.autoconfigure.hateoas.HypermediaAutoConfiguration,\
 org.springframework.boot.autoconfigure.hazelcast.HazelcastAutoConfiguration,\
 org.springframework.boot.autoconfigure.hazelcast.HazelcastJpaDependencyAutoConfiguration,\
 org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration,\
 org.springframework.boot.autoconfigure.http.codec.CodecsAutoConfiguration,\
 org.springframework.boot.autoconfigure.influx.InfluxDbAutoConfiguration,\
 org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration,\
 org.springframework.boot.autoconfigure.integration.IntegrationAutoConfiguration,\
 org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration,\
 org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
 org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration,\
 org.springframework.boot.autoconfigure.jdbc.JndiDataSourceAutoConfiguration,\
 org.springframework.boot.autoconfigure.jdbc.XADataSourceAutoConfiguration,\
 org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration,\
 org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration,\
 org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration,\
 org.springframework.boot.autoconfigure.jms.JndiConnectionFactoryAutoConfiguration,\
 org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration,\
 org.springframework.boot.autoconfigure.jms.artemis.ArtemisAutoConfiguration,\
 org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAutoConfiguration,\
 org.springframework.boot.autoconfigure.jersey.JerseyAutoConfiguration,\
 org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration,\
 org.springframework.boot.autoconfigure.jsonb.JsonbAutoConfiguration,\
 org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration,\
 org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration,\
 org.springframework.boot.autoconfigure.ldap.LdapAutoConfiguration,\
 org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration,\
 org.springframework.boot.autoconfigure.mail.MailSenderAutoConfiguration,\
 org.springframework.boot.autoconfigure.mail.MailSenderValidatorAutoConfiguration,\
 org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration,\
 org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,\
 org.springframework.boot.autoconfigure.mongo.MongoReactiveAutoConfiguration,\
 org.springframework.boot.autoconfigure.mustache.MustacheAutoConfiguration,\
 org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,\
 org.springframework.boot.autoconfigure.quartz.QuartzAutoConfiguration,\
 org.springframework.boot.autoconfigure.rsocket.RSocketMessagingAutoConfiguration,\
 org.springframework.boot.autoconfigure.rsocket.RSocketRequesterAutoConfiguration,\
 org.springframework.boot.autoconfigure.rsocket.RSocketServerAutoConfiguration,\
 org.springframework.boot.autoconfigure.rsocket.RSocketStrategiesAutoConfiguration,\
 org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration,\
 org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration,\
 org.springframework.boot.autoconfigure.security.servlet.SecurityFilterAutoConfiguration,\
 org.springframework.boot.autoconfigure.security.reactive.ReactiveSecurityAutoConfiguration,\
 org.springframework.boot.autoconfigure.security.reactive.ReactiveUserDetailsServiceAutoConfiguration,\
 org.springframework.boot.autoconfigure.security.rsocket.RSocketSecurityAutoConfiguration,\
 org.springframework.boot.autoconfigure.security.saml2.Saml2RelyingPartyAutoConfiguration,\
 org.springframework.boot.autoconfigure.sendgrid.SendGridAutoConfiguration,\
 org.springframework.boot.autoconfigure.session.SessionAutoConfiguration,\
 org.springframework.boot.autoconfigure.security.oauth2.client.servlet.OAuth2ClientAutoConfiguration,\
 org.springframework.boot.autoconfigure.security.oauth2.client.reactive.ReactiveOAuth2ClientAutoConfiguration,\
 org.springframework.boot.autoconfigure.security.oauth2.resource.servlet.OAuth2ResourceServerAutoConfiguration,\
 org.springframework.boot.autoconfigure.security.oauth2.resource.reactive.ReactiveOAuth2ResourceServerAutoConfiguration,\
 org.springframework.boot.autoconfigure.solr.SolrAutoConfiguration,\
 org.springframework.boot.autoconfigure.task.TaskExecutionAutoConfiguration,\
 org.springframework.boot.autoconfigure.task.TaskSchedulingAutoConfiguration,\
 org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration,\
 org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration,\
 org.springframework.boot.autoconfigure.transaction.jta.JtaAutoConfiguration,\
 org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration,\
 org.springframework.boot.autoconfigure.web.client.RestTemplateAutoConfiguration,\
 org.springframework.boot.autoconfigure.web.embedded.EmbeddedWebServerFactoryCustomizerAutoConfiguration,\
 org.springframework.boot.autoconfigure.web.reactive.HttpHandlerAutoConfiguration,\
 org.springframework.boot.autoconfigure.web.reactive.ReactiveWebServerFactoryAutoConfiguration,\
 org.springframework.boot.autoconfigure.web.reactive.WebFluxAutoConfiguration,\
 org.springframework.boot.autoconfigure.web.reactive.error.ErrorWebFluxAutoConfiguration,\
 org.springframework.boot.autoconfigure.web.reactive.function.client.ClientHttpConnectorAutoConfiguration,\
 org.springframework.boot.autoconfigure.web.reactive.function.client.WebClientAutoConfiguration,\
 org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,\
 org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration,\
 org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration,\
 org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration,\
 org.springframework.boot.autoconfigure.web.servlet.MultipartAutoConfiguration,\
 org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,\
 org.springframework.boot.autoconfigure.websocket.reactive.WebSocketReactiveAutoConfiguration,\
 org.springframework.boot.autoconfigure.websocket.servlet.WebSocketServletAutoConfiguration,\
 org.springframework.boot.autoconfigure.websocket.servlet.WebSocketMessagingAutoConfiguration,\
 org.springframework.boot.autoconfigure.webservices.WebServicesAutoConfiguration,\
 org.springframework.boot.autoconfigure.webservices.client.WebServiceTemplateAutoConfiguration
 
 ![newCodeMoreWhite.png][]
 
 * 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
 * 42
 * 43
 * 44
 * 45
 * 46
 * 47
 * 48
 * 49
 * 50
 * 51
 * 52
 * 53
 * 54
 * 55
 * 56
 * 57
 * 58
 * 59
 * 60
 * 61
 * 62
 * 63
 * 64
 * 65
 * 66
 * 67
 * 68
 * 69
 * 70
 * 71
 * 72
 * 73
 * 74
 * 75
 * 76
 * 77
 * 78
 * 79
 * 80
 * 81
 * 82
 * 83
 * 84
 * 85
 * 86
 * 87
 * 88
 * 89
 * 90
 * 91
 * 92
 * 93
 * 94
 * 95
 * 96
 * 97
 * 98
 * 99
 * 100
 * 101
 * 102
 * 103
 * 104
 * 105
 * 106
 * 107
 * 108
 * 109
 * 110
 * 111
 * 112
 * 113
 * 114
 * 115
 * 116
 * 117
 * 118
 * 119
 * 120
 * 121
 * 122
 * 123
 * 124
 * 125
 * 126
 * 127
 
 * 每一个这样的XXXAutoConfrigulation类都是容器的一个组件，都加入到容器中；用他们来做自动配置；
 * 每一个自动配置类进行自动配置功能；
 * 以\*\*HttpEncodingAutoConfiguration（Http编码自动配置）\*\*为例解释自动配置原理；
 * @Configuration(
 proxyBeanMethods = false
 )//表示这是一个配置类，与之前编写配置文件一样，也可以给容器中添加组件
 @EnableConfigurationProperties({
 HttpProperties.class})//启用ConfigurationProperties功能:将配置文件中对应的值和HttpEncodingProperties绑定起来;并把 HttpProperties 加入到Spring的ioc容器中来
 @ConditionalOnWebApplication(
 type = Type.SERVLET
 )//考虑webapp，Spring底层@Conditional注解，根据不同的条件，如果满足指定的条件，整个配置类就会生效; 判断当前应用是否是web应用，如果是，当前配置类才生效
 @ConditionalOnClass({
 CharacterEncodingFilter.class})//判断当前项目有没有这个类 CharacterEncodingFilter ：SpringMVC进行乱码解决的过滤器
 @ConditionalOnProperty(
 prefix = "spring.http.encoding",
 value = {
 "enabled"},
 matchIfMissing = true
 )//判断配置文件中是否存在某个配置spring.http.encoding.enabled ; 如果不存在判断也是成立的，即使配置文件中不配值，也是默认生效的；
 public class HttpEncodingAutoConfiguration {
 
 /**
 *他已经和SpringBoot的配置文件映射了
 *
 **/
 private final Encoding properties;
 //只有一个有参构造器的情况下，参数的值就会从容器中拿
 public HttpEncodingAutoConfiguration(HttpProperties properties) {
 this.properties = properties.getEncoding();
 }
 
 @Bean//给容器中添加组件，这个组件的某些值需要从properties中获取
 @ConditionalOnMissingBean
 public CharacterEncodingFilter characterEncodingFilter() {
 CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
 filter.setEncoding(this.properties.getCharset().name());//获取编码
 filter.setForceRequestEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.REQUEST));
 filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.RESPONSE));
 return filter;
 }
 
 \}
 
 ![newCodeMoreWhite.png][]
 
 * 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
 
 * 根据当前不同条件判断，决定这个配置类是否生效？
 * SpringBoot1.X中属性在HttpEncodingProperties中可以查看，2.X中无注释
 * 一旦这个配置类生效；这个配置就会给容器中添加各种组件；这些组件的属性是从对应的properties中获取的，这些类中的每一个属性又是和配置文件绑定的
 * 所有配置文件中能配置的属性都是在xxxxProperties类中封装着
 * 
 * //
 // Source code recreated from a .class file by IntelliJ IDEA
 // (powered by Fernflower decompiler)
 //
 
 package org.springframework.boot.autoconfigure.http;
 
 import java.nio.charset.Charset; 
 import java.nio.charset.StandardCharsets; 
 import java.util.Locale; 
 import java.util.Map; 
 import org.springframework.boot.context.properties.ConfigurationProperties;
 
 @ConfigurationProperties( 
 prefix = “spring.http” 
 )//从配置文件中获取指定的值和bean的属性进行绑定 
 public class HttpProperties \{ 
 private boolean logRequestDetails; 
 private final HttpProperties.Encoding encoding = new HttpProperties.Encoding();
 
 //… 
 \}
 
 <div class="hljs-button {2}" data-title="复制"></div></code><div class="hide-preCode-box"><img class="look-more-preCode contentImg-no-view" src="https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/33b8b72b51ec4c3381ede8134ce97fdf.png" alt="" title=""></div><ul class="pre-numbering" style=""><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li><li style="color: rgb(153, 153, 153);">3</li><li style="color: rgb(153, 153, 153);">4</li><li style="color: rgb(153, 153, 153);">5</li><li style="color: rgb(153, 153, 153);">6</li><li style="color: rgb(153, 153, 153);">7</li><li style="color: rgb(153, 153, 153);">8</li><li style="color: rgb(153, 153, 153);">9</li><li style="color: rgb(153, 153, 153);">10</li><li style="color: rgb(153, 153, 153);">11</li><li style="color: rgb(153, 153, 153);">12</li><li style="color: rgb(153, 153, 153);">13</li><li style="color: rgb(153, 153, 153);">14</li><li style="color: rgb(153, 153, 153);">15</li><li style="color: rgb(153, 153, 153);">16</li><li style="color: rgb(153, 153, 153);">17</li><li style="color: rgb(153, 153, 153);">18</li><li style="color: rgb(153, 153, 153);">19</li><li style="color: rgb(153, 153, 153);">20</li><li style="color: rgb(153, 153, 153);">21</li><li style="color: rgb(153, 153, 153);">22</li><li style="color: rgb(153, 153, 153);">23</li><li style="color: rgb(153, 153, 153);">24</li></ul></pre> 
 <ul><li> <pre data-index="32" class="prettyprint"><code class="prism language-properties has-numbering" onclick="mdcp.copyCode(event)" style="position: unset;">#我们能配置的属性都来源于这个功能的properties类
 spring.http.encoding.enabled=true
 #字符集
 spring.http.encoding.charset=utf-8
 #强制编码 请求响应必须为UTF8
 spring.http.encoding.force=true
 <div class="hljs-button {2}" data-title="复制"></div></code><ul class="pre-numbering" style=""><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li><li style="color: rgb(153, 153, 153);">3</li><li style="color: rgb(153, 153, 153);">4</li><li style="color: rgb(153, 153, 153);">5</li><li style="color: rgb(153, 153, 153);">6</li></ul></pre> </li></ul> 
 <h3><a name="t48"></a><a id="_1050"></a>精髓</h3> 
 <ol><li>SpringBoot启动会加载大量自动配置类</li><li>我们看我们需要的功能有没有SpringBoot默认写好的自动配置类；</li><li>我们再来看这个自动配置类中到底配置了哪些组件； 
 <ul><li>只要我们要用的组件存在，我们就不需要配置</li></ul> </li><li>给容器中自动配置类添加组件的时候，会从properties类中获取某些属性，我们就可以在配置文件中指定这些属性的值</li></ol> 
 xxxxxAutoConfiguration:自动配置类； 
 给容器中添加组件 
 xxxxproperties:封装配置文件中相关属性； 
 for example: 
 <ol><li>全局搜索相关自动配置类<img src="https://img-blog.csdnimg.cn/20200228231056650.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw==,size_16,color_FFFFFF,t_70" alt="在这里插入图片描述"></li><li>点击查看XXXXProperties，类中属性即为可以配置的属性<img src="https://img-blog.csdnimg.cn/20200228231136321.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw==,size_16,color_FFFFFF,t_70" alt="在这里插入图片描述"></li></ol> 
 <h2><a name="t49"></a><a id="3_1069"></a>3.自动配置原理（细节）</h2> 
 <h3><a name="t50"></a><a id="1ConditionalSpringConditional_1071"></a>1）@Conditional派生注解（Spring注解版原生的@Conditional作用）</h3> 
 作用：必须是@Conditional指定的条件成立，才给容器中添加组件，配置配里面的内容才生效 
 <div class="table-box"><table><thead><tr><th align="left">@Conitional扩展注解</th><th>作用（判断是否满足当前指定条件）</th></tr></thead><tbody><tr><td align="left">@ConditionalOnJava</td><td>系统的Java版本是否符合要求</td></tr><tr><td align="left">@ConditionalOnBean</td><td>容器中存在指定Bean</td></tr><tr><td align="left">@ConditionalOnMissingBean</td><td>容器中不存在指定Bean</td></tr><tr><td align="left">@ConditionalOnExpression</td><td>满足SpEl表达式指定</td></tr><tr><td align="left">@ConditionalOnClass</td><td>系统中有指定的类</td></tr><tr><td align="left">@ConditionalOnMissingClass</td><td>系统中没有指定的类</td></tr><tr><td align="left">@ConditionalOnSingleCandidate</td><td>容器中只有一个指定的Bean，或者这个Bean是首选Bean</td></tr><tr><td align="left">@ConditionalOnProperty</td><td>系统中指定的属性是否有指定的值</td></tr><tr><td align="left">@ConditionalOnResource</td><td>类路径下是否存在指定资源文件</td></tr><tr><td align="left">@ConditionalOnWebApplication</td><td>当前是web环境</td></tr><tr><td align="left">@ConditionalOnNotWebApplication</td><td>当前不是web环境</td></tr><tr><td align="left">@ConditionalOnJndi</td><td>JNDI存在指定项</td></tr></tbody></table></div>
 自动配置类必须在一定条件下生效? 
 我们怎么知道那些自动配置类生效？ 
 在配置文件中编写 
 <pre data-index="33" class="prettyprint"><code class="prism language-properties has-numbering" onclick="mdcp.copyCode(event)" style="position: unset;">#开启SpringBoot的debug
 debug=true
 <div class="hljs-button {2}" data-title="复制"></div></code><ul class="pre-numbering" style=""><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li></ul></pre> 
 我们可以通过启用debug=true属性；来让控制台打印自动生成报告，这样我们就可以很方便的知道哪些自动配置类生效 
 Positive matches: 自动配置类启用的 
 Negative matches: 未匹配到 
 <h1><a name="t51"></a><a id="Spring_Boot__1111"></a>三、Spring Boot 与日志</h1> 
 <h2><a name="t52"></a><a id="1_1113"></a>1、日志框架</h2> 
 小张在开发一个大型系统； 
 <ol><li>System.out.println("");将关键信息打印在控制台；老板希望去掉；又想要用</li><li>做成一个框架记录系统运行时的信息；</li><li>高大上的几个功能： 
 <ul><li>异步模式</li><li>自动归档</li><li>XXXX</li></ul> </li><li>卸载老框架，换新框架，重新修改相关API;（很麻烦）</li><li>JDBC—数据库驱动启发； 
 <ul><li>写了一个接口层：日志门面（日志的一个抽象层）；logging-abstract.jar</li><li>给项目中导入具体的日志实现就行了；我们之前的日志框架都是实现的抽象层</li></ul> </li></ol> 
 市面上的日志框架 
 JUL , JCL , Jboss-logging , logback , log4j , log4j2 , slf4j 
 <div class="table-box"><table><thead><tr><th>日志门面（日志抽象层）</th><th>日志实现</th></tr></thead><tbody><tr><td><s>JCL(Jakarta Commons Logging)</s>、SLF4j(Simple Logging Facae For Java)、<s>Jboss-logging</s></td><td>log4j、JUL(java.util.logging)、log4j2、logback</td></tr></tbody></table></div>
 左边选一个门面（抽象层）、右边来选一个实现 
 <ul><li>Jboss 太复杂 JCL 最后一次更新在2014年</li><li>SLF4j log4j logback出自同一人</li><li>Log4j2 Apache公司的全新日志框架</li></ul> 
 日志门面：SLF4J; 
 日志实现：Logback > log4j 
 SpringBoot ：底层是Spring框架，Spring框架默认使用是JCL 
 SpringBoot 选用SLF4j和logback 
 <h2><a name="t53"></a><a id="2SLF4j_1150"></a>2、SLF4j使用</h2> 
 <a href="http://slf4j.org/">SLF4j官网</a> 
 <h3><a name="t54"></a><a id="1SLF4j_1154"></a>1）如何在系统中使用SLF4j</h3> 
 以后在开发的时候，日志记录方法的调用，不应该来直接调用日志的实现类，二傻调用日志抽象层里面的方法； 
 给系统里面导入slf4j的jar和logback的实现jar 
 <pre data-index="34" class="prettyprint"><code class="prism language-java has-numbering" onclick="mdcp.copyCode(event)" style="position: unset;">import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 public class HelloWorld {
 public static void main(String[] args) {
 Logger logger = LoggerFactory.getLogger(HelloWorld.class);
 logger.info("Hello World");
 }
 }
 <div class="hljs-button {2}" data-title="复制"></div></code><ul class="pre-numbering" style=""><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li><li style="color: rgb(153, 153, 153);">3</li><li style="color: rgb(153, 153, 153);">4</li><li style="color: rgb(153, 153, 153);">5</li><li style="color: rgb(153, 153, 153);">6</li><li style="color: rgb(153, 153, 153);">7</li><li style="color: rgb(153, 153, 153);">8</li><li style="color: rgb(153, 153, 153);">9</li></ul></pre> 
 slf4j使用的情况 
 <img src="https://img-blog.csdnimg.cn/2020022823120178.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw==,size_16,color_FFFFFF,t_70" alt="在这里插入图片描述"> 
 SELF4j关联了logback日志框架后的正确使用情况 <img src="https://img-blog.csdnimg.cn/20200228231211287.png" alt="在这里插入图片描述"> 
 调用SELF4j的接口，SELF4j调用底层日志的jar包 
 使用log4j时，系统会使用适配层<img src="https://img-blog.csdnimg.cn/20200228231229738.png" alt="在这里插入图片描述"> 
 通过适配层将两者关联 
 <h3><a name="t55"></a><a id="2_1185"></a>2）遗留问题</h3> 
 for example:a情况（slf4j+logback):Spring (commons-logging)、Hibernate( jBOSS-logging)、Mybatis… 
 统一日志记录，即使 是别的框架，和我一起统一使用slf4j进行输出 
 <a href="http://slf4j.org/legacy.html">介绍</a> 
 <img src="https://img-blog.csdnimg.cn/20200228231244662.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw==,size_16,color_FFFFFF,t_70" alt="在这里插入图片描述"> 
 <ol><li>将系统中其他日志框架先排出去</li><li>用中间包替换所有的日志框架</li><li>导入slf4j其他的实现</li></ol> 
 ----------------------SpringBoot就是这么实现的 
 <h3><a name="t56"></a><a id="3SpringBoot_1201"></a>3）SpringBoot日志关系</h3> 
 使用idea创建，选择web，默认携带self4j+logback 
 在pom文件中，选择导入的依赖，右键，选择Diagrams->Show Dependencies,idea就可以用树状图的方式展现依赖之间的关系，按住alt即可放大镜查看<img src="https://img-blog.csdnimg.cn/20200228231300359.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw==,size_16,color_FFFFFF,t_70" alt="在这里插入图片描述"> 
 <pre data-index="35" class="prettyprint"><code class="prism language-xml has-numbering" onclick="mdcp.copyCode(event)" style="position: unset;"><dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter</artifactId>
 </dependency>
 <div class="hljs-button {2}" data-title="复制"></div></code><ul class="pre-numbering" style=""><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li><li style="color: rgb(153, 153, 153);">3</li><li style="color: rgb(153, 153, 153);">4</li></ul></pre> 
 SpringBoot 使用他来做日志功能 
 <pre data-index="36" class="prettyprint"><code class="prism language-xml has-numbering" onclick="mdcp.copyCode(event)" style="position: unset;"><dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-logging</artifactId>
 <version>2.2.0.RELEASE</version>
 <scope>compile</scope>
 </dependency>
 <div class="hljs-button {2}" data-title="复制"></div></code><ul class="pre-numbering" style=""><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li><li style="color: rgb(153, 153, 153);">3</li><li style="color: rgb(153, 153, 153);">4</li><li style="color: rgb(153, 153, 153);">5</li><li style="color: rgb(153, 153, 153);">6</li></ul></pre> 
 <img src="https://img-blog.csdnimg.cn/20200228231311772.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw==,size_16,color_FFFFFF,t_70" alt="在这里插入图片描述"> 
 <img src="https://img-blog.csdnimg.cn/20200228231321810.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw==,size_16,color_FFFFFF,t_70" alt="在这里插入图片描述"> 
 总结： 
 <ol><li>使用logback记录日志</li><li>把其他日志转为slf4j</li><li>导入抽象层</li><li>中间替换包（偷梁换柱）</li><li>如果我们要引入其他框架，一定要把这个框架的默认日志依赖移除 
 <ol><li>新版本的Spring不再使用commons-logging,所以新的Spring Boot中没有去除该框架</li></ol> </li></ol> 
 SpringBoot能自动适配所有的日志，而且底层使用的是slf4j+logback的方式记录日志，引入其他框架的时候，只需要把这个框架依赖的日志框架排除掉 
 <h2><a name="t57"></a><a id="3_1241"></a>3.日志使用</h2> 
 <h3><a name="t58"></a><a id="1_1243"></a>1）默认配置</h3> 
 SpringBoot 默认帮我们配置好了日志； 
 <pre data-index="37" class="set-code-hide prettyprint"><code class="prism language-java has-numbering" onclick="mdcp.copyCode(event)" style="position: unset;"> //记录器
 org.slf4j.Logger logger= org.slf4j.LoggerFactory.getLogger(getClass());
 
 @Test
 void contextLoads() {
 //日志的级别
 //由低到高 trace debug info warn error
 //可以调整需要输出的日志级别，日志就只会在这个级别的更高级别生效
 logger.trace("这是trance日志");
 logger.debug("这是debug日志");
 //SpringBoot 默认使用的是info级别,没有指定级别的就用SpringBoot默认规定的级别：root级别(info)
 logger.info("这是info日志");
 logger.warn("这是warn日志");
 logger.error("这是error日志");
 }
 
 <div class="hljs-button {2}" data-title="复制"></div></code><div class="hide-preCode-box"><img class="look-more-preCode contentImg-no-view" src="https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/33b8b72b51ec4c3381ede8134ce97fdf.png" alt="" title=""></div><ul class="pre-numbering" style=""><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li><li style="color: rgb(153, 153, 153);">3</li><li style="color: rgb(153, 153, 153);">4</li><li style="color: rgb(153, 153, 153);">5</li><li style="color: rgb(153, 153, 153);">6</li><li style="color: rgb(153, 153, 153);">7</li><li style="color: rgb(153, 153, 153);">8</li><li style="color: rgb(153, 153, 153);">9</li><li style="color: rgb(153, 153, 153);">10</li><li style="color: rgb(153, 153, 153);">11</li><li style="color: rgb(153, 153, 153);">12</li><li style="color: rgb(153, 153, 153);">13</li><li style="color: rgb(153, 153, 153);">14</li><li style="color: rgb(153, 153, 153);">15</li><li style="color: rgb(153, 153, 153);">16</li></ul></pre> 
 SpringBoot修改日志默认配置 
 path和file都存在，file为主 
 <pre data-index="38" class="prettyprint"><code class="prism language-properties has-numbering" onclick="mdcp.copyCode(event)" style="position: unset;">logging.level.com.jirath=trace
 #在当前磁盘下新建Spring和log文件夹：使用spring.log作为默认文件
 logging.file.path=/spring/log
 #不指定路径就在当前项目下生成日志
 #logging.file.name=springboot.log
 #可以指定完整路径
 logging.file.name=E:/springboot.log
 #在控制台输出的日志格式
 logging.pattern.console================%n%d{yyyy-MM-dd} [%thread] %-5level %logger{50} - %msg%n
 #指定文件中日志输出格式
 logging.pattern.file=
 <div class="hljs-button {2}" data-title="复制"></div></code><ul class="pre-numbering" style=""><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li><li style="color: rgb(153, 153, 153);">3</li><li style="color: rgb(153, 153, 153);">4</li><li style="color: rgb(153, 153, 153);">5</li><li style="color: rgb(153, 153, 153);">6</li><li style="color: rgb(153, 153, 153);">7</li><li style="color: rgb(153, 153, 153);">8</li><li style="color: rgb(153, 153, 153);">9</li><li style="color: rgb(153, 153, 153);">10</li><li style="color: rgb(153, 153, 153);">11</li></ul></pre> 
 <img src="https://img-blog.csdnimg.cn/20200228231336360.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw==,size_16,color_FFFFFF,t_70" alt="在这里插入图片描述"> 
 SpringBoot 关于日志的其他默认设置在哪里？ 
 位于 
 spring-boot-2.2.0.RELEASE.jar!/org/springframework/boot/logging/logback/中 
 打开即为SpringBoot针对LogBack的配置封装。 
 for example:<img src="https://img-blog.csdnimg.cn/20200228231348674.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw==,size_16,color_FFFFFF,t_70" alt="在这里插入图片描述"> 
 其中，SpringBoot将默认级别(root)设置为了info 
 在配置文件中配置的属性会被一个名为LoggingApplicationListener（单击配置文件配置项即可查看）相似的类接收 
 LoggingApplicationListener同时与一个LoggingSystemProperties（在logback桶目录下）的类对应在这里获取输入的值，进行解析 
 在base.xml中SpringBoot针对控制台与文件输出有分别的定义，如图 
 <img src="https://img-blog.csdnimg.cn/20200228231401193.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw==,size_16,color_FFFFFF,t_70" alt="在这里插入图片描述"> 
 在文件默认配置中，SpringBoot同时设置了文件在最大数值，当超出数值，日志就会自动分文件记录，如：log1,log2<img src="https://img-blog.csdnimg.cn/20200228231417530.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw==,size_16,color_FFFFFF,t_70" alt="在这里插入图片描述"> 
 <h3><a name="t59"></a><a id="2_1307"></a>2）指定配置</h3> 
 在实际使用时，同时会遇到其他功能的需求，自动归档等等等等， 
 要想使用自己的配置文件，Spring.io中在特性下有一章节专门讲述了SpringBoot配置默认日志的方法：在Spring目录中放logback.xml即可 
 给类路径下放上每个框架自己的配置文件即可：SpringBoot就不再使用默认配置<img src="https://img-blog.csdnimg.cn/2020022823142913.png" alt="在这里插入图片描述"> 
 Spring Boot includes a number of extensions to Logback that can help with advanced configuration. You can use these extensions in your <code>logback-spring.xml</code> configuration file. 
 logback.xml:直接被日志框架识别 
 logback-spring.xml：日志就不直接加载日志配置项，由SpringBoot解析日志配置，就可以使用SpringBoot的高级Profile功能 
 <pre data-index="39" class="prettyprint"><code class="prism language-xml has-numbering" onclick="mdcp.copyCode(event)" style="position: unset;"><springProfile name="dev">
 	
 </springProfile>
 <div class="hljs-button {2}" data-title="复制"></div></code><ul class="pre-numbering" style=""><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li><li style="color: rgb(153, 153, 153);">3</li></ul></pre> 
 <h3><a name="t60"></a><a id="3_1327"></a>3）切换日志框架</h3> 
 例子：使用log4j 
 <ol><li>打开依赖关系图，选择logback,exclude,将logback排除</li><li>去除log4j-over-slf4j(将log4j替换为slf4j的包)</li><li>导入slf4j-log4j12(无需写版本)，会自动的导入log4j</li><li>运行</li></ol> 
 但是，此行为无意义，log4j因为表现不理想，原作开发了logback; 
 使用其他日志框架： 
 <ol><li>排除stater-logging</li><li>引入stater-log4j2</li></ol> 
 <h1><a name="t61"></a><a id="SpringBootWeb_1343"></a>四、SpringBoot与Web开发</h1> 
 <blockquote> 
 Thymeleaf、web定制、容器定制 
 </blockquote> 
 <h2><a name="t62"></a><a id="1SpringBoot_1347"></a>1、使用SpringBoot</h2> 
 <ol><li>创建SpringBoot应用，选中我们需要的模块；</li><li>SpringBoot已经默认将这些场景布置好，只需要在配置文件中指定少量配置就可以运行起来；</li><li>自己编写业务代码；</li></ol> 
 自动配置原理？ 
 这个场景SpringBoot帮我们配置了什么？能不能修改？能不能扩展？… 
 <ol><li>XXXXAutoConfiguration:帮我们给容器中自动配置组件</li><li>在Spring-boot-autoconfigure中找到web模块</li><li>自动配置类在其中</li><li>XXXProperties：配置类来封装配置文件的内容</li></ol> 
 <h2><a name="t63"></a><a id="2SpringBoot_1362"></a>2、SpringBoot对静态页面的映射规则</h2> 
 在WebMvcAutoConfiguration中 
 <h3><a name="t64"></a><a id="_1366"></a>访问静态资源</h3> 
 <h4><a id="_webjars_1368"></a>第一种 导入的webjars</h4> 
 <pre data-index="40" class="set-code-hide prettyprint"><code class="prism language-java has-numbering" onclick="mdcp.copyCode(event)" style="position: unset;">public void addResourceHandlers(ResourceHandlerRegistry registry) {
 if (!this.resourceProperties.isAddMappings()) {
 logger.debug("Default resource handling disabled");
 } else {
 Duration cachePeriod = this.resourceProperties.getCache().getPeriod();
 CacheControl cacheControl = this.resourceProperties.getCache().getCachecontrol().toHttpCacheControl();
 if (!registry.hasMappingForPattern("/webjars/**")) {
 this.customizeResourceHandlerRegistration(registry.addResourceHandler(new String[]{"/webjars/**"}).addResourceLocations(new String[]{"classpath:/META-INF/resources/webjars/"}).setCachePeriod(this.getSeconds(cachePeriod)).setCacheControl(cacheControl));
 }
 
 String staticPathPattern = this.mvcProperties.getStaticPathPattern();
 if (!registry.hasMappingForPattern(staticPathPattern)) {
 this.customizeResourceHandlerRegistration(registry.addResourceHandler(new String[]{staticPathPattern}).addResourceLocations(WebMvcAutoConfiguration.getResourceLocations(this.resourceProperties.getStaticLocations())).setCachePeriod(this.getSeconds(cachePeriod)).setCacheControl(cacheControl));
 }
 
 }
 }
 
 <div class="hljs-button {2}" data-title="复制"></div></code><div class="hide-preCode-box"><img class="look-more-preCode contentImg-no-view" src="https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/33b8b72b51ec4c3381ede8134ce97fdf.png" alt="" title=""></div><ul class="pre-numbering" style=""><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li><li style="color: rgb(153, 153, 153);">3</li><li style="color: rgb(153, 153, 153);">4</li><li style="color: rgb(153, 153, 153);">5</li><li style="color: rgb(153, 153, 153);">6</li><li style="color: rgb(153, 153, 153);">7</li><li style="color: rgb(153, 153, 153);">8</li><li style="color: rgb(153, 153, 153);">9</li><li style="color: rgb(153, 153, 153);">10</li><li style="color: rgb(153, 153, 153);">11</li><li style="color: rgb(153, 153, 153);">12</li><li style="color: rgb(153, 153, 153);">13</li><li style="color: rgb(153, 153, 153);">14</li><li style="color: rgb(153, 153, 153);">15</li><li style="color: rgb(153, 153, 153);">16</li><li style="color: rgb(153, 153, 153);">17</li><li style="color: rgb(153, 153, 153);">18</li></ul></pre> 
 <ol><li> 由上方代码，所有/webjars/**,下的请求都会去classpath:/META-INF/resources/webjars/中寻找资源 
 <ul><li>webjars：以jar包的方式引入静态资源；</li><li><a href="https://www.webjars.org/">webJars</a></li><li>将常用的前端框架给了一个Maven依赖的方式</li><li>选好要使用的版本，在pom文件中引入即可</li><li>引入后在jar包中，设置中显示隐藏文件夹即可打开，符合映射规则</li></ul> </li><li> 代码中同时设置了缓存时间，缓存时间可以在resourceProperties中设置 
 <ul><li> <pre data-index="41" class="prettyprint"><code class="prism language-java has-numbering" onclick="mdcp.copyCode(event)" style="position: unset;">Duration cachePeriod = this.resourceProperties.getCache().getPeriod();
 <div class="hljs-button {2}" data-title="复制"></div></code><ul class="pre-numbering" style=""><li style="color: rgb(153, 153, 153);">1</li></ul></pre> </li><li> <pre data-index="42" class="prettyprint"><code class="prism language-java has-numbering" onclick="mdcp.copyCode(event)" style="position: unset;">@ConfigurationProperties(
 prefix = "spring.resources",
 ignoreUnknownFields = false
 )
 public class ResourceProperties {
 //可以设置与静态资源有关的参数，缓存时间
 <div class="hljs-button {2}" data-title="复制"></div></code><ul class="pre-numbering" style=""><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li><li style="color: rgb(153, 153, 153);">3</li><li style="color: rgb(153, 153, 153);">4</li><li style="color: rgb(153, 153, 153);">5</li><li style="color: rgb(153, 153, 153);">6</li></ul></pre> </li></ul> </li></ol> 
 <h4><a id="_1414"></a>第二种"/**"访问当前项目的任何资源</h4> 
 <img src="https://img-blog.csdnimg.cn/20200228231443388.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw==,size_16,color_FFFFFF,t_70" alt="在这里插入图片描述"> <img src="https://img-blog.csdnimg.cn/20200228231451954.png" alt="在这里插入图片描述"> <img src="https://img-blog.csdnimg.cn/20200228231500108.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw==,size_16,color_FFFFFF,t_70" alt="在这里插入图片描述"> 
 第二种规则："/**"访问当前项目的任何资源， 
 <pre data-index="43" class="prettyprint"><code class="prism language-java has-numbering" onclick="mdcp.copyCode(event)" style="position: unset;"> String staticPathPattern = this.mvcProperties.getStaticPathPattern();
 if (!registry.hasMappingForPattern(staticPathPattern)) {
 this.customizeResourceHandlerRegistration(registry.addResourceHandler(new String[]{staticPathPattern}).addResourceLocations(WebMvcAutoConfiguration.getResourceLocations(this.resourceProperties.getStaticLocations())).setCachePeriod(this.getSeconds(cachePeriod)).setCacheControl(cacheControl));
 }
 <div class="hljs-button {2}" data-title="复制"></div></code><ul class="pre-numbering" style=""><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li><li style="color: rgb(153, 153, 153);">3</li><li style="color: rgb(153, 153, 153);">4</li></ul></pre> 
 进入getResoutceLocations 
 <pre data-index="44" class="prettyprint"><code class="prism language-java has-numbering" onclick="mdcp.copyCode(event)" style="position: unset;">static String[] getResourceLocations(String[] staticLocations) {
 String[] locations = new String[staticLocations.length + SERVLET_LOCATIONS.length];
 System.arraycopy(staticLocations, 0, locations, 0, staticLocations.length);
 System.arraycopy(SERVLET_LOCATIONS, 0, locations, staticLocations.length, SERVLET_LOCATIONS.length);
 return locations;
 }
 <div class="hljs-button {2}" data-title="复制"></div></code><ul class="pre-numbering" style=""><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li><li style="color: rgb(153, 153, 153);">3</li><li style="color: rgb(153, 153, 153);">4</li><li style="color: rgb(153, 153, 153);">5</li><li style="color: rgb(153, 153, 153);">6</li></ul></pre> 
 查看代码是从其他方法中引入了参数（与1版本不同） 
 返回查看参数的来源 
 <pre data-index="45" class="prettyprint"><code class="prism language-java has-numbering" onclick="mdcp.copyCode(event)" style="position: unset;">getStaticLocations
 <div class="hljs-button {2}" data-title="复制"></div></code><ul class="pre-numbering" style=""><li style="color: rgb(153, 153, 153);">1</li></ul></pre> 
 <pre data-index="46" class="prettyprint"><code class="prism language-java has-numbering" onclick="mdcp.copyCode(event)" style="position: unset;">private static final String[] CLASSPATH_RESOURCE_LOCATIONS = new String[]{"classpath:/META-INF/resources/", "classpath:/resources/", "classpath:/static/", "classpath:/public/"};
 
 <div class="hljs-button {2}" data-title="复制"></div></code><ul class="pre-numbering" style=""><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li></ul></pre> 
 得总结 
 "/**"访问当前项目的任何资源（静态资源文件夹）都会在下方的文件夹中找内容 
 <ul><li>“classpath:/META-INF/resources/”,</li><li>“classpath:/resources/”，非默认的resources,而是新建的resources文件夹</li><li>“classpath:/static/”</li><li>“classpath:/public/”,(默认无，需要新建)</li><li>“/”:当前项目的路径</li></ul> 
 <h3><a name="t65"></a><a id="_1467"></a>欢迎页配置</h3> 
 <pre data-index="47" class="prettyprint"><code class="prism language-java has-numbering" onclick="mdcp.copyCode(event)" style="position: unset;">@Bean
 public WelcomePageHandlerMapping welcomePageHandlerMapping(ApplicationContext applicationContext, FormattingConversionService mvcConversionService, ResourceUrlProvider mvcResourceUrlProvider) {
 WelcomePageHandlerMapping welcomePageHandlerMapping = new WelcomePageHandlerMapping(new TemplateAvailabilityProviders(applicationContext), applicationContext, this.getWelcomePage(), this.mvcProperties.getStaticPathPattern());
 welcomePageHandlerMapping.setInterceptors(this.getInterceptors(mvcConversionService, mvcResourceUrlProvider));
 return welcomePageHandlerMapping;
 }
 <div class="hljs-button {2}" data-title="复制"></div></code><ul class="pre-numbering" style=""><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li><li style="color: rgb(153, 153, 153);">3</li><li style="color: rgb(153, 153, 153);">4</li><li style="color: rgb(153, 153, 153);">5</li><li style="color: rgb(153, 153, 153);">6</li></ul></pre> 
 <pre data-index="48" class="prettyprint"><code class="prism language-java has-numbering" onclick="mdcp.copyCode(event)" style="position: unset;">private Optional<Resource> getWelcomePage() {
 String[] locations = WebMvcAutoConfiguration.getResourceLocations(this.resourceProperties.getStaticLocations());
 return Arrays.stream(locations).map(this::getIndexHtml).filter(this::isReadable).findFirst();
 }
 private Resource getIndexHtml(String location) {
 return this.resourceLoader.getResource(location + "index.html");
 }
 <div class="hljs-button {2}" data-title="复制"></div></code><ul class="pre-numbering" style=""><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li><li style="color: rgb(153, 153, 153);">3</li><li style="color: rgb(153, 153, 153);">4</li><li style="color: rgb(153, 153, 153);">5</li><li style="color: rgb(153, 153, 153);">6</li><li style="color: rgb(153, 153, 153);">7</li></ul></pre> 
 静态资源文件夹下所有index.html页面：被"/**"映射 
 <h3><a name="t66"></a><a id="_1490"></a>图标</h3> 
 所有的**/favicon.ico都是在静态资源环境下找； 
 同时静态资源的位置是可以改变的 
 spring.resources.static-location=位置 
 <h3><a name="t67"></a><a id="3_1498"></a>3、模板引擎</h3> 
 <blockquote> 
 之前多使用jsp页面，可以很方便的嵌入数据等，但SpringBoot 使用嵌入式的tomcat,不支持jsp页面，只能支持HTML, 
 </blockquote> 
 JSP、Velocity、Freemarker、Thymeleaf； 
 模板引擎的作用：在写页面时，将一些数据与渲染数据的模板结合输出，JSP与其他的模板引擎都是这一原理 
 SpringBoot推荐的Thymeleaf； 
 语法更简单，功能更强大； 
 <h4><a id="thymeleaf_1510"></a>引入thymeleaf</h4> 
 <pre data-index="49" class="prettyprint"><code class="has-numbering" onclick="mdcp.copyCode(event)" style="position: unset;">- ````xml
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-thymeleaf</artifactId>
 </dependency>
 ````
 
 - 详情见SpringBoot官网文档
 
 - 布局功能的支持程序 thymeleaf3主程序 layout2以上版本
 <div class="hljs-button {2}" data-title="复制"></div></code><ul class="pre-numbering" style=""><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li><li style="color: rgb(153, 153, 153);">3</li><li style="color: rgb(153, 153, 153);">4</li><li style="color: rgb(153, 153, 153);">5</li><li style="color: rgb(153, 153, 153);">6</li><li style="color: rgb(153, 153, 153);">7</li><li style="color: rgb(153, 153, 153);">8</li><li style="color: rgb(153, 153, 153);">9</li><li style="color: rgb(153, 153, 153);">10</li></ul></pre> 
 <h4><a id="Thymeleaf_1523"></a>Thymeleaf使用&语法</h4> 
 <pre data-index="50" class="set-code-hide prettyprint"><code class="has-numbering" onclick="mdcp.copyCode(event)" style="position: unset;">- 在AutoConf...中有配置类，打开properties有默认自动配置项
 
 - ````java
 private static final Charset DEFAULT_ENCODING;
 public static final String DEFAULT_PREFIX = "classpath:/templates/";
 public static final String DEFAULT_SUFFIX = ".html";
 private boolean checkTemplate = true;
 private boolean checkTemplateLocation = true;
 private String prefix = "classpath:/templates/";
 private String suffix = ".html";
 private String mode = "HTML";
 private Charset encoding;
 private boolean cache;
 private Integer templateResolverOrder;
 private String[] viewNames;
 private String[] excludedViewNames;
 private boolean enableSpringElCompiler;
 private boolean renderHiddenMarkersBeforeCheckboxes;
 private boolean enabled;
 private final ThymeleafProperties.Servlet servlet;
 private final ThymeleafProperties.Reactive reactive;
 //只要我们把HTML文件放在classpath:/templates/，thymeleaf就能自动渲染
 //同时可以在配置文件中修改配置
 ````
 
 - [thymeleaf官网](https://www.thymeleaf.org/)
 
 - [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T6RP63CQ-1675329888395)(image-20191122231053533.png)]
 
 - 现代化java服务端的模板引擎
 
 - [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-K329anbf-1675329888395)(image-20191122231204398.png)]
 
 - 使用
 
 ````ht
 导入开启thymeleaf的语法空间，开启语法提示
 <html lang="en" xmlns:th="http://www.thymeleaf.org">
 
 @RequestMapping("/html")
 public String testHtml(Map<String,Object> map){
 
 map.put("hello", "这是Controller中返回的话");
 return "testPage";
 }
 
 ![newCodeMoreWhite.png][]
 
 * 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
 * 42
 * 43
 * 44
 * 45
 * 46
 * 47
 
 ````html
 <!DOCTYPE html>
 <html lang="en" xmlns:th="http://www.thymeleaf.org">
 <head>
 <meta charset="UTF-8">
 <title>test</title>
 </head>
 <body>
 <h1>这是一个测试文字</h1>
 
 <div th:text="${hello}">这是静态的语句</div>
 </body>
 </html>
 ````
 
 
 
 
 
 
 
 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14
 
 ##### 语法规则 #####
 
 详见官方文档：Attribute Precedence
 
 使用$\{AttributeName\}取值
 
 ###### 1)、th:text 改变当前元素里面的内容 ######
 
 th:任意html属性 替换原生属性的值
 
 ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 13]
 
 ###### 2）表达式 ######
 
 详见thymeleaf文档 expression
 
 Simple expressions:(表达式语法)
 
 ###### Variable Expressions: $\{…\} 获取变量值，OGNL; ######
 
 1. 获取对象的属性、调用方法
 
 1. 使用内置的基本对象
 
 1. \#ctx : the context object.
 2. \#vars: the context variables.
 3. \#locale : the context locale.
 4. \#request : (only in Web Contexts) the HttpServletRequest object.
 5. \#response : (only in Web Contexts) the HttpServletResponse object.
 6. \#session : (only in Web Contexts) the HttpSession object.
 7. \#servletContext : (only in Web Contexts) the ServletContext object.例子：附录中更详细
 8. `Established locale country: US.`
 2. 内置的一些工具对象 
 \#execInfo : information about the template being processed. 
 \#messages : methods for obtaining externalized messages inside variables expressions, in the same way as they would be obtained using \#\{…\} syntax. 
 \#uris : methods for escaping parts of URLs/URIs 
 \#conversions : methods for executing the configured conversion service (if any). 
 \#dates : methods for java.util.Date objects: formatting, component extraction, etc. 
 \#calendars : analogous to 
 \#dates , but for java.util.Calendar objects. \#numbers : methods for formatting numeric objects. 
 \#strings : methods for String objects: contains, startsWith, prepending/appending, etc. 
 \#objects : methods for objects in general. 
 \#bools : methods for boolean evaluation. 
 \#arrays : methods for arrays. 
 \#lists : methods for lists. \#sets : methods for sets. \#maps : methods for maps. 
 \#aggregates : methods for creating aggregates on arrays or collections. 
 \#ids : methods for dealing with id attributes that might be repeated (for example, as a result of an iteration). 
 用法详见附录中的示例 
 Selection Variable Expressions: \*\{…\} 变量的选择表达式，与$\{\}在性质上是一样的，补充：配合th:object 使用
 3. 例子：附录中更详细
 
 ###### Message Expressions: \#\{…\} 获取国际化内容 ######
 
 ###### Link URL Expressions: @\{…\} 定义URL链接 ######
 
 ###### Fragment Expressions: ~\{…\} 插入文档 ######
 
 ###### Literals（字面量） ######
 
 1. Text literals: ‘one text’ , ‘Another one!’ ,…
 2. Number literals: 0 , 34 , 3.0 , 12.3 ,…
 3. Boolean literals: true , false
 4. Null literal: null
 5. Literal tokens: one , sometext , main ,…
 
 ###### Text operations: （文本操作） ######
 
 1. String concatenation: +
 2. Literal substitutions: |The name is $\{name\}|
 
 ###### Arithmetic operations: (数学运算) ######
 
 1. Binary operators: + , - , \* , / , %
 2. Minus sign (unary operator):
 
 ###### Boolean operations: (布尔运算) ######
 
 1. Binary operators: and , or
 2. Boolean negation (unary operator): ! , not
 
 ###### Comparisons and equality:(比较运算) ######
 
 1. Comparators: > , < , >= , <= ( gt , lt , ge , le )
 2. Equality operators: == , != ( eq , ne )
 
 ###### Conditional operators:(条件运算)（三元运算符也支持） ######
 
 1. If-then: (if) ? (then)
 2. If-then-else: (if) ? (then) : (else)
 3. Default: (value) ?: (defaultvalue)
 
 ###### Special tokens:(特殊) ######
 
 1. No-Operation: \_ **不做处理**
 
 OGNL的例子
 /* * Access to properties using the point (.). Equivalent to calling property getters. */ 
 ${
 person.father.name}
 /* * Access to properties can also be made by using brackets ([]) and writing * the name of the property as a variable or between single quotes. */ 
 ${
 person['father']['name']}
 /* * If the object is a map, both dot and bracket syntax will be equivalent to * executing a call on its get(...) method. */ ${
 countriesByCode.ES} ${
 personsByName['Stephen Zucchini'].age}
 /* * Indexed access to arrays or collections is also performed with brackets, * writing the index without quotes. */ ${
 personsArray[0].name}
 /* * Methods can be called, even with arguments. */ ${
 person.createCompleteName()} ${
 person.createCompleteNameWithSeparator('-')}
 
 * 1
 * 2
 * 3
 * 4
 * 5
 * 6
 * 7
 * 8
 * 9
 
 ### 4、SpringMVC自动配置 ###
 
 [SpringBoot官方文档对SpringMVC的介绍][SpringBoot_SpringMVC]
 
 ##### 7.1.1. Spring MVC Auto-configuration #####
 
 Spring Boot provides auto-configuration for Spring MVC that works well with most applications.
 
 The auto-configuration adds the following features on top of Spring’s defaults:
 
 以下是SpringBoot 对SpringMVC的默认配置：
 
 * Inclusion of `ContentNegotiatingViewResolver` and `BeanNameViewResolver` beans.
 
 * 自动配置ViewResolver(视图解析器:根据方法的返回值得到视图对象(View),视图对象决定如何渲染（转发？重定向？）)
 * 如何定制：我们可以自己给容器中添加一个视图解析器；自动的将其整合进来；
 * Support for serving static resources, including support for WebJars (covered [later in this document][])). 静态资源文件夹路径和webjars
 * Automatic registration of `Converter`, `GenericConverter`, and `Formatter` beans.
 
 * 自动注册了`Converter`, `GenericConverter`, and `Formatter` beans
 * `Converter`转换器：SpringMVC中类型转换使用Converter
 * `Formatter`格式化器：2017-11-3–>Date，不同国家的表示不同，按照一定格式转化过来为转化器
 * SpringBoot2.2.0与1版本不同，格式化器通过此方法注入容器
 
 /**
 		在配置文件中配置日期格式化的规则
 		*/
 		@Bean
 public FormattingConversionService mvcConversionService() {
 
 WebConversionService conversionService = new WebConversionService(this.mvcProperties.getDateFormat());
 this.addFormatters(conversionService);
 return conversionService;//日期格式化组件
 }
 
 
 
 
 
 
 
 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9
 * Support for `HttpMessageConverters` (covered [later in this document][later in this document 1]).
 
 * `HttpMessageConverters`:SpringMVC中转换Http请求和响应的；User类->json
 * `HttpMessageConverters`是从容器中确定的；获取所有的HttpMessageConverter;
 * 自己给容器中添加HttpMessageConverter,只需要将自己的组件注册容器中(@Bean、@Component)
 * Automatic registration of `MessageCodesResolver` (covered [later in this document][later in this document 2]).定义错误代码生成规则
 * Static `index.html` support. **静态首页访问**
 * Custom `Favicon` support (covered [later in this document][later in this document 3]).
 * Automatic use of a `ConfigurableWebBindingInitializer` bean (covered [later in this document][later in this document 4]).从容器中取出，故可以自己配一个`ConfigurableWebBindingInitializer`来替换默认的
 
 * 作用：初始化web数据绑定器WebDataBinder
 * 把请求数据绑定到JavaBean中
 
 **org.springframework.boot.autoconfigure.web :web中所有的自动配置**
 
 If you want to keep Spring Boot MVC features and you want to add additional [MVC configuration][] (interceptors, formatters, view controllers, and other features), you can add your own `@Configuration` class of type `WebMvcConfigurer` but **without** `@EnableWebMvc`. If you wish to provide custom instances of `RequestMappingHandlerMapping`, `RequestMappingHandlerAdapter`, or `ExceptionHandlerExceptionResolver`, you can declare a `WebMvcRegistrationsAdapter` instance to provide such components.
 
 If you want to take complete control of Spring MVC, you can add your own `@Configuration` annotated with `@EnableWebMvc`.
 
 #### 扩展SpringMVC ####
 
 参考：
 
 If you want to keep Spring Boot MVC features and you want to add additional [MVC configuration][] (interceptors, formatters, view controllers, and other features), you can add your own `@Configuration` class of type `WebMvcConfigurer` but **without** `@EnableWebMvc`. If you wish to provide custom instances of `RequestMappingHandlerMapping`, `RequestMappingHandlerAdapter`, or `ExceptionHandlerExceptionResolver`, you can declare a `WebMvcRegistrationsAdapter` instance to provide such components.
 
 **编写一个配置类(@Configuration),是`WebMvcConfigurer`类型；不能标注@EnableWebMvc**
 
 * WebMvcConfigurer是SpringMVC的自动配置类
 * 在做其他自动配置的时候会导入@Import(EnableWebMvcConfiguration.class)
 * EnableWebMvcConfiguration继承DelegationWebMvcConfiguration，从容器中获取所有的WebMvcConfigure一起来起作用
 * 容器中所有的WebMvcConfigure都会起作用
 * 我们的配置类也会起作用
 
 #### 全面接管SpringMVC ####
 
 If you want to take complete control of Spring MVC, you can add your own `@Configuration` annotated with `@EnableWebMvc`.
 
 SpringBoot对MVC的自动配置不再需要，所有内容都是自己来配；
 
 add your own `@Configuration` annotated with `@EnableWebMvc`.
 
 效果：所有的SpringMVC的自动配置都失效了
 
 原理：
 
 * 自动配置类是@ConditionOnMissingBean判断是否自动配置的
 * 使用了这个注解将引入该类，导致判断为容器中已经存在配置类，自动配置失效
 
 源码的原理与SpringMVC中相同，不再编写
 
 ### 5、如何修改SpringBoot的默认配置 ###
 
 模式
 
 1）由于SpringBoot大量使用了Condition注解，SpringBoot在自动配置很多组件的时候，先看容器中有没有这个组件（通常为用户自己配置的@Bean@Component）,若没有，再进行自动配置；如果有些组件可以有多个（如ViewResolver）将用户的配置和自己的默认组合起来
 
 2）在SpringBoot 中会有非常多的xxxxConfigure帮助我们进行扩展配置
 
 3）在SpringBoot中会有很多的xxxCustomizer帮助我们进行定制配置
 
 ### 6、RestfulCRUD ###
 
 #### 1）、设置默认访问首页 ####
 
 1. 将页面命名为index.html置于"classpath:/META-INF/resources/", “classpath:/resources/”, “classpath:/static/”, "classpath:/public/"目录下
 2. 编写Handler拦截路径"/“和”/index.html"返回到指定的视图
 3. 
 4. 在一个 WebMvcConfigurerAdapter（已经过时）中编写一个addViewControllers完成一个视图映射
 
 * [相关解决链接][Link 2]
 * 新方法继承WebMvcConfigurer接口，需要@Bean注册到容器（@Configuration中包含了@Bean)
 * package com.jirath.springboot_learn.config;
 
 import com.jirath.springboot\_learn.service.HelloService; 
 import org.springframework.context.annotation.Bean; 
 import org.springframework.context.annotation.Configuration; 
 import org.springframework.web.servlet.config.annotation.ViewControllerRegistry; 
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
 /\*\*
 
 * ‘@Configuration’ point out that current object is a Configuration Class,which used to replace the Spring Configuration file before. 
 */ 
 @Configuration 
 public class MyConfig implements WebMvcConfigurer \{ 
 /*\*
 
 * add current function’s returned value to the ContextContainer,
 * the id of the module in this ContextContainer is the name of function;
 * @return the object which used to build a Bean 
 \*/ 
 @Bean 
 public HelloService helloService()\{ 
 return new HelloService(); 
 \}
 
 /\*\* 
 在这里编写一个ViewController 
 \*/ 
 @Override 
 public void addViewControllers(ViewControllerRegistry registry) \{ 
 registry.addViewController(“/”).setViewName(“index”); 
 registry.addViewController(“/index.html”).setViewName(“index”); 
 \} 
 \}
 
 ![newCodeMoreWhite.png][]
 
 * 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
 
 #### 2）、国际化 ####
 
 ###### SprigMVC的情况 ######
 
 1. 编写国际化配置文件
 2. 使用ResourceBundleMessageSource管理国际化资源文件
 3. 在页面使用fmt:message取出国际化内容
 
 ###### SpringBoot模式 ######
 
 步骤：
 
 1. 编写国际化配置文件，抽取页面需要显示的国际化信息
 
 * 新建文件夹，新建文件 页面\_国家代码.properties
 * idea可以自动识别国际化配置文件，可以快速新建文件，如下图
 * 在idea的国际化视图中编写属性
 2. SpringBoot自动配置好了管理国际化资源文件的组件
 
 * MessageSourceAutoConfiguration
 * @Configuration(
 proxyBeanMethods = false
 )
 @ConditionalOnMissingBean(
 name = {
 "messageSource"},
 search = SearchStrategy.CURRENT
 )
 @AutoConfigureOrder(-2147483648)
 @Conditional({
 MessageSourceAutoConfiguration.ResourceBundleCondition.class})
 @EnableConfigurationProperties
 public class MessageSourceAutoConfiguration {
 
 private static final Resource[] NO_RESOURCES = new Resource[0];
 public MessageSourceAutoConfiguration() {
 }
 
 @Bean
 @ConfigurationProperties(
 prefix = "spring.messages"
 )
 public MessageSourceProperties messageSourceProperties() {
 return new MessageSourceProperties();
 }
 
 @Bean
 public MessageSource messageSource(MessageSourceProperties properties) {
 ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
 if (StringUtils.hasText(properties.getBasename())) {
 //设置国际化管理的基础名（去掉语言，国家代码的）
 messageSource.setBasenames(StringUtils.commaDelimitedListToStringArray(StringUtils.trimAllWhitespace(properties.getBasename())));
 }
 
 if (properties.getEncoding() != null) {
 messageSource.setDefaultEncoding(properties.getEncoding().name());
 }
 
 messageSource.setFallbackToSystemLocale(properties.isFallbackToSystemLocale());
 Duration cacheDuration = properties.getCacheDuration();
 if (cacheDuration != null) {
 messageSource.setCacheMillis(cacheDuration.toMillis());
 }
 
 messageSource.setAlwaysUseMessageFormat(properties.isAlwaysUseMessageFormat());
 messageSource.setUseCodeAsDefaultMessage(properties.isUseCodeAsDefaultMessage());
 return messageSource;
 }
 
 //我们的配置文件可以直接放在类路径下叫messages.properties;
 protected static class ResourceBundleCondition extends SpringBootCondition {
 private static ConcurrentReferenceHashMap<String, ConditionOutcome> cache = new ConcurrentReferenceHashMap();
 
 protected ResourceBundleCondition() {
 }
 
 public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
 String basename = context.getEnvironment().getProperty("spring.messages.basename", "messages");
 ConditionOutcome outcome = (ConditionOutcome)cache.get(basename);
 if (outcome == null) {
 outcome = this.getMatchOutcomeForBasename(context, basename);
 cache.put(basename, outcome);
 }
 
 return outcome;
 }
 
 private ConditionOutcome getMatchOutcomeForBasename(ConditionContext context, String basename) {
 Builder message = ConditionMessage.forCondition("ResourceBundle", new Object[0]);
 String[] var4 = StringUtils.commaDelimitedListToStringArray(StringUtils.trimAllWhitespace(basename));
 int var5 = var4.length;
 
 for(int var6 = 0; var6 < var5; ++var6) {
 String name = var4[var6];
 Resource[] var8 = this.getResources(context.getClassLoader(), name);
 int var9 = var8.length;
 
 for(int var10 = 0; var10 < var9; ++var10) {
 Resource resource = var8[var10];
 if (resource.exists()) {
 return ConditionOutcome.match(message.found("bundle").items(new Object[]{resource}));
 }
 }
 }
 
 return ConditionOutcome.noMatch(message.didNotFind("bundle with basename " + basename).atAll());
 }
 
 private Resource[] getResources(ClassLoader classLoader, String name) {
 String target = name.replace('.', '/');
 
 try {
 return (new PathMatchingResourcePatternResolver(classLoader)).getResources("classpath*:" + target + ".properties");
 } catch (Exception var5) {
 return MessageSourceAutoConfiguration.NO_RESOURCES;
 }
 }
 }
 
 \}
 
 ![newCodeMoreWhite.png][]
 
 * 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
 * 42
 * 43
 * 44
 * 45
 * 46
 * 47
 * 48
 * 49
 * 50
 * 51
 * 52
 * 53
 * 54
 * 55
 * 56
 * 57
 * 58
 * 59
 * 60
 * 61
 * 62
 * 63
 * 64
 * 65
 * 66
 * 67
 * 68
 * 69
 * 70
 * 71
 * 72
 * 73
 * 74
 * 75
 * 76
 * 77
 * 78
 * 79
 * 80
 * 81
 * 82
 * 83
 * 84
 * 85
 * 86
 * 87
 * 88
 * 89
 * 90
 * 91
 * 92
 * 93
 * 94
 * 95
 * 96
 * 97
 * 98
 * 去页面获取国际化的值；
 
 1. 利用thymeleaf模板引擎，标准语法中的messages
 2. \#\{\}获取国际化信息，\#\{配置的文件头(默认为message).属性\}
 * ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 14] 
 ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 15]
 
 ###### 原理 ######
 
 国际

[Spring Boot]: https://spring.io/projects/spring-boot#learn
[Link 1]: https://so.csdn.net/so/search?q=%E5%BE%AE%E6%9C%8D%E5%8A%A1&spm=1001.2101.3001.7020
[Martin Fowler_microservices]: https://martinfowler.com/microservices/
[Microservices]: https://so.csdn.net/so/search?q=Microservices&spm=1001.2101.3001.7020
[Maven]: https://so.csdn.net/so/search?q=Maven&spm=1001.2101.3001.7020
[newCodeMoreWhite.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/33b8b72b51ec4c3381ede8134ce97fdf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/315c837f11624ec9bfecf5e9c73bb101.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/a89d2392e713450bb6b79ea2a10b3675.png
[20200228230429605.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/aaba0c9e77ec44a0aa6acaa0e5148a67.png
[20200228230445671.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/b92e12609f3a4376bb3853079cdb6ac8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/7c19dedf002a47579629eeb8a240762b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/908b76ab6be04d358eda7b494a2630ba.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/9ef5653cc6f9496290beee41600c2a58.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/92661466c4ab45459aa341dcc5b50a55.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/3732088440104a75a320e4abdd4a3fe7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/92a21ea4466f4899bcd303b20be9da58.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/011e3068711c4452b0b1fc38d3bde39d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 9]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/2ad4902bcfb044a488ae213e04c61261.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 10]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/355d0f6773234d1f8cacd05bdbddc7e1.png
[CSDN]: https://blog.csdn.net/weixin_44494373/article/details/102779187
[Spring boot _Validated_Valid]: https://blog.csdn.net/MR_L_0927/article/details/84784482
[Validated]: https://blog.csdn.net/qq_19663899/article/details/79386043
[SpringBoot_PropertySource _properties_yaml_yml]: https://blog.csdn.net/liusf1993/article/details/87889868
[20200228230812142.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/01432072f8f64498973ffc25ca973a0e.png
[20200228230832293.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/87bd6f3143b34f9a9c67231b67385bfe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 11]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/4a8ff23c6c3f4a749b463dadc171b0c7.png
[20200228230947142.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/d92af98eeb3f49f4be0c52b758749f6b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 12]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/1d0806e85011495681e9d08dab15c6f8.png
[image-20191109135006909]: 
[Spring Boot 1]: https://docs.spring.io/spring-boot/docs/2.2.2.BUILD-SNAPSHOT/reference/html/spring-boot-features.html#boot-features-external-config
[Spring Boot 2]: https://docs.spring.io/spring-boot/docs/2.2.2.BUILD-SNAPSHOT/reference/html/appendix-application-properties.html#common-application-properties
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 13]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/cd1a55189e1b41bc943db5fc0a410aa6.png
[SpringBoot_SpringMVC]: https://docs.spring.io/spring-boot/docs/2.2.2.BUILD-SNAPSHOT/reference/html/spring-boot-features.html#boot-features-developing-web-applications
[later in this document]: https://docs.spring.io/spring-boot/docs/2.2.2.BUILD-SNAPSHOT/reference/html/spring-boot-features.html#boot-features-spring-mvc-static-content
[later in this document 1]: https://docs.spring.io/spring-boot/docs/2.2.2.BUILD-SNAPSHOT/reference/html/spring-boot-features.html#boot-features-spring-mvc-message-converters
[later in this document 2]: https://docs.spring.io/spring-boot/docs/2.2.2.BUILD-SNAPSHOT/reference/html/spring-boot-features.html#boot-features-spring-message-codes
[later in this document 3]: https://docs.spring.io/spring-boot/docs/2.2.2.BUILD-SNAPSHOT/reference/html/spring-boot-features.html#boot-features-spring-mvc-favicon
[later in this document 4]: https://docs.spring.io/spring-boot/docs/2.2.2.BUILD-SNAPSHOT/reference/html/spring-boot-features.html#boot-features-spring-mvc-web-binding-initializer
[MVC configuration]: https://docs.spring.io/spring/docs/5.2.2.BUILD-SNAPSHOT/spring-framework-reference/web.html#mvc
[Link 2]: https://blog.csdn.net/u012862619/article/details/81559351
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 14]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/2f7375f226e8421abe43570209290a7e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ5NDM3Mw_size_16_color_FFFFFF_t_70 15]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/f8153c8501af4c08b13721d27a0206da.png