（五）分组约束

有的时候博客内容会有变动，首发博客是最新的，其他博客地址可能会未同步, 认准https://blog.zysicyj.top

一、请求组

1. 人组

1
2
3
4
5
6
7
8
9
package org.hibernate.validator.referenceguide.chapter05;
public class Person {
    @NotNull
    private String name;
    public Person(String name) {
        this.name = name;
    }
    // getters and setters ...
}

2. 驱动组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class Driver extends Person {
    @Min(
            value = 18,
            message = "You have to be 18 to drive a car",
            groups = DriverChecks.class
    )
    public int age;
    @AssertTrue(
            message = "You first have to pass the driving test",
            groups = DriverChecks.class
    )
    public boolean hasDrivingLicense;
    public Driver(String name) {
        super(name);
    }
    public void passedDrivingTest(boolean b) {
        hasDrivingLicense = b;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

3. 汽车组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class Car {
    @NotNull
    private String manufacturer;
    @NotNull
    @Size(min = 2, max = 14)
    private String licensePlate;
    @Min(2)
    private int seatCount;
    @AssertTrue(
            message = "The car has to pass the vehicle inspection first",
            groups = CarChecks.class
    )
    private boolean passedVehicleInspection;
    @Valid
    private Driver driver;
    public Car(String manufacturer, String licencePlate, int seatCount) {
        this.manufacturer = manufacturer;
        this.licensePlate = licencePlate;
        this.seatCount = seatCount;
    }
    public boolean isPassedVehicleInspection() {
        return passedVehicleInspection;
    }
    public void setPassedVehicleInspection(boolean passedVehicleInspection) {
        this.passedVehicleInspection = passedVehicleInspection;
    }
    public Driver getDriver() {
        return driver;
    }
    public void setDriver(Driver driver) {
        this.driver = driver;
    }
    // getters and setters ...
}

4. 使用验证组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
// create a car and check that everything is ok with it.
Car car = new Car("Morris", "DD-AB-123", 2 );
Set<ConstraintViolation<Car>> constraintViolations = validator.validate(car);
assertEquals(0, constraintViolations.size());
// but has it passed the vehicle inspection?
constraintViolations = validator.validate(car, CarChecks.class);
assertEquals(1, constraintViolations.size());
assertEquals(
        "The car has to pass the vehicle inspection first",
        constraintViolations.iterator().next().getMessage()
);
// let's go to the vehicle inspection
car.setPassedVehicleInspection(true );
assertEquals(0, validator.validate(car, CarChecks.class).size());
// now let's add a driver. He is 18, but has not passed the driving test yet
Driver john = new Driver("John Doe" );
john.setAge(18 );
car.setDriver(john);
constraintViolations = validator.validate(car, DriverChecks.class);
assertEquals(1, constraintViolations.size());
assertEquals(
        "You first have to pass the driving test",
        constraintViolations.iterator().next().getMessage()
);
// ok, John passes the test
john.passedDrivingTest(true );
assertEquals(0, validator.validate(car, DriverChecks.class).size());
// just checking that everything is in order now
assertEquals(
        0, validator.validate(
        car,
        Default.class,
        CarChecks.class,
        DriverChecks.class
).size()
);

二、组继承(🐮)

  • 定义一个超级跑车
1
2
3
4
5
6
7
8
public class SuperCar extends Car {
    @AssertTrue(
            message = "Race car must have a safety belt",
            groups = RaceCarChecks.class
    )
    private boolean safetyBelt;
    // getters and setters ...
}
1
2
3
import javax.validation.groups.Default;
public interface RaceCarChecks extends Default {
}
  • 使用组继承
1
2
3
4
5
6
7
8
9
// create a supercar and check that it's valid as a generic Car
SuperCar superCar = new SuperCar("Morris", "DD-AB-123", 1  );
assertEquals("must be greater than or equal to 2", validator.validate(superCar).iterator().next().getMessage());
// check that this supercar is valid as generic car and also as race car
Set<ConstraintViolation<SuperCar>> constraintViolations = validator.validate(superCar, RaceCarChecks.class);
assertThat(constraintViolations).extracting("message" ).containsOnly(
        "Race car must have a safety belt",
        "must be greater than or equal to 2"
);

三、定义组序列（🐮）

  • 定义序列组
1
2
3
4
5
import javax.validation.GroupSequence;
import javax.validation.groups.Default;
@GroupSequence({ Default.class, CarChecks.class, DriverChecks.class })
public interface OrderedChecks {
}
  • 使用序列组
1
2
3
4
5
6
7
Car car = new Car("Morris", "DD-AB-123", 2 );
car.setPassedVehicleInspection(true );
Driver john = new Driver("John Doe" );
john.setAge(18 );
john.passedDrivingTest(true );
car.setDriver(john);
assertEquals(0, validator.validate(car, OrderedChecks.class).size());

四、重新定义默认的组顺序

@GroupSequence

  • 定义一个具有重定义的默认组的类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
@GroupSequence({ RentalChecks.class, CarChecks.class, RentalCar.class })
public class RentalCar extends Car {
    @AssertFalse(message = "The car is currently rented out", groups = RentalChecks.class)
    private boolean rented;
    public RentalCar(String manufacturer, String licencePlate, int seatCount) {
        super(manufacturer, licencePlate, seatCount);
    }
    public boolean isRented() {
        return rented;
    }
    public void setRented(boolean rented) {
        this.rented = rented;
    }
}
1
2
public interface RentalChecks {
}
  • 使用重新定义的默认组
1
2
3
4
5
6
7
8
9
10
11
12
13
RentalCar rentalCar = new RentalCar("Morris", "DD-AB-123", 2 );
rentalCar.setPassedVehicleInspection(true );
rentalCar.setRented(true );
Set<ConstraintViolation<RentalCar>> constraintViolations = validator.validate(rentalCar);
assertEquals(1, constraintViolations.size());
assertEquals(
        "Wrong message",
        "The car is currently rented out",
        constraintViolations.iterator().next().getMessage()
);
rentalCar.setRented(false );
constraintViolations = validator.validate(rentalCar);
assertEquals(0, constraintViolations.size());

@GroupSequenceProvider

  • 实现和使用默认组序列
1
2
3
4
5
6
7
8
9
10
11
12
public class RentalCarGroupSequenceProvider
        implements DefaultGroupSequenceProvider<RentalCar> {
    @Override
    public List<Class<?>> getValidationGroups(RentalCar car) {
        List<Class<?>> defaultGroupSequence = new ArrayList<Class<?>>();
        defaultGroupSequence.add(RentalCar.class);
        if (car != null && !car.isRented()) {
            defaultGroupSequence.add(CarChecks.class);
        }
        return defaultGroupSequence;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
@GroupSequenceProvider(RentalCarGroupSequenceProvider.class)
public class RentalCar extends Car {
    @AssertFalse(message = "The car is currently rented out", groups = RentalChecks.class)
    private boolean rented;
    public RentalCar(String manufacturer, String licencePlate, int seatCount) {
        super(manufacturer, licencePlate, seatCount);
    }
    public boolean isRented() {
        return rented;
    }
    public void setRented(boolean rented) {
        this.rented = rented;
    }
}

五、组转换（🐮）

  • 必须集合 @Valid 哦，否则报错
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class Driver {
    @NotNull
    private String name;
    @Min(
            value = 18,
            message = "You have to be 18 to drive a car",
            groups = DriverChecks.class
    )
    public int age;
    @AssertTrue(
            message = "You first have to pass the driving test",
            groups = DriverChecks.class
    )
    public boolean hasDrivingLicense;
    public Driver(String name) {
        this.name = name;
    }
    public void passedDrivingTest(boolean b) {
        hasDrivingLicense = b;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    // getters and setters ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
@GroupSequence({ CarChecks.class, Car.class })
public class Car {
    @NotNull
    private String manufacturer;
    @NotNull
    @Size(min = 2, max = 14)
    private String licensePlate;
    @Min(2)
    private int seatCount;
    @AssertTrue(
            message = "The car has to pass the vehicle inspection first",
            groups = CarChecks.class
    )
    private boolean passedVehicleInspection;
    @Valid
    @ConvertGroup(from = Default.class, to = DriverChecks.class)
    private Driver driver;
    public Car(String manufacturer, String licencePlate, int seatCount) {
        this.manufacturer = manufacturer;
        this.licensePlate = licencePlate;
        this.seatCount = seatCount;
    }
    public boolean isPassedVehicleInspection() {
        return passedVehicleInspection;
    }
    public void setPassedVehicleInspection(boolean passedVehicleInspection) {
        this.passedVehicleInspection = passedVehicleInspection;
    }
    public Driver getDriver() {
        return driver;
    }
    public void setDriver(Driver driver) {
        this.driver = driver;
    }
    // getters and setters ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// create a car and validate. The Driver is still null and does not get validated
Car car = new Car("VW", "USD-123", 4 );
car.setPassedVehicleInspection(true );
Set<ConstraintViolation<Car>> constraintViolations = validator.validate(car);
assertEquals(0, constraintViolations.size());
// create a driver who has not passed the driving test
Driver john = new Driver("John Doe" );
john.setAge(18 );
// now let's add a driver to the car
car.setDriver(john);
constraintViolations = validator.validate(car);
assertEquals(1, constraintViolations.size());
assertEquals(
        "The driver constraint should also be validated as part of the default group",
        constraintViolations.iterator().next().getMessage(),
        "You first have to pass the driving test"
);
```ss the driving test"
);