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>
到此这篇关于SpringBoot请求处理之常用参数注解介绍与源码分析的文章就介绍到这了,更多相关SpringBoot请求处理内容请搜索Devmax以前的文章或继续浏览下面的相关文章希望大家以后多多支持Devmax！