Spring Boot非常适合web应用程序开发。您可以使用嵌入式Tomcat、Jetty、Undertow或Netty来创建一个自包含的HTTP服务器。大多数web应用程序使用spring-boot-starter-web模块来快速启动和运行。你也可以选择使用spring-boot-starter-webflux模块来构建响应式web应用。

1. Web场景

SpringBoot的Web开发能力，由SpringMVC提供。

1. 自动配置

1）整合web场景，导入spring-boot-starter-web

    org.springframework.boot
    spring-boot-starter-web

2）引入了autoconfigure功能

spring-boot-starter-web导入了一个spring-boot-starter，而spring-boot-starter又导入了spring-boot-autoconfigure包，引入了autoconfigure功能。spring-boot-autoconfigure包依赖一个注解：@EnableAutoConfiguration，有了这个注解，SpringBoot会让spring-boot-autoconfigure包下写好的配置类生效。

3）@EnableAutoConfiguration注解

@Import(AutoConfigurationImportSelector.class)注解使用@Import(AutoConfigurationImportSelector.class)批量导入组件

4）@Import注解

@Import(AutoConfigurationImportSelector.class)是通过加载spring-boot-autoconfigure下META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件中配置的所有组件，将配置类导入进来

5）web相关所有的自动配置类如下：

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.ReactiveMultipartAutoConfiguration
org.springframework.boot.autoconfigure.web.reactive.ReactiveWebServerFactoryAutoConfiguration
org.springframework.boot.autoconfigure.web.reactive.WebFluxAutoConfiguration
org.springframework.boot.autoconfigure.web.reactive.WebSessionIdResolverAutoConfiguration
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

最终，我们只要分析清楚每一个自动配置类产生了什么样的效果，那在SpringMVC底层，SpringBoot给它自动配置了哪些组件就非常清楚了。

说明：带reactive是响应式web场景，和这里分析的普通web场景没有关系

6）这些自动配置类又绑定了配置文件的许多配置项

•  SpringMVC的所有配置项：以spring.mvc为前缀
•  Web场景通用配置：以spring.web为前缀
•  文件上传配置：以spring.servlet.multipart为前缀
•  服务器的配置：以server为前缀

  2. 默认效果（Spring MVC Auto-configuration）

  Spring Boot为Spring MVC提供了自动配置，可以很好地与大多数应用程序配合使用。

  自动配置在Spring默认设置的基础上增加了以下特性:

  • 包含了ContentNegotiatingViewResolver和BeanNameViewResolver组件，方便视图解析
  • 支持服务静态资源，包括支持WebJars
  • 自动注册Converter、GenericConverter和Formatter组件，适配常见的数据类型转换和格式化需求
  • 支持HttpMessageConverters，可以方便返回json等数据类型
  • 自动注册MessageCodesResolver，方便国际化及错误消息处理
  • 支持静态index.html
  • 自动使用ConfigurableWebBindingInitializer，实现消息处理、数据绑定、类型转换、数据校验等功能

    重要：

    如果你想保留那些Spring Boot MVC默认配置，并且自定义更多的MVC配置(interceptors(拦截器)，formatters(格式化器)，view controllers(视图控制器)，and other features(其他功能))，可以使用@Configuration注解添加一个WebMvcConfigurer类型的配置类，但不添加@EnableWebMvc。

    如果你想提供RequestMappingHandlerMapping、RequestMappingHandlerAdapter或ExceptionHandlerExceptionResolver的自定义实例，并且仍然保持Spring Boot MVC默认配置，你可以声明一个WebMvcRegistrations类型的bean，并使用它来提供这些组件的自定义实例。

    如果你想全面接管Spring MVC，使用@Configuration 标注一个配置类，并加上 @EnableWebMvc注解，实现 WebMvcConfigurer 接口，或者像在@EnableWebMvc的Javadoc中描述的那样添加你自己的带有@Configuration注解的DelegatingWebMvcConfiguration。

    3. WebMvcAutoConfiguration原理

    3.1. 生效条件

    @AutoConfiguration(after = { DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class,
    		ValidationAutoConfiguration.class }) //在这些自动配置类之后配置
    @ConditionalOnWebApplication(type = Type.SERVLET) //如果是web应用就生效，类型SERVLET，是一个普通的web应用。与之对应的还有REACTIVE(响应式web)
    @ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
    @ConditionalOnMissingBean(WebMvcConfigurationSupport.class) //容器中没有WebMvcConfigurationSupport这个Bean才生效。默认就是没有
    @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)//优先级
    @ImportRuntimeHints(WebResourcesRuntimeHints.class)
    public class WebMvcAutoConfiguration { 
    }

    3.2. WebMvcAutoConfiguration自动配置类生效后，做了什么

    1）向容器中添加了2个Filter：HiddenHttpMethodFilter、FormContentFilter

    HiddenHttpMethodFilter：页面表单可以提交rest请求（GET、POST、PUT、DELETE）。由于浏览器只支持发送GET和POST方式的请求，而DELETE、PUT等method并不支持，Spring3.0添加了一个过滤器，可以将这些请求转换为标准的http方法，使得支持GET、POST、PUT与DELETE请求，该过滤器为HiddenHttpMethodFilter。

    FormContentFilter： 表单内容Filter，GET（数据放URL后面）、POST（数据放请求体）请求可以携带数据，而PUT、DELETE 的请求体数据会被忽略。

    为了让Tomcat不忽略PUT、DELETE请求的请求体，可以向容器中添加FormContentFilter。

    2）向容器中添加了WebMvcConfigurer组件，给SpringMVC添加各种定制功能

    WebMvcConfigure提供的所有功能的相关配置，最终会和配置文件进行绑定

    • WebMvcProperties： 与配置文件中前缀为 spring.mvc 的配置项进行绑定
    • WebProperties： 与配置文件中前缀为 spring.web 的配置项进行绑定

      //定义为一个嵌套配置，以确保不在类路径上时不会读取WebMvcConfigurer
      // Defined as a nested config to ensure WebMvcConfigurer is not read when not on the classpath
      @Configuration(proxyBeanMethods = false)
      @Import(EnableWebMvcConfiguration.class) //额外导入了其他配置
      @EnableConfigurationProperties({ WebMvcProperties.class, WebProperties.class })
      @Order(0)
      public static class WebMvcAutoConfigurationAdapter implements WebMvcConfigurer, ServletContextAware{
              
      }

      3）其它组件...

      3.3. WebMvcConfigurer接口

      提供了配置SpringMVC底层的所有组件入口

      

      3.4. 静态资源处理规则(源码)

      添加处理器，以服务静态资源，如图像、js和css文件，这些文件来自于web应用程序根下的特定位置，类路径以及其他。

      //配置本地资源映射路径
      public void addResourceHandlers(ResourceHandlerRegistry registry) {
      	if (!this.resourceProperties.isAddMappings()) {
      		logger.debug("Default resource handling disabled");
      		return;
      	}
      	addResourceHandler(registry, this.mvcProperties.getWebjarsPathPattern(),
      					"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);
      		}
      	});
      }

      规则1：路径匹配：/webjars/*。访问路径匹配 "/webjars/**"，就去"classpath:/META-INF/resources/webjars/"下找资源。

      访问示例：

      http://localhost:8081/webjars/ant-design__icons-vue/6.0.1/AccountBookFilled.js

      我们在开发JavaWeb项目的时候，会使用像Maven、Gradle等构建工具以实现对jar包版本依赖管理，以及项目的自动化管理，但对于javascript、css等前端资源包，我们只能采用拷贝到webapp下的方式，这样做就无法对这些资源进行依赖管理。而Webjars提供给我们这些前端资源的jar包形式，我们就可以进行依赖管理。如：

      
         org.webjars.npm
         ant-design__icons-vue
         6.0.1
      
      

      规则2 ：路径匹配： /** 。访问路径匹配 "/**" ，就去静态资源默认的4个位置找资源。默认的4个位置如下：

      "classpath:/META-INF/resources/", "classpath:/resources/", "classpath:/static/", "classpath:/public/"

      规则3：静态资源默认都有缓存规则的设置

      所有缓存规则，直接通过配置文件设置： 配置项前缀为 "spring.web"

      cachePeriod： 缓存周期；多久不用找服务器要新的。 默认没有，以s为单位

      cacheControl： HTTP缓存控制；可以参照https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Caching

      useLastModified：是否使用最后一次修改。配合HTTP Cache规则

      缓存最终的作用和效果：浏览器访问了一个静态资源，如index.js，如果服务器上这个资源没有发生变化，下次访问的时候就可以直接让浏览器用自己缓存中的东西，而不用给服务器发请求。

      registration.setCachePeriod(getSeconds(this.resourceProperties.getCache().getPeriod()));
      registration.setCacheControl(this.resourceProperties.getCache().getCachecontrol().toHttpCacheControl());
      registration.setUseLastModified(this.resourceProperties.getCache().isUseLastModified());

      3.5. EnableWebMvcConfiguration 源码

      //SpringBoot给容器中放WebMvcConfigurationSupport组件。
      //如果我们自己在容器中添加了WebMvcConfigurationSupport组件，SprinBoot的WebMvcAutoConfiguration都会失效。
      @Configuration(proxyBeanMethods = false)
      @EnableConfigurationProperties(WebProperties.class)
      public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration implements ResourceLoaderAware 
      {
      }
      

      HandlerMapping作用：根据请求的url、method等信息，找哪个Handler能处理请求。

      EnableWebMvcConfiguration会向容器中添加WelcomePageHandlerMapping（欢迎页处理器映射）。

      WelcomePageHandlerMapping：

      访问 /**路径下的所有请求，都是在以上4个静态资源路径下找资源，欢迎页也一样。关于欢迎页：访问/**路径，是在以上4个静态资源路径下找index.html，只要静态资源的位置有一个 index.html页面，项目启动默认访问。

      3.6. 为什么容器中放一个WebMvcConfigurer就能配置底层行为

      WebMvcAutoConfiguration 是一个自动配置类，它里面有一个 EnableWebMvcConfiguration配置类，而EnableWebMvcConfiguration继于 DelegatingWebMvcConfiguration，这两个配置类都会生效。DelegatingWebMvcConfiguration通过依赖注入把容器中所有 WebMvcConfigurer 注入进来，当调用 DelegatingWebMvcConfiguration 的方法来配置底层规则时，它就会调用所有的WebMvcConfigurer相应的配置底层方法。所以，最终我们自己写的配置底层的方法就 会被调用。

      因为项目一启动，WebMvcAutoConfiguration要用EnableWebMvcConfiguration来配置底层，而这个配置类在配置底层的时候，就会从容器中拿到所有的WebMvcConfigurer，当调用 DelegatingWebMvcConfiguration 配置底层规则的方法时，就会调用所有的WebMvcConfigurer相应的配置底层方法。

      @Configuration(proxyBeanMethods = false)
      public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
      	private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();
      	@Autowired(required = false)
      	public void setConfigurers(List configurers) {
      		if (!CollectionUtils.isEmpty(configurers)) {
      			this.configurers.addWebMvcConfigurers(configurers);
      		}
      	}
      }
      

      3.7. WebMvcConfigurationSupport

      提供了很多的默认设置。

      其中的一项功能是addDefaultHttpMessageConverters（添加一组默认的HttpMessageConverter实例），其中会判断系统中是否有相应的类（在pom中添加了相关依赖的话就会有），如果有，就加入相应的HttpMessageConverter。

      jackson2Present = ClassUtils.isPresent("com.fasterxml.jackson.databind.ObjectMapper", classLoader) &&
      				ClassUtils.isPresent("com.fasterxml.jackson.core.JsonGenerator", classLoader);
      jackson2XmlPresent = ClassUtils.isPresent("com.fasterxml.jackson.dataformat.xml.XmlMapper", classLoader);
      jackson2SmilePresent = ClassUtils.isPresent("com.fasterxml.jackson.dataformat.smile.SmileFactory", classLoader);
      protected final void addDefaultHttpMessageConverters(List> messageConverters) {
      		messageConverters.add(new ByteArrayHttpMessageConverter());
      		messageConverters.add(new StringHttpMessageConverter());
      		messageConverters.add(new ResourceHttpMessageConverter());
      		messageConverters.add(new ResourceRegionHttpMessageConverter());
      		messageConverters.add(new AllEncompassingFormHttpMessageConverter());
      		if (romePresent) {
      			messageConverters.add(new AtomFeedHttpMessageConverter());
      			messageConverters.add(new RssChannelHttpMessageConverter());
      		}
      		if (jackson2XmlPresent) {
      			Jackson2ObjectMapperBuilder builder = Jackson2ObjectMapperBuilder.xml();
      			if (this.applicationContext != null) {
      				builder.applicationContext(this.applicationContext);
      			}
      			messageConverters.add(new MappingJackson2XmlHttpMessageConverter(builder.build()));
      		}
      		else if (jaxb2Present) {
      			messageConverters.add(new Jaxb2RootElementHttpMessageConverter());
      		}
      		if (kotlinSerializationCborPresent) {
      			messageConverters.add(new KotlinSerializationCborHttpMessageConverter());
      		}
      		if (kotlinSerializationJsonPresent) {
      			messageConverters.add(new KotlinSerializationJsonHttpMessageConverter());
      		}
      		if (kotlinSerializationProtobufPresent) {
      			messageConverters.add(new KotlinSerializationProtobufHttpMessageConverter());
      		}
      		if (jackson2Present) {
      			Jackson2ObjectMapperBuilder builder = Jackson2ObjectMapperBuilder.json();
      			if (this.applicationContext != null) {
      				builder.applicationContext(this.applicationContext);
      			}
      			messageConverters.add(new MappingJackson2HttpMessageConverter(builder.build()));
      		}
      		else if (gsonPresent) {
      			messageConverters.add(new GsonHttpMessageConverter());
      		}
      		else if (jsonbPresent) {
      			messageConverters.add(new JsonbHttpMessageConverter());
      		}
      		if (jackson2SmilePresent) {
      			Jackson2ObjectMapperBuilder builder = Jackson2ObjectMapperBuilder.smile();
      			if (this.applicationContext != null) {
      				builder.applicationContext(this.applicationContext);
      			}
      			messageConverters.add(new MappingJackson2SmileHttpMessageConverter(builder.build()));
      		}
      		if (jackson2CborPresent) {
      			Jackson2ObjectMapperBuilder builder = Jackson2ObjectMapperBuilder.cbor();
      			if (this.applicationContext != null) {
      				builder.applicationContext(this.applicationContext);
      			}
      			messageConverters.add(new MappingJackson2CborHttpMessageConverter(builder.build()));
      		}
      	}
      

      2. 静态资源

      2.1. 默认规则

      2.1.1. 静态资源映射

      静态资源映射规则在 WebMvcAutoConfiguration 中进行了定义：

      1) 访问路径匹配 "/webjars/**"，就去"classpath:/META-INF/resources/webjars/"下找资源

      2) 访问路径匹配 "/**" ，就去静态资源默认的4个位置找资源，资源都在 classpath:/META-INF/resources/、classpath:/resources/、classpath:/static/、classpath:/public/ 

      2.1.2. 静态资源缓存

      如前面所述，所有静态资源都定义了缓存规则（浏览器访问过一次，就会缓存一段时间）:

      period： 缓存间隔。 默认 0S；

      cacheControl：缓存控制。 默认无；

      useLastModified：是否使用lastModified头（默认是true）；配合HTTP Cache规则

      使用lastModified头，浏览器的响应头中会包含Last-Modified

      

      关于useLastModified：

      1）如果浏览器每次发送请求，都要向服务器获取新的资源，而如果资源在服务器中又没有发生变化，由于这些资源可能很大，又限制于网络传输的速率，这个时候去加载页面的速度可能就不会很快，那么进一步就会影响到用户的使用感。

      2）如果请求只是从缓存中获取，那服务器中的资源如果发生了变化，浏览器也不会及时获取。

      有了useLastModified，就可以解决这两个问题。浏览器请求服务器资源的时候，发现自己缓存的文件有 Last Modified ，那么在请求中会包含 If Modified Since，去找服务器确认：服务器中静态资源的修改时间和If Modified Since是否相同。如果相同，浏览器就用缓存中的资源，如果不同，则服务器给浏览器返回最新的资源。

      2.1.3. 欢迎页

      欢迎页规则在 WebMvcAutoConfiguration 中进行了定义：

      在静态资源目录下找 index.html，没有就在 templates下找index模板页

      2.1.4. Favicon

      与其他静态资源一样，Spring Boot在配置的静态内容位置中检查favicon.ico。如果存在这样的文件，它将自动用作应用程序的图标。

      2.1.5. 缓存实验

      1）配置缓存规则

      server.port=8081
      #spring.web:
      #1.配置国际化的区域信息
      #2.配置静态资源策略（功能开启、处理链、缓存）
      #开启静态资源映射规则（默认就是true）
      spring.web.resources.add-mappings=true
      #设置缓存
      spring.web.resources.cache.period=3600
      #缓存详细合并项控制：缓存控制HTTP头,仅允许有效的指令合并。覆盖'spring.web.resources.cache.period'属性：浏览器第一次请求服务器,服务器告诉浏览器此资源缓存7200秒,7200秒以内的所有对此资源的访问,不用发请求给服务器,7200秒以后发请求给服务器
      spring.web.resources.cache.cachecontrol.max-age=7200
      #使用资源的最后一次修改时间,来对比服务器和浏览器的资源是否相同,有没有发生变化。相同返回 304
      #默认就是true
      spring.web.resources.cache.use-last-modified=true
      

      2）启动SpringBoot项目，访问项目中的静态资源

      这里，我访问的是自己项目中的 https://blog.csdn.net/2201_75955594/article/details/flowers.jpg

      

      第一次访问 200

      

      第二次访问(F5刷新) 304

      

      

      Ctrl+F5强制刷新 200

      使用ctrl+F5进行刷新，这个时候浏览器就不会重复利用之前已经缓存的数据了，而是去清空缓存，把所有的资源进行重新下载，使网页与本机储存的网页时间标记相同。

      这两个的区别很大：一个网页，不仅仅只是有一个HTML，还会依赖其他很多的资源，比如：CSS、JS、图片等。这些资源都是网络下载到浏览器本地的。由于这些资源可能很大，又限制于网络传输的速率，这个时候去加载页面的速度可能就不会很快，那么进一步就会影响到用户的使用感。这个时候，浏览器就会把这些依赖的资源直接缓存到本地，后续访问的时候速度就很快了， 因为是已经缓存了，就不需要去下载了。 

      我们先使用F5刷新：

      

      下面我们再使用ctrl + F5 刷新：

      

      我们可以看到，此时加载的这些文件大小都来自于网络下载，而且显示了多大的文件。其实我们通过加载时间，也可以理解为什么浏览器会有缓存机制，使用F5刷新的时候，加载时间在4ms左右，但是使用ctrl + F5的时候，加载时间在6ms秒左右，这就能够理解浏览器为什么就会把这些依赖的资源直接缓存到本地，后续访问的时候速度就会很快。

      总结：

      ctrl + F5 是直接请求服务器的资源，让当前页面的资源重新全部从服务器上下载下来，这样就全部更新了。

      关于HTTP 304状态码

      304 未被修改。

      自从上次请求后，请求的网页未被修改过。服务器返回此响应时，不会返回网页内容。

      如果网页自请求者上次请求后再也没有更改过，你应将服务器配置为返回此响应码（称为if-modified-since http标头）。服务器可以告诉浏览器自从上次抓取后网页没有变更，进而节省带宽和开销。

      整个请求响应过程如下：

      客户端在请求一个文件的时候，发现自己缓存的文件有 Last Modified ，那么在请求中会包含 If Modified Since ，这个时间就是缓存文件的 Last Modified 。因此，如果请求中包含 If Modified Since，就说明客户端已经有缓存，服务端只要判断这个时间和当前请求的文件的最近修改时间是否一致，就可以确定是返回 304 还是 200 。对于静态文件，例如：CSS、图片，服务器会自动完成 Last Modified 和 If Modified Since 的比较，完成缓存或者更新。

      2.2. 自定义静态资源规则

      自定义静态资源路径、自定义缓存规则

      2.2.1. 配置方式

      前缀为spring.mvc，可以配置：静态资源访问路径规则

      前缀为spring.web，可以配置：1）静态资源目录      2）静态资源缓存策略

      #共享缓存
      #spring.web.resources.cache.cachecontrol.cache-public=true
      #自定义静态资源文件夹位置
      spring.web.resources.static-locations=classpath:/custom/
      #自定义webjars访问路径规则
      spring.mvc.webjars-path-pattern=/wj/**
      #自定义静态资源访问路径规则
      spring.mvc.static-path-pattern=/static/**

      2.2.2. 代码方式

      • 使用@Configuration注解添加一个WebMvcConfigurer类型的配置类，但不添加@EnableWebMvc
      • @EnableWebMvc 会禁用SpringBoot的默认配置
      • 容器中只要有一个 WebMvcConfigurer 组件，配置的底层行为都会生效

        方式一：

        @Configuration //这是一个配置类
        public class MyConfig implements WebMvcConfigurer {
            @Override
            public void addResourceHandlers(ResourceHandlerRegistry registry) {
                //自定义新的规则(SpringBoot的默认配置仍会保留)
                registry.addResourceHandler("/static/**")
                        .addResourceLocations("classpath:/custom/")
                        .setCacheControl(CacheControl.maxAge(1260, TimeUnit.SECONDS));
            }
        }
        

        方式二：

        @Configuration //这是一个配置类,给容器中添加一个 WebMvcConfigurer 组件，就能自定义底层
        public class MyConfig {
            @Bean
            public WebMvcConfigurer webMvcConfigurer(){
                return new WebMvcConfigurer() {
                    @Override
                    public void addResourceHandlers(ResourceHandlerRegistry registry) {
                        registry.addResourceHandler("/static/**")
                                .addResourceLocations("classpath:/custom/")
                                .setCacheControl(CacheControl.maxAge(1260, TimeUnit.SECONDS));
                    }
                };
            }
        }

        3. 路径匹配

        Spring5.3 之后加入了更多的请求路径匹配的实现策略。以前只支持 AntPathMatcher 策略，现在提供了 PathPatternParser 策略，并且可以让我们指定到底使用哪种策略。

        3.1. Ant风格路径用法

        Ant 风格的路径模式语法具有以下规则：

        • *：表示任意数量的字符
        • ?：表示任意一个字符
        • **：表示任意数量的目录
        • {}：表示一个命名的模式占位符
        • []：表示字符集合，例如[a-z]表示小写字母

          例如：

          *.html 匹配任意名称、扩展名为.html的文件

          /folder1/*/*.java 匹配在folder1目录下的任意两级目录下的.java文件

          /folder2/**/*.jsp 匹配在folder2目录下任意目录深度的.jsp文件

          /{type}/{id}.html 匹配任意文件名为{id}.html，在任意命名的{type}目录下的文件

          注意：Ant 风格的路径模式语法中的特殊字符需要转义，如：

          要匹配文件路径中的星号，则需要转义为\\*

          要匹配文件路径中的问号，则需要转义为\\?

          3.2. 模式切换

          AntPathMatcher 与 PathPatternParser对比:

          • PathPatternParser 在 jmh 基准测试下，有 6~8 倍吞吐量提升，降低 30%~40%空间分配率
          • PathPatternParser 兼容 AntPathMatcher语法，并支持更多类型的路径模式
          • PathPatternParser "**" 多段匹配的支持仅允许在模式末尾使用，不能用在中间

                /**
                 * {}：表示一个命名的模式占位符。
                 * []：表示字符集合,例如[a-z]表示小写字母,后面的 + 表示可以有多个
                 *
                 * SpringBoot默认使用新版 PathPatternParser 进行路径匹配
                 * 不能匹配 ** 在中间的情况,剩下的和AntPathMatcher语法兼容
                 *
                 */
                //PathPatternParser不能适配ant风格路径 **在中间的情况：@GetMapping("/hel*/b?/**/{p1:[a-f]+}")不支持
                @GetMapping("/hel*/b?/{p1:[a-f]+}")
                public String hello(HttpServletRequest request, @PathVariable("p1") String path) {
                    log.info("路径变量p1： {}", path);
                    //获取请求路径
                    String uri = request.getRequestURI();
                    return uri;
                }

            总结：

            •    使用默认的路径匹配规则，是由 PathPatternParser 提供的
            •    如果路径中间需要有 **，需要改变路径匹配策略，替换成ant风格路径

              # 改变路径匹配策略：
              # 老版策略：ant_path_matcher , 新版策略：path_pattern_parser
              #路径匹配策略,默认是 path_pattern_parser
              spring.mvc.pathmatch.matching-strategy=path_pattern_parser
              

              4. 内容协商

              一套系统适配多端数据返回

              

              内容协商功能本身就是SpringMVC自带的功能，SpringBoot做了一个整合。

              4.1.  多端内容适配

              4.1.1. 默认规则

              SpringBoot 多端内容适配：

              1）基于请求头内容协商（默认开启）：

              • 客户端向服务端发送请求，携带HTTP标准的Accept请求头，Accept: application/json、application/xml、text/yaml
              • 这是HTTP协议中规定的标准，Accept代表客户端想要接收服务端什么样的数据
              • 服务端根据客户端请求头期望的数据类型进行动态返回

                2）基于请求参数内容协商（默认不生效，需要开启）：

                • 发送请求 GET /projects/person?format=json ，匹配到 @GetMapping("/projects/person")
                • 根据参数协商，优先返回 json 类型数据。
                • 发送请求 GET /projects/person?format=xml，优先返回 xml 类型数据

                  4.1.2. 效果演示

                  请求同一个接口，可以返回json和xml不同格式数据

                  4.1.2.1. 基于请求头内容协商

                  1）返回json格式数据

                  ① 控制器方法

                  /**
                   * 1、SpringBoot默认支持把对象写为json,因为web场景导入了jackson的包,可以将Java对象转换为json数据
                   * 2、jackson也支持把数据写为xml,需要导入xml相关依赖
                   */
                   @GetMapping("/person")
                   public Person person() {
                      Person person = new Person();
                      person.setId(1L);
                      person.setUserName("张三");
                      person.setEmail("163@qq.com");
                      person.setAge(20);
                      return person;
                   }
                  

                  ② 发送请求（基于请求头内容协商）

                  

                  2）返回xml格式数据

                  ① 引入支持输出xml内容依赖

                  
                      com.fasterxml.jackson.dataformat
                      jackson-dataformat-xml
                  

                  ② 标注注解

                  @JacksonXmlRootElement  // 可以写出为xml文档
                  @Data
                  public class Person {
                      private Long id;
                      private String userName;
                      private String email;
                      private Integer age;
                  }
                  

                  ③ 发送请求（基于请求头内容协商）

                  

                  4.1.2.2. 基于请求参数的内容协商

                  基于请求参数内容协商，默认不生效，需要开启。

                  ① 开启请求参数内容协商功能

                  # 开启基于请求参数的内容协商功能,默认参数名：format
                  spring.mvc.contentnegotiation.favor-parameter=true
                  # 指定内容协商时使用的参数名
                  spring.mvc.contentnegotiation.parameter-name=type

                  ② 代码等相关配置同上面基于请求头内容协商部分

                  ③ 测试效果

                  

                   

                  4.1.3. 配置协商规则与支持类型

                  1）修改内容协商方式

                  #开启基于请求参数的内容协商功能
                  spring.mvc.contentnegotiation.favor-parameter=true  
                  #自定义参数名，指定内容协商时使用的参数名，默认为format
                  spring.mvc.contentnegotiation.parameter-name=myparam 

                  2）大多数 MediaType 都是开箱即用的。也可以自定义内容类型，如：

                  spring.mvc.contentnegotiation.media-types.myYaml=text/yaml

                  4.2. 自定义内容返回

                  4.2.1. 增加yaml返回支持

                  1）导入依赖

                  
                      com.fasterxml.jackson.dataformat
                      jackson-dataformat-yaml
                  

                  2）编写配置

                  #新增一种媒体类型
                  spring.mvc.contentnegotiation.media-types.yaml=text/yaml

                  说明：要能进行内容协商，相当于要告知SpringBoot，系统中存在一种新格式：yaml。怎么告知？需要在配置文件中编写配置

                  3）增加HttpMessageConverter组件，专门负责把对象写出为yaml格式

                      @Bean
                      public WebMvcConfigurer webMvcConfigurer(){
                          return new WebMvcConfigurer() {
                              @Override //配置一个能把对象转为yaml的messageConverter
                              public void configureMessageConverters(List> converters) {
                                  converters.add(new MyYamlHttpMessageConverter());
                              }
                          };
                      }

                  4）请求示例

                  

                  4.2.2. HttpMessageConverter的示例写法

                  public class MyYamlHttpMessageConverter extends AbstractHttpMessageConverter