devbox
Cpp五条
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SpringBoot系列教程web篇之Get请求参数解析姿势汇总

作者：Cpp五条 | 2024-05-16 19:04:48

赞

踩

springboot对前端get参数进行解码

一般在开发web应用的时候，如果提供http接口，最常见的http请求方式为GET/POST，我们知道这两种请求方式的一个显著区别是GET请求的参数在url中，而post请求可以不在url中；那么一个SpringBoot搭建的web应用可以如何解析发起的http请求参数呢？

下面我们将结合实例汇总一下GET请求参数的几种常见的解析姿势

原文：190824-SpringBoot系列教程web篇之Get请求参数解析姿势汇总

<!-- more -->

I. 环境搭建

首先得搭建一个web应用才有可能继续后续的测试，借助SpringBoot搭建一个web应用属于比较简单的活;

创建一个maven项目，pom文件如下

  1. <parent>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-parent</artifactId>
  4.     <version>2.1.7</version>
  5.     <relativePath/> <!-- lookup parent from update -->
  6. </parent>
  7.  
  8. <properties>
  9.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  10.     <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  11.     <spring-cloud.version>Finchley.RELEASE</spring-cloud.version>
  12.     <java.version>1.8</java.version>
  13. </properties>
  14.  
  15. <dependencies>
  16.     <dependency>
  17.         <groupId>org.springframework.boot</groupId>
  18.         <artifactId>spring-boot-starter-web</artifactId>
  19.     </dependency>
  20. </dependencies>
  21.  
  22. <build>
  23.     <pluginManagement>
  24.         <plugins>
  25.             <plugin>
  26.                 <groupId>org.springframework.boot</groupId>
  27.                 <artifactId>spring-boot-maven-plugin</artifactId>
  28.             </plugin>
  29.         </plugins>
  30.     </pluginManagement>
  31. </build>
  32. <repositories>
  33.     <repository>
  34.         <id>spring-milestones</id>
  35.         <name>Spring Milestones</name>
  36.         <url>https://repo.spring.io/milestone</url>
  37.         <snapshots>
  38.             <enabled>false</enabled>
  39.         </snapshots>
  40.     </repository>
  41. </repositories>

添加项目启动类Application.cass

  1. @SpringBootApplication
  2. public class Application {
  3.     public static void main(String[] args) {
  4.         SpringApplication.run(Application.class);
  5.     }
  6. }

在演示请求参数的解析实例中，我们使用终端的curl命令来发起http请求（主要原因是截图上传太麻烦，还是终端的文本输出比较方便；缺点是不太直观）

II. GET请求参数解析

接下来我们正式进入参数解析的妖娆姿势篇，会介绍一下常见的一些case（并不能说包含了所有的使用case）

下面所有的方法都放在 ParamGetRest 这个Controller中

  1. @RestController
  2. @RequestMapping(path = "get")
  3. public class ParamGetRest {
  4. }

1. HttpServletRequest

直接使用HttpServletRequest来获取请求参数，属于比较原始，但是灵活性最高的使用方法了。

常规使用姿势是方法的请求参数中有一个HttpServletRequest，我们通过ServletRequest#getParameter(参数名)来获取具体的请求参数，下面演示返回所有请求参数的case

  1. @GetMapping(path = "req")
  2. public String requestParam(HttpServletRequest httpRequest) {
  3.     Map<String, String[]> ans = httpRequest.getParameterMap();
  4.     return JSON.toJSONString(ans);
  5. }

测试case，注意下使用curl请求参数中有中文时，进行了url编码（后续会针对这个问题进行说明）

  1. ➜  ~ curl 'http://127.0.0.1:8080/get/req?name=yihuihiu&age=19'
  2. {"name":["yihuihiu"],"age":["19"]}%                                                                                                                                       ➜  ~ curl 'http://127.0.0.1:8080/get/req?name=%E4%B8%80%E7%81%B0%E7%81%B0&age=19'
  3. {"name":["一灰灰"],"age":["19"]}%

使用HttpServletRequest获取请求参数，还有另外一种使用case，不通过参数传递的方式获取Request实例，而是借助RequestContextHolder；这样的一个好处就是，假设我们想写一个AOP，拦截GET请求并输出请求参数时，可以通过下面这种方式来处理

  1. @GetMapping(path = "req2")
  2. public String requestParam2() {
  3.     HttpServletRequest request =
  4.             ((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes()).getRequest();
  5.     String name = request.getParameter("name");
  6.     return "param Name=" + name;
  7. }

测试case

  1. ➜  ~ curl 'http://127.0.0.1:8080/get/req2?name=%E4%B8%80%E7%81%B0%E7%81%B0&age=19'
  2. param Name=一灰灰%

2. 方法参数

这种解析方式比较厉害了，将GET参数与方法的参数根据参数名进行映射，从感官上来看，就像是直接调用这个一样

  1. @GetMapping(path = "arg")
  2. public String argParam(String name, Integer age) {
  3.     return "name: " + name + " age: " + age;
  4. }

针对上面提供的方式，我们的测试自然会区分为下面几种，看下会怎样

  • 正好两个参数，与定义一直
  • 缺少一个请求参数
  • 多一个请求参数
  • 参数类型不一致
  1. # 参数解析正常
  2. ➜  ~ curl 'http://127.0.0.1:8080/get/arg?name=%E4%B8%80%E7%81%B0%E7%81%B0&age=19'
  3. name: 一灰灰 age: 19%
  4. # 缺少一个参数时，为null
  5. ➜  ~ curl 'http://127.0.0.1:8080/get/arg?name=%E4%B8%80%E7%81%B0%E7%81%B0'
  6. name: 一灰灰 age: null% 
  7. # 多了一个参数，无法被解析
  8. ➜  ~ curl 'http://127.0.0.1:8080/get/arg?name=%E4%B8%80%E7%81%B0%E7%81%B0&age=19&id=10'
  9. name: 一灰灰 age: 19%                                                              
  10. # 类型不一致，500 
  11. ➜  ~ curl 'http://127.0.0.1:8080/get/arg?name=%E4%B8%80%E7%81%B0%E7%81%B0&age=haha' -i
  12. HTTP/1.1 500
  13. Content-Length: 0
  14. Date: Sat, 24 Aug 2019 01:45:14 GMT
  15. Connection: close

从上面实际的case可以看出，利用方法参数解析GET传参时，实际效果是：

  • 方法参数与GET传参，通过参数签名进行绑定
  • 方法参数类型，需要与接收的GET传参类型一致
  • 方法参数非基本类型时，若传参没有，则为null；（也就是说如果为基本类型，无法转null，抛异常）
  • 实际的GET传参可以多于方法定义的参数

接下来给一个数组传参解析的实例

  1. @GetMapping(path = "arg2")
  2. public String argParam2(String[] names, int size) {
  3.     return "name: " + (names != null ? Arrays.asList(names) : "null") + " size: " + size;
  4. }

测试case如下，传数组时参数值用逗号分隔；基本类型，必须传参，否则解析异常

  1. ➜  ~ curl 'http://127.0.0.1:8080/get/arg2?name=yihui,erhui&size=2'
  2. name: null size: 2%                                                                                                                                                       ➜  ~ curl 'http://127.0.0.1:8080/get/arg2?name=yihui,erhui' -i
  3. HTTP/1.1 500
  4. Content-Length: 0
  5. Date: Sat, 24 Aug 2019 01:53:30 GMT
  6. Connection: close

3. RequestParam 注解

这种方式看起来和前面有些相似，但更加灵活，我们先看一下注解

  1. @Target(ElementType.PARAMETER)
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Documented
  4. public @interface RequestParam {
  5.   // 指定请求参数名
  6. 	String value() default "";
  7. 	// 指定请求参数名
  8. 	String name() default "";
  9. 	// true表示发起请求时这个参数必须存在
  10. 	boolean required() default true;
  11. 	String defaultValue() default ValueConstants.DEFAULT_NONE;
  12. }

有两个参数需要注意，一个是name表示这个参数与GET传参的哪个关联；required表示这个参数是否可选

下面是一个简单的使用方式

  1. @GetMapping(path = "ano")
  2. public String anoParam(@RequestParam(name = "name") String uname,
  3.         @RequestParam(name = "age", required = false) Integer age,
  4.         @RequestParam(name = "uids", required = false) Integer[] uids) {
  5.     return "name: " + uname + " age: " + age + " uids: " + (uids != null ? Arrays.asList(uids) : "null");
  6. }

测试如下:

  1. # 三个参数全在
  2. ➜  ~ curl 'http://localhost:8080/get/ano?name=%E4%B8%80%E7%81%B0%E7%81%B0blog&age=18&uids=1,3,4'
  3. name: 一灰灰blog age: 18 uids: [1, 3, 4]%
  4. # age不传
  5. ➜  ~ curl 'http://localhost:8080/get/ano?name=%E4%B8%80%E7%81%B0%E7%81%B0blog&uids=1,3,4'
  6. name: 一灰灰blog age: null uids: [1, 3, 4]% 
  7. # 必选参数name不传时
  8. ➜  ~ curl 'http://localhost:8080/get/ano?uids=1,3,4' -i
  9. HTTP/1.1 500
  10. Content-Length: 0
  11. Date: Sat, 24 Aug 2019 13:09:07 GMT
  12. Connection: close

使用RequestParam注解时，如果指定了name/value，这个参数就与指定的GETGET传参关联；如果不指定时，则根据参数签名来关联

下面给出两个更有意思的使用方式，一个是枚举参数解析，一个是Map容纳参数，一个是数组参数解析

  1. public enum TYPE {
  2.     A, B, C;
  3. }
  4.  
  5. @GetMapping(path = "enum")
  6. public String enumParam(TYPE type) {
  7.     return type.name();
  8. }
  9.  
  10. @GetMapping(path = "enum2")
  11. public String enumParam2(@RequestParam TYPE type) {
  12.     return type.name();
  13. }
  14.  
  15. @GetMapping(path = "mapper")
  16. public String mapperParam(@RequestParam Map<String, Object> params) {
  17.     return params.toString();
  18. }
  19.  
  20. // 注意下面这个写法，无法正常获取请求参数，这里用来对比列出
  21. @GetMapping(path = "mapper2")
  22. public String mapperParam2(Map<String, Object> params) {
  23.     return params.toString();
  24. }
  25.  
  26.  
  27. @GetMapping(path = "ano1")
  28. public String anoParam1(@RequestParam(name = "names") List<String> names) {
  29.     return "name: " + names;
  30. }
  31.  
  32. // 注意下面这个写法无法正常解析数组
  33. @GetMapping(path = "arg3")
  34. public String anoParam2(List<String> names) {
  35.     return "names: " + names;
  36. }

测试case如下

  1. ➜  ~ curl 'http://localhost:8080/get/enum?type=A'
  2. A%
  3. ➜  ~ curl 'http://localhost:8080/get/enum2?type=A'
  4. A%
  5. ➜  ~ curl 'http://localhost:8080/get/mapper?type=A&age=3'
  6. {type=A, age=3}%
  7. ➜  ~ curl 'http://localhost:8080/get/mapper2?type=A&age=3'
  8. {}%
  9. ➜  ~ curl 'http://localhost:8080/get/ano1?names=yi,hui,ha'
  10. name: [yi, hui, ha]%
  11. ➜  ~ curl 'http://localhost:8080/get/arg3?names=yi,hui,ha' -i
  12. HTTP/1.1 500
  13. Content-Length: 0
  14. Date: Sat, 24 Aug 2019 13:50:55 GMT
  15. Connection: close

从测试结果可以知道：

  • GET传参映射到枚举时，根据enum.valueOf()来实例的
  • 如果希望使用Map来容纳所有的传参，需要加上注解@RequestParam
  • 如果参数为List类型，必须添加注解@RequestParam；否则用数组来接收

4. PathVariable

从请求的url路径中解析参数，使用方法和前面的差别不大

  1. @GetMapping(path = "url/{name}/{index}")
  2. public String urlParam(@PathVariable(name = "name") String name,
  3.         @PathVariable(name = "index", required = false) Integer index) {
  4.     return "name: " + name + " index: " + index;
  5. }

上面是一个常见的使用方式，对此我们带着几个疑问设计case

  • 只有name没有index，会怎样？
  • 有name，有index，后面还有路径，会怎样？
  1. ➜  ~ curl http://127.0.0.1:8080/get/url/yihhuihui/1
  2. name: yihhuihui index: 1%
  3.  
  4. ➜  ~ curl 'http://127.0.0.1:8080/get/url/yihhuihui' -i
  5. HTTP/1.1 500
  6. Content-Length: 0
  7. Date: Sat, 24 Aug 2019 13:27:08 GMT
  8. Connection: close
  9.  
  10. ➜  ~ curl 'http://127.0.0.1:8080/get/url/yihhuihui/1/test' -i
  11. HTTP/1.1 500
  12. Content-Length: 0
  13. Date: Sat, 24 Aug 2019 13:27:12 GMT
  14. Connection: close

从path中获取参数时，对url有相对严格的要求，注意使用

5. POJO

这种case，我个人用得比较多，特别是基于SpringCloud的生态下，借助Feign来调用第三方微服务，可以说是很舒爽了；下面看一下这种方式的使用姿势

首先定义一个POJO

  1. @Data
  2. public class BaseReqDO implements Serializable {
  3.     private static final long serialVersionUID = 8706843673978981262L;
  4.  
  5.     private String name;
  6.  
  7.     private Integer age;
  8.  
  9.     private List<Integer> uIds;
  10. }

提供一个服务

  1. @GetMapping(path = "bean")
  2. public String beanParam(BaseReqDO req) {
  3.     return req.toString();
  4. }

POJO中定义了三个参数，我们再测试的时候，看一下这些参数是否必选

  1. # GET传参与POJO中成员名进行关联
  2. ➜  ~ curl 'http://127.0.0.1:8080/get/bean?name=yihuihui&age=18&uIds=1,3,4'
  3. BaseReqDO(name=yihuihui, age=18, uIds=[1, 3, 4])%
  4. # 没有传参的属性为null；因此如果POJO中成员为基本类型，则参数必传
  5. ➜  ~ curl 'http://127.0.0.1:8080/get/bean?name=yihuihui&age=18'
  6. BaseReqDO(name=yihuihui, age=18, uIds=null)%

II. 其他

0. 项目

1. 一灰灰Blog

尽信书则不如，以上内容，纯属一家之言，因个人能力有限，难免有疏漏和错误之处，如发现bug或者有更好的建议，欢迎批评指正，不吝感激

下面一灰灰的个人博客，记录所有学习和工作中的博文，欢迎大家前去逛逛

一灰灰blog

转载于:https://my.oschina.net/u/566591/blog/3097207

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/580119
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号