Méthode de vérification des paramètres dans le projet Spring Boot

Restauration de scène

Simulation de scénario d'entreprise simple :

Supposons que vous créiez maintenant un système de saisie de score et que vous utilisiez volontiers le Spring Boot framework pour écrire une interface d'arrière-plan permettant de recevoir l'objet Student transmis depuis le front-end. navigateur et insérez-le dans la base de données principale.

Nous définissons l'objet Student entrant comme :

public class Student {
    private String name;    // 姓名
    private Integer score;  // 考试分数（满分100分）
    private String mobile;  // 电话号码（11位）
}

Ensuite, écrivez une Post requestinterface backend pour recevoir l'objet Student transmis depuis la page Web :

@RestController
public class TestController {

    @Autowired
    private StudentService studentService;

    @PostMapping("/add")
    public String addStudent( @RequestBody Student student ) {
        studentService.addStudent( student ); // 将student对象存入数据库
        return "SUCCESS";
    }
}

À ce moment, je pense que vous devez avoir vu ce qui précède. Il y a une faille dans le code, car nous n'avons effectué aucune vérification des données sur l'objet Student entrant. Par exemple :

L'un des trois champs de l'objet Student a été oublié. Que dois-je faire s'il est nul. ? Que se passe-t-il si la note de l'élève est mal écrite et s'écrit sous la forme de 101 points ? Que dois-je faire si je saisis incorrectement le numéro de téléphone portable à 11 chiffres de l'étudiant et que j'ajoute un chiffre supplémentaire ? ...Attendez

Bien que ces données soient généralement vérifiées sur la page front-end, en tant qu'ingénieur de développement back-end rigoureux et consciencieux, nous devons effectuer une vérification stricte de chaque élément de données transmis. Test , alors que devrions-nous écrire?

@PostMapping("/add")
public String addStudent( @RequestBody Student student ) {
    if( student == null )
        return "传入的Student对象为null，请传值";
    if( student.getName()==null || "".equals(student.getName()) )
        return "传入的学生姓名为空，请传值";
    if( student.getScore()==null )
        return "传入的学生成绩为null，请传值";
    if( (student.getScore()<0) || (student.getScore()>100) )
        return "传入的学生成绩有误，分数应该在0~100之间";
    if( student.getMobile()==null || "".equals(student.getMobile()) )
        return "传入的学生电话号码为空，请传值";
    if( student.getMobile().length()!=11 )
        return "传入的学生电话号码长度有误，应为11位";
    studentService.addStudent( student ); // 将student对象存入MySQL数据库
    return "SUCCESS";
}

J'ai fini d'écrire, mais je sens mes mains sont un peu douloureuses

, et

le cœur est un peu fatigué Cet objet étudiant n'est pas mal Après tout, il n'y a que 3 champs à l'intérieur. l'objet a 30 champs ? C'est inimaginable ! Bénédiction des annotations de Dieu

En fait, le framework Spring utilise des

annotations

depuis les toutes premières versions pour nous fournir facilement divers travaux interactifs de

vérification des données. Par exemple, dans l'exemple ci-dessus, il nous suffit d'ajouter correspondant. les annotations dans les champs de la classe d'entité Student entrante peuvent facilement résoudre le problème :

public class Student {
    @NotNull(message = "传入的姓名为null，请传值")
    @NotEmpty(message = "传入的姓名为空字符串，请传值")
    private String name;    // 姓名

    @NotNull(message = "传入的分数为null，请传值")
    @Min(value = 0,message = "传入的学生成绩有误，分数应该在0~100之间")
    @Max(value = 100,message = "传入的学生成绩有误，分数应该在0~100之间")
    private Integer score;  // 分数

    @NotNull(message = "传入的电话为null，请传值")
    @NotEmpty(message = "传入的电话为空字符串，请传值")
    @Length(min = 11, max = 11, message = "传入的电话号码长度有误，必须为11位")
    private String mobile;  // 电话号码
}

Bien sûr, en même temps, nous devons également ajouter l'annotation @Valid à l'entrée de l'objet pour permettre la vérification du travail de l'objet Student entrant :

@PostMapping("/add")
public String addStudent( @RequestBody  @Valid Student student ) {
    // 棒棒哒！原先各种繁杂的参数校验工作统统都省了！一行代码不用写
    studentService.addStudent( student ); // 将student对象存入MySQL数据库
    return "SUCCESS";
}

À ce moment, si une erreur est saisie dans un certain champ, par exemple, lorsque je transfère des données, le score de l'élève est transmis par erreur comme 101 points, le résultat renvoyé par l'interface demandera les détails de l'erreur :

Bien sûr Concernant le principe de cette matière, puisque des annotations sont utilisées, elle est implémentée à l'aide de diverses réflexions et autres connaissances en Java. Les amis intéressés peuvent profiter de cette opportunité pour l'étudier !

Interception uniforme des anomalies de données

La méthode ci-dessus de vérification unifiée des données à l'aide d'annotations est très agréable

, mais le seul inconvénient est que les

résultats renvoyés sont trop compliqués

et ne sont pas nécessairement dans le format dont nous avons besoin, nous je dois le faire Traitement unifié , par exemple : je veux juste extraire le message d'erreur pour une vérification de paramètre spécifique et le renvoyer au front-end. À cette fin, nous configurons l'intercepteur d'exceptions unifié global pour le projet afin de formater les résultats de retour de toutes les vérifications de données.

@ControllerAdvice
@ResponseBody
public class GlobalExceptionInterceptor {
  @ExceptionHandler(value = Exception.class)
  public String exceptionHandler(HttpServletRequest request, Exception e) {
    String failMsg = null;
    if (e instanceof MethodArgumentNotValidException) {
      // 拿到参数校验具体异常信息提示
      failMsg = ((MethodArgumentNotValidException) e).getBindingResult().getFieldError().getDefaultMessage();
    }
    return failMsg; // 直接吐回给前端
  }
}

Comme le montre le code ci-dessus, nous

avons globalement intercepté l'exception de vérification des paramètres

MethodArgumentNotValidException, et n'avons obtenu que les informations détaillées du message correspondant à l'exception et les avons crachées au front-end. le front-end est beaucoup plus clair :

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!