Bagaimanakah SpringBoot memperoleh parameter bahagian hadapan dan cara bertindak balas secara seragam?

Permintaan

Enam cara untuk SpringBoot menerima parameter bahagian hadapan Pertama, kerana permintaan yang dihantar dari bahagian hadapan tanpa antara muka hanya boleh dihantar dari bar alamat dan hanya boleh menjadi permintaan Dapatkan. . Untuk menguji permintaan lain, jadi Kami menggunakan alat ->Postman ialah pemalam Chrome yang berkuasa untuk menyahpepijat halaman web dan menghantar permintaan HTTP ke halaman web.

Parameter yang diluluskan dari meja depan dibahagikan secara kasar kepada enam jenis Mari kita lakukan demonstrasi dan kaji satu persatu: semaknya sebelum demonstrasi tidak ada cara untuk mendapatkan parameter meja depan melalui SpringBoot ia diperoleh melalui objek permintaan.

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

Dalam persekitaran Springboot, API asal dikapsulkan, dan bentuk parameter penerimaan lebih mudah. Jika ia adalah parameter mudah, nama parameter adalah sama dengan nama pembolehubah parameter formal, dan parameter boleh diterima dengan mentakrifkan parameter formal dengan nama yang sama.

1. Parameter mudah

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

Jika bahagian belakang memerlukannya tetapi bahagian hadapan tidak melepasi parameter yang sepadan, null akan dikembalikan pada masa ini

Nama parameter yang diluluskan oleh bahagian belakang semasa dan parameter yang diterima oleh bahagian belakang Apabila senarai parameter kaedah tidak konsisten, anda boleh menentukan

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

melalui @RequestParam (" " Selain itu, atribut yang diperlukan dalam @RequestParam menjadi lalai (the nilai lalai juga benar), yang bermaksud bahawa parameter permintaan mesti diluluskan Jika tidak lulus, ralat akan dilaporkan Jika parameter adalah pilihan, atribut yang diperlukan boleh ditetapkan kepada palsu

Kod adalah seperti berikut:

@RequestMapping("/simpleParam")
public String simpleParam(@RequestParam(name = "name", required = false) String username, Integer age){
    System.out.println(username+ ":" + age);
    return "OK";
}

Anotasi ini juga mempunyai parameter lain, iaitu defaultValue, yang bermaksud jika meja depan tidak melepasinya Parameter lalai kepada nilai yang ditentukan pada masa ini.

    @RequestMapping("/simpleParam")
    public String simpleParam(@RequestParam(name = "name", required = false,defaultValue ="匿名用户") String userName, Integer age) {
        
//        打印输出
        System.out.println(userName+"----"+age);
        return "ok";
    }

2. Parameter entiti

Objek entiti ringkas:

Apabila menggunakan parameter ringkas sebagai kaedah penghantaran data, berapa banyak parameter permintaan yang diluluskan oleh bahagian hadapan dan kaedah pengawal bahagian belakang Berapa banyak parameter formal yang perlu ditulis. Jika terdapat banyak parameter permintaan, menerima setiap parameter satu persatu melalui kaedah di atas akan menjadi lebih menyusahkan.

Pada ketika ini, kami boleh mempertimbangkan untuk merangkum parameter permintaan ke dalam objek kelas entiti. Untuk melengkapkan enkapsulasi data, anda perlu mematuhi peraturan berikut: Nama parameter permintaan adalah sama dengan nama atribut kelas entiti

Keperluan ialah parameter yang diluluskan daripada hujung hadapan mesti mempunyai nama yang sama dengan parameter dalam objek, mengikut susunan yang sama.

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

Objek entiti kompleks: objek dalam objek

Sebagai contoh, terdapat medan lain dalam Pengguna: Alamat dan kelas ini mempunyai dua atribut Pada masa ini, parameter perlu dihantar ke Meja hadapan. Tukar, latar belakang masih menggunakan Pengguna untuk menerima

public class User {
    private String name;
    private Integer age;
    private Address address; //地址对象
    .....
}


public class Address {
    private String province;
    private String city;
    .....
}

kod kaedah

@RestController
public class RequestController {
    //实体参数：复杂实体对象
    @RequestMapping("/complexPojo")
    public String complexPojo(User user){
        System.out.println(user);
        return "OK";
    }
}

3 parameter pengumpulan tatasusunan parameter koleksi tatasusunan: Dalam borang HTML, terdapat item borang yang menyokong berbilang pilihan (kotak pilihan) dan boleh menyerahkan berbilang nilai yang dipilih.

xxxxxxxx?hobby=game&hobby=java

Terdapat dua cara untuk program hujung belakang menerima berbilang nilai di atas:

Array
Koleksi
Parameter tatasusunan:

Nama parameter permintaan adalah sama dengan nama kumpulan parameter formal dan terdapat berbilang parameter permintaan, hanya tentukan parameter formal jenis tatasusunan Menerima parameter

@RestController
public class RequestController {
    //数组集合参数
    @RequestMapping("/arrayParam")
    public String arrayParam(String[] hobby){
        System.out.println(Arrays.toString(hobby));
        return "OK";
    }
}

Parameter koleksi:

Nama parameter permintaan adalah sama dengan nama objek koleksi parameter formal dan terdapat berbilang parameter permintaan @RequestParam mengikat hubungan parameter

Secara lalai, berbilang nilai dengan nama parameter yang sama dalam permintaan dirangkumkan ke dalam tatasusunan. Jika anda ingin merangkumnya ke dalam koleksi, gunakan @RequestParam untuk mengikat hubungan parameter

Kaedah Pengawal:

@RestController
public class RequestController {
    //数组集合参数
    @RequestMapping("/listParam")
    public String listParam(@RequestParam List<String> hobby){
        System.out.println(hobby);
        return "OK";
    }
}

4 Parameter tarikh

Demonstrasi di atas adalah semua Parameter biasa, dalam beberapa keperluan khas, mungkin melibatkan enkapsulasi data jenis tarikh (sebenarnya, kami biasanya menyimpan rentetan dan tidak memindahkannya ke sekeliling, jadi kami faham di sini). Contohnya, keperluan berikut:

Kerana format tarikh adalah pelbagai (seperti: 2022-12-12 10:05:45, 2022/12/12 10: 05: 45), kemudian apabila merangkum parameter jenis tarikh, format tarikh perlu ditetapkan melalui anotasi @DateTimeFormat dan atribut coraknya.

Format tarikh mana yang dinyatakan dalam atribut corak anotasi @DateTimeFormat, parameter tarikh hujung hadapan mesti dihantar dalam format yang ditentukan.
Dalam kaedah pengawal bahagian belakang, anda perlu menggunakan jenis Tarikh LocalDateT atau jenis LocalDateTime untuk merangkum parameter yang diluluskan.
Kaedah pengawal:

@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 parameter JSON

Apabila mempelajari teknologi hadapan, kami telah bercakap tentang JSON, dan di hadapan-. hujung dan hujung belakang Semasa interaksi, jika parameter lebih kompleks, hujung hadapan dan hujung belakang akan menggunakan data format JSON untuk penghantaran. (JSON ialah kaedah interaksi data bahagian hadapan dan bahagian belakang yang paling biasa digunakan dalam pembangunan, sebenarnya, kita juga akan melihat bahawa jika bahagian belakang mengembalikan data ke bahagian hadapan, ada yang rentetan, ada yang koleksi, dan ada yang JSON. , maka bahagian hadapan akan Ia sangat menyusahkan Kemudian, kelas entiti telah digunakan untuk menyimpan semua data, dan kemudian objek itu dikembalikan Dengan cara ini, meja depan hanya perlu memproses JSON apabila menerimanya nota itu, saya akan menyebut

, yang diperkenalkan di bawah dalam Posmen Cara menghantar data 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方法上或类上

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

如果返回值类型是实体对象/集合，将会转换为JSON格式后在响应给浏览器

在我们前面所编写的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);
    }
}

Atas ialah kandungan terperinci Bagaimanakah SpringBoot memperoleh parameter bahagian hadapan dan cara bertindak balas secara seragam?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!