Data verification is an indispensable function of interactive websites. Front-end js verification can cover most verification responsibilities, such as user name uniqueness, birthday format, Commonly used verifications such as email format verification and so on. However, in order to prevent users from bypassing the browser and using http tools to directly request some illegal data from the backend, server-side data verification is also necessary to prevent dirty data from falling into the database. If an illegal email format appears in the database, it will also It will cause headaches for operation and maintenance personnel. You can use the validation described in this article to verify the data.
1.JSR303/JSR-349: JSR303 is a standard. It only provides specifications but not implementation. It stipulates some verification specifications, namely verification annotations, such as @ Null, @NotNull, @Pattern, located under the javax.validation.constraints package. JSR-349 is its upgraded version, adding some new features.
@Null The annotated element must be null
@NotNull The annotated element must not be null
@AssertTrue The annotated element must be true
@AssertFalse The annotated element must be false
@Min( value) The annotated element must be a number, and its value must be greater than or equal to the specified minimum value
@Max(value) The annotated element must be a number, and its value must be less than Equal to the specified maximum value
@DecimalMin(value) The annotated element must be a number, and its value must be greater than or equal to the specified minimum value
@DecimalMax(value) The annotated element must be a number, and its value must be less than or equal to the specified maximum value
@Size(max, min) The size of the annotated element Must be within the specified range
@Digits (integer, fraction) The annotated element must be a number, and its value must be within the acceptable range
@Past The annotated element must be a past date
@Future The annotated element must be a future date
@Pattern(value) The annotated element must conform to the specified regular expression
2.hibernate validation: hibernate validation is an implementation of this specification and adds some other Validation annotations, such as @Email, @Length, @Range, etc.
@Email The annotated element must be an email address
@Length The size of the annotated string must be within the specified range
@NotEmpty The size of the annotated string must be non-empty
@Range The annotated element must be within the appropriate range
3.spring validation: spring validation re-encapsulates hibernate validation and adds automatic validation in the springmvc module. And the verification information is encapsulated into a specific class
The spring-web module uses hibernate -validation, and the databind module also provides corresponding data binding functions.
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>We only need to introduce the spring-boot-starter-web dependency. If you look at its sub-dependencies, you can find the following dependencies:
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>@SpringBootApplication
public class App {
public static void main(String[] args) {
SpringApplication.run(App.class, args);
System.out.println("Start app success.");
}
}public class Person {
@NotEmpty(message = "name不能为空")
private String name;
@Range(min = 0, max = 100, message = "age不能大于100小于0")
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}springmvc provides us with the function of automatically encapsulating form parameters, one that adds parameter verification A typical controller is shown below.
@RequestMapping("/test")
public String valid(@Validated Person person, BindingResult bindingResult) {
if (bindingResult.hasErrors()) {
for (FieldError fieldError : bindingResult.getFieldErrors()) {
System.out.println(fieldError);
}
return "fail";
}
return "success";
}Noteworthy points:
The @Validated annotation needs to be added before the parameter Persison, indicating that spring needs to verify it, and the verification information will be stored to the subsequent BindingResult. Note that they must be adjacent. If there are multiple parameters that need to be verified, the form can be as follows. valid(@Validated Person person, BindingResult personBindingResult, @Validated Person2 person2, BindingResult person2BindingResult); that is, one verification class corresponds to one verification result.
The verification results will be automatically filled in. In the controller, specific operations can be determined based on business logic, such as jumping to an error page.
The most basic verification is completed.
Start the container and the test results are as follows:
Field error in object 'person' on field 'age': value rejected [105]; codes [Range.person.age,Range.age,Range.int,Range]; arguments [org.springframework.context.support.DefaultMessageSourceResolvable: codes [person.age,age ]; arguments []; default message [age],100,0]; default message [age cannot be greater than 100 and less than 0]
The previous method Handling verification errors is a bit complicated, and most websites will encapsulate request errors in a unified 404 page. If the data verification fails, Spring boot will throw a BindException exception. We can capture this exception and use Result encapsulation to return the result. . To define an exception catching class, use @RestControllerAdvice.
Controller class:
@RequestMapping(value = "valid", method = RequestMethod.GET)
public String valid(@Validated Person person) {
System.out.println(person);
return "success";
}Unified exception handling class:
@RestControllerAdvice
public class BindExceptionHanlder {
@ExceptionHandler(BindException.class)
public String handleBindException(HttpServletRequest request, BindException exception) {
List<FieldError> allErrors = exception.getFieldErrors();
StringBuilder sb = new StringBuilder();
for (FieldError errorMessage : allErrors) {
sb.append(errorMessage.getField()).append(": ").append(errorMessage.getDefaultMessage()).append(", ");
}
System.out.println(sb.toString());
return sb.toString();
}
}Test: http://localhost:8080/valid?age=105&name=steven
输出：age: age不能大于100小于0,
@Documented
@Constraint(validatedBy = NameValidationValidator.class)
@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RUNTIME)
public @interface NameValidation {
String message() default "不是合法的名字";
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
@Target({PARAMETER, ANNOTATION_TYPE})
@Retention(RUNTIME)
@Documented
@interface List {
NameValidation[] value();
}
}public class NameValidationValidator implements ConstraintValidator<NameValidation, String> {
@Override
public boolean isValid(String value, ConstraintValidatorContext context) {
if ("steven".equalsIgnoreCase(value)) {
return true;
}
String defaultConstraintMessageTemplate = context.getDefaultConstraintMessageTemplate();
System.out.println("default message :" + defaultConstraintMessageTemplate);
//禁用默认提示信息
//context.disableDefaultConstraintViolation();
//设置提示语
//context.buildConstraintViolationWithTemplate("can not contains blank").addConstraintViolation();
return false;
}
}@NotEmpty(message = "name不能为空") @NameValidation private String name;
测试: http://localhost:8080/valid?age=105&name=lxy
输出：age: age不能大于100小于0, name: 不是合法的名字,
The above is the detailed content of How SpringBoot uses validation to implement elegant verification parameters. For more information, please follow other related articles on the PHP Chinese website!
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
