SpringBoot请求处理之常用参数注解介绍与源码分析

1、注解

@PathVariable：将请求url中的占位符参数与控制器方法入参绑定起来（Rest风格请求）

@RequestHeader：获取请求头中的参数，通过指定参数 value 的值来获取请求头中指定的参数值

@ModelAttribute：两种用法

• 用在参数上，会将客户端传递过来的参数按名称注入到指定对象中，并且会将这个对象自动加入ModelMap中，便于View层使用

• 用在方法上，被@ModelAttribute注释的方法会在此controller的每个方法执行前被执行 ，如果有返回值，则自动将该返回值加入到ModelMap中，类似于Junit的@Before

@RequestParam：获取url中的请求参数并映射到控制器方法的入参

@MatrixVariable：获取矩阵变量

• 矩阵变量：路径片段中可以可以包含键值对，用分号进行分割，也就是说我们的请求路径可以表示为/test/pathVaribales;name=decade;age=24

• 注意，矩阵变量默认是关闭的，需要在自定义的配置类中实现WebMvcConfigurer接口，并重写configurePathMatch()方法，将UrlPathHelper对象的removeSemicolonContent属性设置为false，或者或者直接使用@Configuration+@Bean的方式，创建一个新的bean放到容器中

package com.decade.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.PathMatchConfigurer;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.util.UrlPathHelper;
@Configuration(proxyBeanMethods = false)
public class MyMvcConfig implements WebMvcConfigurer {
   // 方式一：实现WebMvcConfigure接口，重写指定方法
   @Override
   public void configurePathMatch(PathMatchConfigurer configurer) {
       UrlPathHelper urlPathHelper = new UrlPathHelper();
       // 设置为false，矩阵变量生效，请求路径分号后面的内容才不会被移除
       urlPathHelper.setRemoveSemicolonContent(false);
       configurer.setUrlPathHelper(urlPathHelper);
   }
   // 方式二：直接使用@Configuration+@Bean的方式，创建一个新的WebMvcConfigure放到容器中，因为接口有默认实现，所以我们只需要重写指定方法
   @Bean
   public WebMvcConfigurer createWebMvcConfigure() {
       return new WebMvcConfigurer() {
           @Override
           public void configurePathMatch(PathMatchConfigurer configurer) {
               UrlPathHelper urlPathHelper = new UrlPathHelper();
               // 设置为false，矩阵变量生效，请求路径分号后面的内容才不会被移除
               urlPathHelper.setRemoveSemicolonContent(false);
               configurer.setUrlPathHelper(urlPathHelper);
           }
       };
   }
}

• @CookieValue：获取cookie中的参数

• @RequestBody：获取请求体中的参数，通过指定参数 value 的值来获取请求头中指定的参数值（POST请求）

• @RequestAttrible：获取request域属性，也就是获取当前这次请求中的属性

package com.decade.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Controller
public class ParameterTestController {
   @RequestMapping(value = "/testPathVariable/{userId}/split/{userName}")
   @ResponseBody
   public Map<String, Object> testPathVariable(@PathVariable("userId") String userId,
       @PathVariable("userName") String userName, @PathVariable Map<String, String> variables) {
       final Map<String, Object> map = new HashMap<>();
       // @PathVariable("userId")可以获取请求路径中指定变量，并绑定到对应入参
       map.put("userId", userId);
       map.put("userName", userName);
       // @PathVariable搭配Map<String, String>可以获取路径变量中的所有占位符参数
       map.put("variables", variables);
       return map;
   }
   @RequestMapping(value = "/testRequestHeader")
   @ResponseBody
   public Map<String, Object> testRequestHeader(@RequestHeader("User-Agent") String userAgent,
       @RequestHeader Map<String, String> headerVariables) {
       final Map<String, Object> map = new HashMap<>();
       // @RequestHeader("User-Agent")可以获取请求头中指定参数
       map.put("userAgent", userAgent);
       // @RequestHeader搭配Map<String, String>可以获取请求头中的所有参数
       map.put("headerVariables", headerVariables);
       return map;
   }
   @RequestMapping(value = "/testRequestParam")
   @ResponseBody
   public Map<String, Object> testRequestParam(@RequestParam("userId") String userId,
       @RequestParam List<String> interest, @RequestParam Map<String, String> variables) {
       final Map<String, Object> map = new HashMap<>();
       // @RequestParam("userId")可以获取请求URL中指定参数并绑定到控制器方法入参
       map.put("userId", userId);
       // 同一个参数如果传入了多个值，那也可以获取之后统一放入list列表
       map.put("interest", interest);
       // @RequestParam搭配Map<String, String>可以获取请求头中的所有参数
       map.put("variables", variables);
       return map;
   }
   @RequestMapping(value = "/testCookieValue")
   @ResponseBody
   public Map<String, Object> testCookieValue(@CookieValue("_ga") String ga, @CookieValue("_ga") Cookie cookie) {
       final Map<String, Object> map = new HashMap<>();
       // @CookieValue("_ga")可以获取指定cookie的value
       map.put("_ga", ga);
       // @CookieValue Cookie可以获取指定cookie的所有信息，包括name和value等
       map.put("cookie", cookie);
       return map;
   }
   @PostMapping(value = "/testRequestBody")
   @ResponseBody
   public Map<String, Object> testRequestBody(@RequestBody String content) {
       final Map<String, Object> map = new HashMap<>();
       // 获取post请求表单中的所有参数
       map.put("content", content);
       return map;
   }
   @GetMapping(value = "/testRequestAttribute")
   public String goToSuccess(HttpServletRequest request) {
       // 向请求域中设置值
       request.setAttribute("msg", "test");
       request.setAttribute("code", 200);
       // 将请求转发到/success
       return "forward:/success";
   }
   @GetMapping(value = "/success")
   @ResponseBody
   public Map<String, Object> test(@RequestAttribute("msg") String msg,
       @RequestAttribute("code") int code, HttpServletRequest request) {
       Map<String, Object> map = new HashMap<>();
       // 利用注解获取request请求域中的值
       map.put("msgFromAnnotation", msg);
       map.put("codeFromAnnotation", code);
       // 从HttpServletRequest对象中获取
       map.put("msgFromRequest", request.getAttribute("msg"));
       return map;
   }
   // 矩阵变量的请求方式：http://localhost:8080/car/queryInfo;hobby=game;hobby=music;age=24
   // 注意，矩阵变量必须放在占位符参数的后边，使用分号进行分割
   @GetMapping(value = "/car/{path}")
   @ResponseBody
   public Map<String, Object> testMatrixVariable(@MatrixVariable("hobby") List<String> hobby,
       @MatrixVariable("age") int age, @PathVariable("path") String path) {
       Map<String, Object> map = new HashMap<>();
       map.put("age", age);
       map.put("hobby", hobby);
       map.put("path", path);
       return map;
   }
   // 如果请求路径为http://localhost:8080/car/1;age=39/2;age=23，那么就要使用pathVar来区分变量名相同的矩阵变量
   @GetMapping(value = "/car/{bossId}/{staffId}")
   @ResponseBody
   public Map<String, Object> testMatrixVariable(@MatrixVariable(value = "age", pathVar = "bossId") int bossAge,
       @MatrixVariable(value = "age", pathVar = "staffId") int staffAge) {
       Map<String, Object> map = new HashMap<>();
       map.put("bossAge", bossAge);
       map.put("staffAge", staffAge);
       return map;
   }
}

然后我们写一个html页面测试一下各个注解

<!DOCTYPE html>
<html lang="en">
<head>
   <meta charset="UTF-8">
   <title>主页</title>
</head>
<body>
Hello World!
<a href="/testPathVariable/001/split/decade" rel="external nofollow" >测试@PathVariable注解</a>
<br>
<a href="/testRequestHeader" rel="external nofollow" >测试RequestHeader注解</a>
<br>
<a href="/testRequestParam?userId=001&interest=games&interest=music" rel="external nofollow" >测试@RequestParam注解</a>
<br>
<a href="/testCookieValue" rel="external nofollow" >测试@CookieValue注解</a>
<br>
<a href="/testRequestAttribute" rel="external nofollow" >测试@RequestAttribute注解</a>
<br>
<a href="/car/queryInfo;hobby=game;hobby=music;age=24" rel="external nofollow" >测试@MatrixVariable注解</a>
<br>
<a href="/car/1;age=39/2;age=23" rel="external nofollow" >测试@MatrixVariable注解2</a>
<br>
<form action="/testRequestBody" method="post">
   <input name="name" type="hidden" value="decade">
   <input name="age" type="hidden" value="24">
   <input type="submit" value="测试@RequestBody注解">
</form>
</body>
</html>

2、注解生效相关源码分析

学习完注解之后，我们不禁疑问，这些注解是怎么将请求中的参数绑定到控制器方法的入参上的呢

那么接下来，我们就来看一下相关源码

首先，我们的目光肯定还是聚焦到DiapatcherServlet这个类，我们还是找到doDispatch()这个方法

在使用getHandler()方法获取到handler之后，它会去获取HandlerAdapter

try {
processedRequest = this.checkMultipart(request);
multipartRequestParsed = processedRequest != request;
mappedHandler = this.getHandler(processedRequest);
if (mappedHandler == null) {
this.noHandlerFound(processedRequest, response);
return;
}
// 获取HandlerAdapter
HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());
...
// 执行目标方法
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

我们跟进这个getHandlerAdapter()方法，发现他是做了一个遍历，为当前Handler 找一个适配器 HandlerAdapter，最后返回RequestMappingHandlerAdapter

找到适配器之后，我们做了一系列判断，接着我们会使用mv = ha.handle(processedRequest, response, mappedHandler.getHandler())来执行目标方法，这句代码会将我们上面找到的handler、请求request以及响应response都传入其中

我们继续深入，发现断点走到了RequestMappingHandlerAdapter这个类下的handleInternal()方法，然后它又调用了invokeHandlerMethod()

这个方法中做了如下几件重要的事情

设置参数解析器，我们通过观察可以看到，这里可用的参数解析器似乎和我们之前学习的参数注解有关，比如RequestParam、PathVariable等

点击this.argumentResolvers并一直深入，我们可以发现它是实现了HandlerMethodArgumentResolver 这个接口，这个接口里面只有2个方法，也就是说，在这个接口的27个实现类中，我们满足哪个参数解析器的supportsParameter()方法，它就会调用对应的resolveArgument()方法来解析参数

public interface HandlerMethodArgumentResolver {
// 判断是否支持此类型参数
   boolean supportsParameter(MethodParameter parameter);
// 解析参数
   @Nullable
   Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception;
}

设置返回值处理器

我们的方法能返回多少种类型的返回值，也取决于返回值处理器支持哪些类型

执行目标方法

我们看完上面的参数解析器和返回值处理器后，直接转到invocableMethod.invokeAndHandle(webRequest, mavContainer, new Object[0]);

跟着断点深入到ServletInvocableHandlerMethod类下的invokeAndHandle()这个方法

发现只要执行Object returnValue = this.invokeForRequest(webRequest, mavContainer, providedArgs);之后，断点就会跳转到控制器类的具体方法中，也就是说，这里才是真正的方法调用处

我们来分析一下invokeForRequest()这个方法

@Nullable
public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
  // 确定目标方法的每一个参数的值
  Object[] args = this.getMethodArgumentValues(request, mavContainer, providedArgs);
  if (logger.isTraceEnabled()) {
      logger.trace("Arguments: " + Arrays.toString(args));
  }
  //使用反射调用对应方法
  return this.doInvoke(args);
}

最后，我们发现参数的解析是在getMethodArgumentValues()这个方法进行的，它通过一个for循环，判断每一个参数适合用哪个解析器来进行参数解析

protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
  // 获取所有参数的详细信息，包括类型，注解，位置等
  MethodParameter[] parameters = this.getMethodParameters();
  if (ObjectUtils.isEmpty(parameters)) {
      return EMPTY_ARGS;
  } else {
      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) {
  // 循环所有支持的参数解析器，判断当前参数被哪种解析器支持，并且把当前参数和解析器当作k-v键值对放进缓存，方便以后直接取
              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 var10) {
                  if (logger.isDebugEnabled()) {
                      String exMsg = var10.getMessage();
                      if (exMsg != null && !exMsg.contains(parameter.getExecutable().toGenericString())) {
                          logger.debug(formatArgumentError(parameter, exMsg));
                      }
                  }
                  throw var10;
              }
          }
      }
      return args;
  }
}

有兴趣的可以继续深入，哈哈~

3、Servlet API

如果入参类型是下列中的某一种

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

对应的参数解析器就是ServletRequestMethodArgumentResolver

4、复杂参数

• Map、Model：map、model里面的数据会被放在request的请求域 ，类似于request.setAttribute

• RedirectAttributes（ 重定向携带数据）

• ServletResponse（response）、SessionStatus、UriComponentsBuilder、ServletUriComponentsBuilder、Errors/BindingResult

代码样例：

我们写一个控制器接口/testModelAndMap，将请求转发到/testOk这个接口

@GetMapping(value = "/testModelAndMap")
public String testModelAndMap(Model model, Map<String, Object> map,
   HttpServletRequest request, HttpServletResponse response) {
   map.put("name", "decade");
   model.addAttribute("age", 24);
   request.setAttribute("sex", "man");
   Cookie cookie = new Cookie("n1", "v1");
   cookie.setMaxAge(1);
   response.addCookie(cookie);
   // 将请求转发到/testOk
   return "forward:/testOk";
}
@GetMapping(value = "/testOk")
@ResponseBody
public Map<String, Object> testOk(HttpServletRequest request) {
   Map<String, Object> map = new HashMap<>();
   map.put("name", request.getAttribute("name"));
   map.put("age", request.getAttribute("age"));
   map.put("sex", request.getAttribute("sex"));
   return map;
}

调用接口发现，我们在/testModelAndMap接口中放入Map、Model和HttpServletRequest中的参数，在/testOk中也可以取到，这说明这些参数会被放在request的请求域中，本次请求完成时都可以取到

相关源码还是DispatcherServlet类下面的doDispatch()

关键点就是根据参数类型去找对应的参数解析器和返回值处理器

• Map类型：MapMethodProcessor

• Model类型：ModelMethodProcessor

• HttpServletRequest：ServletRequestMethodArgumentResolver

注意：ModelAndViewContainer中包含要去的页面地址View，还包含Model数据

大家可以自己debug一下，不在赘述，否则篇幅太长了

5、自定义参数

测试代码，先写2个实体类

package com.decade.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {
   private String name;
   private int age;
   private Date birth;
   private Pet pet;
}
package com.decade.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Pet {
   private String name;
   private int age;
}

然后写控制器处理方法

@PostMapping(value = "/savePerson")
@ResponseBody
public Person savePerson(Person person) {
   return person;
}

最后写一个HTML页面

<!DOCTYPE html>
<html lang="en">
<head>
   <meta charset="UTF-8">
   <title>Title</title>
</head>
<body>
Hello World!
<form action="/savePerson" method="post">
   姓名： <input name="name" type="text" value="decade">
   年龄： <input name="age" type="text" value="24">
   生日： <input name="birth" type="text" value="2022/01/01">
   宠物姓名： <input name="pet.name" type="text" value="十年的小狗">
   宠物年龄： <input name="pet.age" type="text" value="1">
   <input type="submit" value="提交保存">
</form>
</body>
</html>

测试结果如下，我们发现简单属性和存在引用关系的属性都成功绑定了

对应解析类：ServletModelAttributeMethodProcessor和其父类ModelAttributeMethodProcessor

数据绑定核心代码：

ModelAttributeMethodProcessor类下的resolveArgument()方法

this.bindRequestParameters(binder, webRequest);

binder:web数据绑定器，将请求参数的值绑定到指定的JavaBean里面

WebDataBinder 利用它里面的 Converters 将请求数据转成指定的数据类型，再次封装到JavaBean中

GenericConversionService类：getConverter()---->find()

在将请求参数的值转化为指定JavaBean的对应属性时，它会去缓存中寻找是否有合适的Converters转换器，如果没有就和上面寻找参数解析器一样，遍历所有的转换器，寻找能将request中的类型转换成目标类型的转换器

6、类型转换器Converters

有时候，Spring默认提供的converter满足不了我们的需求

我们就可以直接使用@Configuration+@Bean的方式，自定义一些类转换器，创建一个新的WebMvcConfigure放到容器中，因为接口有默认实现，所以我们只需要重写指定方法

package com.decade.config;
import com.decade.pojo.Pet;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.convert.converter.Converter;
import org.springframework.format.FormatterRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration(proxyBeanMethods = false)
public class MyMvcConfig implements WebMvcConfigurer {
   @Bean
   public WebMvcConfigurer createConvert() {
       return new WebMvcConfigurer() {
           @Override
           public void addFormatters(FormatterRegistry registry) {
               registry.addConverter(new Converter<String, Pet>() {
                   @Override
                   public Pet convert(String source) {
                       final String[] split = source.split(",");
                       final Pet pet = new Pet();
                       pet.setName(split[0]);
                       pet.setAge(Integer.parseInt(split[1]));
                       return pet;
                   }
               });
           }
       };
   }

然后写一个HTML页面进行测试

<!DOCTYPE html>
<html lang="en">
<head>
   <meta charset="UTF-8">
   <title>Title</title>
</head>
<body>
Hello World!
<form action="/savePerson" method="post">
   姓名： <input name="name" type="text" value="decade">
   年龄： <input name="age" type="text" value="24">
   生日： <input name="birth" type="text" value="2022/01/01">
   宠物信息： <input name="pet" type="text" value="十年的小狗,1">
   <input type="submit" value="提交保存">
</form>
</body>
</html>

来源：https://blog.csdn.net/Decade0712/article/details/126445525