SpringBoot接收接口入参的方式小结

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.9.RELEASE</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--Hutool是一个小而全的Java工具类库-->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.6.3</version>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.30</version>
        </dependency>
        <!--fastjson-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.6</version>
        </dependency>
    </dependencies>

method: [DELETE], uri: [/test_query/requestparam_1], param type: [Query]  ---> SUCCESS! requestParam1 name = wangwu-delete, age = 18

{
    "code": 0,
    "data": "method: [DELETE], uri: [/test_query/requestparam_1], param type: [Query]  ---> SUCCESS! requestParam1 name = wangwu-delete, age = 18",
    "msg": "操作成功",
    "timestamp": 1704766444205
}

package com.su.demo.controller.param_type;

import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.Date;


@RestController
@RequestMapping(value = "/param_type/query")
public class TestQueryController {

    /**
     * <ul>
     *     <li><b>入参类别</b>：Query参数
     *     <li><b>定义方式</b>: 在方法形参的位置,把每个参数都平铺开来</li>
     *     <li><b>调用方式</b>: 入参拼接在接口的uri后面,如 /test_get/requestparam_1?name=wangwu&age=18</li>
     *     <li><b>兼容的请求方式</b>：GET POST PUT DELETE</li>
     *     <li><b>适用场景</b>：虽然这种传参方式,适用于GET POST PUT DELETE等请求方式,但是一般偏向于应用在 入参个数少(一般少于5个)的<b>GET</b>请求方式中</li>
     *     <li><b>优点</b>:方便简单</li>
     *     <li><b>缺点</b>:1) 入参直接显示在uri中，不太安全 2）参数个数如果过多,方法体结构会显得很臃肿; 3）没有入参校验</li>
     * </ul>
     * <p><b>注意</b>:根据自己的需求决定是否在形参中加上HttpServletRequest,我这里是为了从request中获取method,所以加上了</p>
     */
    @RequestMapping(value = "/test1")
    public String test1(String name, Integer age, HttpServletRequest request) {
        // 从request中获取一些接口请求时的元数据信息，包括请求方式，Content-type等
        String requestMetaInfo = String.format("method: [%s], uri: [%s], Content-Type: [%s] ", request.getMethod(), request.getRequestURI(),  request.getHeader("Content-Type"));

        return requestMetaInfo + " ---> SUCCESS! name = " + name + ", age = " + age;
    }

}

package com.su.demo.controller.param_type;

import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.Date;

@RestController
@RequestMapping(value = "/param_type/query")
public class TestQueryController {

    /**
     * <ul>
     *     <li><b>入参类别</b>：Query参数
     *     <li><b>定义方式</b>: 在方法形参的位置,把每个参数都平铺开来.并且相较于前一种定义方式,这种方式使用 {@link RequestParam}绑定请求参数到方法形参， 且需要注意该注解中的各个属性的作用！</li>
     *     <li><b>调用方式</b>: 入参拼接在接口的uri后面,如 /test_get/requestparam_1?name=wangwu&age=18</li>
     *     <li><b>兼容的请求方式</b>：GET POST PUT DELETE</li>
     *     <li><b>适用场景</b>：虽然这种传参方式,适用于GET POST PUT DELETE等请求方式,但是一般偏向于应用在 入参个数少(一般少于5个)的<b>GET</b>请求方式中</li>
     *     <li><b>优点</b>:方便简单;且结合{@link RequestParam},可实现入参的必填校验/重命名/默认值等简单的功能</li>
     *     <li><b>缺点</b>:1) 入参直接显示在uri中，不太安全
     *                    2）参数个数如果过多,方法体结构会显得很臃肿(当前这个方法有4个入参,其实就已经有点臃肿了)
     *                    3){@link RequestParam}能支持的校验相对来说还是比较简单</li>
     * </ul>
     */
    @RequestMapping(value = "/test2_requestparam")
    public String test2(@RequestParam String name,
                                @RequestParam(name = "newAge") Integer age,
                                @RequestParam(name = "birth", required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date birth,
                                @RequestParam(defaultValue = "true") Boolean enable,
                                HttpServletRequest request) {
        // 从request中获取一些接口请求时的元数据信息，包括请求方式，Content-type等
        String requestMetaInfo = String.format("method: [%s], uri: [%s], Content-Type: [%s] ", request.getMethod(), request.getRequestURI(),  request.getHeader("Content-Type"));

        return requestMetaInfo + " ---> SUCCESS! name = " + name + ", age = " + age + ", birth = " + birth + ", enable = " + enable;
    }

}

package com.su.demo.controller.param_type;

import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.Date;

@RestController
@RequestMapping(value = "/param_type/query")
public class TestQueryController {

    /**
     * <ul>
     *     <li><b>入参类别</b>：Query参数
     *     <li><b>定义方式</b>: 把入参封装到一个实体中(入参个数多于5个时一般用这种方式)
     *     <li><b>调用方式</b>: 入参拼接在接口的uri后面,如 /test_get/requestparam_1?name=wangwu&age=18</li>
     *     <li><b>兼容的请求方式</b>：GET POST PUT DELETE</li>
     *     <li><b>适用场景</b>：从技术上来说这种传参方式,同时适用于GET POST PUT DELETE等多种请求方式,但是一般我个从偏向于在入参个数大于5个的<b>GET</b>请求方式中使用</li>
     *     <li><b>优点</b>:因为参数都封装在实体bean当中了,所以对参数的个数就没有什么的限制了,接口定义的时候方便多了
     *     <li><b>缺点</b>:对于这种入参的[定义方式]来说,它是没有什么缺点的.硬要说缺点的话,其实是针对Query这种传参方式来说的,即当参数个数一多的时候,参数都放在请求uri中容易造成uri的长度过过长
     *     (虽然http协议中未明确对url进行长度限制，但在真正实现中，url的长度还是受到限制的，一是服务器端的限制，二就是游览器端的限制)</li>
     * </ul>
     */
    @RequestMapping(value = "/test3_entity")
    public String test3(UserDTO userDTO, HttpServletRequest request) {
        // 从request中获取一些接口请求时的元数据信息，包括请求方式，Content-type等
        String requestMetaInfo = String.format("method: [%s], uri: [%s], Content-Type: [%s] ", request.getMethod(), request.getRequestURI(),  request.getHeader("Content-Type"));

        return requestMetaInfo + " ---> SUCCESS! userDTO = " + userDTO;
    }

}

package com.su.demo.bean.dto;

import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;
import java.util.Date;

@Data
public class UserDTO {
    /**
     * 主键ID
     */
    private Long id;

    /**
     * 用户姓名
     */
    private String name;

    /**
     * 用户状态 true：启用；false：禁用
     */
    private Boolean enable;

    /**
     * 用户生日
     */
    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date birth;
}

package com.su.demo.controller.param_type;

import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.Date;

@RestController
@RequestMapping(value = "/param_type/query")
public class TestQueryController {

    /**
     * <ul>
     *     <li><b>入参类别</b>：Query参数
     *     <li><b>定义方式</b>: 在方式形参的位置,用原生的{@link HttpServletRequest}接收
     *     <li><b>调用方式</b>: 入参拼接在接口的uri后面,如 /test_get/requestparam_1?name=wangwu&age=18</li>
     *     <li><b>兼容的请求方式</b>：GET POST PUT DELETE</li>
     *     <li><b>适用场景</b>：从技术上来说,这种传参方式同时适用于GET POST PUT DELETE等请求方式,但是正常情况下比较少用这种方式来获取参数了</li>
     *     <li><b>优点</b>:{@link HttpServletRequest}是整个请求，可以获取到所有的数据.且HttpServletRequest、HttpServletResponse都是内置对象，可以使用</li>
     *     <li><b>缺点</b>:代码中再去从request中拿到参数,比较麻烦</li>
     * </ul>
     * <p> 注意,这种方式其实也可以获取body请求体里面的数据,参考https://blog.csdn.net/qq_24850045/article/details/121927722
     */
    @RequestMapping(value = "/test4_request")
    public String test4(HttpServletRequest request) throws IOException {
        // 从request中获取一些接口请求时的元数据信息，包括请求方式，Content-type等
        String requestMetaInfo = String.format("method: [%s], uri: [%s], Content-Type: [%s] ", request.getMethod(), request.getRequestURI(),  request.getHeader("Content-Type"));

        String name = request.getParameter("name");
        Integer age = Integer.parseInt(request.getParameter("age")); // 需要进行类型转换

        return requestMetaInfo + " ---> SUCCESS! name = " + name + ", age = "  + age;
    }

}

package com.su.demo.controller.param_type;

import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.Date;

@RestController
@RequestMapping(value = "/param_type/query")
public class TestQueryController {

    /**
     * <ul>
     *     <li><b>入参类别</b>：Query参数
     *     <li><b>定义方式</b>: 在方式形参的位置,结合{@link RequestParam}用Map接收
     *     <li><b>调用方式</b>: 入参拼接在接口的uri后面,如 /test_get/requestparam_1?name=wangwu&age=18</li>
     *     <li><b>兼容的请求方式</b>：GET POST PUT DELETE</li>
     *     <li><b>适用场景</b>：适用于参数个数较多，但是自己又想偷懒不想专门定义一个实体来接收入参的场景。一般不推荐使用这种方式。</li>
     *     <li><b>优点</b>:简单方便</li>
     *     <li><b>缺点</b>:需要在代码中通过指定特定的key的方式去获取入参，比较麻烦；而且这种接收入参的方式，没有办法结合{@link org.springframework.validation.annotation.Validated}来做入参校验</li>
     * </ul>
     */
    @RequestMapping(value = "/test5_map")
    public String test5(@RequestParam Map<String, String> paramMap, HttpServletRequest request) throws IOException {
        // 从request中获取一些接口请求时的元数据信息，包括请求方式，Content-type等
        String requestMetaInfo = String.format("method: [%s], uri: [%s], Content-Type: [%s] ", request.getMethod(), request.getRequestURI(),  request.getHeader("Content-Type"));

        String name = paramMap.get("name");
        // 判断：如果paramMap.get("age")为null，则age赋默认值0；否则进行入参类型的转换
        Integer age = null == paramMap.get("age") ? 0: Integer.parseInt(paramMap.get("age"));

        return requestMetaInfo + " ---> SUCCESS! name = " + name + ", age = "  + age;
    }

}

package com.su.demo.controller.param_type;

import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;

@RestController
@RequestMapping(value = "/param_type/path_variable")
public class TestPathVarController {


    /**
     * <ul>
     *     <li><b>入参类别</b>：PathVariable路径参数方式
     *     <li><b>定义方式</b>: 用占位符的方式把入参封装到请求路径中,然后再通过@PathVariable注解可以将URL中的占位符参数绑定到控制器（controller）处理方法的形参中. </li>
     *     <li><b>调用方式</b>: REST风格路径参数,入参拼接在接口的URI里面,如/test_pathvar/test1/zhangsan/1 </li>
     *     <li><b>兼容的请求方式</b>：GET POST PUT DELETE</li>
     *     <li><b>适用场景</b>：从技术上来说,这种传参方式同时适用于GET POST PUT DELETE等多种请求方式.
     *         但是一般入参个数小于5个,且你开发的是REST风格的接口,那可以考虑用这种方式
     *         </li>
     * </ul>
     * <p>REST(英文：Representational State Transfer，简称REST，意思：表述性状态转换，描述了一个架构样式的网络系统，比如web应用)，是一种软件架构风格不是标准哦！
     * 只是提供了一组设计原则和约束条件。它主要用于客户端和服务器交互类的软件。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。
     * REST 指的是一组架构（约束条件）和原则。满足这些（约束条件）和（原则）的应用程序或设计就是 Restful。</p>
     */
    @RequestMapping(value = "/test1/{name}/{age}")
    public String test1(@PathVariable("name") String name, @PathVariable("age") Integer myage, HttpServletRequest request) {
        // 从request中获取一些接口请求时的元数据信息，包括请求方式，Content-type等
        String requestMetaInfo = String.format("method: [%s], uri: [%s], Content-Type: [%s] ", request.getMethod(), request.getRequestURI(),  request.getHeader("Content-Type"));
        return requestMetaInfo + " ---> SUCCESS! name = " + name + ", myage = "  + myage;
    }
}

package com.su.demo.controller.param_type;

import cn.hutool.core.io.IoUtil;
import com.alibaba.fastjson.JSON;
import com.su.demo.bean.dto.UserDTO;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

@RestController
@RequestMapping(value = "/param_type/body_json")
public class TestBodyController {


    /**
     * <ul>
     *     <li><b>入参类别</b>：body参数方式
     *     <li><b>定义方式</b>: 在方式形参的位置,用原生的{@link HttpServletRequest}接收
     *     <li><b>调用方式</b>: 参数放在请求体 body 当中
     *     <li><b>兼容的请求方式</b>：GET POST PUT DELETE</li>
     *     <li><b>适用场景</b>：从技术上来说,这种传参方式同时适用于GET POST PUT DELETE等请求方式,但是正常情况下比较少用这种方式来获取body参数了</li>
     *     <li><b>优点</b>:{@link HttpServletRequest}是整个请求，可以获取到所有的数据.且HttpServletRequest、HttpServletResponse都是内置对象，可以使用</li>
     *     <li><b>缺点</b>:代码中再去从request中拿到参数,老麻烦,可以看下面的代码</li>
     * </ul>
     * <p> 注意,这种方式其实也可以获取body请求体里面的数据,参考https://blog.csdn.net/qq_24850045/article/details/121927722
     */
    @RequestMapping(value = "/test1_request")
    public String test1(HttpServletRequest request) throws IOException {
        // 从request中获取一些接口请求时的元数据信息，包括请求方式，Content-type等
        String requestMetaInfo = String.format("method: [%s], uri: [%s], Content-Type: [%s] ", request.getMethod(), request.getRequestURI(),  request.getHeader("Content-Type"));

        ServletInputStream inputStream = request.getInputStream();
        // 用hutool工具包的read方式,将inputStream读取成string
        String body = IoUtil.read(inputStream, "UTF-8");
        System.out.println("body = " + body);
        // 用fastjson将json字符串转换成bean
        UserDTO userDTO = JSON.parseObject(body, UserDTO.class);

        return requestMetaInfo + " ---> SUCCESS! userDTO = " + userDTO;
    }
}

package com.su.demo.bean.dto;

import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;

import java.util.Date;

@Data
public class UserDTO {
    /**
     * 主键ID
     */
    private Long id;

    /**
     * 用户姓名
     */
    private String name;

    /**
     * 用户状态 true：启用；false：禁用
     */
    private Boolean enable;

    /**
     * 用户生日
     */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private Date birth;
}

package com.su.demo.controller.param_type;

import cn.hutool.core.io.IoUtil;
import com.alibaba.fastjson.JSON;
import com.su.demo.bean.dto.UserDTO;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

@RestController
@RequestMapping(value = "/param_type/body_json")
public class TestBodyController {

   /**
     * <ul>
     *     <li><b>入参类别</b>：body参数方式
     *     <li><b>定义方式</b>: 在方式形参的位置,用{@link RequestBody}接收
     *     <li><b>调用方式</b>: 参数放在请求体 body 当中
     *     <li><b>兼容的请求方式</b>：GET POST PUT DELETE</li>
     *     <li><b>适用场景</b>：从技术上来说,这种传参方式同时适用于GET POST PUT DELETE等请求方式,但是正常情况下一般用在POST或PUT请求中</li>
     *     <li><b>优点</b>:1)方法形参的定义非常简洁;
     *                  2)调用的时候参数放在body中,参数体可以很大,不像Query入参方式在当参数过多的时候容易触发服务器端"Request header is too large"的报错
     *         </li>
     *     <li><b>缺点</b>:用String类型来接收参数,接收之后再转换成bean实体,还是稍微显得有点麻烦</li>
     * </ul>
     */
    @RequestMapping(value = "/test2_requestbody_string")
    public String test2(@RequestBody String body, HttpServletRequest request) {
        // 从request中获取一些接口请求时的元数据信息，包括请求方式，Content-type等
        String requestMetaInfo = String.format("method: [%s], uri: [%s], Content-Type: [%s] ", request.getMethod(), request.getRequestURI(),  request.getHeader("Content-Type"));

        System.out.println("body = " + body);
        // 用fastjson将json字符串转换成bean
        UserDTO userDTO = JSON.parseObject(body, UserDTO.class);

        return requestMetaInfo + " ---> SUCCESS! userDTO = " + userDTO;
    }

}

package com.su.demo.controller.param_type;

import cn.hutool.core.io.IoUtil;
import com.alibaba.fastjson.JSON;
import com.su.demo.bean.dto.UserDTO;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

@RestController
@RequestMapping(value = "/param_type/body_json")
public class TestBodyController {

    /**
     * <ul>
     *     <li><b>入参类别</b>：body参数方式
     *     <li><b>定义方式</b>: 在方式形参的位置,用{@link RequestBody}接收,
     *         而且是直接用一个实例类来接收了(spring自动调用相应的{@link org.springframework.http.converter.HttpMessageConverter}去做转换)
     *         </li>
     *     <li><b>调用方式</b>: 参数放在请求体 body 当中
     *     <li><b>兼容的请求方式</b>：GET POST PUT DELETE</li>
     *     <li><b>适用场景</b>：从技术上来说,这种传参方式同时适用于GET POST PUT DELETE等请求方式,但是正常情况下一般用在POST或PUT请求中</li>
     *     <li><b>优点</b>:1)方法形参的定义非常简洁;
     *                  2)调用的时候参数放在body中,参数体可以很大,不像Query入参方式在当参数过多的时候容易触发服务器端"Request header is too large"的报错
     *         </li>
     *     <li><b>缺点</b>:好像没啥缺点</li>
     * </ul>
     */
    @RequestMapping(value = "/test3_requestbody_entity")
    public String test3(@RequestBody UserDTO userDTO, HttpServletRequest request) {
        // 从request中获取一些接口请求时的元数据信息，包括请求方式，Content-type等
        String requestMetaInfo = String.format("method: [%s], uri: [%s], Content-Type: [%s] ", request.getMethod(), request.getRequestURI(),  request.getHeader("Content-Type"));

        return requestMetaInfo + " ---> SUCCESS! userDTO = " + userDTO;
    }

}

package com.su.demo.controller.param_type;

import cn.hutool.core.io.IoUtil;
import com.alibaba.fastjson.JSON;
import com.su.demo.bean.dto.UserDTO;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

@RestController
@RequestMapping(value = "/param_type/body_json")
public class TestBodyController {

   /**
     * <ul>
     *     <li><b>入参类别</b>：body参数方式
     *     <li><b>定义方式</b>: 在方式形参的位置,用{@link RequestBody}接收,
     *         而且是直接用一个Map对象实例类来接收了(spring自动调用相应的{@link org.springframework.http.converter.HttpMessageConverter}去做转换)
     *         </li>
     *     <li><b>调用方式</b>: 参数放在请求体 body 当中
     *     <li><b>兼容的请求方式</b>：GET POST PUT DELETE</li>
     *     <li><b>适用场景</b>：从技术上来说,这种传参方式同时适用于GET POST PUT DELETE等请求方式,一般使用在偷懒不想专门定义一个实体来接收入参的场景。一不太推荐使用这种方式/li>
     *     <li><b>优点</b>:1)方法形参的定义非常简洁;
     *                  2)调用的时候参数放在body中,参数体可以很大,不像Query入参方式在当参数过多的时候容易触发服务器端"Request header is too large"的报错
     *         </li>
     *     <li><b>缺点</b>:好像没啥缺点</li>
     * </ul>
     */
    @RequestMapping(value = "/test4_requestbody_map")
    public String test4(@RequestBody Map<String, String> paramMap, HttpServletRequest request) {
        // 从request中获取一些接口请求时的元数据信息，包括请求方式，Content-type等
        String requestMetaInfo = String.format("method: [%s], uri: [%s], Content-Type: [%s] ", request.getMethod(), request.getRequestURI(),  request.getHeader("Content-Type"));

        String name = paramMap.get("name");
        // 判断：如果paramMap.get("age")为null，则age赋默认值0；否则进行入参类型的转换
        Integer age = null == paramMap.get("age") ? 0: Integer.parseInt(paramMap.get("age"));

        return requestMetaInfo + " ---> SUCCESS! name = " + name + ", age = " + age;
    }

}

package com.su.demo.controller.param_type;

import cn.hutool.core.io.IoUtil;
import com.su.demo.bean.dto.TeacherDTO;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.net.URLDecoder;
import java.util.Map;

@RestController
@RequestMapping(value = "/param_type/body_form_urlencoded")
public class TestFormUrlEncodeController {

    /**
     * <p>注意，如果使用GET请求方式，则后端获取不到入参！！！</p>
     * <ul>
     *     <li><b>入参类别</b>：表单参数方式，Content-Type=application/x-www-form-urlencoded
     *     <li><b>定义方式</b>: 在方法形参的位置,把每个参数都平铺开来</li>
     *     <li><b>调用方式</b>: 入参放在表单中，且Content-Type=application/x-www-form-urlencoded</li>
     *     <li><b>兼容的请求方式</b>：POST PUT DELETE</li>
     *     <li><b>适用场景</b>：虽然这种传参方式,适用于POST PUT DELETE等请求方式,但是一般偏向于应用在 用<b>POST</b>或b>PUT</b>方式去发送的表单数据，且参数个数少，且表单字段都是普通类型(即表单字段不是File文件)，</li>
     *     <li><b>优点</b>:方便简单</li>
     *     <li><b>缺点</b>:1)参数个数如果过多,方法体结构会显得很臃肿</li>
     * </ul>
     */
    @RequestMapping(value = "/test1_requestparam")
    public String test1(String name, @RequestParam(name = "age", required = false) Integer age, Boolean enable, HttpServletRequest request) {
        // 从request中获取一些接口请求时的元数据信息，包括请求方式，Content-type等
        String requestMetaInfo = String.format("method: [%s], uri: [%s], Content-Type: [%s] ", request.getMethod(), request.getRequestURI(),  request.getHeader("Content-Type"));

        return requestMetaInfo + " ---> SUCCESS! name = " + name + ", age = " + age + ", enable = " + enable;
    }
}

package com.su.demo.controller.param_type;

import cn.hutool.core.io.IoUtil;
import com.su.demo.bean.dto.TeacherDTO;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.net.URLDecoder;
import java.util.Map;

@RestController
@RequestMapping(value = "/param_type/body_form_urlencoded")
public class TestFormUrlEncodeController {

    /**
     * <p>注意，如果使用GET请求方式，则后端获取不到入参！！！只支持POST PUT DELETE</p>
     * <p>且形参定义那里，一定不能使用{@link RequestParam}修饰</p>
     * <ul>
     *     <li><b>入参类别</b>：表单参数方式，Content-Type=application/x-www-form-urlencoded
     *     <li><b>定义方式</b>: 把入参封装到一个实体中(入参个数多于5个时一般用这种方式)</li>
     *     <li><b>调用方式</b>: 入参放在表单中，且Content-Type=application/x-www-form-urlencoded</li>
     *     <li><b>兼容的请求方式</b>：POST PUT DELETE</li>
     *     <li><b>适用场景</b>：虽然这种传参方式,适用于POST PUT DELETE等请求方式,但是一般偏向于应用在 用<b>POST</b>或<b>PUT</b>方式去发送的表单数据，且表单字段都是普通类型(即表单字段不是File文件)，</li>
     *     <li><b>优点</b>:方便简单，不管表单字段个个数多或少，一般如果表单字段类型没有File文件类型的，都可以使用这种方式</li>
     *     <li><b>缺点</b>:缺点的话就是针对Content-Type=application/x-www-form-urlencoded这种入参方式来说了：不能上传文件</li>
     * </ul>
     */
    @RequestMapping(value = "/test2_entity")
    public String test2(TeacherDTO teacherDTO, HttpServletRequest request) {
        // 从request中获取一些接口请求时的元数据信息，包括请求方式，Content-type等
        String requestMetaInfo = String.format("method: [%s], uri: [%s], Content-Type: [%s] ", request.getMethod(), request.getRequestURI(),  request.getHeader("Content-Type"));

        return requestMetaInfo + " ---> SUCCESS! teacherDTO = " + teacherDTO;
    }

}

package com.su.demo.controller.param_type;

import cn.hutool.core.io.IoUtil;
import com.su.demo.bean.dto.TeacherDTO;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.net.URLDecoder;
import java.util.Map;

@RestController
@RequestMapping(value = "/param_type/body_form_urlencoded")
public class TestFormUrlEncodeController {

    /**
     * <p>注意，只支持GET请求方式，如果使用POST、PUT、DELETE请求方式，则后端获取不到入参！！！</p>
     * <ul>
     *     <li><b>入参类别</b>：表单参数方式，Content-Type=application/x-www-form-urlencoded
     *     <li><b>定义方式</b>: 在方法形参的位置，用{@link HttpServletRequest}来接收入参</li>
     *     <li><b>调用方式</b>: 入参放在表单中，且Content-Type=application/x-www-form-urlencoded</li>
     *     <li><b>兼容的请求方式</b>：GET</li>
     *     <li><b>适用场景</b>：由于当请求的Content-Type=application/x-www-form-urlencoded时，只支持GET请求方式，
     *     并且即使是GET请求方式能获取到入参了，之后的校验和处理也很麻烦，所以一般不用这种方式来接收Content-Type=application/x-www-form-urlencoded的请求</li>
     *     <li><b>优点</b>:方便简单，且这接收入参的方式，直接调用方用GET的请求方式传参</li>
     *     <li><b>缺点</b>:1）需要自己在代码中显式的从request的inputStream流【获取+转换+解码】数据，很麻烦
     *                    2）如果请求方式是POST PUT DELETE等，同时Content-Type=application/x-www-form-urlencoded，则无法将入参传到后面代码中！
     *      </li>
     * </ul>
     */
    @RequestMapping(value = "/test3_request")
    public String test3(HttpServletRequest request) throws IOException {
        // 从request中获取一些接口请求时的元数据信息，包括请求方式，Content-type等
        String requestMetaInfo = String.format("method: [%s], uri: [%s], Content-Type: [%s] ", request.getMethod(), request.getRequestURI(),  request.getHeader("Content-Type"));

        ServletInputStream inputStream = request.getInputStream();
        String inputStr = IoUtil.read(inputStream, "UTF-8");
        String decodeRes = URLDecoder.decode(inputStr, "UTF-8");

        return requestMetaInfo + " ---> SUCCESS! " + inputStr + ", decodeResult = " + decodeRes;
    }

}

package com.su.demo.controller.param_type;

import cn.hutool.core.io.IoUtil;
import com.su.demo.bean.dto.TeacherDTO;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.net.URLDecoder;
import java.util.Map;

@RestController
@RequestMapping(value = "/param_type/body_form_urlencoded")
public class TestFormUrlEncodeController {

    /**
     * <p>这是一种错误的定义方式，这种方式，无论是否在map前面添加{@link RequestParam}还是{@link RequestBody}, 代码都获取不到 Content-Type=application/x-www-form-urlencoded类型请求的入参！！！</p>
     * <ul>
     *     <li><b>入参类别</b>：表单参数方式，Content-Type=application/x-www-form-urlencoded
     *     <li><b>定义方式</b>: 在方法形参的位置，用Map来接收入参</li>
     *     <li><b>调用方式</b>: 入参放在表单中，且Content-Type=application/x-www-form-urlencoded</li>
     * </ul>
     */
    @RequestMapping(value = "/test4_map")
    public String test4(Map<String, String> paramMap, HttpServletRequest request) {
        // 从request中获取一些接口请求时的元数据信息，包括请求方式，Content-type等
        String requestMetaInfo = String.format("method: [%s], uri: [%s], Content-Type: [%s] ", request.getMethod(), request.getRequestURI(),  request.getHeader("Content-Type"));

        String name = paramMap.get("name");
        // 判断：如果paramMap.get("age")为null，则age赋默认值0；否则进行入参类型的转换
        Integer age = null == paramMap.get("age") ? 0: Integer.parseInt(paramMap.get("age"));

        return requestMetaInfo + " ---> SUCCESS! name = " + name + ", age = " + age;
    }

}

package com.su.demo.controller.param_type;

import cn.hutool.core.io.IoUtil;
import com.su.demo.bean.dto.TeacherDTO;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.net.URLDecoder;
import java.util.Map;

@RestController
@RequestMapping(value = "/param_type/body_form_urlencoded")
public class TestFormUrlEncodeController {

    /**
     * <p>
     *     虽然在方法定义这里，形参中添加了MultipartFile，但是如果调用接口的时候入参类型是Content-Type=application/x-www-form-urlencoded，
     *     那由于Content-Type=application/x-www-form-urlencoded入参类型限制了入参就无法将【文件】传过来，所以该方法的MultipartFile对象始终为空！
     * </p>
     * <ul>
     *     <li><b>入参类别</b>：表单参数方式，Content-Type=application/x-www-form-urlencoded
     *     <li><b>定义方式</b>: 在方法形参的位置,把每个参数都平铺开来</li>
     *     <li><b>调用方式</b>: 入参放在表单中，且Content-Type=application/x-www-form-urlencoded</li>
     * </ul>
     */
    @RequestMapping(value = "/test5_requestparam_file")
    public String test5(String name, Integer age, Boolean enable, MultipartFile myfile, HttpServletRequest request) throws IOException {
        // 从request中获取一些接口请求时的元数据信息，包括请求方式，Content-type等
        String requestMetaInfo = String.format("method: [%s], uri: [%s], Content-Type: [%s] ", request.getMethod(), request.getRequestURI(),  request.getHeader("Content-Type"));
        String fileName = null;
        if (null != myfile) {
            fileName = myfile.getOriginalFilename();
        }

        return requestMetaInfo + " ---> SUCCESS! name = " + name + ", age = " + age + ", enable = " + enable + ", fileName = " + fileName;
    }

}