Methode zur Parameterüberprüfung im Spring Boot-Projekt

Szenenrestaurierung

Einfache Geschäftsszenariosimulation:

Wenn Sie jetzt ein Punkteeingabesystem erstellen, können Sie es problemlos verwenden # 🎜🎜#Spring Boot FrameworkSchreiben Sie eine Hintergrundschnittstelle, um das vom Front-End-Browser übergebene Student-Objekt zu empfangen und in die Hintergrunddatenbank einzufügen.

Wir definieren das eingehende Student-Objekt als:

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

und schreiben dann eine

Post-Anfrage Hintergrundschnittstelle, um es vom Student-Objekt der Webseite zu empfangen :

@RestController
public class TestController {

    @Autowired
    private StudentService studentService;

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

An diesem Punkt denke ich, dass Sie die Lücken im obigen

Code gesehen haben müssen, weil wir nichts# mit dem eingehenden Student-Objekt 🎜🎜#Daten gemacht haben Verifizierung, zum Beispiel: Wenn eines der drei Felder im Student-Objekt vergessen wird, was soll ich tun, wenn es null ist? Was passiert, wenn die Punktzahl des Schülers falsch angegeben ist und 101 Punkte beträgt? Was soll ich tun, wenn ich die 11-stellige Mobiltelefonnummer des Schülers falsch eingebe und eine weitere Ziffer hinzufüge? ...Warten

Obwohl diese Daten im Allgemeinen auf der Front-End-Seite überprüft werden, müssen wir als

strenge und gewissenhafte Back-End-Entwicklungsingenieure unbedingt alle eingegebenen Daten überprüfen ist

streng verifiziert, wie sollen wir es also schreiben?

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

Ich habe mit dem Schreiben fertig, aber ich habe das Gefühl, dass meine Hände ein wenig wund sind

und

Herz ist ein wenig müde, dieses Studentenobjekt ist schließlich nicht schlecht, intern Es gibt nur 3 Felder Was ist, wenn ein komplexes Objekt 30 Felder hat? Es ist unvorstellbar! 神NoteBLESSING

Tatsächlich stellt uns das Spring-Framework seit sehr frühen Versionen

Anmerkungen

verschiedene Elemente zur Verfügung # Datenüberprüfung

Arbeit, wie im obigen Beispiel, wir müssen nur entsprechende Anmerkungen zu den Feldern der eingehenden Student-Entitätsklasse hinzufügen, um das Problem einfach zu lösen:

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;  // 电话号码
}

#🎜 🎜#Natürlich, bei Gleichzeitig müssen wir auch die Anmerkung @Valid am Objekteingang hinzufügen, um die Überprüfung des eingehenden Student-Objekts zu starten:

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

Wenn zu diesem Zeitpunkt ein bestimmtes Feld fehlerhaft übergeben wird, z Wenn ich beispielsweise Daten übertrage und die Punktzahl des Schülers fälschlicherweise mit 101 Punkten übertrage, gibt die Schnittstelle das Ergebnis zurück und fordert die Fehlerdetails an:

Natürlich In Bezug auf das Prinzip dieser Angelegenheit werden Anmerkungen verwendet und verschiedene Reflexionen und andere Kenntnisse in Java verwendet. Interessierte Freunde können diese Gelegenheit nutzen, um sie zu studieren!

Einheitliches Abfangen von Datenanomalien

Die obige Methode verwendet Annotationen, um eine einheitliche Datenüberprüfung durchzuführen

Es fühlt sich sehr gut an

, ist aber der einzige Wermutstropfen Salbe ist die zurückgegebene # 🎜🎜#Das Ergebnis ist zu kompliziert

und liegt möglicherweise nicht in dem Format vor, das wir benötigen. Wir müssen eine

einheitliche Verarbeitung

durchführen, zum Beispiel: Ich möchte nur geben die Fehlermeldung der spezifischen Parameterüberprüfung# 🎜🎜#Puel out Geben Sie es einfach an das Frontend zurück. Zu diesem Zweck konfigurieren wir den Global Unified Exception Interceptor für das Projekt, um die Rückgabeergebnisse aller Datenüberprüfungen zu formatieren.

@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; // 直接吐回给前端
  }
}

Wie im obigen Code gezeigt, fangen wir global die

Parameterüberprüfungsausnahme MethodArgumentNotValidException ab und erhalten nur die detaillierten Nachrichteninformationen, die der Ausnahme entsprechen, und spucken sie an die aus Frontend. Die an das Frontend zurückgegebenen Daten sind viel klarer:

Das obige ist der detaillierte Inhalt vonMethode zur Parameterüberprüfung im Spring Boot-Projekt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!