SpringBoot接受前台参数的六种方式以及统一响应

请求

springboot接受前台参数的六种方式，首先因为从前台发送的请求没有界面的话只能是从地址栏发送并且只能是get请求，为了测试其他的请求，所以我们使用一个工具->postman,postman是一款功能强大的网页调试与发送网页http请求的chrome插件。

对于前台传过来的参数大致分为六种，下面一个一个的做演示学习：演示之前先复习一下，没用springboot获取前台参数的方式，通过request对象获取。

@restcontroller
public class requestcontroller {
    //原始方式
    @requestmapping("/simpleparam")
    public string simpleparam(httpservletrequest request){
        // http://localhost:8080/simpleparam?name=tom&age=10
        // 请求参数： name=tom&age=10   （有2个请求参数）
        // 第1个请求参数： name=tom   参数名:name，参数值:tom
        // 第2个请求参数： age=10     参数名:age , 参数值:10

        string name = request.getparameter("name");//name就是请求参数名
        string agestr = request.getparameter("age");//age就是请求参数名

        int age = integer.parseint(agestr);//需要手动进行类型转换
        system.out.println(name+"  :  "+age);
        return "ok";
    }
}

在springboot的环境中，对原始的api进行了封装，接收参数的形式更加简单。 如果是简单参数，参数名与形参变量名相同，定义同名的形参即可接收参数。

1、简单参数

@restcontroller
public class requestcontroller {
        // http://localhost:8080/simpleparam?name=tom&age=10
    // 第1个请求参数： name=tom   参数名:name，参数值:tom
    // 第2个请求参数： age=10     参数名:age , 参数值:10
    
    //springboot方式
    @requestmapping("/simpleparam")
    public string simpleparam(string name , integer age ){//形参名和请求参数名保持一致
        system.out.println(name+"  :  "+age);
        return "ok";
    }
}

如果后台需要但是前台并没传对应的参数，这个时候会返回 null

当前台传的参数名和后台接受参数的方法形参列表不一致的时候，可以通过@requestparam（“ ”）来指定

@restcontroller
public class requestcontroller {
    // http://localhost:8080/simpleparam?name=tom&age=20
    // 请求参数名：name

    //springboot方式
    @requestmapping("/simpleparam")
    public string simpleparam(@requestparam("name") string username , integer age ){
        system.out.println(username+"  :  "+age);
        return "ok";
    }
}

另外@requestparam中的required属性默认为true（默认值也是true），代表该请求参数必须传递，如果不传递将报错，如果该参数是可选的，可以将required属性设置为false

代码如下：

@requestmapping("/simpleparam")
public string simpleparam(@requestparam(name = "name", required = false) string username, integer age){
    system.out.println(username+ ":" + age);
    return "ok";
}

这个注解还有一个参数，是defaultvalue表示如果前台没有传递参数就默认为当前指定的值。

    @requestmapping("/simpleparam")
    public string simpleparam(@requestparam(name = "name", required = false,defaultvalue ="匿名用户") string username, integer age) {
        
//        打印输出
        system.out.println(username+"----"+age);
        return "ok";
    }

2、实体参数

简单实体对象:

在使用简单参数做为数据传递方式时，前端传递了多少个请求参数，后端controller方法中的形参就要书写多少个。如果请求参数比较多，通过上述的方式一个参数一个参数的接收，会比较繁琐。

此时，我们可以考虑将请求参数封装到一个实体类对象中。 要想完成数据封装，需要遵守如下规则：请求参数名与实体类的属性名相同

要求是前台传过来的参数必须和对象中的参数名称相同，顺序相同。

@restcontroller
public class requestcontroller {
    // http://localhost:8080/simpleparam?name=tom&age=20
    
    //实体参数：简单实体对象  user有两个属性,一个是name 一个是age,这样spring就会自动完成赋值
    @requestmapping("/simplepojo")
    public string simplepojo(user user){
        system.out.println(user);
        return "ok";
    }
}

复杂实体对象:对象套对象

比如说user中又多了一个字段: address 而这个类又有两个属性,这个时候前台传递参数的时候就需要发生改变,后台还是用user接受

public class user {
    private string name;
    private integer age;
    private address address; //地址对象
    .....
}


public class address {
    private string province;
    private string city;
    .....
}

方法代码

@restcontroller
public class requestcontroller {
    //实体参数：复杂实体对象
    @requestmapping("/complexpojo")
    public string complexpojo(user user){
        system.out.println(user);
        return "ok";
    }
}

3、数组集合参数

数组集合参数的使用场景：在html的表单中，有一个表单项是支持多选的(复选框)，可以提交选择的多个值。

xxxxxxxx?hobby=game&hobby=java

后端程序接收上述多个值的方式有两种：

1. 数组
2. 集合

数组参数：请求参数名与形参数组名称相同且请求参数为多个，定义数组类型形参即可接收参数

@restcontroller
public class requestcontroller {
    //数组集合参数
    @requestmapping("/arrayparam")
    public string arrayparam(string[] hobby){
        system.out.println(arrays.tostring(hobby));
        return "ok";
    }
}

集合参数：请求参数名与形参集合对象名相同且请求参数为多个，@requestparam 绑定参数关系

controller方法:

@restcontroller
public class requestcontroller {
    //数组集合参数
    @requestmapping("/listparam")
    public string listparam(@requestparam list<string> hobby){
        system.out.println(hobby);
        return "ok";
    }
}

4、日期参数

上述演示的都是一些普通的参数，在一些特殊的需求中，可能会涉及到日期类型数据的封装(其实我们一般都存字符串,不会转来转去,所以这里了解)。比如，如下需求：

因为日期的格式多种多样（如：2022-12-12 10:05:45 、2022/12/12 10:05:45），那么对于日期类型的参数在进行封装的时候，需要通过@datetimeformat注解，以及其pattern属性来设置日期的格式。

• @datetimeformat注解的pattern属性中指定了哪种日期格式，前端的日期参数就必须按照指定的格式传递。
• 后端controller方法中，需要使用date类型 localdatet或localdatetime类型，来封装传递的参数。

controller方法:

@restcontroller
public class requestcontroller {
    //日期时间参数
   @requestmapping("/dateparam")
    public string dateparam(@datetimeformat(pattern = "yyyy-mm-dd hh:mm:ss") localdatetime updatetime){
        system.out.println(updatetime);
        return "ok";
    }
}

5、json参数

在学习前端技术时，我们有讲到过json，而在前后端进行交互时，如果是比较复杂的参数，前后端通过会使用json格式的数据进行传输。 （json是开发中最常用的前后端数据交互方式） ,其实我们也会看到, 后台如果返回给前台数据的时候,有的是字符串,又的是集合,有的是json, 那么前台在解析的时候就十分的麻烦, 后来经过一个实体类用来存放所有的数据, 然后返回这个对象, 这样前台在接受的时候只要处理json就好.在笔记的最后会提到

下面介绍在postman中怎么发送json数据:

服务端controller方法接收json格式数据：

• 传递json格式的参数，在controller中会使用实体类进行封装。
• 封装规则：json数据键名与形参对象属性名相同，定义pojo类型形参即可接收参数。需要使用 @requestbody标识。

• @requestbody注解：将json数据映射到形参的实体类对象中（json中的key和实体类中的属性名保持一致）

通过添加@requestbody注解spring可以自动的将json转换为对象.

实体类:

public class user {
    private string name;
    private integer age;
    private address address;
    
    //省略get , set 方法
}  

@restcontroller
public class requestcontroller {
    //json参数
    @requestmapping("/jsonparam")
    public string jsonparam(@requestbody user user){
        system.out.println(user);
        return "ok";
    }
}

6、路径参数(开发中使用的模式)

传统的开发中请求参数是放在请求体(post请求)传递或跟在url后面通过?key=value的形式传递(get请求)。

在现在的开发中，经常还会直接在请求的url中传递参数。例如：

http://localhost:8080/user/1		
http://localhost:880/user/1/0

上述的这种传递请求参数的形式呢，我们称之为：路径参数。

学习路径参数呢，主要掌握在后端的controller方法中，如何接收路径参数。

路径参数：

• 前端：通过请求url直接传递参数
• 后端：使用{…}来标识该路径参数，需要使用@pathvariable获取路径参数

controller方法:

@restcontroller
public class requestcontroller {
    //路径参数
    @requestmapping("/path/{id}")
    public string pathparam(@pathvariable integer id){
        system.out.println(id);
        return "ok";
    }
}

传递多个路径参数：

@restcontroller
public class requestcontroller {
    //路径参数  前台路径  xxxx/path/12/jack
    @requestmapping("/path/{id}/{name}")
    public string pathparam2(@pathvariable integer id, @pathvariable string name){
        system.out.println(id+ " : " +name);
        return "ok";
    }
}

响应:

前面我们学习过httl协议的交互方式：请求响应模式（有请求就有响应）

那么controller程序呢，除了接收请求外，还可以进行响应。先说一下使用到的注解:

@responsebody

• 类型：方法注解、类注解

• 位置：书写在controller方法上或类上

• 作用：将方法返回值直接响应给浏览器

在我们前面所编写的controller方法中，都已经设置了响应数据。看一下类的注解@restcontroller, 这个注解是一个复合注解,里面包括了 @responsebody

结论：在类上添加@restcontroller就相当于添加了@responsebody注解。

• 类上有@restcontroller注解或@responsebody注解时：表示当前类下所有的方法返回值做为响应数据
• 方法的返回值，如果是一个pojo对象或集合时，会先转换为json格式，在响应给浏览器

下面我们来测试下响应数据：

@restcontroller
public class responsecontroller {
    //响应字符串
    @requestmapping("/hello")
    public string hello(){
        system.out.println("hello world ~");
        return "hello world ~";
    }
    //响应实体对象
    @requestmapping("/getaddr")
    public address getaddr(){
        address addr = new address();//创建实体类对象
        addr.setprovince("广东");
        addr.setcity("深圳");
        return addr;
    }
    //响应集合数据
    @requestmapping("/listaddr")
    public list<address> listaddr(){
        list<address> list = new arraylist<>();//集合对象
        
        address addr = new address();
        addr.setprovince("广东");
        addr.setcity("深圳");

        address addr2 = new address();
        addr2.setprovince("陕西");
        addr2.setcity("西安");

        list.add(addr);
        list.add(addr2);
        return list;
    }
}

在服务响应了一个对象或者集合，那私前端获取到的数据是什么样子的呢？我们使用postman发送请求来测试下。测试效果如下：

统一响应结果

可能大家会发现,我们在前面所编写的这些controller方法中，返回值各种各样，没有任何的规范。

如果我们开发一个大型项目，项目中controller方法将成千上万，使用上述方式将造成整个项目难以维护。那在真实的项目开发中是什么样子的呢？

在真实的项目开发中，无论是哪种方法，我们都会定义一个统一的返回结果。方案如下：

这样前端只需要按照统一格式的返回结果进行解析(仅一种解析方案)，就可以拿到数据。

统一的返回结果使用类来描述，在这个结果中包含：

• 响应状态码：当前请求是成功，还是失败

• 状态码信息：给页面的提示信息

• 返回的数据：给前端响应的数据（字符串、对象、集合）

定义在一个实体类result来包含以上信息。代码如下：

public class result {
    private integer code;//响应码，1 代表成功; 0 代表失败
    private string msg;  //响应码 描述字符串
    private object data; //返回的数据

    public result() { }
    public result(integer code, string msg, object data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }

    public integer getcode() {
        return code;
    }

    public void setcode(integer code) {
        this.code = code;
    }

    public string getmsg() {
        return msg;
    }

    public void setmsg(string msg) {
        this.msg = msg;
    }

    public object getdata() {
        return data;
    }

    public void setdata(object data) {
        this.data = data;
    }

    //增删改 成功响应(不需要给前端返回数据)
    public static result success(){
        return new result(1,"success",null);
    }
    //查询 成功响应(把查询结果做为返回数据响应给前端)
    public static result success(object data){
        return new result(1,"success",data);
    }
    //失败响应
    public static result error(string msg){
        return new result(0,msg,null);
    }
}

改造后的controller：统一返回result

@restcontroller
public class responsecontroller { 
    //响应统一格式的结果
    @requestmapping("/hello")
    public result hello(){
        system.out.println("hello world ~");
        //return new result(1,"success","hello world ~");
        return result.success("hello world ~");
    }

    //响应统一格式的结果
    @requestmapping("/getaddr")
    public result getaddr(){
        address addr = new address();
        addr.setprovince("广东");
        addr.setcity("深圳");
        return result.success(addr);
    }

    //响应统一格式的结果
    @requestmapping("/listaddr")
    public result listaddr(){
        list<address> list = new arraylist<>();

        address addr = new address();
        addr.setprovince("广东");
        addr.setcity("深圳");

        address addr2 = new address();
        addr2.setprovince("陕西");
        addr2.setcity("西安");

        list.add(addr);
        list.add(addr2);
        return result.success(list);
    }
}