Spring Boot接收从前端传过来的数据常用方式以及处理的技巧

一 角度1：是否是json格式的数据

1. 前端传递过来的数据类型，老师这里会把它分为两个主要的方向：
   1. 第1个方向：非json格式的数据
   2. 第2个方向：json格式的数据
2. 非json格式的数据
   1. 方式1：直接可以将控制层方法的参数名称和请求的参数名称保持一致来进行接收。
      1. 场景：数据量（参数个数）比较小，<=3个参数
      2. 优点：简单
      3. 缺点：如果参数比较多，如果我们还是把每个前端传输过来参数，在后端用单独的一个参数去接收会比较麻烦。
      4. 注意：
         1. 因为我们这里涉及到与前端进行通信，所以项目必须要添加spring-web依赖。
         2. 为了构建业务的场景，我们得有一个数据的载体，即实体类User.java。
      5. 案例：
         1. 代码

                /*
                * 非json格式
                *   第1种方式：如果有数据从前端过来，后端直接把这些数据都当成（看作是）字符串。
                *   如：
                *       String username：如果你前端传输过来的用户名，后端直接看成字符串来接收。
                *       String password：如果你前端传输过来的密码，后端直接看成字符串来接收。
                */
                @RequestMapping("add1")
                public String add1(String username,String password){
                    System.out.println("username = "+username);
                    System.out.println("password = "+ password);
                    return "success";
                }

         2. 支持get请求，如下图所示：
         3. 支持post请求，如下图所示：
   2. 方式2：把前端传输过来的参数，后端封装成一个实体类。
      1. 注意：
         1. 前端提交的参数名称，需要和后端实体类的属性名称保持一致。
      2. 代码：

         ​
             /*
              * 非json格式
              *   第2种方式：把前端传输过来的参数，后端封装成一个实体类。
              *   如：
              *      把前端传输过来的参数，（后端）封装到User user实体类中。
              */
             @RequestMapping("add2")
             public String add2(User user){
                 System.out.println(user);
                 return "success";
             }
         
         ​

      3. 支持get请求，同上

      4. 支持post请求，同上

   3. 方式3：restful风格的请求与数据提交 —— 需要使用{变量名称}语法来声明RestFul的参数列表，通过一个注解@PathVariable指定参数的映射规则。

      1. 概述
         1. 思想路
            1. RestFul风格：只关注数据的的内容。
      2. 应用场景
         1. 数据量不大
         2. 数据的安全性没有严格要求
      3. get请求

         1. 以前：localhost:8080/users/add1?username=tom&password=123&&&

            1. 缺点：因为get请求所提交的数据是有限制的，所以这里key=value的数据提交方式中"key="占用了很多空间，导致了可以传输的数据量的减少。如果可以把"key="给删除掉，那么前端就可以多提交几个参数给后端了。

         2. restful风格：localhost:8080/users/add1?tom/123//

         3. 案例：后端接收方式

            ​
                /*
                 * 非json格式
                 *   第3种方式：restful风格：get请求：localhost:8080/users/add3?tom/123456
                 *   注意：
                 *   （1）@RequestMapping支持变量占位符的写法。如：@RequestMapping("add3/{username}/{password}")，其中的{username}和{password}是变量占位符，而其中的username和password是变量名称。
                 *   （2）@RequestMapping只是成功接收到前端传输的数据，我们是还是把数据放到方法的参数列表中。
                 *   （3）使用@PathVariable注解，可以指定请求路径中的哪个变量（@RequestMapping接收的参数）与add3参数列表中的哪个参数对应起来。
                 *         1）如果@RequestMapping的变量名称和add3参数列表中的参数名称一致，只需要加@PathVariable即可，它会自动注入。
                 *         2）如果名称不一致，@RequestMapping("add3/{name}/{password}") 》 add3(@PathVariable("name") String username, @PathVariable String password)
                 */
                @RequestMapping("add3/{name}/{password}")
                public String add3(@PathVariable("name") String username, @PathVariable String password){
                    System.out.println(username+" / "+password);
                    return "success";
                }
            
            ​

   4. 方式4：借助HttpServletRequest对象来接收

          /*
           * 非json格式
           *   第4种方式：借助HttpServletRequest对象来接收
           *            无论前端提交的数据是简单类型的还是复杂类型的，都会整体被打包放在HttpServletRequest对象中传输到后端了。
           *   注：
           *      （1）通过HttpServletRequest对象中的数据是以key- value的键值对的形式存储的。比如，key就是前端的参数名称username=tom - (key就是username)
           *      （2）通过HttpServletRequest，不光可以获取到前端提交的数据，还可以获取到关于前端的其它信息，如http协议版本、请求url、提交的数据的类型等
           */
          @RequestMapping("add4")
          public String add4(HttpServletRequest request){
              String username = request.getParameter("username");
              String password = request.getParameter("password");
              System.out.println(username+"//"+password);
              return "success";
          }

3. json格式的数据

   1. 概述

      1. 注意1：凡是前端提交的数据是json数据，那么前端都会将数据存储在请求的实体中，后端在获取前端数据的时需要到请求的实体中获取，因此后端会使用一个注解@RequestBody注解来进行标记。@RequestBody注解表明（指明），后端会从请求实体类拿数据，也只有人请求实体中获取才能拿到：

   2. 方式5：后端会将前端传递过来的json数据直接封装到pojo对象中：

          /*
           *  json格式
           *   第1种：后端会将前端传递过来的json数据直接封装到pojo对象中。
           *   注意：
           *      （1）这种方式在前端提交数据的时候，不能够在postman Body和postman Query中使用key=value的方式进行提交，而是通过json来提交
           */
          @RequestMapping("add5")
          public User add5(@RequestBody User user){
              System.out.println(user.toString());
              return user;
          }

   3. 方式6：引用类型。实体类对象中有除了有基本数据类型外，还有复杂数据类型的出现，如引用类型。如果一个实体类中定义有引用数据类型，在传递数据的时候，使用{}的形式来进行提交。后端会使用一个注解@RequestBody注解来进行标记。

      1. 案例

         1. 实体类：

         2. 方法：

                /*
                 *  json格式
                 *   第2种：实体类对象中有除了有基本数据类型外，还有复杂数据类型的出现
                 */
                @RequestMapping("add6")
                public User add6(@RequestBody User user){
                    System.out.println(user.toString());
                    return user;
                }

         3. postman：

   4. 方式7：List集合，在实体类中出现

      1. 实体类：
      2. 代码：

             /*
              *  json格式
              *   第3种：实体类对象中有List集合
              */
             @RequestMapping("add7")
             public User add7(@RequestBody User user){
                 System.out.println(user.toString());
                 return user;
             }

      3. postman：

   5. 方式8：Map

      1. 方法：

             /*
              *  json格式
              *   第4种：Map
              *         因为在java看来json本质意义上就是一种map结构的内容。
              *   如：key分别会是"username"和"password"
              *      {
              *          "username":"tom",
              *          "password":"123456"
              *      }
              */
             @RequestMapping("add8")
             public String add8(@RequestBody Map map){
                 System.out.println(map.get("username"));
                 System.out.println(map.get("password"));
                 return "success";
             }

      2. postman：
4. 附1：完整的代码
   1. User.java

      package com.pojo;
      
      import java.util.List;
      
      public class User {
          private String username;
          private String password;
          private Cat cat;
          private List courseList;
      
          @Override
          public String toString() {
              return "User{" +
                      "username='" + username + '\'' +
                      ", password='" + password + '\'' +
                      ", cat=" + cat +
                      ", courseList=" + courseList +
                      '}';
          }
      }
      

   2. UserController.java

      package com.controller;
      
      import com.pojo.User;
      import org.springframework.web.bind.annotation.PathVariable;
      import org.springframework.web.bind.annotation.RequestBody;
      import org.springframework.web.bind.annotation.RequestMapping;
      import org.springframework.web.bind.annotation.RestController;
      
      import javax.servlet.http.HttpServletRequest;
      import java.util.Map;
      
      @RequestMapping("users")
      @RestController
      public class UserController {
          /*
          * 非json格式
          *   第1种方式：如果有数据从前端过来，后端直接把这些数据都当成（看作是）字符串。
          *   如：
          *       String username：如果你前端传输过来的用户名，后端直接看成字符串来接收。
          *       String password：如果你前端传输过来的密码，后端直接看成字符串来接收。
          */
          @RequestMapping("add1")
          public String add1(String username,String password){
              System.out.println("username = "+username);
              System.out.println("password = "+ password);
              return "success";
          }
      
          /*
           * 非json格式
           *   第2种方式：把前端传输过来的参数，后端封装成一个实体类。
           *   如：
           *      把前端传输过来的参数，（后端）封装到User user实体类中。
           */
          @RequestMapping("add2")
          public String add2(User user){
              System.out.println(user);
              return "success";
          }
      
          /*
           * 非json格式
           *   第3种方式：restful风格：get请求：localhost:8080/users/add3?tom/123456
           *   注意：
           *   （1）@RequestMapping支持变量占位符的写法。如：@RequestMapping("add3/{username}/{password}")，其中的{username}和{password}是变量占位符，而其中的username和password是变量名称。
           *   （2）@RequestMapping只是成功接收到前端传输的数据，我们是还是把数据放到方法的参数列表中。
           *   （3）使用@PathVariable注解，可以指定请求路径中的哪个变量（@RequestMapping接收的参数）与add3参数列表中的哪个参数对应起来。
           *         1）如果@RequestMapping的变量名称和add3参数列表中的参数名称一致，只需要加@PathVariable即可，它会自动注入。
           *         2）如果名称不一致，@RequestMapping("add3/{name}/{password}") 》 add3(@PathVariable("name") String username, @PathVariable String password)
           */
          @RequestMapping("add3/{name}/{password}")
          public String add3(@PathVariable("name") String username, @PathVariable String password){
              System.out.println(username+" / "+password);
              return "success";
          }
      
          /*
           * 非json格式
           *   第4种方式：借助HttpServletRequest对象来接收
           *            无论前端提交的数据是简单类型的还是复杂类型的，都会整体被打包放在HttpServletRequest对象中传输到后端了。
           *   注：
           *      （1）通过HttpServletRequest对象中的数据是以key- value的键值对的形式存储的。比如，key就是前端的参数名称username=tom - (key就是username)
           *      （2）通过HttpServletRequest，不光可以获取到前端提交的数据，还可以获取到关于前端的其它信息，如http协议版本、请求url、提交的数据的类型等
           */
          @RequestMapping("add4")
          public String add4(HttpServletRequest request){
              String username = request.getParameter("username");
              String password = request.getParameter("password");
              System.out.println(username+"//"+password);
              return "success";
          }
      
          /*
           *  json格式
           *   第1种：后端会将前端传递过来的json数据直接封装到pojo对象中。
           *   注意：
           *      （1）这种方式在前端提交数据的时候，不能够在postman Body和postman Query中使用key=value的方式进行提交，而是通过json来提交
           */
          @RequestMapping("add5")
          public User add5(@RequestBody User user){
              System.out.println(user.toString());
              return user;
          }
      
          /*
           *  json格式
           *   第2种：实体类对象中有除了有基本数据类型外，还有复杂数据类型的出现
           */
          @RequestMapping("add6")
          public User add6(@RequestBody User user){
              System.out.println(user.toString());
              return user;
          }
      
          /*
           *  json格式
           *   第3种：实体类对象中有List集合
           */
          @RequestMapping("add7")
          public User add7(@RequestBody User user){
              System.out.println(user.toString());
              return user;
          }
      
      
          /*
           *  json格式
           *   第4种：Map
           *         因为在java看来json本质意义上就是一种map结构的内容。
           *   如：key分别会是"username"和"password"
           *      {
           *          "username":"tom",
           *          "password":"123456"
           *      }
           */
          @RequestMapping("add8")
          public String add8(@RequestBody Map map){
              System.out.println(map.get("username"));
              System.out.println(map.get("password"));
              return "success";
          }
      }

5. 参考

   1. ​​​​​​​【Spring Boot接收前端数据】Spring Boot接收从前端传过来的数据常用8种方式，带你轻松搞定前后端数据联调、

二 角度2：基于何种注解或无注解

1. 一、基于@PathVariable注解

   二、基于@RequestParam注解

   三、基于@PathVariable+@RequestParam混合

   四、基于@RequestBody注解

   五、基于HttpServletRequest请求

   六、不基于任何注解进行表单传参 

2. 参考：
   1. ​​​​​​​​​​​​​​(415条消息) SpringBoot接收参数的六种常用方式（全面详细）_黄团团的博客-CSDN博客_springboot接收参数