目录
1、SpringBoot 集成SpringMVC 底层，表单提交REST风格请求，后端GET/POST/PUT/DELETE 四种方式处理细节
2、请求映射原理(只看RequestMappingHandlerMapping)
3、@MatrixVariable 接收请求的矩阵变量（不是传统意义的请求参数）
1、SpringBoot 集成SpringMVC 底层，表单提交REST风格请求，后端GET/POST/PUT/DELETE 四种方式处理细节
首先，前端表单只能发起 GET 和 POST 请求，但后端四种请求均可处理。那么前端如何发起DELETE 和 PUT 请求呢？
如下图所示，四种请求，在后端不作任何配置的情况下，同样是 /user 路径，get 和 post 能找到对应的后端请求，但是 delete 和 put 却都跑到了 后端的 get 请求里面
我们看一下SpringBoot 底层如何处理的请求
我们找到 WebMvcAutoConfiguration 下的 Http方法过滤器
（注释：SpringBoot 底层关于SpringMVC 的配置基本在 WebMvcAutoConfiguration 这个类中可以找到）
@Bean
@ConditionalOnMissingBean({HiddenHttpMethodFilter.class})
@ConditionalOnProperty(
prefix = "spring.mvc.hiddenmethod.filter",
name = {"enabled"},
matchIfMissing = false
)
public OrderedHiddenHttpMethodFilter hiddenHttpMethodFilter() {
return new OrderedHiddenHttpMethodFilter();
}我们发现，它已经默认给返回了一个过滤器，直接点进去 ，发现他继承了 HiddenHttpMethodFilter ，在 HiddenHttpMethodFilter 中我们发现真正过滤http方法的实现代码如下：
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
HttpServletRequest requestToUse = request;
// 当请求为POST 时
if ("POST".equals(request.getMethod()) && request.getAttribute("javax.servlet.error.exception") == null) {
// 续上，我才会将你请求中的一个key为 _method 的value拿出来
String paramValue = request.getParameter(this.methodParam);
// 如果传的方法名不为空
if (StringUtils.hasLength(paramValue)) {
// 那么我帮你转成大写
String method = paramValue.toUpperCase(Locale.ENGLISH);
// 校验一下，是否在我的承受范围内，这里的 ALLOWED_METHODS ，见注释代码 2
if (ALLOWED_METHODS.contains(method)) {
// 最后返回一个包装的request（详见注释代码3），意思就是帮你转成你想要的那个 DELETE 或PUT
requestToUse = new HiddenHttpMethodFilter.HttpMethodRequestWrapper(request, method);
}
}
}
注释代码：
1、
private String methodParam = "_method";
2、
static {
ALLOWED_METHODS = Collections.unmodifiableList(Arrays.asList(HttpMethod.PUT.name(), HttpMethod.DELETE.name(), HttpMethod.PATCH.name()));
}
3、
public HttpMethodRequestWrapper(HttpServletRequest request, String method) {
super(request);
this.method = method;
}
HttpMethodRequestWrapper 继承了HttpServletRequest ，只是重写了他的构造方法，将你传进来的方法名称放进去而已那么，依照上面的规则，我们只需要在表单请求中添加key 为 _method 的参数，既可以让表单请求到想要的后端方法了
修改过的表单代码如下：
再次请求delete 和 put ，发现还是不对，反而两个都跳转 post 里面了
先别着急，我们回过头再看下一开始 hiddenHttpMethodFilter 这个过滤器头上的注解
//我是一个需要被IOC容器管理的组件
@Bean
//按需加载：如果用户没配我，我就加载我，反之不加载
@ConditionalOnMissingBean({HiddenHttpMethodFilter.class})
//按需加载：看你有没有配置 spring.mvc.hiddenmethod.filter 这个属性，你配置true 我才加载它，你不配置，我就默认false，于是你后面的一切过滤条件都不会生效
@ConditionalOnProperty(
prefix = "spring.mvc.hiddenmethod.filter",
name = {"enabled"},
matchIfMissing = false
)那好吧，我们在yaml中配置一下这个属性为true，再试
发现，这次可以了✅
2、请求映射原理(只看RequestMappingHandlerMapping)
我们再深入一下，看SpringBoot底层处理请求，如何准确找到要访问的路径
我们知道，所有请求来到后端都会经过DispacherServlet
先找到DispacherServlet ：/org/springframework/spring-webmvc/5.3.6/spring-webmvc-5.3.6.jar!/org/springframework/web/servlet/DispatcherServlet.class
发现 doPost doGet 的实现，我们在 DispacherServlet 继承的 FrameworkServlet 中 找到了 doPost 的实现，而doPost又调用 processRequest()
protected final void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
this.processRequest(request, response);
}继续进去processRequest 查看具体的实现代码，在DispacherServlet 中 找到了 doService 的实现代码
protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
this.logRequest(request);
Map<String, Object> attributesSnapshot = null;
if (WebUtils.isIncludeRequest(request)) {
attributesSnapshot = new HashMap();
Enumeration attrNames = request.getAttributeNames();
label104:
while(true) {
String attrName;
do {
if (!attrNames.hasMoreElements()) {
break label104;
}
attrName = (String)attrNames.nextElement();
} while(!this.cleanupAfterInclude && !attrName.startsWith("org.springframework.web.servlet"));
attributesSnapshot.put(attrName, request.getAttribute(attrName));
}
}
request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.getWebApplicationContext());
request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
request.setAttribute(THEME_SOURCE_ATTRIBUTE, this.getThemeSource());
if (this.flashMapManager != null) {
FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
if (inputFlashMap != null) {
request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
}
request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
}
RequestPath previousRequestPath = null;
if (this.parseRequestPath) {
previousRequestPath = (RequestPath)request.getAttribute(ServletRequestPathUtils.PATH_ATTRIBUTE);
ServletRequestPathUtils.parseAndCache(request);
}
try {
// 前面都是初始化的set方法
this.doDispatch(request, response);
} finally {
if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted() && attributesSnapshot != null) {
this.restoreAttributesAfterInclude(request, attributesSnapshot);
}
ServletRequestPathUtils.setParsedRequestPath(previousRequestPath, request);
}
}
掠过一系列set初始化方法，继续进入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 {
try {
ModelAndView mv = null;
Object dispatchException = null;
try {
processedRequest = this.checkMultipart(request);
multipartRequestParsed = processedRequest != request;
// 这里最关键，获取处理器（即那个controller 处理请求）
mappedHandler = this.getHandler(processedRequest);
if (mappedHandler == null) {
this.noHandlerFound(processedRequest, response);
return;
}
HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());
String method = request.getMethod();
boolean isGet = "GET".equals(method);
if (isGet || "HEAD".equals(method)) {
long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
if ((new ServletWebRequest(request, response)).checkNotModified(lastModified) && isGet) {
return;
}
}
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
return;
}
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
if (asyncManager.isConcurrentHandlingStarted()) {
return;
}
this.applyDefaultViewName(processedRequest, mv);
mappedHandler.applyPostHandle(processedRequest, response, mv);
} catch (Exception var20) {
dispatchException = var20;
} catch (Throwable var21) {
dispatchException = new NestedServletException("Handler dispatch failed", var21);
}
this.processDispatchResult(processedRequest, response, mappedHandler, mv, (Exception)dispatchException);
} catch (Exception var22) {
this.triggerAfterCompletion(processedRequest, response, mappedHandler, var22);
} catch (Throwable var23) {
this.triggerAfterCompletion(processedRequest, response, mappedHandler, new NestedServletException("Handler processing failed", var23));
}
} finally {
if (asyncManager.isConcurrentHandlingStarted()) {
if (mappedHandler != null) {
mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
}
} else if (multipartRequestParsed) {
this.cleanupMultipart(processedRequest);
}
}
}
只看关键的一部，进入 this.getHandler(processedRequest)
@Nullable
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
if (this.handlerMappings != null) {
Iterator var2 = this.handlerMappings.iterator();
while(var2.hasNext()) {
HandlerMapping mapping = (HandlerMapping)var2.next();
HandlerExecutionChain handler = mapping.getHandler(request);
if (handler != null) {
return handler;
}
}
}
return null;
}实际发起一个/ user 的 GET 请求，第一行断点，我们看到handlerMappings 中有四个mapping
可以简单看到，第一个是关于controller 的mapping，第五个是欢迎页的mapping
这个getHandler方法逻辑就是，拿request 通过while循环，匹配到适合的那个handler，并且返回给你供你使用
3、@MatrixVariable 接收请求的矩阵变量（不是传统意义的请求参数）
场景举例：通常会有一些信息存储在Session中，sessionId通常会存储在Cookie中进行前后端传递，如果用户吧该网站的Cookie 设置为禁用，那么我们就无法获取Cookie 进而无法获取Session中的某些信息。这时就可以使用区别于表单传参的方式，使用矩阵变量传参方式进行前后端交互。
例如这样写
前端：
/car/sell;low=34;brand=byd.bmw后端接收：
@GetMapping("cars/sell")
public Map carSell(@MatrixVariable("low") Integer low,
@MatrixVariable("brand") List<String> brand){
...
}但是矩阵变量在SpringBoot自动配置文件中的 UrlPathHelp 中又是默认禁止的，我们需要手动开启矩阵变量功能
我们先看他是怎么禁用的，然后在去开启
找到WebMvcAutoConfiguration 中的 configurePathMatch 路径映射配置
public void configurePathMatch(PathMatchConfigurer configurer) {
if (this.mvcProperties.getPathmatch().getMatchingStrategy() == MatchingStrategy.PATH_PATTERN_PARSER) {
configurer.setPatternParser(new PathPatternParser());
}
configurer.setUseSuffixPatternMatch(this.mvcProperties.getPathmatch().isUseSuffixPattern());
configurer.setUseRegisteredSuffixPatternMatch(this.mvcProperties.getPathmatch().isUseRegisteredSuffixPattern());
this.dispatcherServletPath.ifAvailable((dispatcherPath) -> {
String servletUrlMapping = dispatcherPath.getServletUrlMapping();
if (servletUrlMapping.equals("/") && this.singleDispatcherServlet()) {
UrlPathHelper urlPathHelper = new UrlPathHelper();
urlPathHelper.setAlwaysUseFullPath(true);
configurer.setUrlPathHelper(urlPathHelper);
}
});
}倒数第三行代码中的UrlPathHelper 中有一个 removeSemicolonContent 类型为布尔的变量默认是 true，他的意思就是移除分号内容
这就说明但凡在一个后端采用SpringBoot框架构建的网站的健康的网址中加入分号的后缀，都会被默认过滤掉
正好我们矩阵变量的传递方式也是以分号间隔的方式坠在网址后面，同样会被 UrlPathHelper 默认过滤掉
解除默认过滤配置的封印需要自己新增配置类覆盖默认配置
两种方式：第一种：配置类实现 WebMvcConfigurer 中的 configurePathMatch方法，并设置 removeSemicolonContent 为 false
第二种：自己新增一个配置类，并在配置类中新增一个用@bean注解加持的方法，返回一个 removeSemicolonContent 为 false 的WebMvcConfigrer
两种方法如下图所示：
