Method for parameter verification in Spring Boot project

Scenario restoration

Simple business scenario simulation:

If you are making a score entry system now, you can happily use Spring Boot frameworkWrite a backend interface to receive the Student object passed from the frontend browser and insert it into the backend database.

We define the incoming Student object as:

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

Then write a Post request background interface to receive the Student object passed from the web page:

@RestController
public class TestController {

    @Autowired
    private StudentService studentService;

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

At this point I think you must have seen the loopholes in the above code, because we did not do any data verification on the incoming Student object, such as ：

What should I do if one of the three fields in the Student object is null? What if the Student's score is written incorrectly and is written as 101 points? What should I do if I fill in the student's 11-digit mobile phone number incorrectly and add one more digit? ...Wait

Although these data are generally verified on the front-end page, as a rigorous and conscientious back-end development engineer, we must definitely verify every incoming A piece of data needs to be strictly verified, so how should we write it?

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

I have finished writing, but I feel

my hands are a little sore, and heart is a little tired. This Student object is not bad. After all, there are only 3 fields inside. If What to do if a complex object has 30 fields? It’s unimaginable!

God's Annotation Blessing

In fact, the Spring framework has provided us with various interactive

data through annotation since its very early version. Verification work, such as the above example, we only need to add corresponding annotations to the fields of the incoming Student entity class to easily solve the problem:

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

Of course, at the same time, we also It is necessary to add the annotation @Valid at the object entrance to start the verification of the incoming Student object:

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

At this time, if an error is entered in a certain field, for example, when I transfer data, the student's If the score is misreported as 101 points, the interface will return the result and the error details will be prompted:

Of course, regarding the principle of this matter, since annotations are used, it is nothing more than useful. It is implemented using various reflection and other knowledge in Java. Interested friends can take this opportunity to study it!

Unified interception of data anomalies

The above method uses annotations to perform unified data verification

It feels very good, but the only drawback is that the returned results are too complicated , not necessarily the format we need, we need to do unified processing, for example: I just want to extract the error message for specific parameter verification and return it to the front end That’s it.

To this end, we configure the

global unified exception interceptor for the project to format the return results of all data verification.

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

As shown in the above code, we

globally intercept the parameter verification exception MethodArgumentNotValidException, and only get the detailed Message information corresponding to the exception and spit it out to the front end, and then return it to the front end The data is much clearer:

The above is the detailed content of Method for parameter verification in Spring Boot project. For more information, please follow other related articles on the PHP Chinese website!