Spring Boot参数验证（上）——Bean Validation及其Hibernate实现

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

@Data
public class Car {

    @NotNull
    // 生产厂家
    private String manufacturer;

    @NotNull
    @Size(min = 5, max = 12)
    // 牌照
    private String licensePlate;

    @Min(2)
    // 座位数
    private int seatCount;

    public Car(String manufacturer, String licencePlate, int seatCount) {
        this.manufacturer = manufacturer;
        this.licensePlate = licencePlate;
        this.seatCount = seatCount;
    }
}

public class CarTest {

    private static Validator validator;

    @Before
    public void setUp() {
        validator = Validation.buildDefaultValidatorFactory().getValidator();
    }

    /**
     * manufacturer违反NotNull约束
     */
    @Test
    public void testManufacturerIsNull() {
        Car car = new Car(null, "川A﹒1234", 5);
        Set<ConstraintViolation<Car>> cvs = validator.validate(car);
        // 有一条错误信息
        assertEquals(1, cvs.size());
        // hibernate-validator：ValidationMessages_zh_CN.properties
        assertEquals("不能为null", cvs.iterator().next().getMessage());
    }

    /**
     * 牌照不合法
     */
    @Test
    public void testLicensePlateIsInvalid() {
        Car car = new Car("ford", "川A﹒1", 5);
        Set<ConstraintViolation<Car>> constraintViolations =
                validator.validate(car);
        assertEquals(1, constraintViolations.size());
        // hibernate-validator：ValidationMessages_zh_CN.properties
        assertEquals("个数必须在5和12之间", constraintViolations.iterator().next().getMessage());
    }

    /**
     * 座位数太小
     */
    @Test
    public void testSeatCountIsTooLow() {
        Car car = new Car("ford", "川A﹒1234", 1);
        Set<ConstraintViolation<Car>> constraintViolations =
                validator.validate(car);
        assertEquals(1, constraintViolations.size());
        // hibernate-validator：ValidationMessages_zh_CN.properties
        assertEquals("最小不能小于2", constraintViolations.iterator().next().getMessage());
    }

    /**
     * 验证通过
     */
    @Test
    public void testCarIsValid() {
        Car car = new Car("ford", "川A﹒1234", 5);
        Set<ConstraintViolation<Car>> constraintViolations =
                validator.validate(car);
        assertEquals(0, constraintViolations.size());
    }
}

@NotNull(message = "生产厂家不能为空")
private String manufacturer;

@NotEmpty(message = "出租车站不能为空")
public String getRentalStation() {
    return rentalStation;
}

@PassengerCount(value = 2, message = "你确定要超载？")
public class Car {
    ……
}

public class RentalCar extends Car {
    ……
}

@Test
public void testRentalCar() {
    // 会校验子类，同时还会校验父类，这就是约束继承，这同样适用于接口。如果子类覆盖了父类的方法，那么子类和父类的约束都会被校验。
    RentalCar rentalCar = new RentalCar(null);
    Set<ConstraintViolation<RentalCar>> constraintViolations =
            validator.validate(rentalCar);
    assertEquals(4, constraintViolations.size());
}

@PassengerCount(value = 2, message = "你确定要超载？")
public class Car {
    ……

    // valid注解会级联验证关联对象，如果对象是集合、Map、数组，也会验证其中的元素
    @Valid
    private Driver driver;

    @Valid
    private List<User> passengers;
}

@Test
public void testDriver() {
    // 司机，年龄未满18, 无驾照
    Driver driver = new Driver("司机", "siji@123.com", 10, false);
    // 车辆，生产厂商不能为空
    Car car = new Car(null, "川A﹒12345", 5);
    car.setDriver(driver);
    Set<ConstraintViolation<Car>> constraintViolations =
            validator.validate(car);
    assertEquals(3, constraintViolations.size());
}

@Test
public void testPassengers() {
    // 生产厂商不对
    Car car = new Car(null, "川A﹒12345", 5);
    List<User> passengers = new ArrayList<>();
    // 正确
    User passenger1 = new User("baby", "baby@123.com");
    // 邮箱不对
    User passenger2 = new User("kid", "kid123.com");
    // 邮箱为空
    User passenger3 = new User("ghost", null);
    passengers.add(passenger1);
    passengers.add(passenger2);
    passengers.add(passenger3);
    // 载人数为2，超载了
    car.setPassengers(passengers);
    Set<ConstraintViolation<Car>> constraintViolations =
            validator.validate(car);
    assertEquals(4, constraintViolations.size());
}

``public interface CarChecks {}``

``public interface DriverChecks {}``

@Data
@PassengerCount(value = 2, message = "你确定要超载？")
public class Car {
    ……

    @AssertTrue(message = "必须先通过上路检测", groups = CarChecks.class)
    private boolean passedVehicleInspection;
}

@Min(value = 18, message = "驾驶员年龄必须大于18", groups = DriverChecks.class)
@Max(value = 60, message = "驾驶员年龄必须小于60", groups = DriverChecks.class)
private Integer age;

@AssertTrue(message = "你想无证驾驶？", groups = DriverChecks.class)
private boolean hasDrivingLicense;

@Test
public void driveAway() {
    // 通过校验，默认组，由于passedVehicleInspection属于另外的组，所以这里并不校验该属性
    Car car = new Car("ford", "川A12345", 2);
    Set<ConstraintViolation<Car>> constraintViolations = validator.validate(car);
    assertEquals(0, constraintViolations.size());
    // 未通过上路检测
    constraintViolations = validator.validate(car, CarChecks.class);
    assertEquals(1, constraintViolations.size());
    assertEquals("必须先通过上路检测", constraintViolations.iterator().next().getMessage());
    // 设置通过上路检测
    car.setPassedVehicleInspection(true);
    assertEquals(0, validator.validate(car).size());
    // 设置一个司机
    Driver john = new Driver("john", "john@123.com", 20);
    car.setDriver(john);
    constraintViolations = validator.validate(car, DriverChecks.class);
    assertEquals(1, constraintViolations.size());
    assertEquals("你想无证驾驶？", constraintViolations.iterator().next().getMessage());
    // 司机通过了驾照考试
    john.setHasDrivingLicense(true);
    assertEquals(0, validator.validate(car, DriverChecks.class).size());
    // 全部通过
    assertEquals(0, validator.validate(car, Default.class, CarChecks.class, DriverChecks.class).size());
}

@Documented
@Constraint(validatedBy = PassengerCountValidator.class)
@Target({ElementType.TYPE, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface PassengerCount {
    String message() default "{com.belonk.car.passengerCount}";

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

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

    int value();
}

public interface ConstraintValidator<A extends Annotation, T> {
    // 初始化一些必要的信息
    default void initialize(A constraintAnnotation) {}

    // 校验逻辑，value为被校验目标（类、属性、方法）的值
    boolean isValid(T value, ConstraintValidatorContext context);
}

public class PassengerCountValidator implements ConstraintValidator<PassengerCount, Car> {
    public static final int MIN_SEAT_COUNT = 2;

    private int passengerCount;

    @Override
    public boolean isValid(Car car, ConstraintValidatorContext context) {
        if (this.passengerCount < MIN_SEAT_COUNT) {
            return false;
        }
        if (car == null) {
            return true;
        }
        List<User> passengers = car.getPassengers();
        if (passengers == null) {
            return true;
        }
        if (passengers.size() > passengerCount) {
            return false;
        }
        return true;
    }

    @Override
    public void initialize(PassengerCount passengerCount) {
        // 根据注解的value属性来获取核载人数
        this.passengerCount = passengerCount.value();
    }
}

``com.belonk.car.passengerCount=核载人数为{value}，请勿超载``