Six façons pour SpringBoot d'accepter les paramètres front-end. Premièrement, parce que la requête envoyée depuis le front-end sans interface ne peut être envoyée qu'à partir de la barre d'adresse et ne peut être qu'une requête Get afin de tester d'autres. requêtes, nous utilisons un outil -> ;Postman, Postman est un puissant plug-in Chrome pour déboguer les pages Web et envoyer des requêtes HTTP aux pages Web.
Les paramètres transmis par la réception sont grossièrement divisés en six types. Faisons une démonstration et étudions-les un par un : examinez-la avant la démonstration. Il n'y a aucun moyen d'obtenir les paramètres de la réception via SpringBoot, et ils sont obtenus via. l'objet de la requête.
@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";
}
}Dans l'environnement Springboot, l'API d'origine est encapsulée et la forme de réception des paramètres est plus simple. S'il s'agit d'un paramètre simple, le nom du paramètre est le même que le nom de la variable du paramètre formel, et le paramètre peut être reçu en définissant un paramètre formel du même nom.
@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";
}
}Si le backend en a besoin mais que le frontend ne transmet pas les paramètres correspondants, null sera renvoyé à ce moment
Lorsque le nom du paramètre transmis par le frontend est incohérent avec la liste des paramètres de la méthode que le backend accepte les paramètres, vous pouvez passer @RequestParam (" ") pour spécifier
@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";
}
}De plus, l'attribut requis dans @RequestParam est par défaut vrai (la valeur par défaut est également vraie), ce qui signifie que le paramètre de requête doit être transmis . S'il n'est pas transmis, une erreur sera signalée. Si le paramètre est facultatif, obligatoire peut être L'attribut est défini sur false
Le code est le suivant :
@RequestMapping("/simpleParam")
public String simpleParam(@RequestParam(name = "name", required = false) String username, Integer age){
System.out.println(username+ ":" + age);
return "OK";
}Cette annotation a également un paramètre, qui est defaultValue, ce qui signifie. que si aucun paramètre n'est transmis au frontal, la valeur par défaut sera la valeur actuellement spécifiée.
@RequestMapping("/simpleParam")
public String simpleParam(@RequestParam(name = "name", required = false,defaultValue ="匿名用户") String userName, Integer age) {
// 打印输出
System.out.println(userName+"----"+age);
return "ok";
}Objet d'entité simple :
Lors de l'utilisation de paramètres simples comme méthode de transfert de données, combien de paramètres de requête sont transmis par le front-end, combien de paramètres formels dans la méthode du contrôleur backend doivent être écrits. S'il existe de nombreux paramètres de requête, recevoir chaque paramètre un par un via la méthode ci-dessus sera plus fastidieux.
À ce stade, nous pouvons envisager d'encapsuler les paramètres de la requête dans un objet de classe d'entité. Pour terminer l'encapsulation des données, vous devez respecter les règles suivantes : Le nom du paramètre de requête est le même que le nom de l'attribut de la classe d'entité
L'exigence est que les paramètres transmis depuis le front-end doivent avoir le même nom et le même ordre que les paramètres dans l’objet.
@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";
}
}Objets d'entité complexes : objets dans les objets
Par exemple, il y a un autre champ dans Utilisateur : Adresse, et cette classe a deux attributs. À ce stade, lors de la transmission des paramètres dans le frontend, des modifications doivent être apportées, et Utilisateur. est toujours utilisé dans le backend pour les accepter
public class User {
private String name;
private Integer age;
private Address address; //地址对象
.....
}
public class Address {
private String province;
private String city;
.....
}Code de méthode
@RestController
public class RequestController {
//实体参数：复杂实体对象
@RequestMapping("/complexPojo")
public String complexPojo(User user){
System.out.println(user);
return "OK";
}
}
Scénarios d'utilisation des paramètres de collection de tableaux : Dans le formulaire HTML, il existe un élément de formulaire qui prend en charge plusieurs sélections (vérifiez cases), et vous pouvez soumettre plusieurs valeurs de sélection.
xxxxxxxx?hobby=game&hobby=java
Il existe deux façons pour le programme backend de recevoir les multiples valeurs ci-dessus :
array
set
: demander le nom du paramètre et le paramètre formel group Si le nom est le même et qu'il y a plusieurs paramètres de requête, définissez un paramètre de type tableau pour recevoir les paramètres
@RestController
public class RequestController {
//数组集合参数
@RequestMapping("/arrayParam")
public String arrayParam(String[] hobby){
System.out.println(Arrays.toString(hobby));
return "OK";
}
}Paramètres de collection :Le nom du paramètre de requête est le même que le nom de l'objet de collection de paramètres formels et il y a plusieurs requêtes paramètres, @RequestParam lie la relation des paramètres
Par défaut, plusieurs valeurs avec le même nom de paramètre dans la requête sont encapsulées dans un tableau. Si vous souhaitez l'encapsuler dans une collection, vous devez utiliser @RequestParam pour lier la relation des paramètres
Méthode du contrôleur :
@RestController
public class RequestController {
//数组集合参数
@RequestMapping("/listParam")
public String listParam(@RequestParam List<String> hobby){
System.out.println(hobby);
return "OK";
}
}Les démonstrations ci-dessus sont quelques paramètres courants, qui peuvent être impliqués dans certains. besoins particuliers Encapsulation de données de type date (en fait, nous stockons généralement des chaînes et ne les transférons pas, nous les comprenons donc ici). Par exemple, les exigences suivantes :
Étant donné que les dates ont différents formats (tels que : 2022-12-12 10:05:45, 2022/12/12 10:05:45), les paramètres de type de date sont Dans Lors de l'encapsulation, vous devez définir le format de date via l'annotation @DateTimeFormat et son attribut de modèle.
Quel format de date est spécifié dans l'attribut pattern de l'annotation @DateTimeFormat, le paramètre de date frontal doit être transmis dans le format spécifié.
Dans la méthode du contrôleur backend, vous devez utiliser le type Date LocalDateT ou LocalDateTime pour encapsuler les paramètres transmis.
Méthode du contrôleur :
@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";
}
}Lors de l'apprentissage de la technologie front-end, nous avons parlé de JSON lors de l'interaction avec le front-end et le back-end, s'il s'agit d'un paramètre plus complexe, le. le front-end et le back-end utiliseront les données au format JSON pour la transmission. (JSON est la méthode d'interaction de données front-end et back-end la plus couramment utilisée dans le développement. En fait, nous verrons également que si le backend renvoie des données au frontend, certaines sont des chaînes, d'autres sont des collections et d'autres sont JSON). , puis le frontend a été très gênant. Plus tard, j'ai utilisé une classe d'entité pour stocker toutes les données, puis j'ai renvoyé cet objet, de cette façon, la réception n'a besoin que de traiter JSON lors de sa réception. la fin de la note
Ce qui suit présente comment envoyer du JSON dans Postman Data :
服务端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";
}
}传统的开发中请求参数是放在请求体(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);
}
}
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Étapes de création du projet SpringBoot
Quelle est la différence entre j2ee et springboot
La différence entre null et NULL en langage C
Que signifie serveur Web ?
tutoriel de balançoire
Quel est le format m4a ?
Quelle est la différence entre mysql et mssql
Comment résoudre l'impossibilité de se connecter à NVIDIA
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
