Wie erhält SpringBoot Front-End-Parameter und wie reagiert es einheitlich?

Request

Sechs Möglichkeiten, wie SpringBoot Front-End-Parameter akzeptiert. Erstens, weil die vom Front-End ohne Schnittstelle gesendete Anfrage nur über die Adressleiste gesendet werden kann und nur ein Get sein kann Um andere Anfragen zu testen, verwenden wir ein Tool: Postman ist ein leistungsstarkes Chrome-Plugin zum Debuggen von Webseiten und zum Senden von HTTP-Anfragen.

Die von der Rezeption übergebenen Parameter sind grob in sechs Typen unterteilt. Führen Sie eine Demonstration durch und studieren Sie sie einzeln: Überprüfen Sie sie vor der Demonstration. Es gibt keine Möglichkeit, die Parameter der Rezeption über SpringBoot zu erhalten , und sie werden über das Anforderungsobjekt abgerufen.

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

In der Springboot-Umgebung ist die ursprüngliche API gekapselt und die Form des Empfangens von Parametern ist einfacher. Wenn es sich um einen einfachen Parameter handelt, ist der Parametername mit dem Variablennamen des formalen Parameters identisch, und der Parameter kann durch Definieren eines formalen Parameters mit demselben Namen empfangen werden.

1. Einfache Parameter

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

Wenn das Backend es benötigt, aber das Frontend die entsprechenden Parameter nicht übergibt, wird zu diesem Zeitpunkt null zurückgegeben

#🎜🎜 #Der aktuelle hat es übergeben. Wenn der Parametername nicht mit der formalen Parameterliste der Methode übereinstimmt, die Parameter im Hintergrund akzeptiert, können Sie ihn über @RequestParam (" ") angeben

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

Außerdem Das erforderliche Attribut in @RequestParam ist standardmäßig true (der Standardwert ist auch true). Wenn der Anforderungsparameter nicht übergeben wird, wird ein Fehler gemeldet. Wenn der Parameter optional ist, kann das erforderliche Attribut festgelegt werden zu false

Der Code lautet wie folgt:

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

Diese Anmerkung Es gibt einen weiteren Parameter, defaultValue, was bedeutet, dass, wenn keine Parameter an die Rezeption übergeben werden, der Standardwert verwendet wird auf den aktuell angegebenen Wert.

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

2. Entitätsparameter

Einfaches Entitätsobjekt:

Wie viele Anfragen werden vom Frontend übergeben, wenn einfache Parameter als Datenübertragung verwendet werden Methodenparameter: Wie viele formale Parameter sollen in die Backend-Controller-Methode geschrieben werden? Wenn viele Anforderungsparameter vorhanden sind, ist es umständlicher, jeden Parameter einzeln über die obige Methode zu empfangen.

An diesem Punkt können wir erwägen, die Anforderungsparameter in ein Entitätsklassenobjekt zu kapseln. Um die Datenkapselung abzuschließen, müssen Sie die folgenden Regeln einhalten:

Der Anforderungsparametername ist derselbe wie der Attributname der Entitätsklasse

Die Voraussetzung ist, dass die Von der Rezeption übergebene Parameter müssen mit den Parametern im Objekt übereinstimmen. Gleicher Name, gleiche Reihenfolge.

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

Komplexes Entitätsobjekt: Objekt innerhalb des Objekts

Zum Beispiel gibt es ein weiteres Feld in Benutzer: Adresse und diese Klasse hat zwei Attribute. Zu diesem Zeitpunkt übergibt das Frontend Parameter Wenn es geändert werden muss, verwendet der Hintergrund weiterhin den Benutzer, um

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


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

Methodencode

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

3 zu akzeptieren #🎜 🎜#

Verwendungsszenarien für Array-Sammlungsparameter: Im HTML-Formular gibt es ein Formularelement, das Mehrfachauswahlen (Kontrollkästchen) unterstützt, und mehrere ausgewählte Werte können übermittelt werden.

xxxxxxxx?hobby=game&hobby=java

Es gibt zwei Möglichkeiten für das Back-End-Programm, die oben genannten Mehrfachwerte zu empfangen:

#🎜 🎜## 🎜🎜#array

• Collection

• Array-Parameter:

  Parameternamen anfordern und formaler Parameter Wenn die Gruppennamen identisch sind und mehrere Anforderungsparameter vorhanden sind, definieren Sie den Array-Typparameter zum Empfangen der Parameter

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

Sammlungsparameter: Der Name des Anforderungsparameters ist derselbe wie der Name des formalen Parametersammlungsobjekts und Es gibt mehrere Anforderungsparameter, @RequestParam-Bindungsparameterbeziehung

Standardmäßig mehrere Werte mit demselben Parameternamen in der Anfrage werden in einem Array gekapselt. Wenn Sie es in eine Sammlung einkapseln möchten, verwenden Sie @RequestParam, um die Parameterbeziehung zu binden. Bei den obigen Demonstrationen handelt es sich allesamt um gängige Parameter. Bei einigen besonderen Anforderungen kann es sich um die Kapselung von Datumstypdaten handeln (tatsächlich speichern wir im Allgemeinen Zeichenfolgen und übertragen sie nicht, daher verstehen wir das hier). Zum Beispiel die folgenden Anforderungen:

Da die Datumsformate unterschiedlich sind (z. B.: 2022-12-12 10:05:45, 2022/ 12/ 12 10:05:45), müssen Sie beim Kapseln von Datumstypparametern das Datumsformat über die Annotation @DateTimeFormat und ihr Musterattribut festlegen.

Welches Datumsformat im Musterattribut der Annotation @DateTimeFormat angegeben ist, der Front-End-Datumsparameter muss im angegebenen Format übergeben werden.

In der Backend-Controller-Methode müssen Sie den Datumstyp LocalDateT oder LocalDateTime verwenden, um die übergebenen Parameter zu kapseln.

Controller-Methode:

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

  5, JSON-Parameter

Wir haben beim Erlernen der Front-End-Technologie darüber gesprochen Wenn es sich bei der Interaktion mit dem Front-End und dem Back-End über JSON um einen komplexeren Parameter handelt, verwenden das Front-End und das Back-End Daten im JSON-Format für die Übertragung. (JSON ist die in der Entwicklung am häufigsten verwendete Front-End- und Back-End-Dateninteraktionsmethode.) Tatsächlich werden wir auch feststellen, dass es sich bei einigen um Zeichenfolgen, andere um Sammlungen und einige um JSON handelt, wenn das Backend Daten an das Frontend zurückgibt , dann wird das Frontend Es war sehr mühsam. Später wurde eine Entitätsklasse verwendet, um alle Daten zu speichern, und dann wurde das Objekt zurückgegeben, sodass die Rezeption beim Akzeptieren nur JSON verarbeiten musste ,

• wird unten erwähnt. So senden Sie JSON-Daten in Postman:

  

  服务端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);
      }
  }

  

  

  Das obige ist der detaillierte Inhalt vonWie erhält SpringBoot Front-End-Parameter und wie reagiert es einheitlich?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!