投稿
  1. 半码博客首页
  2. 后端笔记

【Spring Boot】请求处理—常用参数注解与相关源码解读

飞熊 • • 后端笔记 • 阅读 67

生活中，最使人疲惫的往往不是道路的遥远，而是心中的郁闷;最使人痛苦的往往不是生活的不幸，而是希望的破灭;最使人颓废的往往不是前途的坎坷，而是自信的丧失;最使人绝望的往往不是挫折的打击，而是心灵的死亡。所以我们要有自己的梦想，让梦想的星光指引着我们走出落漠，走出惆怅，带着我们走进自己的理想。

导读：本篇文章讲解 【Spring Boot】请求处理—常用参数注解与相关源码解读，希望对大家有帮助，欢迎收藏，转发！站点地址：www.bmabk.com，来源：原文

一、注解

  • @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">测试@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注解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://www.bmabk.com/index.php/post/136751.html

赞 (0)
飞熊的头像飞熊bm
0 0

相关推荐

发表回复

登录后才能评论
半码博客——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！