Spring/SpringBoot 参数校验-526互联

基础设施搭建
- 1. 相关依赖
- 2. 实体类案例
校验参数注解
- JSR提供的校验注解:
- Hibernate Validator提供的校验注解：
实践案例?
补充

基础设施搭建

1. 相关依赖

普通 Java 程序的的话，需要像下面这样依赖：

   <dependency>
            <groupId>org.hibernate.validator</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>6.0.9.Final</version>
   </dependency>
   <dependency>
             <groupId>javax.el</groupId>
             <artifactId>javax.el-api</artifactId>
             <version>3.0.0</version>
     </dependency>
     <dependency>
            <groupId>org.glassfish.web</groupId>
            <artifactId>javax.el</artifactId>
            <version>2.2.6</version>
     </dependency>

使用 Spring Boot 程序的话只需要spring-boot-starter-web 就够了，它的子依赖包含了我们所需要的东西。除了这个依赖，下面的演示还用到了 lombok ，所以不要忘记添加上相关依赖。

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

2. 实体类案例

@Data
@AllArgsConstructor
@NoArgsConstructor
publicclass Person {

    @NotNull(message = "classId 不能为空")
    private String classId;

    @Size(max = 33)
    @NotNull(message = "name 不能为空")
    private String name;

    @Pattern(regexp = "((^Man$|^Woman$|^UGM$))", message = "sex 值不在可选范围")
    @NotNull(message = "sex 不能为空")
    private String sex;

    @Email(message = "email 格式不正确")
    @NotNull(message = "email 不能为空")
    private String email;
}

正则表达式说明：

^string : 匹配以 string 开头的字符串
string$ ：匹配以 string 结尾的字符串
^string$ ：精确匹配 string 字符串
((^Man$|Woman$|^UGM$)) : 值只能在 Man,Woman,UGM 这三个值中选择

校验参数注解

JSR提供的校验注解:

@Null 被注释的元素必须为 null
@NotNull 被注释的元素必须不为 null
@AssertTrue 被注释的元素必须为 true
@AssertFalse 被注释的元素必须为 false
@Min(value) 被注释的元素必须是一个数字，其值必须大于等于指定的最小值
@Max(value) 被注释的元素必须是一个数字，其值必须小于等于指定的最大值
@DecimalMin(value) 被注释的元素必须是一个数字，其值必须大于等于指定的最小值
@DecimalMax(value) 被注释的元素必须是一个数字，其值必须小于等于指定的最大值
@Size(max=, min=) 被注释的元素的大小必须在指定的范围内
@Digits (integer, fraction) 被注释的元素必须是一个数字，其值必须在可接受的范围内
@Past 被注释的元素必须是一个过去的日期
@Future 被注释的元素必须是一个将来的日期
@Pattern(regex=,flag=) 被注释的元素必须符合指定的正则表达式

Hibernate Validator提供的校验注解：

@NotBlank(message =) 验证字符串非null，且长度必须大于0
@Email 被注释的元素必须是电子邮箱地址
@Length(min=,max=) 被注释的字符串的大小必须在指定的范围内
@NotEmpty 被注释的字符串的必须非空
@Range(min=,max=,message=) 被注释的元素必须在合适的范围内

实践案例?

1. 验证 Controller 的输入

1. 1 验证请求体

(RequestBody)

我们在需要验证的参数上加上了@Valid注解
如果验证失败，它将抛出MethodArgumentNotValidException（可自定义异常进行处理?）

@RestController
@RequestMapping("/api")
publicclass PersonController {

    @PostMapping("/person")
    public ResponseEntity<Person> getPerson(@RequestBody @Valid Person person) {
        return ResponseEntity.ok().body(person);
    }
}

ExceptionHandler

自定义异常处理器可以帮助我们捕获异常，并进行一些简单的处理

//监控哪个Controller
@ControllerAdvice(assignableTypes = {PersonController.class})
publicclass GlobalExceptionHandler {
  
    //捕获哪些controller的异常
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<Map<String, String>> handleValidationExceptions(
            MethodArgumentNotValidException ex) {
        Map<String, String> errors = new HashMap<>();
        ex.getBindingResult().getAllErrors().forEach((error) -> {
            String fieldName = ((FieldError) error).getField();
            String errorMessage = error.getDefaultMessage();
            errors.put(fieldName, errorMessage);
        });
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(errors);
    }
}

通过测试验证

使用 Postman 验证结果如下:

//请求参数：
{
    "sex": "Man111",
    "name": "2323sdfsgvvggdffffdfdfdshfhfgsdfdgvvggdffffdfdfdshfhfgsdf",
    "email": "4547q.com",
    "classId": "1"
}


----------------------------------------------------


//返回结果
{
    "sex": "sex 值不在可选范围####",
    "name": "个数必须在0和33之间",
    "email": "email 格式不正确"
}

1.2 验证请求参数

(Path Variables 和 Request Parameters)

Controller

不要忘记在类上加上@Validated注解，这个参数可以告诉 Spring 去校验方法参数。
我们在需要验证的参数上加上了@Valid注解，如果验证失败，它将抛出MethodArgumentNotValidException。

@RestController
@RequestMapping("/api")
@Validated
publicclass PersonController {

    @GetMapping("/person/{id}")
    public ResponseEntity<Integer> getPersonByID(@Valid @PathVariable("id") @Max(value = 5,message = "超过 id 的范围了") Integer id) {
        return ResponseEntity.ok().body(id);
    }

    @PutMapping("/person")
    public ResponseEntity<String> getPersonByName(@Valid @RequestParam("name") @Size(max = 6,message = "超过 name 的范围了") String name) {
        return ResponseEntity.ok().body(name);
    }
}

ExceptionHandler

@ExceptionHandler(ConstraintViolationException.class)
    ResponseEntity<String> handleConstraintViolationException(ConstraintViolationException e) {
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(e.getMessage());
    }

测试

请求：localhost:8080/api/person/6

返回：getPersonByID.id: 超过 id 的范围了

2. 验证 Service 中的方法

@Validated和@Valid注释的组合来实现这一需求
对参数中传的实体进行校验

实体

@Data
@AllArgsConstructor
@NoArgsConstructor
publicclass Person {

    @NotNull(message = "classId 不能为空")
    private String classId;

    @Size(max = 33)
    @NotNull(message = "name 不能为空")
    private String name;

    @Pattern(regexp = "((^Man$|^Woman$|^UGM$))", message = "sex 值不在可选范围")
    @NotNull(message = "sex 不能为空")
    private String sex;

    @Email(message = "email 格式不正确")
    @NotNull(message = "email 不能为空")
    private String email;
}

service

@Service
@Validated
publicclass PersonService {

    public void validatePerson(@Valid Person person){
        // do something
    }
}

通过测试验证：

@RunWith(SpringRunner.class)
@SpringBootTest
@AutoConfigureMockMvc
publicclass PersonServiceTest {
  
    @Autowired
    private PersonService service;

    @Test(expected = ConstraintViolationException.class)
    public void should_throw_exception_when_person_is_not_valid() {
        Person person = new Person();
        person.setSex("Man22");
        person.setClassId("82938390");
        person.setEmail("SnailClimb");
        service.validatePerson(person);
    }
}

3. Validator 手动参数验证

某些场景下可能会需要我们手动校验并获得校验结果。通过@Autowired 将Validator validate;进行注入

@RestController
@RequestMapping("/api")
@Validated
public class PersonController {

    @Autowired
    Validator validate;

    @PostMapping("/validate")
    public ResponseEntity<Person> Testvalidate() {

        System.out.println("手动获取校验结果 validate >>> ");
        Person person2 = new Person();
        //person.setSex("Man22");
        //person.setClassId("82938390");
        //person.setEmail("SnailClimb");

        Set<ConstraintViolation<Person>> violations = this.validate.validate(person2);
        for (ConstraintViolation<Person> constraintViolation : violations) {
            System.out.println(constraintViolation.getMessage());
        }

        System.out.println("validate <<< ");
        return ResponseEntity.ok().body(person);
    }

手动获取校验结果 validate >>> 
sex 不能为空
email 不能为空
classId 不能为空
name 不能为空
validate <<<

上面我们是通过 Validator 工厂类获得的 Validator 示例，当然你也可以通过 @Autowired 直接注入的方式。但是在非 Spring Component 类中使用这种方式的话，只能通过工厂类来获得 Validator。

@Autowired
Validator validate

4.自定义注解【参数校验】?

如果自带的校验注解无法满足你的需求的话，你还可以自定义实现注解。

案例一：校验特定字段的值是否在可选范围

比如我们现在多了这样一个需求：Person类多了一个 region 字段，region 字段只能是China、China-Taiwan、China-HongKong这三个中的一个。

第一步：创建一个注解 @Region：

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = RegionValidator.class)
@Documented
public@interface Region {

    String message() default "Region 值不在可选范围内!!!";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};
}

第二步：创建 ConstraintValidator接口实现类，并重写isValid 方法

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import java.util.HashSet;

/**
    * ConstraintValidator<A extends Annotation, T>
    *   A 第一个是自定义的注解类
    *   T 第二个就是要验证的数据的类型
    *   例如写了String, 那么这个类只接收String类型的参数, 写了Long就接收Long类型的参数...
    *   还可以写Object, 那么这个类就接收所有类型的参数, 可以用instanceof区分, 例子在下一个类
    */
publicclass RegionValidator implements ConstraintValidator<Region, String> {

    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        HashSet<Object> regions = new HashSet<>();
        regions.add("China");
        regions.add("China-Taiwan");
        regions.add("China-HongKong");
        return regions.contains(value);
    }
}

第三步：使用自定义的注解

@Region
private String region;

案例二：校验电话号码

校验我们的电话号码是否合法，这个可以通过正则表达式来做，相关的正则表达式都可以在网上搜到，甚至可以搜索到针对特定运营商电话号码段的正则表达式。

第一步：创建一个注解 @PhoneNumber

import javax.validation.Constraint;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;

importstatic java.lang.annotation.ElementType.FIELD;
importstatic java.lang.annotation.ElementType.PARAMETER;
importstatic java.lang.annotation.RetentionPolicy.RUNTIME;

@Documented
@Constraint(validatedBy = PhoneNumberValidator.class)
@Target({FIELD, PARAMETER})
@Retention(RUNTIME)
public@interface PhoneNumber {
    String message() default "Invalid phone number";
    Class[] groups() default {};
    Class[] payload() default {};
}

第二步：创建 ConstraintValidator接口实现类，并重写isValid 方法

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

publicclass PhoneNumberValidator implements ConstraintValidator<PhoneNumber,String> {

    @Override
    public boolean isValid(String phoneField, ConstraintValidatorContext context) {
        if (phoneField == null) {
            // can be null
            returntrue;
        }
        return phoneField.matches("^1(3[0-9]|4[57]|5[0-35-9]|8[0-9]|70)\\d{8}$") && phoneField.length() > 8 && phoneField.length() < 14;
    }
}

第三步：使用注解

@PhoneNumber(message = "phoneNumber 格式不正确")
@NotNull(message = "phoneNumber 不能为空")
private String phoneNumber;

补充

@NotNull vs @Column(nullable = false) (重要)

在使用 JPA 操作数据的时候会经常碰到 @Column(nullable = false) 这种类型的约束，那么它和 @NotNull 有何区别呢？搞清楚这个还是很重要的！

@NotNull是 JSR 303 Bean验证批注,它与数据库约束本身无关。
@Column(nullable = false) : 是JPA声明列为非空的方法。

总结来说就是即前者用于验证，而后者则用于指示数据库创建表的时候对表的约束。

requestmapping参数spring

springboot参数tomcat

springboot参数valid

springboot graalvm spring native

springboot project spring maven

servlet-spring参数servlet方式

springboot2 springboot spring3 spring