1.1. 请求

1.1 Query

  • Query类型参数指 k=v形式在地址栏的参数

简单参数:在向服务器发起请求时,向服务器传递的是一些普通的请求数据。

image-20220826180550583

那么在后端程序中,如何接收传递过来的普通参数数据呢?

我们在这里讲解两种方式:

  1. 原始方式
  2. SpringBoot方式

2.1.1 原始方式

在原始的Web程序当中,需要通过Servlet中提供的API:HttpServletRequest(请求对象),获取请求的相关信息。比如获取请求参数:

Tomcat接收到http请求时:把请求的相关信息封装到HttpServletRequest对象中

在Controller中,我们要想获取Request对象,可以直接在方法的形参中声明 HttpServletRequest 对象。然后就可以通过该对象来获取请求信息:

//根据指定的参数名获取请求参数的数据值
String  request.getParameter("参数名")
@RequestMapping("/login")
public String login(HttpServletRequest request){
    //最原始的方式 Servlet提供的api来获取
    //request.getParameter("名字")
    //获取用户名和密码
    String username = request.getParameter("username");
    return "login : "+username;
}

以上这种方式,我们仅做了解。(在以后的开发中不会使用到)

2.2.2 SpringBoot方式

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

@RequestMapping("/login")
public String login(String username,String password){
    //boot帮助咱们简化的版本
    //获取用户名和密码
    System.out.println(username + "=======================" +password);
    return "login : "+username;
}

postman测试( GET 请求):

image-20221203122405075

postman测试( POST请求 ):

image-20220826181117898

结论:不论是GET请求还是POST请求,对于简单参数来讲,只要保证==请求参数名和Controller方法中的形参名保持一致==,就可以获取到请求参数中的数据值。

2.2.3 参数名不一致

运行没有报错。 controller方法中的username值为:null,age值为20

  • 结论:对于简单参数来讲,请求参数名和controller方法中的形参名不一致时,无法接收到请求数据

那么如果我们开发中,遇到了这种请求参数名和controller方法中的形参名不相同,怎么办?

解决方案:可以使用Spring提供的@RequestParam注解完成映射

在方法形参前面加上 @RequestParam 然后通过value属性执行请求参数名,从而完成映射。代码如下:

    @RequestMapping("/login")
    public String login(@RequestParam("name") String username,@RequestParam("pass") String password){
        //boot帮助咱们简化的版本
        //获取用户名和密码
        System.out.println(username + "=======================" +password);
        return "login : "+username;
    }

1.2 实体参数

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

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

image-20221203131954932

2.2.1 简单实体对象

定义POJO实体类:

public class User {
    private String name;
    private Integer age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Controller方法:

@RestController
public class UserInfoController {

    @RequestMapping("/simplePojo")
    public String simplePojo(User user){
        System.out.println(user);
        return "OK";
    }
}

Postman测试:

  • 参数名和实体类属性名一致时

image-20221203161246168

  • 参数名和实体类属性名不一致时

image-20221203161004349

2.2.2 复杂实体对象

上面我们讲的呢是简单的实体对象,下面我们在来学习下复杂的实体对象。

复杂实体对象指的是,在实体类中有一个或多个属性,也是实体对象类型的。如下:

  • User类中有一个Address类型的属性(Address是一个实体类)

image-20221203160447953

复杂实体对象的封装,需要遵守如下规则:

  • 请求参数名与形参对象属性名相同,按照对象层次结构关系即可接收嵌套实体类属性参数。

定义POJO实体类:

  • Address实体类
public class Address {
    private String province;
    private String city;

    public String getProvince() {
        return province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    @Override
    public String toString() {
        return "Address{" +
                "province='" + province + '\'' +
                ", city='" + city + '\'' +
                '}';
    }
}
  • User实体类
public class User {
    private String name;
    private Integer age;
    private Address address; //地址对象

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address=" + address +
                '}';
    }
}

Controller方法:

@RequestMapping("/complexPojo")
public String complexPojo(User user){
    System.out.println(user);
    return "OK";
}

Postman测试:

image-20221203162706175

2. 响应

前面我们学习过HTTL协议的交互方式:请求响应模式(有请求就有响应)

那么Controller程序呢,除了接收请求外,还可以进行响应。

2.1 @ResponseBody

在我们前面所编写的controller方法中,都已经设置了响应数据。

image-20221204100656376

controller方法中的return的结果,怎么就可以响应给浏览器呢?

答案:使用@ResponseBody注解

@ResponseBody注解:

  • 类型:方法注解、类注解
  • 位置:书写在Controller方法上或类上
  • 作用:将方法返回值直接响应给浏览器
    • 如果返回值类型是实体对象/集合,将会转换为JSON格式后在响应给浏览器

但是在我们所书写的Controller中,只在类上添加了@RestController注解、方法添加了@RequestMapping注解,并没有使用@ResponseBody注解,怎么给浏览器响应呢?

@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String hello(){
        System.out.println("Hello World ~");
        return "Hello World ~";
    }
}

原因:在类上添加的@RestController注解,是一个组合注解。

  • @RestController = @Controller + @ResponseBody

@RestController源码:

@Target({ElementType.TYPE})   //元注解(修饰注解的注解)
@Retention(RetentionPolicy.RUNTIME)  //元注解
@Documented    //元注解
@Controller   
@ResponseBody 
public @interface RestController {
    @AliasFor(
        annotation = Controller.class
    )
    String value() default "";
}

结论:在类上添加@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发送请求来测试下。测试效果如下:

image-20221204172339375

image-20221204172705426

2.2 统一响应结果

大家有没有发现一个问题,我们在前面所编写的这些Controller方法中,返回值各种各样,没有任何的规范。

image-20221204174052622

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

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

image-20221204174537686

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

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

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

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

  • 返回的数据:给前端响应的数据(字符串、对象、集合)

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

public class Result {
    /** 响应码,1 代表成功; 0 代表失败 */
    private Integer code;
     /** 响应码 描述字符串 */
    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:

@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);
    }
}

使用Postman测试:

image-20221204180946963

image-20221204180744084

其他

3.1. Restful风格

在如下的代码中

@GetMapping("/user/{id}")
public Result findById(@PathVariable("id") Integer id){
    // 具体业务逻辑
 XXX...
}

/users/{id}中的{id}表示路径参数,可以有一个或多个

  • 多个的时候 /users/{参数1}/{参数2}/{参数3}/......

在方法的参数上,需要使用@PathVariable("XXX")注解解析路径参数

3.2. 请求方法和参数注意事项

3.2.1.不同请求类型对应不同方法

在controller中,我们通过同一个请求的不同请求方式,来指向不同功能的代码

一般情况下,我们习惯于使用以下规则

  • get => 查询
  • post => 添加
  • put => 修改
  • delete => 删除

3.2.2. 避免使用基本数据类型接收

我们在接收前台的参数的时候,如果需要接收基本数据类型,尽量使用其包装类。因为基本数据类型有默认值,而默认值经常是有其他含义的。而包装类是引用类型,可以为NULL

3.2.3. 接收时间类型

日期参数,我们需要让他将字符串转换成日期,使用注解@DateTimeFormat

如:

@GetMapping("/emps")
public Result findByPage(@RequestParam(name = "page", defaultValue = "1") Integer page,
       @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
       @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate begin,
       @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate end,
       String name, Integer gender) {

 //具体业务逻辑
    XXXXXXXXX
}
如人饮水,冷暖自知。
最后更新于 2023-08-05