SpringBoot2 核心技术与响应式编程](https://www.yuque.com/atguigu/springboot)

一、SpringBoot 是什么

1、为什么要用 SpringBoot

• Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can “just run”.
  • 能快速创建出生产级别的 Spring 应用。

1.1、Spring的能力

1.2、Spring的生态

https://spring.io/projects/spring-boot

覆盖了：

web开发

数据访问

安全控制

分布式

消息服务

移动开发

批处理

……

1.3、Spring5重大升级

1.3.1、响应式编程

1.3.2、内部源码设计

基于Java8的一些新特性，如：接口默认实现。重新设计源码架构。

2、SpringBoot 优点

• Create stand-alone Spring applications
  • 创建独立 Spring 应用
• Embed Tomcat, Jetty or Undertow directly (no need to deploy WAR files)
  • 内嵌 Web 服务器（默认使用 Tomcat）
• Provide opinionated ‘starter’ dependencies to simplify your build configuration
  • 自动starter依赖，简化构建配置
• Automatically configure Spring and 3rd party libraries whenever possible
  • 自动配置 Spring 以及第三方功能
• Provide production-ready features such as metrics, health checks, and externalized configuration
  • 提供生产级别的监控、健康检查及外部化配置
• Absolutely no code generation and no requirement for XML configuration
  • 无代码生成、无需编写 XML

SpringBoot 是整合 Spring 技术栈的一站式框架。

SpringBoot 是简化 Spring 技术栈的快速开发脚手架。

3、SpringBoot 缺点

• 迭代快，需要时刻关注版本变化。
• 封装太深，内部原理复杂，不容易精通。

4、微服务

James Lewis and Martin Fowler (2014) 提出微服务完整概念。

In short, the microservice architectural style is an approach to developing a single application as a suite of small services, each running in its own process and communicating with lightweight mechanisms, often an HTTP resource API. These services are built around business capabilities and independently deployable by fully automated deployment machinery. There is a bare minimum of centralized management of these services, which may be written in different programming languages and use different data storage technologies.— James Lewis and Martin Fowler (2014)

• 微服务是一种架构风格
• 一个应用拆分为一组小型服务
• 每个服务运行在自己的进程内，也就是可独立部署和升级
• 服务之间使用轻量级 HTTP 交互
• 服务围绕业务功能拆分
• 可以由全自动部署机制独立部署
• 去中心化，服务自治。服务可以使用不同的语言、不同的存储技术

5、分布式

分布式的困难

• 配置管理
• 服务发现
• 远程调用
• 负载均衡
• 服务容错
• 服务监控
• 链路追踪
• 日志管理
• 任务调度
• ……

分布式的解决

• SpringBoot + SpringCloud

6、云原生（Cloud Native）

原生应用如何上云。

上云的困难

• 服务自愈
• 弹性伸缩
• 服务隔离
• 自动化部署
• 灰度发布
• 流量治理
• ……

上云的解决

• Docker 容器化技术
• Kubernetes 容器编排，简称 k8s
• DevOps，企业 CI/CD，构建企业云平台
• 拥抱新一代架构 Service Mesh 与 Serverless

7、如何学习SpringBoot

7.1、官网文档架构

查看版本新特性；

https://github.com/spring-projects/spring-boot/wiki#release-notes

二、基础入门

1、环境准备

参照官方帮助文档配置：

• Java 8 及以上。
• Maven 3.3+：项目管理工具，可以对 Java 项目进行构建、依赖管理。
  • pom.xml 按照官方帮助文档设定。
• Gradle 6.x：基于 Apache Ant 和 Apache Maven 概念的项目自动化构建开源工具。它使用一种基于 Groovy 的特定领域语言(DSL)来声明项目设置，目前也增加了基于 Kotlin 语言的 kotlin-based DSL，抛弃了基于 XML 的各种繁琐配置。
• SpringBoot CLI：命令行工具，用于使用 Spring 进行快速原型搭建。它允许你运行 Groovy 脚本，这意味着你可以使用类 Java 的语法，并且没有那么多的模板代码。
• IntellIJ IDEA： 微云上下载。

1.1 Maven 设置

给 Maven 的 settings.xml 中添加默认 JDK 版本以及默认 UTF-8 编码。

<mirrors>
      <mirror>
        <id>nexus-aliyun</id>
        <mirrorOf>central</mirrorOf>
        <name>Nexus aliyun</name>
        <url>http://maven.aliyun.com/nexus/content/groups/public</url>
      </mirror>
  </mirrors>
  <profiles>
         <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.compiler.target>
                <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
              </properties>
         </profile>
  </profiles>

1.2 IDEA 设置

将 Maven 整合进来，IDEA 中 设置 和 新项目设置 中的 Maven 都要设定。

2、HelloWorld

功能：浏览器发送/hello请求，服务器接受请求并处理，响应 Hello World 字符串。

2.1 创建一个 Maven 工程

新建一个名为 spring-boot-01-helloworld 的 Maven 工程。

2.2 导入 SpringBoot 相关的依赖

pom.xml 中加入 SpringBoot 依赖。

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

2.3 编写主程序 MainApplication

src\main\java 下新建一个 com.atguigu.HelloWorldMainApplication类。

/**
 * 主程序类
 * @SpringBootApplication：这是一个SpringBoot应用
 */
@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
        SpringApplication.run(MainApplication.class,args);
    }
}

2.4 编写 Controller、Service

src\main\java 下新建一个 controller.HelloController 类。

@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String handle01(){
        return "Hello, Spring Boot 2!";
    }
}

2.5 运行主程序测试

Ctrl+F5 运行 HelloWorldMainApplication。

2.6、简化配置

application.properties

server.port=8888

2.7 简化部署

 <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

把项目打成jar包，直接在目标服务器执行即可。

注意点：

• 取消掉cmd的快速编辑模式

3、Hello World探究

3.1 POM文件

3.1.1 父项目

项目下的 pom.xml：

<parent>
    <groupId>org.springframework.boot</groupId>
    <!-- SpringBoot 的版本仲裁中心 -->
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.6.RELEASE</version>
</parent>

spring-boot-starter-parent 包下的 spring-boot-starter-parent-a.b.c.pom（a.b.c 就是上面 pom.xml 中的版本号，本文是 2.2.6）：

<!-- 管理SpringBoot应用里面的所有默认依赖版本 -->
<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-dependencies</artifactId>
  <version>2.2.6.RELEASE</version>
  <relativePath>../../spring-boot-dependencies</relativePath>
</parent>

以后我们导入默认依赖是不需要写版本号的（没有在 dependencies 里面管理的依赖需要声明版本号）。

3.1.2 启动器

<dependency>
    <groupId>org.springframework.boot</groupId>
    <!-- Web 应用开发场景 -->
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

spring-boot-starter-*：SpringBoot 官方场景启动器，会导入相关开发场景所需的所有依赖。

**-spring-boot-starter：自定义的场景启动器。

SpringBoot 将所有的功能场景都抽取出来，做成一个个的 starter（启动器），只需要在项目里面引入这些 starter，相关场景的所有依赖都会导入进来。要用什么功能就导入什么场景的启动器，引入之后记得点击编辑区右上角的 m 图标，来下载这些依赖。

SpringBoot 支持的所有场景。

3.2 主程序类

/**
 *  SpringBootApplication 标注一个主程序类，说明这是一个SpringBoot应用
 */
@SpringBootApplication
public class HelloWorldMainApplication {
    public static void main(String[] args) {
        // 启动Spring应用
        SpringApplication.run(HelloWorldMainApplication.class, args);
    }
}

@SpringBootApplication：标注在某个类上说明这个类是 SpringBoot 的主配置类，SpringBoot 就应该运行这个类的 main() 方法来启动 SpringBoot 应用。

4、快速创建 SpringBoot 项目

4.1 IDEA：使用 Spring Initializer 快速创建项目

项目类型选择 Spring Initializr，修改完组（公司名）、工件（项目名）和Java版本后，选择我们需要的模块（如 Spring Web），向导会联网创建 SpringBoot 项目并下载到本地。

• 主程序已经生成好了，只需编写自己的业务代码。
• resources文件夹中目录结构
  • static：静态资源， js、css、images。
  • templates：模板页面（SpringBoot 默认默认不支持 jsp 页面），可以使用模板引擎（FreeMarker、Thymeleaf）。
  • application.properties：配置文件，可以修改一些默认设置。

4.2 Eclipse：使用 STS 快速创建项目

三、容器功能

1、配置文件

SpringBoot 使用一个全局的配置文件，配置文件名是固定的。

• application.properties
• application.yml 或 application.yaml（建议使用）

配置文件的作用：修改 SpringBoot 自动配置的默认值。

YAML（YAML Ain’t Markup Language）

YAML  A Markup Language：是一种**标记语言**
YAML  isn't Markup Language：不是一种标记语言
Yet another  Markup Language：仍是一种标记语言

优点：没有额外的定界符，更轻量，更易读。

2、YAML语法

2.1 基本语法

• key: value -> value 前面一定要有空格
• 大小写敏感
• 使用缩进表示层级关系
• 缩进不允许使用tab，只允许空格
• 缩进的空格数不重要，只要相同层级的元素左对齐即可
• # 表示注释

server:
    port: 8081
    path: /hello

2.2 值的写法

2.2.1 字面量

普通的值（数字，字符串，布尔值）

`k: v`
    字符串默认不用加上单引号或者双引号。
    ""：双引号。**不会转义**字符串里面的特殊字符，特殊字符会作为本身想表示的意思。
            `name: "zhangsan \n lisi"`    输出：**zhangsan** **换行**  **lisi**
    ''：单引号。**会转义**特殊字符，特殊字符最终只是一个普通的字符串数据。
            `name: 'zhangsan \n lisi'`    输出：**zhangsan** **\n**  **lisi**

2.2.2 对象、Map

（属性和值、键值对）

`k: v` 在下一行来写对象的属性和值的关系，注意缩进。
    对象还是 `k: v` 的方式：

friends:
    lastName: zhangsan
    age: 20

    行内写法：

friends: {lastName: zhangsan,age: 18}

2.2.3 数组（List、Set）

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

pets: - cat - dog - pig

行内写法：

pets: [cat, dog, pig]yaml

3、配置文件值注入

配置文件 application.yml：

person:  userName: zhangsan  boss: false  birth: 2019/12/12 20:12:33  age: 18  pet:     name: tomcat    weight: 23.4  interests: [篮球,游泳]  animal:     - jerry    - mario  score:    english:       first: 30      second: 40      third: 50    math: [131,140,148]    chinese: {first: 128,second: 136}  salarys: [3999,4999.98,5999.99]  allPets:    sick:      - {name: tom}      - {name: jerry,weight: 47}    health: [{name: mario,weight: 47}]

JavaBean：

/**
 * @ConfigurationProperties：告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定。
 */
@Component // 只有将组件注册到容器中，才能使用容器提供的ConfigurationProperties功能。
@ConfigurationProperties(prefix = "person") // 映射到配置文件中的person属性。
@Data
public class Person {
  private String userName;
  private Boolean boss;
  private Date birth;
  private Integer age;
  private Pet pet;
  private String[] interests;
  private List<String> animal;
  private Map<String, Object> score;
  private Set<Double> salarys;
  private Map<String, List<Pet>> allPets;
}
@Data
public class Pet {
  private String name;
  private Double weight;
}

自定义的类和配置文件绑定一般没有提示，我们可以导入配置文件处理器。

<!-- 导入配置文件处理器，配置文件进行绑定就会有提示 --><dependency>    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-configuration-processor</artifactId>    <optional>true</optional></dependency>

3.1 配置文件的坑

3.1.1 中文乱码

application.properties 配置中文值的时候，读取出来的属性值会出现乱码问题。但是 application.yml 不会出现乱码问题。原因是，Spring Boot 是以 ISO-8859-1 的编码方式读取 application.properties 配置文件。

3.1.2 加载顺序

Java 的 Properties 加载属性文件后是无法保证输出的顺序与文件中一致的，因为 Properties 是继承自 Hashtable 的， key/value 都是直接存在 Hashtable 中的，而 Hashtable 是不保证进出顺序的。

所以如果需要属性保持有序，请使用 application.yml。

3.1.3 用户名

如果定义一个键值对 user.name=xxx , 这里会读取不到对应写的属性值。为什么呢？SpringBoot 的默认 StandardEnvironment 首先将会加载 systemEnvironment 作为首个 PropertySource。而 source 即为 System.getProperties()，按照读取顺序，返回 systemEnvironment 的值即 System.getProperty("user.name")，Mac 电脑会读取自己的登录账号。

3.3 @Value和@ConfigurationProperties比较

无论配置文件是 yml 还是 properties 他们都能获取到值。

如果说，我们只是在某个业务逻辑中需要获取一下配置文件中的某项值，使用 @Value。

如果说，我们专门编写了一个 JavaBean 来和配置文件进行映射，我们就直接使用@ConfigurationProperties。

4、输入数据校验

@Component
@ConfigurationProperties(prefix = "person")
@Validated // 启用数据校验
public class Person {
    /**
     * <bean class="Person">
     *      <property name="lastName" value="字面量/${key}从环境变量、配置文件中获取值/#{SpEL}"></property>
     * <bean/>
     */
    // lastName必须是邮箱格式
    @Email
    // @Value("${person.last-name}")
    private String lastName;
    // @Value("#{11*2}")
    private Integer age;
    // @Value("true")
    private Boolean boss;
    private Date birth;
    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;

5、加载配置文件

5.1 @PropertySource

加载指定的 properties 配置文件。

/**
 * @ConfigurationProperties：告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定。
 */
@Component // 只有将组件注册到容器中，才能使用容器提供的ConfigurationProperties功能。
@PropertySource(value = {"classpath:person.properties"}) // 指定加载配置文件person.properties。
@ConfigurationProperties(prefix = "person") // 映射到配置文件中的person属性。
//@Validated
public class Person {
    /**
     * <bean class="Person">
     *      <property name="lastName" value="字面量/${key}从环境变量、配置文件中获取值/#{SpEL}"></property>
     * <bean/>
     */
   //lastName必须是邮箱格式
   // @Email
    //@Value("${person.last-name}")
    private String lastName;
    //@Value("#{11*2}")
    private Integer age;
    //@Value("true")
    private Boolean boss;

5.2 @ImportResource

为了兼容 Spring 应用，导入 Spring 的 xml 配置文件，让配置文件里面的内容生效。

@ImportResource(locations = {"classpath:beans.xml"}) // 导入Spring的配置文件@SpringBootApplicationpublic class SpringBoot02ConfigApplication {

beans.xml：

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">    <bean id="helloService" class="com.atguigu.springboot.service.HelloService"></bean></beans>

SpringBoot 推荐给容器中添加组件的方式。推荐使用全注解的方式：

1、配置类 @Configuration Spring 配置文件

2、使用 @Bean 给容器中添加组件

3、组件注解：@Component、@Controller、@Service、@Repository

/**
 * @Configuration指明当前类是一个配置类，替代Spring配置文件。
 * 在配置文件中是使用<bean></bean>标签添加组件。
 */
@Configuration
public class MyAppConfig {
    // 将方法的返回值添加到容器中，容器中这个组件默认的ID就就是方法名
    @Bean
    public HelloService helloService() {
        System.out.println("配置类使用@Bean给容器中添加组件");
        return new HelloService();
    }
}

6、配置文件占位符

6.1 随机数

${random.uuid}、${random.value}、${random.int}、${random.long}${random.int(10)}、${random.int[1024,65536]}

6.2 使用占位符

占位符获取之前配置的值，可以使用 : 指定默认值。

person.last-name=王五${random.uuid}person.age=${random.int}person.birth=2020/04/18person.boss=falseperson.maps.k11=v11person.maps.k22=v22person.lists=a,b,cperson.dog.name=${person.hello:hello}_小黑person.dog.age=2

7、Profile

7.1 多 Profile 文件

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

默认使用 application.properties 的配置。

7.2 yml 支持多文档块方式

server:  port: 8081spring:  profiles:    active: dev---# 文档块2server:  port: 8083spring:  profiles: dev---# 文档块3server:  port: 8084spring:  profiles: prod

7.3 激活指定 Profile

1、在 **application.properties** 配置文件中指定：

spring.profiles.active=dev

2、命令行：

java -jar spring-boot-02-config-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev

可以直接在测试的时候，配置传入命令行参数。

3、虚拟机参数：

-Dspring.profiles.active=dev

8、配置文件加载位置

SpringBoot 启动会扫描以下位置的 application.properties 或者 application.yml 文件作为 SpringBoot 的默认配置文件。

当前工程根目录和 resources 文件夹下：

/config/

/

优先级由高到底，高优先级的配置会覆盖低优先级的配置。

SpringBoot 会从这四个位置全部加载主配置文件，共同起作用形成互补配置。

我们还可以通过 spring.config.location 来改变默认的配置文件位置。

项目打包好以后，我们可以使用命令行参数的形式，启动项目的时候来指定配置文件的新位置。

指定配置文件和默认加载的这些配置文件共同起作用形成互补配置。

java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --spring.config.location=D:/application.properties

多个配置用空格分开，—配置项=值。

SpringBoot 也可以从外部加载配置。

9、了解自动配置原理

1、SpringBoot特点

1.1、依赖管理

• 父项目做依赖管理

依赖管理    
<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
</parent>
他的父项目
 <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.3.4.RELEASE</version>
  </parent>
几乎声明了所有开发中常用的依赖的版本号,自动版本仲裁机制

• 开发导入starter场景启动器

1、见到很多 spring-boot-starter-* ： *就某种场景
2、只要引入starter，这个场景的所有常规需要的依赖我们都自动引入
3、SpringBoot所有支持的场景
https://docs.spring.io/spring-boot/docs/current/reference/html/using-spring-boot.html#using-boot-starter
4、见到的  *-spring-boot-starter： 第三方为我们提供的简化开发的场景启动器。
5、所有场景启动器最底层的依赖
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter</artifactId>
  <version>2.3.4.RELEASE</version>
  <scope>compile</scope>
</dependency>

• 无需关注版本号，自动版本仲裁

1、引入依赖默认都可以不写版本
2、引入非版本仲裁的jar，要写版本号。

• 可以修改默认版本号

1、查看spring-boot-dependencies里面规定当前依赖的版本 用的 key。
2、在当前项目里面重写配置
    <properties>
        <mysql.version>5.1.43</mysql.version>
    </properties>

1.2、自动配置

• 自动配好Tomcat
• • 引入Tomcat依赖。
  • 配置Tomcat

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-tomcat</artifactId>
      <version>2.3.4.RELEASE</version>
      <scope>compile</scope>
    </dependency>

• 自动配好SpringMVC
• • 引入SpringMVC全套组件
  • 自动配好SpringMVC常用组件（功能）
• 自动配好Web常见功能，如：字符编码问题
• • SpringBoot帮我们配置好了所有web开发的常见场景
• 默认的包结构
• • 主程序所在包及其下面的所有子包里面的组件都会被默认扫描进来
  • 无需以前的包扫描配置
• • 想要改变扫描路径，@SpringBootApplication(scanBasePackages=“com.atguigu”)
• • • 或者@ComponentScan 指定扫描路径

@SpringBootApplication
等同于
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com.atguigu.boot")

• 各种配置拥有默认值
• • 默认配置最终都是映射到某个类上，如：MultipartProperties
  • 配置文件的值最终会绑定每个类上，这个类会在容器中创建对象
• 按需加载所有自动配置项
• • 非常多的starter
  • 引入了哪些场景这个场景的自动配置才会开启
• • SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面
  • 
    
• ……

2、容器功能

2.1、组件添加

1、@Configuration

• 基本使用
• Full模式与Lite模式
• • 示例
  • 最佳实战
• • • 配置 类组件之间无依赖关系用Lite模式加速容器启动过程，减少判断
    • 配置类组件之间有依赖关系，方法会被调用得到之前单实例组件，用Full模式

#############################Configuration使用示例######################################################
/**
 * 1、配置类里面使用@Bean标注在方法上给容器注册组件，默认也是单实例的
 * 2、配置类本身也是组件
 * 3、proxyBeanMethods：代理bean的方法
 *      Full(proxyBeanMethods = true)、【保证每个@Bean方法被调用多少次返回的组件都是单实例的】
 *      Lite(proxyBeanMethods = false)【每个@Bean方法被调用多少次返回的组件都是新创建的】
 *      组件依赖必须使用Full模式默认。其他默认是否Lite模式
 *
 *
 *
 */
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
public class MyConfig {
    /**
     * Full:外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
     * @return
     */
    @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public User user01(){
        User zhangsan = new User("zhangsan", 18);
        //user组件依赖了Pet组件
        zhangsan.setPet(tomcatPet());
        return zhangsan;
    }
    @Bean("tom")
    public Pet tomcatPet(){
        return new Pet("tomcat");
    }
}
################################@Configuration测试代码如下########################################
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com.atguigu.boot")
public class MainApplication {
    public static void main(String[] args) {
        //1、返回我们IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
        //2、查看容器里面的组件
        String[] names = run.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
        //3、从容器中获取组件
        Pet tom01 = run.getBean("tom", Pet.class);
        Pet tom02 = run.getBean("tom", Pet.class);
        System.out.println("组件："+(tom01 == tom02));
        //4、com.atguigu.boot.config.MyConfig$$EnhancerBySpringCGLIB$$51f1e1ca@1654a892
        MyConfig bean = run.getBean(MyConfig.class);
        System.out.println(bean);
        //如果@Configuration(proxyBeanMethods = true)代理对象调用方法。SpringBoot总会检查这个组件是否在容器中有。
        //保持组件单实例
        User user = bean.user01();
        User user1 = bean.user01();
        System.out.println(user == user1);
        User user01 = run.getBean("user01", User.class);
        Pet tom = run.getBean("tom", Pet.class);
        System.out.println("用户的宠物："+(user01.getPet() == tom));
    }
}

2、@Bean、@Component、@Controller、@Service、@Repository

3、@ComponentScan、@Import

 * 4、@Import({User.class, DBHelper.class})
 *      给容器中自动创建出这两个类型的组件、默认组件的名字就是全类名
 *
 *
 *
 */
@Import({User.class, DBHelper.class})
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
public class MyConfig {
}

@Import 高级用法： https://www.bilibili.com/video/BV1gW411W7wy?p=8

4、@Conditional

条件装配：满足Conditional指定的条件，则进行组件注入

=====================测试条件装配==========================
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
//@ConditionalOnBean(name = "tom")
@ConditionalOnMissingBean(name = "tom")
public class MyConfig {
    /**
     * Full:外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
     * @return
     */
    @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public User user01(){
        User zhangsan = new User("zhangsan", 18);
        //user组件依赖了Pet组件
        zhangsan.setPet(tomcatPet());
        return zhangsan;
    }
    @Bean("tom22")
    public Pet tomcatPet(){
        return new Pet("tomcat");
    }
}
public static void main(String[] args) {
        //1、返回我们IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
        //2、查看容器里面的组件
        String[] names = run.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
        boolean tom = run.containsBean("tom");
        System.out.println("容器中Tom组件："+tom);
        boolean user01 = run.containsBean("user01");
        System.out.println("容器中user01组件："+user01);
        boolean tom22 = run.containsBean("tom22");
        System.out.println("容器中tom22组件："+tom22);
    }

2.2、原生配置文件引入

1、@ImportResource

======================beans.xml=========================
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <bean id="haha" class="com.atguigu.boot.bean.User">
        <property name="name" value="zhangsan"></property>
        <property name="age" value="18"></property>
    </bean>
    <bean id="hehe" class="com.atguigu.boot.bean.Pet">
        <property name="name" value="tomcat"></property>
    </bean>
</beans>
@ImportResource("classpath:beans.xml")
public class MyConfig {}
======================测试=================
        boolean haha = run.containsBean("haha");
        boolean hehe = run.containsBean("hehe");
        System.out.println("haha："+haha);//true
        System.out.println("hehe："+hehe);//true

2.3、配置绑定

如何使用Java读取到properties文件中的内容，并且把它封装到JavaBean中，以供随时使用；

public class getProperties {
     public static void main(String[] args) throws FileNotFoundException, IOException {
         Properties pps = new Properties();
         pps.load(new FileInputStream("a.properties"));
         Enumeration enum1 = pps.propertyNames();//得到配置文件的名字
         while(enum1.hasMoreElements()) {
             String strKey = (String) enum1.nextElement();
             String strValue = pps.getProperty(strKey);
             System.out.println(strKey + "=" + strValue);
             //封装到JavaBean。
         }
     }
 }

1、@ConfigurationProperties

/**
 * 只有在容器中的组件，才会拥有SpringBoot提供的强大功能
 */
@Component
@ConfigurationProperties(prefix = "mycar")
public class Car {
    private String brand;
    private Integer price;
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public Integer getPrice() {
        return price;
    }
    public void setPrice(Integer price) {
        this.price = price;
    }
    @Override
    public String toString() {
        return "Car{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                '}';
    }
}

2、@EnableConfigurationProperties + @ConfigurationProperties

3、@Component + @ConfigurationProperties

@EnableConfigurationProperties(Car.class)
//1、开启Car配置绑定功能
//2、把这个Car这个组件自动注册到容器中
public class MyConfig {
}

3、自动配置原理入门

3.1、引导加载自动配置类

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication{}
======================

1、@SpringBootConfiguration

@Configuration。代表当前是一个配置类

2、@ComponentScan

指定扫描哪些，Spring注解；

3、@EnableAutoConfiguration

@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {}

1、@AutoConfigurationPackage

自动配置包？指定了默认的包规则

@Import(AutoConfigurationPackages.Registrar.class)  //给容器中导入一个组件
public @interface AutoConfigurationPackage {}
//利用Registrar给容器中导入一系列组件
//将指定的一个包下的所有组件导入进来？MainApplication 所在包下。

2、@Import(AutoConfigurationImportSelector.class)

1、利用getAutoConfigurationEntry(annotationMetadata);给容器中批量导入一些组件
2、调用List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes)获取到所有需要导入到容器中的配置类
3、利用工厂加载 Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader)；得到所有的组件
4、从META-INF/spring.factories位置来加载一个文件。
    默认扫描我们当前系统里面所有META-INF/spring.factories位置的文件
    spring-boot-autoconfigure-2.3.4.RELEASE.jar包里面也有META-INF/spring.factories

文件里面写死了spring-boot一启动就要给容器中加载的所有配置类
spring-boot-autoconfigure-2.3.4.RELEASE.jar/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.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.LifecycleAutoConfiguration,\
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.ElasticsearchDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveElasticsearchRestClientAutoConfiguration,\
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.r2dbc.R2dbcDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.r2dbc.R2dbcRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.r2dbc.R2dbcTransactionManagerAutoConfiguration,\
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.ElasticsearchRestClientAutoConfiguration,\
org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration,\
org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration,\
org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAutoConfiguration,\
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.jersey.JerseyAutoConfiguration,\
org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration,\
org.springframework.boot.autoconfigure.jsonb.JsonbAutoConfiguration,\
org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration,\
org.springframework.boot.autoconfigure.availability.ApplicationAvailabilityAutoConfiguration,\
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.r2dbc.R2dbcAutoConfiguration,\
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

3.2、按需开启自动配置项

虽然我们127个场景的所有自动配置启动的时候默认全部加载。xxxxAutoConfiguration
按照条件装配规则（@Conditional），最终会按需配置。

3.3、修改默认配置

        @Bean
        @ConditionalOnBean(MultipartResolver.class)  //容器中有这个类型组件
        @ConditionalOnMissingBean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME) //容器中没有这个名字 multipartResolver 的组件
        public MultipartResolver multipartResolver(MultipartResolver resolver) {
            //给@Bean标注的方法传入了对象参数，这个参数的值就会从容器中找。
            //SpringMVC multipartResolver。防止有些用户配置的文件上传解析器不符合规范
            // Detect if the user has created a MultipartResolver but named it incorrectly
            return resolver;
        }
给容器中加入了文件上传解析器；

SpringBoot默认会在底层配好所有的组件。但是如果用户自己配置了以用户的优先

@Bean
    @ConditionalOnMissingBean
    public CharacterEncodingFilter characterEncodingFilter() {
    }

总结：

• SpringBoot先加载所有的自动配置类 xxxxxAutoConfiguration
• 每个自动配置类按照条件进行生效，默认都会绑定配置文件指定的值。xxxxProperties里面拿。xxxProperties和配置文件进行了绑定
• 生效的配置类就会给容器中装配很多组件
• 只要容器中有这些组件，相当于这些功能就有了
• 定制化配置
• • 用户直接自己@Bean替换底层的组件
  • 用户去看这个组件是获取的配置文件什么值就去修改。

xxxxxAutoConfiguration —-> 组件 —-> xxxxProperties里面拿值 ——> application.properties

3.4、最佳实践

• 引入场景依赖
• • https://docs.spring.io/spring-boot/docs/current/reference/html/using-spring-boot.html#using-boot-starter
• 查看自动配置了哪些（选做）
• • 自己分析，引入场景对应的自动配置一般都生效了
  • 配置文件中debug=true开启自动配置报告。Negative（不生效）\Positive（生效）
• 是否需要修改
• • 参照文档修改配置项
• • • https://docs.spring.io/spring-boot/docs/current/reference/html/appendix-application-properties.html#common-application-properties
    • 自己分析。xxxxProperties绑定了配置文件的哪些。
• • 自定义加入或者替换组件
• • • @Bean、@Component。。。
• • 自定义器 XXXXXCustomizer；
  • ……

4、开发小技巧

4.1、Lombok

简化JavaBean开发

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
idea中搜索安装lombok插件
===============================简化JavaBean开发===================================
@NoArgsConstructor
//@AllArgsConstructor
@Data
@ToString
@EqualsAndHashCode
public class User {
    private String name;
    private Integer age;
    private Pet pet;
    public User(String name,Integer age){
        this.name = name;
        this.age = age;
    }
}
================================简化日志开发===================================
@Slf4j
@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String handle01(@RequestParam("name") String name){
        log.info("请求进来了....");
        return "Hello, Spring Boot 2!"+"你好："+name;
    }
}

4.2、dev-tools

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

项目或者页面修改以后：Ctrl+F9；

4.3、Spring Initailizr（项目初始化向导）

0、选择我们需要的开发场景

1、自动依赖引入

2、自动创建项目结构

3、自动编写好主配置类

9.1 引导加载自动配置类

SpringBoot 启动的时候加载主配置类，主配置类上的 @SpringBootApplication 注解开启了自动配置功能 @EnableAutoConfiguration。

@SpringBootConfiguration
@EnableAutoConfiguration // 开启自动配置
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
    @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {

9.1.1 @SpringBootConfiguration

标注在某个类上，表示这是一个 SpringBoot 的配置类。

• @Configuration：配置类上使用这个注解。

配置类 → 配置文件，配置类也是容器中的一个组件（@Component）。

9.1.2 @ComponentScan

指定扫描哪些包，默认扫描主程序 MainApplication 所在的包及其子包。

9.1.3@EnableAutoConfiguration

开启自动配置功能。

以前我们需要配置的东西，SpringBoot 帮我们自动配置。

    @AutoConfigurationPackage
    @Import({AutoConfigurationImportSelector.class})
    public @interface EnableAutoConfiguration {

• @AutoConfigurationPackage：自动配置包。

    @Import({Registrar.class})
    public @interface AutoConfigurationPackage {

Spring 的底层注解 `@Import`，给容器中导入一个 `Registrar.class` 类型的组件。
然后利用 `Registrar` 将主程序 `MainApplication` 所在的包及其子包里面的所有组件扫描并配置到 Spring 容器。

• @Import({AutoConfigurationImportSelector.class})：导入组件。
  • 利用 AutoConfigurationImportSelector.getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) 给容器中导入一些组件；
  • 可以查看 AutoConfigurationImportSelector.selectImports(AnnotationMetadata annotationMetadata) 方法的内容；
  • 获取候选的配置项。

    List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);

• 加载配置

  List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());

扫描所有 jar 包类路径下 META-INF/spring.factories，把扫描到的这些文件的内容包装成 properties 对象。

从 properties 中获取到 EnableAutoConfiguration 属性下的类全限定名列表，然后把他们添加到容器中。

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
...

每一个这样的 xxxAutoConfiguration 类都是容器中的一个组件，都加入到容器中，用他们来做自动配置。

9.2 按需开启自动配置项

9.2.1 @Conditional

作用：必须是 @Conditional 指定的条件成立，才给容器中添加组件，配置里面的所有内容才生效。

自动配置类必须在一定的条件下才能生效。

我们怎么知道哪些自动配置类生效？

我们可以通过启用 debug=true 属性，来让控制台打印自动配置报告，这样我们就可以很方便地知道哪些自动配置类生效。

=========================
AUTO-CONFIGURATION REPORT
=========================
Positive matches: // 自动配置类启用的
-----------------
   DispatcherServletAutoConfiguration matched:
      - @ConditionalOnClass found required class 'org.springframework.web.servlet.DispatcherServlet'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition)
      - @ConditionalOnWebApplication (required) found StandardServletEnvironment (OnWebApplicationCondition)
Negative matches: // 没有启动，没有匹配成功的自动配置类
-----------------
   ActiveMQAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required classes 'javax.jms.ConnectionFactory', 'org.apache.activemq.ActiveMQConnectionFactory' (OnClassCondition)
   AopAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required classes 'org.aspectj.lang.annotation.Aspect', 'org.aspectj.lang.reflect.Advice' (OnClassCondition)

9.3 Spring MVC 自动配置

以下是 SpringBoot 对 SpringMVC 的默认配置（WebMvcAutoConfiguration）：

• Inclusion of ContentNegotiatingViewResolver and BeanNameViewResolver beans.
  • 自动配置了 ViewResolver（视图解析器）：根据方法的返回值得到视图对象（View），视图对象决定如何渲染（转发？重定向？）.
  • ContentNegotiatingViewResolver：组合所有的视图解析器的。
  • 可以自己给容器中添加一个视图解析器（@Bean，@Component），SpringBoot 会自动地将其组合进来。
• Support for serving static resources, including support for WebJars (see below).
  • 静态资源文件夹路径，包括 webjars。
• Static index.html support.
  • 静态首页访问（欢迎页）。
• Custom Favicon support (see below).
  • 网站图标支持，即 favicon.ico。

• 自动注册了 of Converter, GenericConverter, Formatter beans.

  • Converter<S, T>：转换器接口，将源类型 S 转换为目标类型 T。
  • GenericConverter：通用转换器接口，用于两个以上类型之间的转换。
  • Formatter<T> 格式化器接口，格式化成目标类型 T。

    @Bean
    @ConditionalOnProperty(prefix = "spring.mvc", name = "date-format") // 在文件中配置日期格式化的规则
    public Formatter<Date> dateFormatter() {
    return new DateFormatter(this.mvcProperties.getDateFormat()); // 日期格式化组件
    }

    
    可以自己给容器中添加一个格式化器转换器。

• Support for HttpMessageConverters (see below).

  • HttpMessageConverter：SpringMVC 用来转换 HTTP 请求和响应的。
  • HttpMessageConverters 是从容器中确定的，获取所有的 HttpMessageConverter，然后看哪一个转换器能处理。
  • 可以自己给容器中添加一个 HttpMessageConverter。
• Automatic registration of MessageCodesResolver (see below).
  • 定义错误代码生成规则。
• Automatic use of a ConfigurableWebBindingInitializer bean (see below).
  • 可以自己给容器中添加一个 ConfigurableWebBindingInitializer 来替换默认的。

9.4 扩展SpringMVC

编写一个配置类（@Configuration），是 WebMvcConfigurer 类型。不能标注@EnableWebMvc 。

既保留了所有的自动配置，也能用我们扩展的配置。

// 使用 WebMvcConfigurer 可以扩展 SpringMVC 的功能
@Configuration
public class MyMvcConfig implements WebMvcConfigurer {
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        // 浏览器发送 /atguigu 请求来到 success 页面
        registry.addViewController("/atguigu").setViewName("success");
    }
}

原理：

1. WebMvcConfigurer 是 SpringMVC 的自动配置类;
2. 在做其他自动配置时会导入；

@Import(EnableWebMvcConfiguration.class)
@Configuration
public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration {

父类 DelegatingWebMvcConfiguration：

@Configuration(proxyBeanMethods = false)
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
    private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();
    // 从容器中获取所有的 WebMvcConfigurer。
    @Autowired(required = false)
    public void setConfigurers(List<WebMvcConfigurer> configurers) {
        if (!CollectionUtils.isEmpty(configurers)) {
            this.configurers.addWebMvcConfigurers(configurers);
            // 一个参考实现：将所有 WebMvcConfigurer 相关配置一起调用。
            // @Override
            // protected void addViewControllers(ViewControllerRegistry registry) {
            //     this.configurers.addViewControllers(registry);
            // }
        }
    }

1. 容器中所有的 WebMvcConfigurer 都会同时起作用；
2. 我们的配置类也会被调用。

效果：SpringMVC 的自动配置和我们的扩展配置都会起作用。

9.5 全面接管 SpringMVC

不使用 SpringBoot 对 SpringMVC 的自动配置，而是使用自定义配置。

只要配置类中添加 @EnableWebMvc 即可：

// 使用 WebMvcConfigurerAdapter 可以来扩展 SpringMVC 的功能
@EnableWebMvc
@Configuration
public class MyMvcConfig extends WebMvcConfigurerAdapter {
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        // super.addViewControllers(registry);
        //浏览器发送 /atguigu 请求来到 success 页面
        registry.addViewController("/atguigu").setViewName("success");
    }
}

原理：

为什么使用 @EnableWebMvc 自动配置就失效了。

1. @EnableWebMvc 导入了 DelegatingWebMvcConfiguration 组件；

@Import(DelegatingWebMvcConfiguration.class)
public @interface EnableWebMvc {

1. DelegatingWebMvcConfiguration 继承了 WebMvcConfigurationSupport 类；
   • 把所有系统中的 WebMvcConfigurer 拿过来，所有功能的定制都是这些 WebMvcConfigurer 合起来一起生效的；
   • 自动配置了一些非常底层的组件，RequestMappingHandlerMapping、这些组件依赖的组件都是从容器中获取。

@Configuration
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {

1. WebMvcAutoConfiguration 只有当容器中没有 WebMvcConfigurationSupport 组件的时候才生效；

@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
// 容器中没有这个组件的时候，这个自动配置类才生效。
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
@AutoConfigureAfter({ DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class,
        ValidationAutoConfiguration.class })
public class WebMvcAutoConfiguration {

1. 而第 2 步中，@EnableWebMvc 已经将 WebMvcConfigurationSupport 组件导入进来了。
2. 导入的 WebMvcConfigurationSupport 只是 SpringMVC 最基本的功能。

9.6 修改默认配置

可配置的属性列表。

1. SpringBoot 在自动配置很多组件的时候，先看容器中有没有用户自己配置的（@Bean、@Component）如果有就用用户配置的，如果没有，才自动配置。如果有些组件可以有多个（ViewResolver）将用户配置的和自己默认的组合起来。
2. 在 SpringBoot 中会有非常多的 xxxConfigurer 帮助我们进行扩展配置；
3. 在 SpringBoot 中会有非常多的 xxxCustomizer 帮助我们进行定制配置。

9.7 总结

• SpringBoot 先加载所有的自动配置类 xxxAutoConfiguration。
• 每个自动配置类按照条件生效，默认都会绑定 xxxProperties 类，xxxProperties 类和对应配置文件进行了绑定。
• 定制化配置：
  • 用户直接使用 @Bean、@Component 替换底层的组件；
  • 用户去看这个组件是获取的配置文件什么值就去修改。

场景 starter -> xxxAutoConfiguration -> 导入 xxx 组件 -> 绑定 xxxProperties -> 绑定配置文件项（application.properties）

9.8 最佳实践

• 引入场景依赖；
  • Starters。
• 查看自动配置了哪些（选做）；
  • 自己分析，引入场景对应的自动配置一般都生效了；
  • 配置文件中 debug=true 开启自动配置报告：Negative（不生效） \ Positive（生效）。
• 是否需要修改配置项；
  • 参照文档修改配置项。
    • Common Application Properties；
    • 自己分析，xxxProperties 配置类绑定了哪个配置文件；

• 自定义加入或者替换组件；

  • 编写自定义的配置类 xxxConfiguration + @Bean、@Component 替换、增加容器中默认组件。
    • Web应用：编写一个配置类实现 WebMvcConfigurer 即可定制化 Web 功能 + @Bean 给容器中再扩展一些组件。

      @Configuration
      public class AdminWebConfig implements WebMvcConfigurer {
      @Bean
      public MybatisPlusInterceptor mybatisPlusInterceptor() {
      MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
      // 分页拦截器
      PaginationInnerInterceptor paginationInnerInterceptor = new PaginationInnerInterceptor(DbType.MYSQL);
      // 跳回首页
      paginationInnerInterceptor.setOverflow(true);
      // 每页不受限制
      paginationInnerInterceptor.setMaxLimit(-1L);
      interceptor.addInnerInterceptor(paginationInnerInterceptor);
      return interceptor;
      }
      }

• 自定义器 xxxCustomizer；

• ……

9.9 示例

以 HttpEncodingAutoConfiguration（Http 编码自动配置）为例解释自动配置原理。

@Configuration(proxyBeanMethods = false) // 表示这是一个配置类，关闭 bean 代理（每次获取一个新的 bean，相当于 prototype）
@EnableConfigurationProperties(HttpProperties.class) // 将配置文件中对应的值和HttpProperties绑定起来，并把HttpProperties加入到容器中。
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET) // 仅对 Web 应用生效。
@ConditionalOnClass(CharacterEncodingFilter.class) // CharacterEncodingFilter 类存在时生效。SpringMVC中进行乱码解决的过滤器。
@ConditionalOnProperty(prefix = "spring.http.encoding", value = "enabled", matchIfMissing = true)
// 判断配置文件中是否存在某个配置 spring.http.encoding=enabled。
// 即使我们不配置，pring.http.encoding.enabled=true，也是默认生效的。
public class HttpEncodingAutoConfiguration {
    // 它已经和SpringBoot的配置文件映射了。
    private final HttpProperties.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(Type.REQUEST));
        filter.setForceResponseEncoding(this.properties.shouldForce(Type.RESPONSE));
        return filter;
    }

四、日志

1、日志框架

小张要开发一个大型系统。

1. System.out.println(“”)。将关键数据打印在控制台。去掉？写在一个文件？
2. 框架来记录系统的一些运行时信息。日志框架 。zhanglogging.jar。
3. 高大上的几个功能？异步模式？自动归档？xxx？zhanglogging-good.jar。
4. 将以前框架卸下来？换上新的框架，重新修改之前相关的API。zhanglogging-prefect.jar。
5. JDBC—-数据库驱动。

写了一个统一的接口层，日志门面（日志的一个抽象层）：logging-abstract.jar。

给项目中导入具体的日志实现就行了。我们之前的日志框架都是实现的抽象层。

市面上的日志框架。

JUL、JCL、Jboss-logging、logback、log4j、log4j2、SLF4j…

左边选一个门面（抽象层）、右边来选一个实现。

Spring 框架默认是用 JCL。

SpringBoot 选用 SLF4j 和 logback。

2、SLF4j 使用

2.1 如何在系统中使用 SLF4j

https://www.slf4j.org

以后开发的时候，日志记录方法的调用，不应该来直接调用日志的实现类，而是调用日志抽象层里面的方法。

给系统里面导入 slf4j 的抽象层 jar 和 logback 的实现层 jar。

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");
  }
}

图示：

每一个日志的实现框架都有自己的配置文件。

2.2 遗留问题

A系统（slf4j + logback）: Spring（commons-logging）、Hibernate（jboss-logging）、MyBatis…

统一日志记录，即使是别的框架和我一起统一使用 slf4j 进行输出？

如何让系统中所有的日志都统一到 slf4j？

1. 将系统中其他日志框架先排除出去。
2. 用中间包来替换原有的日志框架。
3. 我们导入 slf4j 其他的实现。

3、SpringBoot 日志关系

SpringBoot 使用它来做日志功能。

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

底层依赖关系：

总结：

1. SpringBoot 底层也是使用 **slf4j** + **logback** 的方式进行日志记录。

2. SpringBoot 也把其他的日志都替换成了**slf4j**。

3. 中间转换包？

@SuppressWarnings("rawtypes")
public abstract class LogFactory {
    static String UNSUPPORTED_OPERATION_IN_JCL_OVER_SLF4J = "http://www.slf4j.org/codes.html#unsupported_operation_in_jcl_over_slf4j";

    static LogFactory logFactory = new SLF4JLogFactory();

4. 如果我们要引入其他框架，一定要把这个框架的默认日志依赖移除掉。

    Spring 框架用的是 **commons-logging（JCL）**。

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <exclusions>
        <exclusion>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>

SpringBoot 能自动适配所有的日志，而且底层使用 slf4j + logback 的方式记录日志，引入其他框架的时候，只需要把这个框架依赖的日志框架排除掉即可。

4、日志使用

4.1 默认配置

SpringBoot 默认帮我们配置好了日志。

// 记录器
Logger logger = LoggerFactory.getLogger(getClass());
@Test
public void contextLoads() {
    // System.out.println();

    // 日志的级别。
    // 由低到高：trace < debug < info < warn < error
    // 可以调整输出的日志级别，日志就只会在这个级别以以后的高级别生效
    logger.trace("这是trace日志...");
    logger.debug("这是debug日志...");
    // SpringBoot 默认给我们使用的是 info 级别的
    logger.info("这是info日志...");
    logger.warn("这是warn日志...");
    logger.error("这是error日志...");
}

日志输出格式：
    %d表示日期时间，
    %thread表示线程名，
    %-5level：级别从左显示5个字符宽度
    %logger{50} 表示logger名字最长50个字符，否则按照句点分割。 
    %msg：日志消息，
    %n是换行符
-->
%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n

SpringBoot 修改日志的默认配置：

logging.level.com.atguigu=trace

# 不指定路径，在当前项目下生成 springboot.log 日志。
#logging.file.path=

# 可以指定完整的路径。
#logging.file.name=D:/springboot.log

# 在当前磁盘的根路径下创建 /spring/log 文件夹，使用 spring.log 作为日志文件。
logging.file.path=/spring/log

# 在控制台输出的日志格式
logging.pattern.console=%d{yyyy-MM-dd} [%thread] %-5level %logger{50} - %msg%n

# 指定文件中输出的日志格式
logging.pattern.file=%d{yyyy-MM-dd} === [%thread] === %-5level === %logger{50} === %msg%n

4.2 指定配置

给类路径下放上每个日志框架自己的配置文件即可，SpringBoot 就不使用它默认配置的了。

logback.xml：直接就被日志框架识别了。

logback-spring.xml：日志框架就不直接加载日志的配置项，由 SpringBoot 解析日志配置，可以使用 SpringBoot 的高级 profile 功能。

<springProfile name="dev">
    <!-- 可以指定某段配置只在某个环境下生效 -->
</springProfile>

如：

<appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
    <!--
    日志输出格式：
        %d表示日期时间，
        %thread表示线程名，
        %-5level：级别从左显示5个字符宽度
        %logger{50} 表示logger名字最长50个字符，否则按照句点分割。 
        %msg：日志消息，
        %n是换行符
    -->
    <layout class="ch.qos.logback.classic.PatternLayout">
        <springProfile name="dev">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ----> [%thread] ---> %-5level %logger{50} - %msg%n</pattern>
        </springProfile>
        <springProfile name="!dev">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ==== [%thread] ==== %-5level %logger{50} - %msg%n</pattern>
        </springProfile>
    </layout>
</appender>

如果使用 logback.xml 作为日志配置文件，还要使用 Profile 功能，会有以下错误

no applicable action for [springProfile]

5、切换日志框架

可以按照 slf4j 的日志适配图，进行相关的切换。

slf4j + log4j 的方式：

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
  <exclusions>
    <exclusion>
      <artifactId>logback-classic</artifactId>
      <groupId>ch.qos.logback</groupId>
    </exclusion>
    <exclusion>
      <artifactId>log4j-over-slf4j</artifactId>
      <groupId>org.slf4j</groupId>
    </exclusion>
  </exclusions>
</dependency>

<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-log4j12</artifactId>
</dependency>

切换为 log4j2：

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

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

五、Web 开发

1、简介

1. 创建 SpringBoot 应用，选中我们需要的 starter 模块。
2. SpringBoot 已经默认将这些场景配置好了，只需要在配置文件中指定少量配置就可以运行起来
3. 自己编写业务代码。

1.1、SpringMVC自动配置概览

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:

• Inclusion of ContentNegotiatingViewResolver and BeanNameViewResolver beans.
• • 内容协商视图解析器和BeanName视图解析器
• 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，Formatter
• Support for HttpMessageConverters (covered later in this document).
• • 支持 HttpMessageConverters （后来我们配合内容协商理解原理）
• Automatic registration of MessageCodesResolver (covered later in this document).
• • 自动注册 MessageCodesResolver （国际化用）
• Static index.html support.
• • 静态index.html 页支持
• Custom Favicon support (covered later in this document).
• • 自定义 Favicon
• Automatic use of a ConfigurableWebBindingInitializer bean (covered later in this document).
• • 自动使用 ConfigurableWebBindingInitializer ，（DataBinder负责将请求数据绑定到JavaBean上）

If you want to keep those Spring Boot MVC customizations and make more MVC customizations (interceptors, formatters, view controllers, and other features), you can add your own @Configuration class of type WebMvcConfigurer but without @EnableWebMvc.

不用@EnableWebMvc注解。使用 **@Configuration** + **WebMvcConfigurer** 自定义规则

If you want to provide custom instances of RequestMappingHandlerMapping, RequestMappingHandlerAdapter, or ExceptionHandlerExceptionResolver, and still keep the Spring Boot MVC customizations, you can declare a bean of type WebMvcRegistrations and use it to provide custom instances of those components.

声明 **WebMvcRegistrations** 改变默认底层组件

If you want to take complete control of Spring MVC, you can add your own @Configuration annotated with @EnableWebMvc, or alternatively add your own @Configuration-annotated DelegatingWebMvcConfiguration as described in the Javadoc of @EnableWebMvc.

使用 **@EnableWebMvc+@Configuration+DelegatingWebMvcConfiguration 全面接管SpringMVC**

2、简单功能分析

2.1 静态资源访问

静态资源：css、jss、html、jpg 等资源文件，用户多次访问都是获取同样的资源，可以被浏览器缓存。

2.1.1 静态资源访问目录

只要静态资源放在类路径下： called /static (or /public or /resources or /META-INF/resources

访问 ： 当前项目根路径/ + 静态资源名

原理： 静态映射/**。

请求进来，先去找Controller看能不能处理。不能处理的所有请求又都交给静态资源处理器。

静态资源也找不到则响应404页面

改变默认的静态资源路径

spring:
  mvc:
    static-path-pattern: /res/**

  resources:
    static-locations: [classpath:/haha/]

2.1.2 静态资源访问前缀

默认无前缀。

spring:
  mvc:
    static-path-pattern: /res/**

访问当前项目根路径 / + static-path-pattern + 静态资源名 ，就可以获取到对应的静态资源。

访问地址：http://localhost:8080/res/hello.jpg，去静态资源文件夹里面找 hello.jpg。

2.1.3 webjar 映射

所有 /webjars/** 请求，都会去 classpath:/META-INF/resources/webjars/ 下找资源。

webjars：以 jar 包的方式引入静态资源。

http://www.webjars.org

<!-- 引入jquery-webjar -->
<dependency>
    <groupId>org.webjars</groupId>
    <artifactId>jquery</artifactId>
    <version>3.5.1</version>
</dependency>

访问地址：http://localhost:8080/webjars/jquery/3.5.1/jquery.js，后面地址要按照依赖里面的包路径，就可以获取到对应的静态资源。

2.1.3 修改静态资源路径

改变默认的静态资源前缀和目录：

spring:
  mvc:
    static-path-pattern: /res/** # 修改前缀
  resources:
    static-locations: [classpath:/haha/] # 修改目录

访问地址：http://localhost:8080/res/haha/hello.jpg，去静态资源目录下找 hello.jpg。

2.2 欢迎页

静态资源路径下的所有 index.html 页面，被 /** 映射。

• 可以配置静态资源访问目录；
• 但是不能配置静态资源访问前缀，否则导致 index.html 不能被默认访问；

spring:
#  mvc:
#    static-path-pattern: /res/**   这个会导致welcome page功能失效

  resources:
    static-locations: [classpath:/haha/]

访问地址：http://localhost:8080/，就会去静态资源目录下找 index.html 页面。

Controller 能处理 /index 请求。

2.3 自定义 Favicon

将 favicon.ico 放在静态资源目录下即可。

跟「欢迎页」一样，不能配置静态资源访问前缀，否则不能访问自定义图标。

spring:
#  mvc:
#    static-path-pattern: /res/**   这个会导致 Favicon 功能失效

2.4 静态资源配置原理

• SpringBoot 启动默认加载 xxxAutoConfiguration 类（自动配置类）。
• SpringMVC 功能的自动配置类 WebMvcAutoConfiguration 生效。

@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
@AutoConfigureAfter({ DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class,
        ValidationAutoConfiguration.class })
public class WebMvcAutoConfiguration {}

• 查看 WebMvcConfigurer 接口的实现类 WebMvcAutoConfigurationAdapter，看看给容器中配置了什么

   @Configuration(proxyBeanMethods = false)
   @Import(EnableWebMvcConfiguration.class)
   @EnableConfigurationProperties({ WebMvcProperties.class, ResourceProperties.class })
   @Order(0)
   public static class WebMvcAutoConfigurationAdapter implements WebMvcConfigurer {}
  

• 配置类和配置文件的相关属性 spring.xxx 进行了绑定。
  • WebMvcProperties 绑定 spring.mvc
  • ResourceProperties（已过时） 绑定 spring.resources

    @Deprecated
    @ConfigurationProperties(prefix = "spring.resources", ignoreUnknownFields = false)
    public class ResourceProperties extends Resources {
    

• WebProperties 绑定 spring.web

  @ConfigurationProperties("spring.web")
  public class WebProperties {
  public static class Resources {
  
    private static final String[] CLASSPATH_RESOURCE_LOCATIONS = { "classpath:/META-INF/resources/",
            "classpath:/resources/", "classpath:/static/", "classpath:/public/" };
  
    /**
     * Locations of static resources. Defaults to classpath:[/META-INF/resources/,
     * /resources/, /static/, /public/].
     */
    private String[] staticLocations = CLASSPATH_RESOURCE_LOCATIONS;
  

2.4.1 配置唯一的有参类构造函数

org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration.WebMvcAutoConfigurationAdapter#WebMvcAutoConfigurationAdapter()

    //有参构造器所有参数的值都会从容器中确定
//ResourceProperties resourceProperties；获取和spring.resources绑定的所有的值的对象
//WebMvcProperties mvcProperties 获取和spring.mvc绑定的所有的值的对象
//ListableBeanFactory beanFactory Spring的beanFactory
//HttpMessageConverters 找到所有的HttpMessageConverters
//ResourceHandlerRegistrationCustomizer 找到 资源处理器的自定义器。=========
//DispatcherServletPath  
//ServletRegistrationBean   给应用注册Servlet、Filter....
    public WebMvcAutoConfigurationAdapter(ResourceProperties resourceProperties, WebMvcProperties mvcProperties,
                ListableBeanFactory beanFactory, ObjectProvider<HttpMessageConverters> messageConvertersProvider,
                ObjectProvider<ResourceHandlerRegistrationCustomizer> resourceHandlerRegistrationCustomizerProvider,
                ObjectProvider<DispatcherServletPath> dispatcherServletPath,
                ObjectProvider<ServletRegistrationBean<?>> servletRegistrations) {
            this.resourceProperties = resourceProperties;
            this.mvcProperties = mvcProperties;
            this.beanFactory = beanFactory;
            this.messageConvertersProvider = messageConvertersProvider;
            this.resourceHandlerRegistrationCustomizer = resourceHandlerRegistrationCustomizerProvider.getIfAvailable();
            this.dispatcherServletPath = dispatcherServletPath;
            this.servletRegistrations = servletRegistrations;
        }

2.4.2 静态资源和 webjars 的处理规则

org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration.WebMvcAutoConfigurationAdapter#addResourceHandlers()

@Override
        public void addResourceHandlers(ResourceHandlerRegistry registry) {
            if (!this.resourceProperties.isAddMappings()) {
                logger.debug("Default resource handling disabled");
                return;
            }
            Duration cachePeriod = this.resourceProperties.getCache().getPeriod();
            CacheControl cacheControl = this.resourceProperties.getCache().getCachecontrol().toHttpCacheControl();
            //webjars的规则
            if (!registry.hasMappingForPattern("/webjars/**")) {
                customizeResourceHandlerRegistration(registry.addResourceHandler("/webjars/**")
                        .addResourceLocations("classpath:/META-INF/resources/webjars/")
                        .setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
            }

            //
            String staticPathPattern = this.mvcProperties.getStaticPathPattern();
            if (!registry.hasMappingForPattern(staticPathPattern)) {
                customizeResourceHandlerRegistration(registry.addResourceHandler(staticPathPattern)
                        .addResourceLocations(getResourceLocations(this.resourceProperties.getStaticLocations()))
                        .setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
            }
        }

2.4.3 欢迎页的处理规则

org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration.EnableWebMvcConfiguration#welcomePageHandlerMapping()

    HandlerMapping：处理器映射。保存了每一个Handler能处理哪些请求。    

    @Bean
        public WelcomePageHandlerMapping welcomePageHandlerMapping(ApplicationContext applicationContext,
                FormattingConversionService mvcConversionService, ResourceUrlProvider mvcResourceUrlProvider) {
            WelcomePageHandlerMapping welcomePageHandlerMapping = new WelcomePageHandlerMapping(
                    new TemplateAvailabilityProviders(applicationContext), applicationContext, getWelcomePage(),
                    this.mvcProperties.getStaticPathPattern());
            welcomePageHandlerMapping.setInterceptors(getInterceptors(mvcConversionService, mvcResourceUrlProvider));
            welcomePageHandlerMapping.setCorsConfigurations(getCorsConfigurations());
            return welcomePageHandlerMapping;
        }

    WelcomePageHandlerMapping(TemplateAvailabilityProviders templateAvailabilityProviders,
            ApplicationContext applicationContext, Optional<Resource> welcomePage, String staticPathPattern) {
        if (welcomePage.isPresent() && "/**".equals(staticPathPattern)) {
            //要用欢迎页功能，必须是/**
            logger.info("Adding welcome page: " + welcomePage.get());
            setRootViewName("forward:index.html");
        }
        else if (welcomeTemplateExists(templateAvailabilityProviders, applicationContext)) {
            // 调用Controller  /index
            logger.info("Adding welcome page template: index");
            setRootViewName("index");
        }
    }

2.4.4 Favicon 的处理规则

// 配置喜欢的图标
@Configuration
@ConditionalOnProperty(value = "spring.mvc.favicon.enabled", matchIfMissing = true)
public static class FaviconConfiguration {

    private final ResourceProperties resourceProperties;

    public FaviconConfiguration(ResourceProperties resourceProperties) {
        this.resourceProperties = resourceProperties;
    }

    @Bean
    public SimpleUrlHandlerMapping faviconHandlerMapping() {
        SimpleUrlHandlerMapping mapping = new SimpleUrlHandlerMapping();
        mapping.setOrder(Ordered.HIGHEST_PRECEDENCE + 1);
        // 映射所有 **/favicon.ico 
        mapping.setUrlMap(Collections.singletonMap("**/favicon.ico",
                faviconRequestHandler()));
        return mapping;
    }

    @Bean
    public ResourceHttpRequestHandler faviconRequestHandler() {
        ResourceHttpRequestHandler requestHandler = new ResourceHttpRequestHandler();
        requestHandler
                .setLocations(this.resourceProperties.getFaviconLocations());
        return requestHandler;
    }
}

新版本没有这个类了，找到了下面这个类：

public enum StaticResourceLocation {
    CSS("/css/**"),
    JAVA_SCRIPT("/js/**"),
    IMAGES("/images/**"),
    WEB_JARS("/webjars/**"),
    FAVICON("/favicon.*", "/*/icon-*");

    private final String[] patterns;

    StaticResourceLocation(String... patterns) {
        this.patterns = patterns;
    }

    public Stream<String> getPatterns() {
        return Arrays.stream(this.patterns);
    }
}

2.4.5 资源处理的默认规则

@Override
        public void addResourceHandlers(ResourceHandlerRegistry registry) {
            if (!this.resourceProperties.isAddMappings()) {
                logger.debug("Default resource handling disabled");
                return;
            }
            Duration cachePeriod = this.resourceProperties.getCache().getPeriod();
            CacheControl cacheControl = this.resourceProperties.getCache().getCachecontrol().toHttpCacheControl();
            //webjars的规则
            if (!registry.hasMappingForPattern("/webjars/**")) {
                customizeResourceHandlerRegistration(registry.addResourceHandler("/webjars/**")
                        .addResourceLocations("classpath:/META-INF/resources/webjars/")
                        .setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
            }

            //
            String staticPathPattern = this.mvcProperties.getStaticPathPattern();
            if (!registry.hasMappingForPattern(staticPathPattern)) {
                customizeResourceHandlerRegistration(registry.addResourceHandler(staticPathPattern)
                        .addResourceLocations(getResourceLocations(this.resourceProperties.getStaticLocations()))
                        .setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
            }
        }

spring:
#  mvc:
#    static-path-pattern: /res/**

  resources:
    add-mappings: false   禁用所有静态资源规则

@ConfigurationProperties(prefix = "spring.resources", ignoreUnknownFields = false)
public class ResourceProperties {

    private static final String[] CLASSPATH_RESOURCE_LOCATIONS = { "classpath:/META-INF/resources/",
            "classpath:/resources/", "classpath:/static/", "classpath:/public/" };

    /**
     * Locations of static resources. Defaults to classpath:[/META-INF/resources/,
     * /resources/, /static/, /public/].
     */
    private String[] staticLocations = CLASSPATH_RESOURCE_LOCATIONS;

3、请求响应参数处理

3.1 请求映射

3.1.1 REST 使用

• @xxxMapping（@GetMapping、@PostMapping、@PutMapping、@DeleteMapping，@PatchMapping是对 Put 的补充，区别是 Patch 是部分更新，Put 是全部更新，这些注解都是 Spring4.3 引入的）；
• REST 风格支持（使用 HTTP 请求方式动词来表示对资源的操作） | 操作 | 以前 | 现在（REST 风格） | | —- | —- | —- | | 获取用户 | /getUser 的 GET 请求 | /user/id 的 GET 请求 | | 保存用户 | /saveUser 的 POST 请求 | /user/id 的 POST 请求 | | 修改用户 | /editUser 的 POST 请求 | /user/id 的 PUT 请求 | | 删除用户 | /deleteUser 的 POST 请求 | /user/id 的 DELETE 请求 |