SpringBoot

SpringBoot1.0.1

导入依赖

<!--    引入了父Maven项目,继承父Maven项目所有的配置信息
        spring-boot-starter-parent 有引入了一个父Maven项目
     <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.5.RELEASE</version>
        <relativePath/>
    </parent>
    spring-boot-starter-parent 帮我们管理了SpringBoot应用中所有依赖的版本,
    以后我们导入已有依赖就不需要写版本号了,它帮我们解决了第三方库之间的版本冲突问题
    SpringBoot的版本仲裁中心
-->
<!--集成springboot的项目-->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.5.RELEASE</version>
    <relativePath/>
</parent>
<!--
  starter 场景启动器 : 不同的场景启动器维护了所有对应的所有依赖,从而简化maven文件书写
  spring-boot-starter-web : 使用Spring MVC构建Web(包括RESTFUL)应用程序,使用TomCat作为默认的嵌入式容器
  -->
<dependencies>
    <!--引入springboot的web支持-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

@Configuration springBeans.xml : 也是配置类 声明Beans.xml 声明容器;

/**
 * @SpringBootApplication : SpringBoot的启动类(入口)
 *
 * @Configuration spring.xml : 也是配置类
 *
 * @ComponentScan  =  <context:component-scan basePackages="com.xao."></context:component-scan>
 *
 * Spring底层在解析配置类, 会去解析@ComponentScan,读取basePackages,
 * 如果没有读取到,会将当前配置类所在的包当做扫描包 com/xiao/Application ......
 *
 * 位置: 最后放在需要扫描包的根目录.或者说放在所有包的顶层目录中
 */

标记SpringBoot启动类 SpringBoot内置TomCat

@SpringBootApplication //标记成SpringBoot的启动类
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

打成jar包 cmd 命令直接启动 无需配置

<!--  部署springboot的插件, 只有加了这个插件 当我们运行 java -jar xxx.jar才能正常启动  -->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

SpringBoot1.0.2

springboot配置文件 约定大于配置

resources —> application.properties

设置端口号
server.port=8088
设置路径前缀 localhost:8088/xiao/hello/world
server.servlet.context-path=/xiao

1.使用Spring Initializer快速创建SpringBoot项目

1.IDEA:使用Spring Initializer快速创建项目

        继承关系-springboot的maven项目
        1.使用spring initializer新建一个父maven,type选择POM
        2.使用spring initizlizer新建一个子maven,type选择project
        修改 子项目中的继承方式:
        之前:

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.6.4</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

        之后:

    <parent>
        <groupId>com.xaio.springboot</groupId>
        <artifactId>springboot_parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>

spring_initializer —-> springboot_parent —->spring-boot-starter-parent

IDE都支持使用Spring的项目创建向导快速创建一个Spring Boot项目:

选择我们需要的模块; 向导会联网创建Spring Boot项目;

默认生成的Spring Boot项目;

    主程序已经生成好了,我们只需要我们自己的逻辑
    resources文件夹中目录结构
            static:保存所有的静态资源 js css images
            templates: 保存所有的模板页面; (Spring Boot默认jar包使用嵌入式的TomCat,默认不支持JSP页面);
                                可以使用模板引擎(freemarker,thymeleaf)
            application.properties:Spring Boot应用的配置文件;  可以修改一些默认设置;

SpringBoot1.0.3自定义SpringApplication

public static void main(String[] args) {
    SpringApplication app = new SpringApplication(SpringInitializrApplication.class);
    app.setBannerMode(Banner.Mode.OFF); //可以关闭springboot启动横幅
    app.run(args);
}

@RestController = @ResponseBody and @Controller 合体

@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String handle01(){
        return "Hello Spring Boot 2!";
    }
    public HelloController(){
        System.out.println("HelloController被执行");
    }
}

1.1、依赖管理

• 父项目做依赖管理
  依赖管理

org.springframework.boot
spring-boot-starter-parent
2.3.4.RELEASE

他的父项目

org.springframework.boot
spring-boot-dependencies
2.3.4.RELEASE

几乎声明了所有开发中常用的依赖的版本号,自动版本仲裁机制

• 开发导入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、所有场景启动器最底层的依赖

org.springframework.boot
spring-boot-starter
2.3.4.RELEASE
compile

• 无需关注版本号，自动版本仲裁
  1、引入依赖默认都可以不写版本
  2、引入非版本仲裁的jar，要写版本号
• 可以修改默认版本号

1、查看spring-boot-dependencies里面规定当前依赖的版本 用的 key。
2、在当前项目里面重写配置

5.1.43

1.2、自动配置

• 自动配好Tomcat
  引入Tomcat依赖
  配置TomCat org.springframework.boot spring-boot-starter-tomcat 2.3.4.RELEASE compile
  自动配置好springMVC
  引入springMVC全套组件
  自动引入好SpringMVC常用组件(功能)
  自动配好Web常见功能,如:字符编码问题
  SpringBoot帮我们的配置好了所有web开发的常见场景
  默认的包结构
  主程序所在包及其下面的所有子包里面的组件都会被默认扫描进来
  想要改变扫描器路径
  无需以前的包扫描配置@SpringBootApplication(“com.xiao”) or @ComponentScan(“com.xiao”)
  各种配置拥有默认值
  默认配置都是映射到MultipartProperties
  配置文件的值最终会绑定每个类上,这个类会在容器中创建对象
  按需加载所有自动配置项
  非常多的starter
  引入了哪些场景这个场景的自动配置才会开启
  SpringBoot的所有自动配置都在spring-boot-autoconfigure包里:

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

  
  ……

查看SpringBoot容器中所有组件

//返回IOC容器
ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
//查看容器里面的组件
String[] names = run.getBeanDefinitionNames();
for (String name : names) {
    System.out.println(name);
}

2,容器功能

2.1,组件添加

1,@Configuration

基本使用

//告诉springboot 这是一个配置类 == 配置文件

Full模式与Lite模式

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

2,@Bean,@Component,@Controller,@Service,@Repository

/**
 * 1,配置类里面可以使用@Bean标注在方法上给容器注册组件,默认也是单实例的
 * 2,配置类本身也是组件
 * proxyBeanMethods: 代理bean的方法
 *      Full(proxyBeanMethods = true),
 *      Lite(proxyBeanMethods = false)
 *      组件依赖
 */
@Configuration(proxyBeanMethods = true) //告诉springboot 这是一个配置类 == 配置文件
public class MyConfig {
    /**
     * 外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
     * @return
     */
    @Bean //给容器中添加组件.以方法名作为组件的id,返回类型就是组件类型,返回的值,就是组件在容器中的实例
    public User user(){
        User zhangsan = new User("zhangsan", 18);
        //user组件依赖了Pet组件
        zhangsan.setPet(tomcatPet());
        return zhangsan;
    }
    @Bean("tom")
    public Pet tomcatPet(){
        return new Pet("tomcat");
    }
}
/**
 * 主程序类
 * @SpringBootApplication : 这是一个SpringBoot应用
 *
 * @SpringBootApplication("com.xiao") 想要改变包扫描器的扫描路径
 */
@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
        //返回IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
        //查看容器里面的组件
        String[] names = run.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
        //从容器中获取组件
        Pet tomcatPet = run.getBean("tom", Pet.class);
        Pet tomcatPet1 = run.getBean("tom", Pet.class);
        System.out.println("组件:"+(tomcatPet == tomcatPet1));
        MyConfig bean = run.getBean(MyConfig.class);
        //如果@Configuration(proxyBeanMethods = true)代理对象调用方法.springboot总会检查这个组件是否在容器中有
        //保持组件单实例
        User user = bean.user();
        User user1 = bean.user();
        System.out.println(user == user1);
        User user2 = run.getBean("user", User.class);
        Pet tom = run.getBean("tom", Pet.class);
        System.out.println(user2.getPet() == tom);
    }
}

3,@ComponentScan,@Import

4,@Import({User.class, DBHelper.class})
  给容器中自动创建出这连个类型的组件,默认组件的名字就是全类名

user自己设置的

//@SpringBootApplication
String[] beanNamesForType = run.getBeanNamesForType(User.class);
System.out.println("=================");
for (String s : beanNamesForType) {
    System.out.println(s);
}
String[] beanNamesForType1 = run.getBeanNamesForType(DBHelper.class);
System.out.println("=================");
for (String s : beanNamesForType1) {
    System.out.println(s);
}

4,@Conditional 条件

在Config中使用 容器创建时

条件装配:满足Conditional指定的条件,则进行组件注册

2.2,原生配置文件引入

1,@ImportResource

//@ImportResource("classpath:beans.xml")导入Spring的配置文件
@ImportResource("classpath:beans.xml")  引入外部容器xml
public class MyConfig {}

2.3,属性绑定

1,@ConfigurationProperties

如何使用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。
}
}
}

2,@EnableConfigurationProperties + @ConfigurationProperties

@EnableConfigurationProperties(Car.class)
//1,开启属性配置绑定功能
//2,把这个Car这个组件自动注册到容器中
public class MyConfig {}
/**
 * 只有在容器中的组件,才会拥有SpringBoot提供的强大功能
 */
//@Component
@ConfigurationProperties(prefix = "mycar")
public class Car {}
//比如导入依赖包 包内没有@Component 就可以使用这个

3,@Component + @ConfigurationProperties

/**
 * 只有在容器中的组件,才会拥有SpringBoot提供的强大功能
 */
@Component
@ConfigurationProperties(prefix = "mycar")
public class Car {}

3,自动配置原理入门

3.1,引导加载自动配置类

@EnableAutoConfiguration //启用自动配置
@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({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {}

1,@AutoConfigurationPackage

@Import({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

3.2,按需开启自动配置项

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

3.3,修改默认配置

        @Bean
        @ConditionalOnBean({MultipartResolver.class})    //容器中有这个类型组件
        @ConditionalOnMissingBean(
            name = {"multipartResolver"}
        )        //容器中没有这个名字multipartResolver的组件
        public MultipartResolver multipartResolver(MultipartResolver resolver) {
            //给@Bean标注的方法传入了对象参数,这个参数的值就会从容器中找.
            //springmvc  multipartResolver.防止有些用户配置的文件上传解析器不符合规范  文件上传解析器
            return resolver;
        }
给容器加入了文件上传解析器

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

    @Bean
    @ConditionalOnMissingBean
    public CharacterEncodingFilter characterEncodingFilter() {}

总结:

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

xxxAutoConfiguration —>组件 —>xxxProperties里面拿值 —-> application.properties

3.4,最佳实践

引入场景依赖

[https://docs.spring.io/spring-boot/docs/current/reference/html/using.html#using.build-systems.starters](https://docs.spring.io/spring-boot/docs/current/reference/html/using.html#using.build-systems.starters)

查看自动配置了哪些(选做)

自己分析,引入场景对应的自动配置一般都生效了
配置文件中debug=true 开启自动配置报告. Negative(不生效)  \  Positive(生效)

是否需要定制化

参考文档修改配置项https://docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html#appendix.application-properties.json
自己分析.xxxProperties绑定了配置文件的哪些

自定义加入或者替换组件

[@Bean ](/Bean ) , [@Component.... ](/Component.... ) 

自定义器 XXXCustomizer;

4,开发小技巧

4.1,Lombok

简化javaBean开发

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
并搜索安装lombok
@Data    //get set
@ToString    //toString
@NoArgsConstructor    //无参构造
@AllArgsConstructor    //有参构造
@Component
@ConfigurationProperties(prefix = "mycar")
public class Car {
    private String brand;
    private Integer price;
}
//写入日志
@Slf4j
@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String handle01(String name) {
        log.info("进入:handle01方法!");              //*********************
        return "Hello Spring Boot 2! 喜傲!"+name;
    }
}

4.2,dev-tools

<!--        springboot 自动快捷键重启-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>

Ctel + F9;

4.3,Spring Initailizer

idea 快速创建 SpringBoot项目

04,配置文件

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,数据类型

字面量: 单个的,不可再分的值. data,boolean,string,number,null

k: v

对象: 键值对的集合.map,hash,set,object

行内写法: k: {k1:v1,k2:v2,k3:v3}
#或
k:
 k1: v1
 k2: v2
 k3: v3

数组: 一组按次序排列的值. array, list , queue

行内写法: k:[v1,v2,v3]
#或者
k:
 - v1
 - v2
 - v3

Component 在yaml 配置时自动提示 不打包自动提示

<!--        bean类在yaml自动提示插件-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
在springboot打包配置中 加入 可以在打包的时候 不打包processor自动提示包
<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>

05,Web开发

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,静态资源访问

1,静态资源目录

类路径下: called/static(or/public or /resources or /META-INF/resources

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

静态资源 和ming请求同名

原理: 静态资源映射/**.

请求进来先去找controller看能不能处理,不能处理所有请求又都交给静态资源处理器.静态资源能不能找到:

静态资源能找到就返回静态资源,静态资源找不到就返回404

改变默认的静态资源路径

spring:
  mvc:
    static-path-pattern: /static/**
  web:
    resources:
#      static-locations: [clsspath:/static,clsspath:/.......]
      static-locations: clsspath:/static

2,静态资源访问前缀

springboot 默认 是/** 是没有前缀的

但是可以在yaml中: 增加前缀

spring:
  mvc:
  #默认是: /** 扫描根目录下所有资源
    static-path-pattern: /static/**

当前项目 + static-path-pattem+静态资源名 = 静态资源文件下找

3,webjar

自动映射

https://www.webjars.org/

        <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.2,欢迎页支持

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

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

controller能处理/index

2.3,自定义 Favicon

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

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

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 {}

给容器中配置了什么

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

配置文件的相关属性和xxx进行了绑定,WebMvcPropertiesspring.mvc,WebPropertiesspring.web

1,配置了只有一个有参构造器

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

@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
   if (!this.resourceProperties.isAddMappings()) {
      logger.debug("Default resource handling disabled");
      return;
   }
    //webjars的规则
   addResourceHandler(registry, "/webjars/**", "classpath:/META-INF/resources/webjars/");
   addResourceHandler(registry, this.mvcProperties.getStaticPathPattern(), (registration) -> {
      registration.addResourceLocations(this.resourceProperties.getStaticLocations());
      if (this.servletContext != null) {
         ServletContextResource resource = new ServletContextResource(this.servletContext, SERVLET_LOCATION);
         registration.addResourceLocations(resource);
      }
   });
}

spring:
  web:
    resources:
      add-mappings: false  #引用所有的静态资源
      cache:
        period: 120 #设置静态缓存时间

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, Resource welcomePage, String staticPathPattern) {
         //要用欢迎页功能必须是/**
        if (welcomePage != null && "/**".equals(staticPathPattern)) {
            logger.info("Adding welcome page: " + welcomePage);
            setRootViewName("forward:index.html");
        }
        else if (welcomeTemplateExists(templateAvailabilityProviders, applicationContext)) {
            //掉用Controller /index
            logger.info("Adding welcome page template: index");
            setRootViewName("index");
        }
    }

4,favicon

浏览器会发送/favicon.ico请求获取到图标,整个session期间不能在获取

3,请求参数处理

[@xxxMapping ](/xxxMapping )    GET POST 
Rest风格支持(谁用Http请求方式动词来表示对资源的操作)
    以前:/getUser 获取用户  /deleteUser 删除用户 /editUser 修改用户  /saveUser保存用户
    现在:/user GET-获取用户  DELETE-删除用户 PUT-修改用户 POST-保存用户
    核心Filter; HiddenHttpMethodFilter
        用法: 表单method=post , 隐藏域_method=put
        SpringBoot中手动开启

@Bean
@ConditionalOnMissingBean(HiddenHttpMethodFilter.class)
@ConditionalOnProperty(prefix = "spring.mvc.hiddenmethod.filter", name = "enabled")
public OrderedHiddenHttpMethodFilter hiddenHttpMethodFilter() {
   return new OrderedHiddenHttpMethodFilter();
}

Rest原理(表单提交使用REST的时候)

表单上提交会带上_method=PUT
请求过来被HiddenHttpMethodFilter拦截
    请求是否正常,并且是POST
        获取到_method的值
        兼容以下请求:

HttpMethod.PUT.name(),HttpMethod.DELETE.name(), HttpMethod.PATCH.name()

        原生request(post),包装模式requesWrapper重写了getMethod方法,返回的是传入的值
        过滤器链放行的时候用wrapper.以后的方法调用getMethod是调用requestWrapper的

Rest使用客户端工具,

如PostMan直接发送Put,delete等方式请求,无需Filter

Spring
    mvc:
      hiddenmethod:
        filter:
              enabled: true  #开启页面表单的Rest功能

自定义修改_method

@Bean
public HiddenHttpMethodFilter hiddenHttpMethodFilter(){
    HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
    hiddenHttpMethodFilter.setMethodParam("_m");
    return hiddenHttpMethodFilter;
}

2,请求映射原理

SpringMVC功能分析都从DispatcherServlet —> doDispatch

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
   HttpServletRequest processedRequest = request;
   HandlerExecutionChain mappedHandler = null;
   boolean multipartRequestParsed = false;
   WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
   try {
      ModelAndView mv = null;
      Exception dispatchException = null;
      try {
         processedRequest = checkMultipart(request);
         multipartRequestParsed = (processedRequest != request);
         //找到当前请求使用那个handler(Controller)处理
         // Determine handler for the current request.
         mappedHandler = getHandler(processedRequest);
          //HandlerMapping : 处理器映射.   /xxx->>xxxxx

RequestMappingHandlerMapping : 保存了所有@RequestMapping和handler的映射规则

所有的请求映射都在HandlerMapping中.

-SpringBoot自动配置欢迎页的 WelcomePageHandlerMapping HandlerMapping.访问/能访问到index.html;

-SpringBoot配置了默认的RequestMappingHandlerAdapter

-请求进来,挨个尝试所有的HandlerMapping看是否有请求信息.

如果有就找到请求对应的Handler
如果没有就是下一个HandlerMapping

我们需要一些自定义的映射处理,我们也可以给容器中放HandlerMapping . 自定义HandlerMapping

1,普通参数与基本注解

**注解**

@PathVariable,@RequestHeader,@ModelAttribute,@RequesParam,@MatrixVariable,@CookieValue,

@RequestBody

@PathVariable 获取路径信息

<a href="/car/3/owner/lisi">/car/{id}/owner/{username}</a>
<li>@PathVariable(路径变量)</li>

//  car/2/owner/zhangsan
@GetMapping("/car/{id}/owner/{username}")
public Map<String,Object> getCar(@PathVariable("id") Integer id,
                                 @PathVariable("username") String name,
                                 @PathVariable() Map<String,String> pv){
    Map<String,Object> map = new HashMap<>();
    map.put("id",id);
    map.put("name",name);
    map.put("pv",pv);
    return map;
}

@RequestHeader 获取请求头数据

//  car/2/owner/zhangsan
@GetMapping("/car/{id}/owner/{username}")
public Map<String,Object> getCar(@PathVariable("id") Integer id,
                                 @PathVariable("username") String name,
                                 @PathVariable() Map<String,String> pv,
                                 @RequestHeader("Host") String userHost,
                                 @RequestHeader Map<String,String> header){
    Map<String,Object> map = new HashMap<>();
    map.put("id",id);
    map.put("name",name);
    map.put("pv",pv);
    map.put("userHost",userHost); //获取请求用户的Host
    map.put("header",header);    //获取请求用户的所有请求头信息
    return map;
}

@RequesParam(“指定name”) 获取表单指定属性

@CookicValue 获取Cookic

//@CookieValue("_ga") String _ga,      //获取指定Cookie
//@CookieValue Cookie cookie,          //获取全部Cookie

@RequestBody post提交 获取表单全部数据

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

@RequestAttribute() //获取转发来的request域中的数据 记住 forward: 请求转发

@GetMapping("/goto")
public String  goToPage(HttpServletRequest request){
    request.setAttribute("msg","成功了");
    request.setAttribute("code",200);
    return "forward:/success";  //转发到  /success请求
}
@ResponseBody
@GetMapping("/success")
public Map success(@RequestAttribute("msg") String msg,
                                   @RequestAttribute("code") Integer code,
                                   HttpServletRequest request){
    Object msg1 = request.getAttribute("msg");
    Map<String,Object> map = new HashMap<>();
    map.put("reqMethod_msg",msg1);
    map.put("annotation_msg",msg);
    map.put("annotation_code",code);
    return map;
}

@MatrixVariable

// /cars/sell;low=34;brand=byd,audi,yd
//SpringBoot默认禁用了矩阵变量的功能
//          手动开启 : 原理. 对于路径的处理.UrlPathHelper进行解析.
//          removeSemicolonContent(移除分号内容)支持矩阵变量
@GetMapping("/cars/{path}")
public Map carsSell(@MatrixVariable("low") Integer low
                    ,@MatrixVariable("brand") List<String> brand,
                    @PathVariable("path") String path){
    Map<String, Object> map = new HashMap<>();
    map.put("low",low);
    map.put("brand",brand);
    map.put("path",path);
    return map;
}

需要配置开启矩阵变量功能 因为默认是禁用矩阵变量 的 true 改成 set false

//1,WebMvcConfigurer定制化SpringMVC的功能
@Bean
public WebMvcConfigurer webMvcConfigurer(){
    return new WebMvcConfigurer() {
        @Override
        public void configurePathMatch(PathMatchConfigurer configurer) {
            UrlPathHelper urlPathHelper = new UrlPathHelper();
            //不移除:后面的内容. 矩阵变量功能就可以生效
            urlPathHelper.setRemoveSemicolonContent(false);
            configurer.setUrlPathHelper(urlPathHelper);
        }
    };
}

@MatrixVariable("low")  //不同名
@MatrixVariable(value = "age" ,pathVar = "bossId") //同名

//如果两个var 是同名 
@GetMapping("/boss/{bossId}/{empId}")
public Map boss(@MatrixVariable(value = "age" ,pathVar = "bossId") Integer bossAge,
                @MatrixVariable(value = "age" ,pathVar = "empId") Integer empAge){
    Map<String, Object> map = new HashMap<>();
    map.put("bossAge",bossAge);
    map.put("empAge",empAge);
    return map;
}

<li>@PathVariable(路径变量)</li>
<li>@RequestHeader(获取请求头)</li>
<li>@RequestParam(获取请求参数)</li>
<li>@CookieValue(获取Cookie值)</li>
<li>@RequestAttribute(获取request域属性)</li>
<li>@RequestBody(获取请求体)</li>
<li>@MatrixVariable(矩阵变量)</li>

Servlet API

WebRequest, ServletRequest,MultipartRequest,HttpSession,javax.servlet.http.PushBuilder,Principal,

InputStream,Reader,HttpMethod,Locale,TimeZone,Zoneld

复杂参数

Map,Errors/BindingResult,Model,RedirectAttributes,ServletResponse,SessionStatus,UriComponentsBuider,ServletUriComponentsBuider

自定义对象参数

可以自动类型格式与格式化,可以级联封装.

2,POJO封装过程

3,参数处理原理

HandlerMappering中找到能处理请求的Handler(Controller.method())

为当前Handler找一个适配器HandlerAdapter; RequestMappingHandlerAdapter

1,HandlerAdapter

0-支持方法上标注@RequestMapping

1-支持函数式编程的

…

2,执行目标方法

// Actually invoke the handler.
//DispatcherServlet --- doDispach
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

mav = invokeHandlerMethod(request, request,handlerMethod); //执行目标方法
//ServietInvocableHandlerMethod
Object returnValue = invokForRequest(webRequest,mavContainer,providedArgs);
//获取方法参数值
Object[] args = getMethodArgumentValues(request,mavContainer,providedArgs)

3,参数解析器

确定将要执行的目标方法的每一个值是什么

SpringMVC目标方法能写多少种参数类型,取决于参数解析器.

当前解析器是否支持解析这种参数

支持就调用 resolveArgument

4,返回值处理器

5,如何确定目标方法每一个参数的值

============InvocableHandlerMethod==========================
protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
            Object... providedArgs) throws Exception {    
    MethodParameter[] parameters = getMethodParameters();
    if (ObjectUtils.isEmpty(parameters)) {
        return EMPTY_ARGS;
    }
    Object[] args = new Object[parameters.length];
    for (int i = 0; i < parameters.length; i++) {
        MethodParameter parameter = parameters[i];
        parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
        args[i] = findProvidedArgument(parameter, providedArgs);
        if (args[i] != null) {
            continue;
        }
        if (!this.resolvers.supportsParameter(parameter)) {
            throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
        }
        try {
            args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
        }
        catch (Exception ex) {
            // Leave stack trace for later, exception may actually be resolved and handled...
            if (logger.isDebugEnabled()) {
                String exMsg = ex.getMessage();
                if (exMsg != null && !exMsg.contains(parameter.getExecutable().toGenericString())) {
                    logger.debug(formatArgumentError(parameter, exMsg));
                }
            }
            throw ex;
        }
    }
    return args;
}

5.1挨个判断所有参数解析器那个支持解析这个参数

@Nullable
private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
    HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
    if (result == null) {
        for (HandlerMethodArgumentResolver resolver : this.argumentResolvers) {
            if (resolver.supportsParameter(parameter)) {
                result = resolver;
                this.argumentResolverCache.put(parameter, result);
                break;
            }
        }
    }
    return result;
}

自定义Converter原理

<form action="/saveuser" method="post">
    姓名:     <input name="userName" value="zhangsan"/> <br>
    年龄:     <input name="age" value="18"/> <br>
    生日:     <input name="birth" value="2019/12/10"><br>
<!--    宠物姓名:  <input name="pet.name" value="阿猫"><br>-->
<!--    宠物年龄;  <input name="pet.age" value="5"><br>-->
    宠物: <input name="pet" value="阿猫,3"/>
    <input type="submit" value="提交">
</form>

@Data
public class Person {
    private String userName;
    private Integer age;
    private Date birth;
    private Pet pet;
}
@Data
public class Pet {
    private String name;
    private Integer age;
}

/**
 * 数据绑定: 页面提交的请求数据(GET,POST)都可以和对象属性进行绑定
 * @param person
 * @return
 */
@PostMapping("/saveuser")
public Person saveuser(Person person){
    return person;
}

自定义Converter
@Bean
public WebMvcConfigurer webMvcConfigurer(){
    return new WebMvcConfigurer() {
        @Override
        public void addFormatters(FormatterRegistry registry) {
            registry.addConverter(new Converter<String , Pet>() {
                @Override
                public Pet convert(String source) {
                    //阿猫. 3
                    if (!StringUtils.isEmpty(source)){
                        Pet pet = new Pet();
                        String[] split = source.split(",");
                        pet.setName(split[0]);
                        pet.setAge(Integer.parseInt(split[1]));
                        return pet;
                    }
                    return null;
                }
            });
        }
    };
}
 浏览器会先传送一个name=pet的，值=”阿猫，3“的数据给服务器，
底层在处理到自定义对象参数（此时没有发生判断，在服务器层面这个参数此时和上面服务器传来的数据无关）的时候会先找到这个自定义对象参数类型，然后调用参数解析器，当调用自定义参数解析器
 处理这个参数的时候，会先找所有的Converter进行类型转换，此时自定义的Converter是String->Pet,此时浏览器传送过来的是String类型的数据，服务器找到的接收数据的对象参数是Person，而Person中有Pet，所以在绑定Person中的Pet属性时，就会调用到String->Pet这个自定义的Converter进行属性数据绑定，而Person中的其他属性比如Integer类型的age和Date类型的birth就会调用其他的Converter比如String->Integer,String->Date来进行属性数据绑定
————————————————
版权声明：本文为CSDN博主「陪安琪度过一生」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_56965737/article/details/118656010

4,响应数据与内容协商

1,响应JSON

1.1,jackson.jar+ResponseBody

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
web场景自动引入了json依赖
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-json</artifactId>
  <version>2.6.4</version>
  <scope>compile</scope>
</dependency>

@ResponseBody

给前段自动返回json数据;

2,返回值解析器原理

1,返回值处理判是否支持这种类型返回值 supportsReturnType

2,返回值处理器调用HandleReturnValue进行处理

3,RequestResponseBodyMethodProcessor可以处理返回值标注了@ResponseBody注解的.

1,利用MessageConverters进行处理 将数据写为json
        1,内容协商(浏览器默认会以请求头的方式告诉服务器他能接受什么样的内容类型)
        2,服务器最终根据自己自身的能力,决定服务器能生产出什么样内容类型的数据
        3,SpringMVC会挨个遍历所有容器底层的 HttpMessageConverter ,看谁能处理
                1,

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

ModelAndView
Mode
View
ResponseEntity
ResponseBodyEmitter
StreamingResonseBody
HttpEntity
HttpHeaders
Callable
DeferredResult
ListenableFuture
CompletionStage
WebAsyncTack
有 @ModelAttribute
@ResponseBady 注解 -----> ResponseBodyMethodProcessor;

1.2,HTTPMessageConverter原理

1,MessageConverter规范

HttpMessageConverter: 看是否支持将此Class类型的对象,转为MediaType类型的数据.

例子:Person对象转为JSON

2,默认的MessageConverter

3,开启浏览器参数方式内容协商功能

为了方便内容协商,开启基于请求参数的内容协商功能.

#开启参数方式的内容协商 地址后面携带 ?format=你要 指定的获取的请求类型类型
spring:
 mvc:
  contentnegotiation:
   favor-parameter: true
   #http://localhost:8080/test/person?format=json 
   #http://localhost:8080/test/person?format=xml

确定客户端接受什么样的内容类型;

1,Parameter策略优先确定是要返回json数据

return request.getParameter(getParameterName());

4,内容协商

WebMvcConfigurationSupport
jackson2XmlPresent = ClassUtils.isPresent("com.fasterxml.jackson.dataformat.xml.XmlMapper", classLoader);

导入了jackson处理xml的包,xml的converter就会自动进来

5,自定义MessageConverter

实现多协议数据兼容.json,xml,x-guigu

0,@ResponseBody,响应数据出去 调用RequestResponseBodyMethodProcessor处理

1,Processor处理方法返回值,通过MessageConverter处理

2,所有MessageConverter合起来可以支持各种媒体类型数据的操作(读,写)

3,内容协商找到最终的messageConverter;

SpringMVC的什么功能.一个入口 给容器中添加一个: WebMvcConfigurer

@Bean
public WebMvcConfigurer webMvcConfigurer(){
    //矩阵变量生效
    return new WebMvcConfigurer() {
        @Override
        public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
        }
}

/**
 * 自定义的Converter
 */
public class XiaoMessageConverter implements HttpMessageConverter<Person> {
    //能不能读     Mappring(String name)
    @Override
    public boolean canRead(Class<?> clazz, MediaType mediaType) {
        return false;
    }
    //能不能写
    @Override
    public boolean canWrite(Class<?> clazz, MediaType mediaType) {
        return clazz.isAssignableFrom(Person.class);
    }
    /**
     * 服务器要统计所有MessageConverter都能写出哪些内容类型
     *
     * application/x-xiao
     * @return
     */
    @Override
    public List<MediaType> getSupportedMediaTypes() {
        return MediaType.parseMediaTypes("application/x-xiao");
    }
    @Override
    public Person read(Class<? extends Person> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
        return null;
    }
    @Override
    public void write(Person person, MediaType contentType, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
        //自定义协议数据的写出
        String data = person.getUserName()+";"+person.getAge()+";"+person.getBirth();
        //写出去
        OutputStream body = outputMessage.getBody();
        body.write(data.getBytes());
    }

@Bean
public WebMvcConfigurer webMvcConfigurer(){
    return new WebMvcConfigurer() {
           /**
             * 自定义内容协商策略
             * @param configurer
             */
            @Override
            public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
                //Map<String, MediaType> mediaTypes
                HashMap<String, MediaType> mediaTypes = new HashMap<>();
                mediaTypes.put("json",MediaType.APPLICATION_JSON);
                mediaTypes.put("xml",MediaType.APPLICATION_ATOM_XML);
                mediaTypes.put("xiao",MediaType.parseMediaType("application/x-xiao"));
                //指定支持解析哪些参数对应的哪些媒体类型
                ParameterContentNegotiationStrategy strategy = new ParameterContentNegotiationStrategy(mediaTypes);
                //软件 基于头的不可以是有加入 
                HeaderContentNegotiationStrategy headerStrategy = new HeaderContentNegotiationStrategy();
                configurer.strategies(Arrays.asList(strategy));
            }
        @Override
        //新增MessageConverters
        public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
            //新增MessageConverters
            converters.add(new XiaoMessageConverter());
        }

有可能我们添加的自定义的功能会覆盖默认很多功能,导致默认功能失效.

5,视图解析器与模板引擎

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

1,视图解析

1,视图解析原理

1,目标方法处理的过程中,所有数据都会被放在 ModelAndViewContainer 里面.包括数据和视图地址

2,方法的参数是一个自定义类型对象(从请求参数中确定的),把他重新放在 ModelAndViewContainer

3,任何目标方法执行完成以后都会返回 ModelAndView(视图和视图地址).

4,processDispatchResult 处理派发结果.(页面改如何响应)

    1,render(mv,request,response);进行界面渲染

2,模板引擎-Thymeleaf

1,thymeleaf简介

现代化,服务端Java模板引擎

2,基本语法

1,表达式

2,字面量

文本值:’one text’,’Another one!’,…

数字:0 , 34 , 3.0 , 12.3 ,…

布尔值:true , false

空值:null

变量: one,two,…变量不能有空格

3,文本操作

字符串拼接:+

变量替换:|The name is ${name}|

4,数学运算

运算符:+,-,*,/,%

5,布尔运算

运算符:and , or

一元运算:! , not

6,比较运算

比较:>,<,>=,<=(gt,lt,ge,le)

等式:=,=,!=(eq,ne)

7,条件运算

If-then:(if)?(then)

If-then-else:(if)?(then):(else)

Default: (value)?:(defaultvalue)

8,特殊操作

无操作: _

遍历操作

<tr class="gradeX" th:each="user:${users}">
    <td>Trident</td>
    <td th:text="${user.userName}"></td>
    <td th:text="${user.password}"></td>
</tr>
                                            stats 当前状态
            <tr class="gradeX" th:each="user,stats:${users}">
                <td th:text="${stats}">Trident</td>
                <td th:text="${user.userName}"></td>
                <td th:text="${user.password}"></td>
            </tr>

当前状态图片解释

引入页面

要引入的页面 common
<div th:fragment="copy">
    ...
</div>
被引入的页面
<div th:insert="~{common :: copy}">
</div>
被引入的页面      要引入的文件名字   和   引进设置的fragment value
<div th:insert="common :: copy">
</div>
也可以根据声明的id name class 进行 不用自己再次声明
<div id="common">
</div>
被引入的页面
<div th:insert="~{commom :: #common}">
</div>
有三种方法引入
<div th:inscrt="footer :: copy">
</div>
<div th:replacr="footer :: copy">
    相当于div 默认没有了
    只有div内的内容
</div>
<div th:include="footer :: copy">
    直接把内容放进来
</div>
th:insert   ：保留自己的主标签，保留th:fragment的主标签。
th:replace ：不要自己的主标签，保留th:fragment的主标签。
th:include ：保留自己的主标签，不要th:fragment的主标签。（官方3.0后不推荐）