Hibernate Validator 第14篇：组约束-请求组

前面章节讨论的在Validator和ExecutableValidator上所有的验证方法，都是关于变量参数-类型的变量组。到目前为止，我们一直忽略了这个组，但是现在是时候拿出来了。

一、请求组

组允许您限制验证期间应用的约束集，其中一种例子是UI向导，这个时候，其中的每一步都需要一个指定的约束子集。这个专门的约束组作为变量-参数这种参数，被传递给恰当的校验方法。

让我们来看一下例子。Person这个类有一个@NotNull的约束注解，在name上。既然没有组被指定在这个默认的javax.validation.groups.Default(假设)注解上。

当超过一个组被需要的时候，对这些组的求值顺序是不确定的，如果没有组被指定在默认的组中。

package org.hibernate.validator.referenceguide.chapter05;

public class Person {

    @NotNull
    private String name;

    public Person(String name) {
        this.name = name;
    }

    // getters and setters ...
}

Driver类继承自Person并且增加了一个树形age和hasDrivingLicense。Driver必须年满18岁（@Min(18)）和同时有一个驾照（@AssertTrue）。这两个定义在属性上的约束属于DriverCheck组。DriverCheck只是一个简单的标签接口。

使用接口作为约束组的类型安全的使用方法，允许你简单的重构。它还意味着组可以通过类继承相互继承。

package org.hibernate.validator.referenceguide.chapter05;

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;
    }
}
package org.hibernate.validator.referenceguide.chapter05;

public interface DriverChecks {
}

最终Car类有一些约束是默认组的一部分，同时@AssertTrue在组CarCheck中，并且属性passedVehicleInspection证明了是否一个car通过了道路测试。

package org.hibernate.validator.referenceguide.chapter05;

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 ...
}
package org.hibernate.validator.referenceguide.chapter05;

public interface CarChecks {
}

纵观例子中的三种约束组：

在Person.name，Car.manufacturer，Car.licensePlate，和Car.seatCount都属于Default的组。
这个在Driver.age和Driver.hasDrivingLIcense上面的约束都属于DriverCheck是约束组。
在Car.passedVehicleInspection上的约束属于CarChecks约束组。

下面的例子展示了，如何传递不同的约束组的组合给Validator#validate()方法，以产生不同的校验结果。

// 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()
);

第一个validate()方法的调用，没有明确的指定组。尽管这个passedVehicleInspection属性是默认为false的，在其上也有约束，其约束属于默认的组，但是不存在校验错误。

下一个约束使用的是CarChecks校验组，直到这个car实例传递给vehicle inspection才校验失败。

给car加一个driver，然后校验DriverChecks约束组，这个组校验，由于driver还没有通过driving Test。只有设置passedDriveringTest为true以后，这个DriverChecks中的约束才可以通过。

最后一个validate()方法调用，最终展示了所以所有的约束组，传递给了校验方法。