SpringBoot2

古城微笑少年丶 2024-04-03 14:09 25阅读 0赞

**目录**

一.SpringBoot2入门

1、系统要求

2、maven设置

3、HelloWorld

1.创建主程序

2.编写业务

3.测试

4.简化配置

5.简化部署

4、了解自动配置原理

1.SpringBoot特点

2、容器功能

@Configuration

@Import

4、@Conditional

二、自动配置原理入门

3.1、引导加载自动配置类

1、@SpringBootConfiguration

2、@ComponentScan

3、@EnableAutoConfiguration

3.2、按需开启自动配置项

3.3、修改默认配置

3.4、最佳实践

4、开发小技巧

4.1、Lombok

4.2、dev-tools

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

x、配置文件

1、文件类型

1.1、properties

1.2、yaml

1.2.1、简介

1.2.2、基本语法

1.2.3、数据类型

2、配置提示

1、SpringMVC自动配置概览

2、简单功能分析

2.1、静态资源访问

1、静态资源目录

2、静态资源访问前缀

2.2、欢迎页支持

2.3、自定义 Favicon

2.4、静态资源配置原理

3、请求参数处理

0、请求映射

1、rest使用与原理

2、请求映射原理

1、普通参数与基本注解

1.1、注解

1.2、Servlet API：

1.3、复杂参数：

4、数据响应与内容协商

1.1、jackson.jar+@ResponseBody

1.2、SpringMVC到底支持哪些返回值

1.3、HTTPMessageConverter原理

2、内容协商

1.引入依赖

2、postman分别测试返回json和xml

5、视图解析与模板引擎

1、视图解析

2、模板引擎-Thymeleaf

1、thymeleaf简介

2、基本语法

3、thymeleaf使用

6、拦截器

1、HandlerInterceptor 接口

2、配置拦截器

3、拦截器原理

7、文件上传

1、页面表单

2、文件上传代码

3.上传信息大小的改变

8、异常处理

1、错误处理

1、默认规则

9、Web原生组件注入（Servlet、Filter、Listener）

1、使用Servlet API

2、使用RegistrationBean

10、嵌入式Servlet容器

1、切换嵌入式Servlet容器

2、定制Servlet容器

11、定制化原理

1、定制化的常见方式

2、原理分析套路

06、数据访问

1、SQL

1、数据源的自动配置-HikariDataSource

3、修改配置项

4、测试

2、使用Druid数据源

1、druid官方github地址

3、使用官方starter方式

3、整合MyBatis操作

4、整合 MyBatis-Plus

5、单元测试

--------------------

## 一.SpringBoot2入门 ##

### 1、系统要求 ###

*  [Java 8][] & 兼容java14 .
 *  Maven 3.3+

### 2、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>
    
        <groupId>com.example</groupId>
        <artifactId>myproject</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.7.4</version>
        </parent>
    
        
    
    </project>

### 3、HelloWorld ###

#### 1.创建主程序 ####

/**
     * @author Chooker
     * @create 2022-10-18 10:45
     * 主程序类
     */
    //告诉Springboot这是一个springboot应用
    @SpringBootApplication
    public class MainApplication {
        public static void main(String[] args) {
            SpringApplication.run(MainApplication.class,args);
    
        }
    }

#### 2.编写业务 ####

//@Controller
    //ResponseBody
    @RestController
    public class HelloContoller {
        @RequestMapping("/hello")
        public String hello(){
            return "hello,springboot";
        }
    }

#### 3.测试 ####

直接运行主程序类的main方法

#### 4.简化配置 ####

application.properties文件

比如想修改端口号

> server.port=8888

#### 5.简化部署 ####

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

### 4、了解自动配置原理 ###

#### 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>
> 
> 里面为控制各种依赖的版本号:例如
> 
>     <mysql.version>8.0.21</mysql.version>

如果想要修改其控制的版本号,改为自己的版本号,只需要在自己的pom文件中修改

> <properties>  
> <mysql.version>5.1.43</mysql.version>  
> </properties>

**starter场景启动器**

1.见到很多spring-boot-starter-\* :\*就某种场景

2.只要引入starter，这个场景的所有常规需要的依赖我们都自动引入

3.SpringBoot所有支持的场景

4.见到的 thirdpartyproject-spring-boot-starter 第三方为我们提供的starter

5.所有场景启动器最底层的依赖

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

例如: [Developing with Spring Boot][]

![ec252384aec44a378ee95df84ff5757b.png][]

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

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

**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常用组件（功能）

>     <dependency>
>       <groupId>org.springframework</groupId>
>       <artifactId>spring-web</artifactId>
>       <version>5.2.9.RELEASE</version>
>       <scope>compile</scope>
>     </dependency>
>     <dependency>
>       <groupId>org.springframework</groupId>
>       <artifactId>spring-webmvc</artifactId>
>       <version>5.2.9.RELEASE</version>
>       <scope>compile</scope>
>     </dependency>

*  自动配好Web常见功能，如：字符编码问题

*   *  SpringBoot帮我们配置好了所有web开发的常见场景

*  默认的包结构

*   *  主程序所在包及其下面的所有子包里面的组件都会被默认扫描进来
     *  无需以前的包扫描配置

也可以自己配置包的扫描

![27cd33b7ae0e4607aacf2134341adccc.png][]

*  各种配置拥有默认值

*   *  默认配置最终都是映射到某个类上，如：MultipartProperties
     *  配置文件的值最终会绑定每个类上，这个类会在容器中创建对象

*  按需加载所有自动配置项

*   *  非常多的starter
     *  引入了哪些场景这个场景的自动配置才会开启
     *  SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面

#### 2、容器功能 ####

**2.1组件添加**

#### @Configuration ####

*  基本使用
 *  **Full模式与Lite模式**

*   *  示例
     *  最佳实战

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

//1.配置类中使用@Bean标注在方法上给容器注册组件,默认也是单实例的
    //2.配置类本身也是组件
    //   3、proxyBeanMethods : 代型bean的方法
    //           FuLL( proxyBeanMethods = true).
    //           Lite( proxyBeanMethods = false)
        //   组件依赖
    
    @Configuration(proxyBeanMethods = false)  //告诉SpringBoot这是一个配置类
    public class MyConfig {
        /**
         * 外部无论对配置类这个组件注册方法调用多少次,获取的都是之前注册到组件中的单实例
         * @return
         */
        @Bean("zxn") //给容器添加注解,以方法名作为组件的id,返回类型就是组件类型
        //返回的值就是组件在容器中保存的实例
        public User user01(){
            return new User("zxn",15,"男","北京市");
        }
    
    
    }

@SpringBootApplication
    public class MainApplication {
        public static void main(String[] args) {
            ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
            String[] beanDefinitionNames = run.getBeanDefinitionNames();
            //查看容器中的组件
            for (String beanDefinitionName : beanDefinitionNames) {
                System.out.println(beanDefinitionName);
            }
            //从容器中获取组件
            User zxn1 = run.getBean("zxn", User.class);
            User zxn2 = run.getBean("zxn", User.class);
            System.out.println("是否为单实例:"+(zxn1==zxn2));
            MyConfig bean = run.getBean(MyConfig.class);
            System.out.println(bean);
    //Configuration(proxyBeanMethods = true )代理对象调用方法。SringBoot总会检杳这个组件是否在容器中的单实例
            User user1 = bean.user01();
            User user2 = bean.user01();
            System.out.println("是否为单实例:"+(user1==user2));
    
    
        }
    }

输出：

> 是否为单实例:true  
> com.javastudy.boot.config.MyConfig@2c30b71f  
> 是否为单实例:false

当proxyBeanMethods = true时,为true

####  ####

#### @Import ####

@Import({User.class, DBHelper.class})

![93a14cd43d74440690a82afe35157222.png][]

#### 4、@Conditional ####

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

![92e42aad72d44a048cc96764ccc9651a.png][]

当pet没有@Bean注解时,在user上面加上

@ConditionalOnBean(name = "tom")

此时容器中就不会注册user01组件

**2.2、原生配置文件引入**

**1、@ImportResource**

在任意一个类上加

@ImportResource("classpath:bean.xml")

bean.xml文件里面的组件就会到容器里面

**2.3、配置绑定**

**1、@Component + @ConfigurationProperties**

@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 +
                    '}';
        }
    }

application.properties

mycar.brand=BYD
    mycar.price=10000

@RestController
    public class HelloContoller {
        @Autowired
        Car car;
        @RequestMapping("/hello")
        public String hello(){
            return "hello,springboot";
        }
    
        @RequestMapping("/car")
        public Car car(){
            return car;
        }
    }

![1bfdad32c0c64e97841c7ad3a6c76350.png][]

**2、@EnableConfigurationProperties + @ConfigurationProperties**

@Configuration(proxyBeanMethods = false)  //告诉SpringBoot这是一个配置类
    @ImportResource("classpath:bean.xml")
    @EnableConfigurationProperties(Car.class)
    //1、开启car配置绑定功能
    //2、把这个car这个组件自动注入到容器中
    public class MyConfig {
    
        /**
         * 外部无论对配置类这个组件注册方法调用多少次,获取的都是之前注册到组件中的单实例
         * @return
         */
        @Bean("zxn")
        @ConditionalOnBean(name = "tom")
       //给容器添加注解,以方法名作为组件的id,返回类型就是组件类型
        //返回的值就是组件在容器中保存的实例
        public User user01(){
            return new User("zxn",15,"男","北京市");
        }
    
    
       @Bean("tom")
        public Pet pettom(){
            return new Pet("xcl");
        }
    
    
    
    }

@ConfigurationProperties(prefix = "mycar")
    public class Car {
    }

## 二、自动配置原理入门 ##

### 3.1、引导加载自动配置类 ###

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

#### 1、@SpringBootConfiguration ####

@Configuration代表是一个配置类

#### 2、@ComponentScan ####

指定扫描哪些，Spring注解；

#### 3、@EnableAutoConfiguration ####

@AutoConfigurationPackage

@Import(AutoConfigurationPackages.Registrar.class)//给容器导入组件
    public @interface AutoConfigurationPackage {
    }

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
    
    		@Override
    		public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
    			register(registry, new PackageImports(metadata).getPackageNames().toArray(new String[0]));
    		}
    
    		@Override
    		public Set<Object> determineImports(AnnotationMetadata metadata) {
    			return Collections.singleton(new PackageImports(metadata));
    		}
    
    	}

//利用Registrar给容器中导入一系列组件
    //将指定的一个包下的所有组件导入进来
    
    
    @Import(AutoConfigurationImportSelector.class)

protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
    		if (!isEnabled(annotationMetadata)) {
    			return EMPTY_ENTRY;
    		}
    		AnnotationAttributes attributes = getAttributes(annotationMetadata);
    		List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
    		configurations = removeDuplicates(configurations);
    		Set<String> exclusions = getExclusions(annotationMetadata, attributes);
    		checkExcludedClasses(configurations, exclusions);
    		configurations.removeAll(exclusions);
    		configurations = getConfigurationClassFilter().filter(configurations);
    		fireAutoConfigurationImportEvents(configurations, exclusions);
    		return new AutoConfigurationEntry(configurations, exclusions);
    	}

1、利用getAutoConfigurationEntrv(annotationMetadata);给容器中批量导入一些组件

2.调用List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);

获取需要导入到容器中的组件

3.利用工厂加载private static 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

![e2b879dccade4d2297ccf3103004b4c3.png][]

![94f78f3c792a46bd869bf0ba254f953c.png][]

### 3.2、按需开启自动配置项 ###

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

### 3.3、修改默认配置 ###

### 3.4、最佳实践 ###

1.引入场景依赖

<dependency>
          <groupId>org.projectlombok</groupId>
          <artifactId>lombok</artifactId>
        </dependency>

[Developing with Spring Boot][]

2.查看自动配置了哪些（选做）

*  自己分析，引入场景对应的自动配置一般都生效了
 *  配置文件中debug=true开启自动配置报告。Negative（不生效）\\Positive（生效）

4.自定义加入或者替换组件

@Bean、@Component。。。

## 4、开发小技巧 ##

### 4.1、Lombok ###

引入依赖

<dependency>
          <groupId>org.projectlombok</groupId>
          <artifactId>lombok</artifactId>
        </dependency>

在setting-plugins中搜索添加

![5560a972aae847f2a593ebd496e48a3d.png][]

使用

![d45bf4a421784f9cad0c01f2fbed71c7.png][]

@Data为get和set方法,@ToString为tostring方法,@NoArgsConstructor无参构造器

@AllArgsConstructor 全参构造器 @EqualsAndHashCode是equals()andhashcode()

@Slf4j注解日志功能

@Slf4j
    @RestController
    public class HelloContoller {
        @Autowired
        Car car;
        @RequestMapping("/hello")
        public String hello(){
            log.info("请求进来");
            return "hello,springboot";
        }
    
        @RequestMapping("/car")
        public Car car(){
            return car;
        }
    }

![e87d64663a19449da2e927bba56d7ae0.png][]

### 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（项目初始化向导） ###

![0e5bfef6694744c29822f283d447cd9f.png][]

![4861f5df6c8c4f7fbe1a11b6630aca26.png][]

创建即可完成

## x、配置文件 ##

## 1、文件类型 ##

### 1.1、properties ###

同以前的properties用法

### 1.2、yaml ###

#### 1.2.1、简介 ####

YAML 是 "YAML Ain't Markup Language"（YAML 不是一种标记语言）的递归缩写。在开发的这种语言时，YAML 的意思其实是："Yet Another Markup Language"（仍是一种标记语言）。

非常适合用来做以数据为中心的配置文件

#### 1.2.2、基本语法 ####

*  key: value；kv之间有空格
 *  大小写敏感
 *  使用缩进表示层级关系
 *  缩进不允许使用tab，只允许空格
 *  缩进的空格数不重要，只要相同层级的元素左对齐即可
 *  '\#'表示注释
 *  字符串无需加引号，如果要加，''与""表示字符串内容 会被 转义/不转义

#### 1.2.3、数据类型 ####

例如:

person:
      username: zhangsan
      boss: true
      birth: 2009/01/25
      age: 15
     # interests: [足球,篮球]
      interests:
        - 篮球
        - 乒乓球
        - 羽毛球
      animal: [张选宁,薛程朗]
    #  score:
    #    english: 80
    #    chinese: 90
    #    math: 60
      score: {english: 80,chinese: 90,math: 10}
      salary :
        - 899.98
        - 1455.5
      pet:
        name: 阿龙
        weight: 99.99
      allPets:
        sick:
          - {name: zxn,weight: 156}
          - {name: ljl,weight: 156}
        health: [{name: ql,weight: 153},{name: cr,weight: 155}]

注意:

username: "zxn \\n lise" 双引号效果:

\{"userName":"zxn \\n lise",\}  
username:'zxn \\n lise' 单引号效果:  
\{"userName":"zxn \\\\n lise"\}

单引号会将ln 作为字符串输出  
双引号会将\\n作为换行输出  
双引号不会转义，单引号会转义

## 2、配置提示 ##

自定义的类和配置文件绑定一般没有提示。

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-configuration-processor</artifactId>
                <optional>true</optional>
            </dependency>
    
    
     <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <configuration>
                        <excludes>
                            <exclude>
                                <groupId>org.springframework.boot</groupId>
                                <artifactId>spring-boot-configuration-processor</artifactId>
                            </exclude>
                        </excludes>
                    </configuration>
                </plugin>
            </plugins>
        </build>

## 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][later in this document 1]).

*   *  支持 `HttpMessageConverters` （后来我们配合内容协商理解原理）

*  Automatic registration of `MessageCodesResolver` (covered [later in this document][later in this document 2]).

*   *  自动注册 `MessageCodesResolver` （国际化用）

*  Static `index.html` support.

*   *  静态index.html 页支持

*  Custom `Favicon` support (covered [later in this document][later in this document 3]).

*   *  自定义 `Favicon`

*  Automatic use of a `ConfigurableWebBindingInitializer` bean (covered [later in this document][later in this document 4]).

*   *  自动使用 `ConfigurableWebBindingInitializer` ，（DataBinder负责将请求数据绑定到JavaBean上）

## 2、简单功能分析 ##

### 2.1、静态资源访问 ###

#### 1、静态资源目录 ####

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

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

原理： 静态映射/\*\*。

请求进来，先去找Controller看能不能处理。不能处理的所有请求又都交给静态资源处理器。静态资源也找不到则响应404页面

#### 2、静态资源访问前缀 ####

默认无前缀

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

当前项目+static-path-pattern+静态资源名

3、webjar  
自动映射 /[webjars][]/\*\*  
[WebJars - Web Libraries in Jars][]

<dependency>
    			<groupId>org.webjars</groupId>
    			<artifactId>jquery</artifactId>
    			<version>3.5.1</version>
    		</dependency>

![30b90c15513844c19f3e59e842757b33.png][]

/webjars/jquery/3.5.1/jquery.js

### 2.2、欢迎页支持 ###

*  静态资源路径下 index.html

*   *  可以配置静态资源路径
     *  但是不可以配置静态资源的访问前缀。否则导致 index.html不能被默认访问
     *  controller能处理/index

### 2.3、自定义 `Favicon` ###

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

记得要关闭static-path-pattern

![46030eb5f9e04508b4f01371253c363e.png][]

### 2.4、静态资源配置原理 ###

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

## 3、请求参数处理 ##

### 0、请求映射 ###

#### 1、rest使用与原理 ####

*  @xxxMapping；
 *  Rest风格支持（*使用**HTTP**请求方式动词来表示对资源的操作*）

*   *  *以前：**/getUser* *获取用户* */deleteUser* *删除用户* */editUser* *修改用户* */saveUser* *保存用户*
     *  *现在： /user* *GET-**获取用户* *DELETE-**删除用户* *PUT-**修改用户* *POST-**保存用户*
     *  核心Filter；HiddenHttpMethodFilter

*   *   *  用法： 表单method=post，隐藏域 \_method=put
         *  SpringBoot中手动开启

*   *  扩展：如何把\_method 这个名字换成我们自己喜欢的。

Rest原理（表单提交要使用REST的时候）  
●表单提交会带上\_method=PUT  
●请求过来被HiddenHttpMethodFilter拦截  
○请求是否正常，并且是POST  
■获取到\_method的值。  
■兼容以下请求；PUT.DELETE.PATCH  
■原生request（post），包装模式requesWrapper重写了getMethod方法，返回的是传入的值。  
■过滤器链放行的时候用wrapper。以后的方法调用getMethod是调用requesWrapper的。  
  
Rest使用客户端工具，  
●如PostMan直接发送Put、delete等方式请求，无需Filter。

spring:
      mvc:
        hiddenmethod:
          filter:
            enabled: true

@RequestMapping(value = "/user",method = RequestMethod.GET)
        public String getUser(){
            return "GET-张三";
        }
    
        @RequestMapping(value = "/user",method = RequestMethod.POST)
        public String saveUser(){
            return "POST-张三";
        }
    
    
        @RequestMapping(value = "/user",method = RequestMethod.PUT)
        public String putUser(){
            return "PUT-张三";
        }
    
        @RequestMapping(value = "/user",method = RequestMethod.DELETE)
        public String deleteUser(){
            return "DELETE-张三";
        }

自定义 \_method  
![0dee73c4e42b472a90eacd58253f0ff6.png][]

#### 2、请求映射原理 ####

![a2119cce9b674e1b8a255be584a46a82.png][]

SpringMVC功能分析都从 org.springframework.web.servlet.DispatcherServlet--->doDispatch（）

### 1、普通参数与基本注解 ###

#### 1.1、注解 ####

@PathVariable、@RequestHeader、@ModelAttribute、@RequestParam、@MatrixVariable、@CookieValue、@RequestBody

@RestController
    public class ParameterController {
    
        @GetMapping("/car/{id}/owner/{name}")
        public Map<String,Object> car(@PathVariable("id") Integer id, @PathVariable("name") String name,
                                      @PathVariable Map<String,String> parameter,
                                      @RequestHeader("User-Agent") String agent,
                                      @RequestHeader Map<String,String> header,
                                      @RequestParam("age") Integer age,
                                      @RequestParam("hobby")List<String> hobby,
                                      @RequestParam Map<String,String> param,
                                      @CookieValue("Idea-1c60499a") String cookie){
            HashMap<String, Object> map = new HashMap<>();
            map.put("id",id);
            map.put("name",name);
            map.put("map",parameter);
            map.put("User-Agent",agent);
            map.put("header",header);
            map.put("age",age);
            map.put("hobby",hobby);
            map.put("param",param);
            map.put("cookie",cookie);
    
    
    
    
            return map;
    
        }
    }

**@RequestBody**

@PostMapping("/save")
        public Map<String,Object> postMethod(@RequestBody String content){
            HashMap<String, Object> map = new HashMap<>();
            map.put("content",content);
            return map;
    
        }

<form action="/save" method="post">
        username:<input type="text" name="username"/><br/>
        password:<input type="password" name="password"/><br/>
        <input type="submit" value="提交"/>
    </form>

**![0470f15cd49d4d188fce72fa05057467.png][]**

**@RequestAttribute**

@Controller
    public class RequestController {
        @RequestMapping("/request")
        public String get(Model model){
            model.addAttribute("name","张选宁");
            model.addAttribute("age",15);
            model.addAttribute("sex","男");
            return "forward:/success";
        }
    
        @RequestMapping("/success")
        @ResponseBody
        public Map<String,Object> success(@RequestAttribute("name") String name,
                                          @RequestAttribute("age") Integer age,
                                          HttpServletRequest request){
            Object sex = request.getAttribute("sex");
            HashMap<String, Object> map = new HashMap<>();
            map.put("name",name);
            map.put("age",age);
            map.put("sex",sex);
    
            return map;
        }
    }

注意:请求转发使用的是一个request,地址也不会发生改变

**矩阵变量**

**/cars/\{path\}?XXX=xxx&aaa=ccc querystring查询字符串。------->@RequestParam; /cars/\{path; low=34;brand=byd ,audi,yd\}; 矩阵变量**

**或者/cars/sell; low=34 ; brand=byd; brand=audi;brand=yd**

首先需要开启矩阵变量

@Configuration
    public class MyConfig implements WebMvcConfigurer {
        @Override
        public void configurePathMatch(PathMatchConfigurer configurer) {
            UrlPathHelper urlPathHelper = new UrlPathHelper();
            //不移除;后面的内容。矩阵变量功能就可以生效
            urlPathHelper.setRemoveSemicolonContent(false);
            configurer.setUrlPathHelper(urlPathHelper);
        }
    }

//  /cars/sell; low=34 ; brand=byd; brand=audi;brand=yd
        //SpringBoot默认禁用了矩阵变量的功能
        //需要手动开启
        @RequestMapping("/car/{path}")
        public Map<String,Object> carSell(@MatrixVariable("low") Integer low,@MatrixVariable("brand")List<String> brand,
                                          @PathVariable("path") String path){
            HashMap<String, Object> map = new HashMap<>();
            map.put("low",low);
            map.put("brand",brand);
            map.put("path",path);
            return map;
    
    
        }
    }

![006eb2fb4975474db31cf405594d7ca7.png][]

#### 1.2、Servlet API： ####

WebRequest、ServletRequest、MultipartRequest、 HttpSession、javax.servlet.http.PushBuilder、Principal、InputStream、Reader、HttpMethod、Locale、TimeZone、ZoneId

#### 1.3、复杂参数： ####

**Map**、**Model（map、model里面的数据会被放在request的请求域 request.setAttribute）、**Errors/BindingResult、**RedirectAttributes（ 重定向携带数据）**、**ServletResponse（response）**、SessionStatus、UriComponentsBuilder、ServletUriComponentsBuilder

## 4、数据响应与内容协商 ##

#### 1.1、jackson.jar+@ResponseBody ####

<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-web</artifactId>
    		</dependency>
    
    里面含有
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-json</artifactId>
          <version>2.7.4</version>
          <scope>compile</scope>
        </dependency>

给前端自动返回json数据；

#### 1.2、SpringMVC到底支持哪些返回值 ####

> ModelAndView
> 
> Model
> 
> View
> 
> ResponseEntity
> 
> ResponseBodyEmitter
> 
> StreamingResponseBody
> 
> HttpEntity
> 
> HttpHeaders
> 
> Callable
> 
> DeferredResult
> 
> ListenableFuture
> 
> CompletionStage
> 
> WebAsyncTask

#### 1.3、HTTPMessageConverter原理 ####

### 2、内容协商 ###

#### 1.引入依赖 ####

<dependency>
    			<groupId>com.fasterxml.jackson.dataformat</groupId>
    			<artifactId>jackson-dataformat-xml</artifactId>
    		</dependency>

#### 2、postman分别测试返回json和xml ####

只需要改变请求头中Accept字段。Http协议中规定的，告诉服务器本客户端可以接收的数据类型

![3df7d5365f764f6c87991153ccd8adc6.png][]

![53d7bad9fbcd49bcbdc2b510fdd66518.png][]

## 5、视图解析与模板引擎 ##

视图解析：**SpringBoot默认不支持 JSP，需要引入第三方模板引擎技术实现页面渲染。**

### 1、视图解析 ###

### 2、模板引擎-Thymeleaf ###

#### 1、thymeleaf简介 ####

Thymeleaf is a modern server-side Java template engine for both web and standalone environments, capable of processing HTML, XML, JavaScript, CSS and even plain text.

#### 2、基本语法 ####

**1、表达式**

![cbfb444a6dfd4f19a08abfc27bbecb03.png][]

### 3、thymeleaf使用 ###

**1、引入Starter**

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

自动配好的策略

*  1、所有thymeleaf的配置值都在 ThymeleafProperties
 *  2、配置好了 **SpringTemplateEngine** 
 *  **3、配好了** **ThymeleafViewResolver** 
 *  4、我们只需要直接开发页面

默认的前缀和后缀

> public static final String DEFAULT\_PREFIX = "classpath:/templates/";
> 
> public static final String DEFAULT\_SUFFIX = ".html"; //xxx.html

## 6、拦截器 ##

### 1、HandlerInterceptor 接口 ###

/**
     * 登录检查
     * 1.配置好拦截哪些请求
     * 2.把这些配置放在容器中
     * @author Chooker
     * @create 2022-10-25 17:36
     */
    public class LoginInterceptor implements HandlerInterceptor {
        @Override  //目标方法完成之前
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
          //登录检查逻辑
            HttpSession session = request.getSession();
            Object loginUser = session.getAttribute("loginUser");
            if(loginUser!=null)
                return true;
            else {
                //未登录,重定向跳转到登录页面
                request.setAttribute("msg","未登录");
                request.getRequestDispatcher("/").forward(request,response);
                return false;
            }
    
    
        }
    
        @Override  //目标方法完成之后
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
            HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
        }
    
        @Override  //页面渲染之后
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
            HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
        }
    }

### 2、配置拦截器 ###

@Configuration
    public class AdminWebConfig implements WebMvcConfigurer {
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
            registry.addInterceptor(new LoginInterceptor()).addPathPatterns("/**").//所有请求包括静态资源
                    excludePathPatterns("/","/login","/css/**","/fonts/**","/images/**","/js/**");
        }
    }

### 3、拦截器原理 ###

1、根据当前请求，找到**HandlerExecutionChain【**可以处理请求的handler以及handler的所有 拦截器】

2、先来**顺序执行** 所有拦截器的 preHandle方法

*  1、如果当前拦截器prehandler返回为true。则执行下一个拦截器的preHandle
 *  2、如果当前拦截器返回为false。直接 倒序执行所有已经执行了的拦截器的 afterCompletion；

**3、如果任何一个拦截器返回false。直接跳出不执行目标方法**

**4、所有拦截器都返回True。执行目标方法**

**5、倒序执行所有拦截器的postHandle方法。**

**6、前面的步骤有任何异常都会直接倒序触发** afterCompletion

7、页面成功渲染完成以后，也会倒序触发 afterCompletion

## 7、文件上传 ##

### 1、页面表单 ###

<form role="form" th:action="@{/upload}" method="post" enctype="multipart/form-data">
                                <div class="form-group">
                                    <label for="exampleInputEmail1">邮箱</label>
                                    <input type="email" name="email" class="form-control" id="exampleInputEmail1" placeholder="Enter email">
                                </div>
                                <div class="form-group">
                                    <label for="exampleInputPassword1">名字</label>
                                    <input type="text" name="username" class="form-control" id="exampleInputPassword1" placeholder="Password">
                                </div>
                                <div class="form-group">
                                    <label for="exampleInputFile">头像</label>
                                    <input type="file" name="headerImg" id="exampleInputFile">
                                </div>
                                <div class="form-group">
                                    <label for="exampleInputFile">生活照</label>
                                    <input type="file" name="photos" multiple>
                                </div>
                                <div class="checkbox">
                                    <label>
                                        <input type="checkbox"> Check me out
                                    </label>
                                </div>
                                <button type="submit" class="btn btn-primary">提交</button>
                            </form>

### 2、文件上传代码 ###

@GetMapping("/form_layouts")
        public String form_layouts(){
            return "/form/form_layouts";
        }
        @PostMapping("/upload")
        public String upload(@RequestParam("email")String email,
                             @RequestParam("username")String username,
                             @RequestPart("headerImg") MultipartFile headImage,
                             @RequestPart("photos")MultipartFile[] photos) throws IOException {
            log.info("上传的信息: email={},username={},headImage={},photos={}",
                    email,username,headImage.getSize(),photos.length);
            if(!headImage.isEmpty()){
                String fileName = headImage.getOriginalFilename();
    
                headImage.transferTo(new File("D:\\photos\\"+fileName));
            }
            if(photos.length>0){
                for (MultipartFile photo : photos) {
                    if(!photo.isEmpty()){
                        String fileName = photo.getOriginalFilename();
                        photo.transferTo(new File("D:\\photos\\"+fileName));
                    }
                }
            }
    
            return "main";
    
    
        }

### 3.上传信息大小的改变 ###

spring:
      mvc:
        hiddenmethod:
          filter:
            enabled: true
      servlet:
        multipart:
          max-file-size: 10MB
          max-request-size: 100MB

## 8、异常处理 ##

### 1、错误处理 ###

#### 1、默认规则 ####

*  默认情况下，Spring Boot提供`/error`处理所有错误的映射
 *  对于机器客户端，它将生成JSON响应，其中包含错误，HTTP状态和异常消息的详细信息。对于浏览器客户端，响应一个“ whitelabel”错误视图，以HTML格式呈现相同的数据

浏览器

![9b65e9050fd44985b0745f5584e76d59.png][] postman![a2f288c855f2436cbe8464b41c462cf0.png][]

**要对其进行自定义，添加**`View`**解析为**`erro`

![df8ae82a9f004873ae11e9835dd70aee.png][]

![a836a0e864ec4dd9810692d370d2c944.png][]

## 9、Web原生组件注入（Servlet、Filter、Listener） ##

### 1、使用Servlet API ###

//指定原生Servlet组件都放在哪里
    @SpringBootApplication  //默认扫描boot包下的所有
    @ServletComponentScan
    public class Boot05Web02Application {
    
    	public static void main(String[] args) {
    		SpringApplication.run(Boot05Web02Application.class, args);
    	}
    
    }

**Servlet**

//直接响应,没有经过Servlet的拦截器
    @WebServlet(urlPatterns = "/my")
    public class MyServlet extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            resp.getWriter().write("66666666");
        }
    }

**Filter**

@Slf4j
    @WebFilter(urlPatterns = {"/css/*","/images/*"})
    public class MyFilter implements Filter {
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
          log.info("filter起作用");
          filterChain.doFilter(servletRequest,servletResponse);
        }
    
        @Override
        public void init(FilterConfig filterConfig) throws ServletException {
            log.info("Filter创建");
        }
    
        @Override
        public void destroy() {
            log.info("filter的销毁");
        }
    }

**Listener**

@Slf4j
    @WebListener
    public class MyListener implements ServletContextListener {
        @Override
        public void contextInitialized(ServletContextEvent sce) {
            log.info("监听到listenr的初始化");
        }
    
        @Override
        public void contextDestroyed(ServletContextEvent sce) {
            log.info("监听到listenr的销毁");
        }
    }

推荐使用这种方式

--------------------

### 2、使用RegistrationBean ###

`ServletRegistrationBean`, `FilterRegistrationBean`, and `ServletListenerRegistrationBean`

@Configuration(proxyBeanMethods = true)  //保证依赖的组件是单实例的
    public class MyRegisterConfig {
        @Bean
        public ServletRegistrationBean myServlet(){
            MyServlet myServlet = new MyServlet();
            return new ServletRegistrationBean(myServlet,"/my","/my02");
        }
        @Bean
        public FilterRegistrationBean myFilter(){
            MyFilter myFilter = new MyFilter();
            //拦截myServlet的路径
    //        return new FilterRegistrationBean(myFilter,myServlet());
            FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(myFilter);
            filterRegistrationBean.setUrlPatterns(Arrays.asList("my","/css/*"));
            return filterRegistrationBean;
    
        }
        @Bean
        public ServletListenerRegistrationBean myListener(){
            MyListener myListener = new MyListener();
            return new ServletListenerRegistrationBean(myListener);
        }
    }

## 10、嵌入式Servlet容器 ##

### 1、切换嵌入式Servlet容器 ###

*  默认支持的webServer

*   *  `Tomcat`, `Jetty`, or `Undertow`
     *  `ServletWebServerApplicationContext 容器启动寻找ServletWebServerFactory 并引导创建服务器`

### 2、定制Servlet容器 ###

*  实现 **WebServerFactoryCu**stomizer<ConfigurableServletWebServerFactory>

*   *  把配置文件的值和`ServletWebServerFactory 进行绑定`

*  修改配置文件 **server.xxx**
 *  直接自定义 **ConfigurableServletWebServerFactory**

**xxxxx****Customizer****：定制化器，可以改变xxxx的默认规则**

import org.springframework.boot.web.server.WebServerFactoryCustomizer;
    import org.springframework.boot.web.servlet.server.ConfigurableServletWebServerFactory;
    import org.springframework.stereotype.Component;
    
    @Component
    public class CustomizationBean implements WebServerFactoryCustomizer<ConfigurableServletWebServerFactory> {
    
        @Override
        public void customize(ConfigurableServletWebServerFactory server) {
            server.setPort(9000);
        }
    
    }

## 11、定制化原理 ##

### 1、定制化的常见方式 ###

*  修改配置文件；
 *  **xxxxxCustomizer；**
 *  **编写自定义的配置类 xxxConfiguration；+** **@Bean替换、增加容器中默认组件；视图解析器** 
 *  **Web应用 编写一个配置类实现** **WebMvcConfigurer 即可定制化web功能；+ @Bean给容器中再扩展一些组件**

*  @EnableWebMvc + WebMvcConfigurer —— @Bean 可以全面接管SpringMVC，所有规则全部自己重新配置； 实现定制和扩展功能

### 2、原理分析套路 ###

**场景starter** **- xxxxAutoConfiguration - 导入xxx组件 - 绑定xxxProperties --** **绑定配置文件项**

## 06、数据访问 ##

### 1、SQL ###

#### 1、数据源的自动配置-HikariDataSource ####

**1、导入JDBC场景**

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

![7cc81ff1880e485f833c04307669e37c.png][]

数据库驱动？

为什么导入JDBC场景，官方不导入驱动？官方不知道我们接下要操作什么数据库。

**数据库版本和驱动版本对应**

<dependency>
    			<groupId>mysql</groupId>
    			<artifactId>mysql-connector-java</artifactId>
    		</dependency>

如果是mysql5版本的话:直接导入版本号,不需要springboot的版本仲裁

<dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>

直接在properties改掉属性

#### 3、修改配置项 ####

spring:
      datasource:
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://localhost:3306/eesy_mybatis?characterEncoding=utf8&useUnicode=true&useSSL=false&serverTimezone=UTC
        username: root
        password: woaini520
        type: com.zaxxer.hikari.HikariDataSource

#### 4、测试 ####

@Slf4j
    @SpringBootTest
    class Boot05Web02ApplicationTests {
    	@Autowired
    	JdbcTemplate jdbcTemplate;
    
    	@Test
    	void contextLoads() {
    		List<Map<String, Object>> maps = jdbcTemplate.queryForList("select * from user");
    		for (Map<String, Object> map : maps) {
    			System.out.println(map);
    		}
    	}
    
    }

### 2、使用Druid数据源 ###

#### 1、druid官方github地址 ####

[https://github.com/alibaba/druid][https_github.com_alibaba_druid]

整合第三方技术的两种方式

*  自定义
 *  找starter

**1.创建数据源**

@Configuration
    public class MyDataSourceConfig {
        @Bean //	容器中没有DataSource才会自动配置Hikari
        // @ConditionalOnMissingBean({ DataSource.class})
        @ConfigurationProperties("spring.datasource")
        public DataSource myDataSource(){
            DruidDataSource druidDataSource = new DruidDataSource();
            return druidDataSource;
    
    
        }
    }

**2、StatViewServlet**

StatViewServlet的用途包括：

*  提供监控信息展示的html页面
 *  提供监控信息的JSON API

<servlet>
    		<servlet-name>DruidStatView</servlet-name>
    		<servlet-class>com.alibaba.druid.support.http.StatViewServlet</servlet-class>
    	</servlet>
    	<servlet-mapping>
    		<servlet-name>DruidStatView</servlet-name>
    		<url-pattern>/druid/*</url-pattern>
    	</servlet-mapping>

@Bean
        public ServletRegistrationBean statViewServlet(){
            StatViewServlet statViewServlet = new StatViewServlet();
            ServletRegistrationBean<StatViewServlet> view = new ServletRegistrationBean<>(statViewServlet,"/druid/*");
            return view;
            
        }

@Bean //	容器中没有DataSource才会自动配置Hikari
        // @ConditionalOnMissingBean({ DataSource.class})
        @ConfigurationProperties("spring.datasource")
        public DataSource myDataSource() throws SQLException {
            DruidDataSource druidDataSource = new DruidDataSource();
            //加入监控功能
            druidDataSource.setFilters("stat");
            return druidDataSource;
    
    
        }

![4a4045c1268b405dbac87f03183713db.png][]

![e41e9fbcdb324cacaa0835ad7a4bde7d.png][]

**3、StatFilter**

用于统计监控信息；如SQL监控、URI监控

@Bean
        public FilterRegistrationBean webStatFilter(){
            WebStatFilter webStatFilter = new WebStatFilter();
    
            FilterRegistrationBean<WebStatFilter> webStatFilterFilterRegistrationBean = new FilterRegistrationBean<>(webStatFilter);
            webStatFilterFilterRegistrationBean.setUrlPatterns(Arrays.asList("/*"));
            webStatFilterFilterRegistrationBean.addInitParameter("exclusions","*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
            return webStatFilterFilterRegistrationBean;
    
        }

#### 3、使用官方starter方式 ####

**1、引入druid-starter**

<dependency>
    			<groupId>com.alibaba</groupId>
    			<artifactId>druid-spring-boot-starter</artifactId>
    			<version>1.1.17</version>
    		</dependency>

**2、配置示例**

spring:
      datasource:
        url: jdbc:mysql://localhost:3306/db_account
        username: root
        password: 123456
        driver-class-name: com.mysql.jdbc.Driver
    
        druid:
          aop-patterns: com.atguigu.admin.*  #监控SpringBean
          filters: stat,wall     # 底层开启功能，stat（sql监控），wall（防火墙）
    
          stat-view-servlet:   # 配置监控页功能
            enabled: true
            login-username: admin
            login-password: admin
            resetEnable: false
    
          web-stat-filter:  # 监控web
            enabled: true
            urlPattern: /*
            exclusions: '*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*'
    
    
          filter:
            stat:    # 对上面filters里面的stat的详细配置
              slow-sql-millis: 1000
              logSlowSql: true
              enabled: true
            wall:
              enabled: true
              config:
                drop-table-allow: false

### 3、整合MyBatis操作 ###

[MyBatis · GitHub][MyBatis _ GitHub]

<dependency>
    			<groupId>org.mybatis.spring.boot</groupId>
    			<artifactId>mybatis-spring-boot-starter</artifactId>
    			<version>2.1.4</version>
    		</dependency>

### 4、整合 MyBatis-Plus ###

<dependency>
    			<groupId>com.baomidou</groupId>
    			<artifactId>mybatis-plus-boot-starter</artifactId>
    			<version>3.5.2</version>
    		</dependency>

### 5、单元测试 ###

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

[Java 8]: https://www.java.com/
[Developing with Spring Boot]: https://docs.spring.io/spring-boot/docs/current/reference/html/using.html#using.build-systems.starters
[ec252384aec44a378ee95df84ff5757b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/f24411d3c4d94bcf86041ee100463cac.png
[27cd33b7ae0e4607aacf2134341adccc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/178fb081356140fd98fc51056a1ffac2.png
[93a14cd43d74440690a82afe35157222.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/2feca52bbaf44f649e19713cd0fa63b1.png
[92e42aad72d44a048cc96764ccc9651a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/6c7e9faab3d841328e57b87e9e57996f.png
[1bfdad32c0c64e97841c7ad3a6c76350.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/e803ec09ec704ac49992c9dbad7d580f.png
[e2b879dccade4d2297ccf3103004b4c3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/075f39ad0bc64dcb84418b5e3bdcc58d.png
[94f78f3c792a46bd869bf0ba254f953c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/37782d7b621a418492c0daae4931650d.png
[5560a972aae847f2a593ebd496e48a3d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/d5870630d610468e8c9c08521dc7672d.png
[d45bf4a421784f9cad0c01f2fbed71c7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/ff62652381ab42d48f065d85ba88800e.png
[e87d64663a19449da2e927bba56d7ae0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/c78c8f2a0c8d4f0f9031a5b739f2febf.png
[0e5bfef6694744c29822f283d447cd9f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/005f596a63264e429c1228986289bd2a.png
[4861f5df6c8c4f7fbe1a11b6630aca26.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/2ffc058b001d464fae5d2d7cc7fbaa3a.png
[later in this document]: https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-spring-mvc-static-content
[later in this document 1]: https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-spring-mvc-message-converters
[later in this document 2]: https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-spring-message-codes
[later in this document 3]: https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-spring-mvc-favicon
[later in this document 4]: https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-spring-mvc-web-binding-initializer
[webjars]: http://localhost:8080/webjars/jquery/3.5.1/jquery.js
[WebJars - Web Libraries in Jars]: https://www.webjars.org/
[30b90c15513844c19f3e59e842757b33.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/3ed52223023a44b2af98cb88ccdadc55.png
[46030eb5f9e04508b4f01371253c363e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/ee32249ac6694395a9b56a96ef268df4.png
[0dee73c4e42b472a90eacd58253f0ff6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/57eeee85f34f4dc6ab01953044f895b9.png
[a2119cce9b674e1b8a255be584a46a82.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/63a3f93eddb04b77ad9cd0e32478c05d.png
[0470f15cd49d4d188fce72fa05057467.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/3ded26e75ce34182b4b31a688123adb1.png
[006eb2fb4975474db31cf405594d7ca7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/b35eb48657774a7f80f3fa0079bbb5f4.png
[3df7d5365f764f6c87991153ccd8adc6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/940ad28a19654211ae9904fcb0518be4.png
[53d7bad9fbcd49bcbdc2b510fdd66518.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/b3762688f1514f45aad6771e5c53d90a.png
[cbfb444a6dfd4f19a08abfc27bbecb03.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/a5c97736c7df48fababe54d0a6cd7ba8.png
[9b65e9050fd44985b0745f5584e76d59.png]: https://img-blog.csdnimg.cn/9b65e9050fd44985b0745f5584e76d59.png
[a2f288c855f2436cbe8464b41c462cf0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/1095768cf6284ad2a2651c542f4811e1.png
[df8ae82a9f004873ae11e9835dd70aee.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/e2833a858016488fbb60b80044abeee8.png
[a836a0e864ec4dd9810692d370d2c944.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/cfa6595eb16940cf96342e179224ec73.png
[7cc81ff1880e485f833c04307669e37c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/152ca0456f6e4a03878e4768c668b82f.png
[https_github.com_alibaba_druid]: https://github.com/alibaba/druid
[4a4045c1268b405dbac87f03183713db.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/9eb76e5df588424888815bbb9c99cc8d.png
[e41e9fbcdb324cacaa0835ad7a4bde7d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/f77fa8c0e22c4e8bae32876425283003.png
[MyBatis _ GitHub]: https://github.com/mybatis