【Spring Boot】常用参数与注解

一、注解

• @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);
            }
        };
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

• @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可以获取路径变量中的所有占位符参数
        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可以获取请求头中的所有参数
        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可以获取请求头中的所有参数
        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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

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

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>主页title>
head>
<body>
Hello World!
<a href="/testPathVariable/001/split/decade">测试@PathVariable注解a>
<br>
<a href="/testRequestHeader">测试RequestHeader注解a>
<br>
<a href="/testRequestParam?userId=001&interest=games&interest=music">测试@RequestParam注解a>
<br>
<a href="/testCookieValue">测试@CookieValue注解a>
<br>
<a href="/testRequestAttribute">测试@RequestAttribute注解a>
<br>
<a href="/car/queryInfo;hobby=game;hobby=music;age=24">测试@MatrixVariable注解a>
<br>
<a href="/car/1;age=39/2;age=23">测试@MatrixVariable注解2a>
<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>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

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());
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

我们跟进这个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;
}
1
2
3
4
5
6
7
8

• 设置返回值处理器
  我们的方法能返回多少种类型的返回值，也取决于返回值处理器支持哪些类型
• 执行目标方法
  我们看完上面的参数解析器和返回值处理器后，直接转到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);
}
1
2
3
4
5
6
7
8
9
10
11

最后，我们发现参数的解析是在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;
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

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

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

调用接口发现，我们在/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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

然后写控制器处理方法

@PostMapping(value = "/savePerson")
@ResponseBody
public Person savePerson(Person person) {
    return person;
}
1
2
3
4
5

最后写一个HTML页面

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
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>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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

• 对应解析类：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;
                    }
                });
            }
        };
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

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

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
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>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

如有错误，欢迎指正！！！