数据校验实践

如果在initialize()或isValid()方法中发生异常，则运行时异常被Jakarta Bean验证引擎包装到ValidationException中。

约束验证实现不允许更改传递给isValid()的值的状态。

注意：

对于null值的情况，是返回为true还是false需要进行考虑。

用于定义ConstraintValidator可以验证的目标。
ConstraintValidator可以针对由约束注释的（返回的）元素、方法或构造函数（又名交叉参数）的参数数组或两者。
如果@SupportedValidationTarget不存在，则ConstraintValidator以ConstraintValidator注释的（返回的）元素为目标。
以交叉参数为目标的ConstraintValidator必须接受Object[] （或Object ）作为它验证的对象类型。

@documented
@Target({ TYPE })
@Retention(RUNTIME)
public @interface SupportedValidationTarget {
	ValidationTarget[] value();
}

public enum ValidationTarget {

	
	ANNOTATED_ELEMENT,

	
	PARAMETERS
}

@SupportedValidationTarget(ValidationTarget.PARAMETERS)
public class scriptAssertValidator implements ConstraintValidator {
    @Override
    public void initialize(scriptAssert constraintAnnotation) {
        [...]
    }

    @Override
    public boolean isValid(Object[] value, ConstraintValidatorContext context) {
        [...]
    }
}

实现必须遵守以下限制：

• T必须解析为非参数化类型（即因为该类型未使用泛型或因为使用原始类型而不是泛型版本）

• 或T泛型参数必须是无界通配符类型

有效的ConstraintValidator：

//String is not making use of generics
public class SizevalidatorForString implements ConstraintValidator {
    [...]
}

//Collection uses generics but the raw type is used
public class SizevalidatorForCollection implements ConstraintValidator {
    [...]
}

//Collection uses generics and unbounded wildcard type
public class SizevalidatorForCollection implements ConstraintValidator> {
    [...]
}

//Validator for cross-parameter constraint
@SupportedValidationTarget(ValidationTarget.PARAMETERS)
public class DateParametersConsistentValidator
    implements ConstraintValidator {
    [...]
}

//Validator for both annotated elements and executable parameters
@SupportedValidationTarget({ValidationTarget.ANNOTATED_ELEMENT, ValidationTarget.PARAMETERS})
public class ELscriptValidator implements ConstraintValidator {
    [...]
}

 
无效的ConstraintValidator：

//parameterized type （参数化类型）
public class SizevalidatorForString implements ConstraintValidator> {
    [...]
}

//parameterized type using bounded wildcard （使用有界通配符的参数化类型）
public class SizevalidatorForCollection implements ConstraintValidator> {
    [...]
}

//cross-parameter validator accepting the wrong type (跨参数的验证接受了错误的类型，应该是Object对象或Object数组而不是Number)
@SupportedValidationTarget(ValidationTarget.PARAMETERS)
public class NumberPositivevalidator implements ConstraintValidator {
    [...]
}

传递给isValid()方法的ConstraintValidatorContext对象携带约束被验证到的上下文中可用的信息和操作。

public interface ConstraintValidatorContext {

	
	void disableDefaultConstraintViolation();

	
	String getDefaultConstraintMessageTemplate();

	
	ClockProvider getClockProvider();

	
	ConstraintViolationBuilder buildConstraintViolationWithTemplate(String messageTemplate);

	
	 T unwrap(Class type);
    
    [。。。]
}

ConstraintValidatorContext接口提供了对特定约束验证有用的上下文信息的访问(例如，getlockprovider())。

它还允许重新定义当约束无效时生成的默认约束消息（即你定义约束注解时定义的mesage属性值）。默认情况下，每个无效的约束将导致生成一个错误对象，该错误对象由ConstraintViolation违例对象表示。

此对象由约束声明定义的默认约束消息模板和放置约束声明的上下文(bean、属性、可执行参数、跨参数、可执行返回值或容器元素)构建。

ConstraintValidatorContext方法让约束实现禁用默认的constraint违例生成（调用disableDefaultConstraintViolation），并创建一个或多个自定义生成。作为参数传递的非插值消息用于构建ConstraintViolation消息(消息插值操作应用于它)。

默认情况下，constraint违例中公开的Path表示bean、属性、参数、跨参数、返回值或承载约束的容器元素的路径(有关更多信息，请参阅constraint违例)。您可以使用约束违背构建器fluent API将其指向此默认路径的子路径。

1、ConstraintValidator 简单实现

public class BeginsWithValidator implements ConstraintValidator {

    private Set allowedPrefixes;

    
    @Override
    public void initialize(BeginsWith constraint) {
        allowedPrefixes = Arrays.stream( constraint.value() )
                .collect( collectingAndThen( toSet(), Collections::unmodifiableSet ) );
    }

    
    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        if ( value == null )
            return true;

        return allowedPrefixes.stream()
                .anyMatch( value::startsWith );
    }
}

 
2、交叉参数 ConstraintValidator 实现

@SupportedValidationTarget(ValidationTarget.PARAMETERS)
public class DateParametersConsistentValidator implements
        ConstraintValidator {

    
    @Override
    public boolean isValid(Object[] value, ConstraintValidatorContext context) {
        if ( value.length != 3 ) {
            throw new IllegalArgumentException( "Unexpected method signature" );
        }
        // one or both limits are unbounded => always consistent
        if ( value[1] == null || value[2] == null ) {
            return true;
        }
        return ( (Date) value[1] ).before( (Date) value[2] );
    }
}

 
3 、泛型和跨参数ConstraintValidator 实现

@SupportedValidationTarget({ValidationTarget.ANNOTATED_ELEMENT, ValidationTarget.PARAMETERS})
public class ELscriptValidator implements ConstraintValidator {

    public void initialize(ELscript constraint) {
        [...]
    }

    public boolean isValid(Object value, ConstraintValidatorContext context) {
        [...]
    }
}    

需要做的是，首先通过disableDefaultConstraintViolation()方法关闭默认ConstraintValidator，并将重新定义的约束消息作为buildConstraintViolationWithTemplate()的参数再调用addConstraintViolation方法即可重新定义约束消息。

更加复杂的操作可以参考：https://beanvalidation.org/2.0/spec/#example-constraintsdefinitionimplementation-validationimplementation-errorbuilder

public class SerialNumberValidator implements ConstraintValidator {

    private int length;

    
    @Override
    public void initialize(SerialNumber constraint) {
        this.length = constraint.length();
    }

    
    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        if ( value == null )
            return true;

        context.disableDefaultConstraintViolation();

        if ( !value.startsWith( "SN-" ) ) {
            String wrongPrefix = "{com.acme.constraint.SerialNumber.wrongprefix}";
            context.buildConstraintViolationWithTemplate( wrongPrefix )
                    .addConstraintViolation();
            return false;
        }
        if ( value.length() != length ) {
            String wrongLength = "{com.acme.constraint.SerialNumber.wronglength}";
            context.buildConstraintViolationWithTemplate( wrongLength )
                    .addConstraintViolation();
            return false;
        }
        return true;
    }
}

时间约束的约束验证器(无论是内置的约束@Past， @PastOrPresent， @Future和@FutureOrPresent或自定义的时间约束)可以从ConstraintValidatorContext# getlockprovider()暴露的ClockProvider对象中获取当前瞬间，ClockProvider接口如下：

public interface ClockProvider {

    
    Clock getClock();
}

 
示例：

// 是否是过去时间
public class PastValidatorForZonedDateTime implements ConstraintValidator {

    @Override
    public boolean isValid(ZonedDateTime value, ConstraintValidatorContext context) {
        if ( value == null ) {
            return true;
        }

        ZonedDateTime now = ZonedDateTime.now( context.getClockProvider().getClock() );

        return value.isBefore( now );
    }
}

该节主要介绍约束验证的目标对象、要求、约束等。

Jakarta Bean进行验证时，对验证的Bean有以下要求：

• 要验证的属性必须遵循JavaBeans 规范中定义读取属性的方法签名约定即getter。

  JavaBeans 规范指定 getter 是一种方法
  
  getxxx - 具有返回类型但没有参数
  
  isxxx - 返回boolean值但没有参数
  

• 静态字段和静态方法被排除在验证之外。

• 约束可以应用于接口（interface）和超类（SuperClass）,但同样也存在限制接下来会说明。

约束验证的目标可以是以下：

• type
• field or property 字段或属性
• constructor or method return value 方法的返回值
• constructor or method parameter 构造器或方法的参数
• constructor or method cross-parameter 构造器或方法的交叉参数
• container element 容器元素

前提是：

• 约束定义支持指定的目标 ( java.lang.annotation.Target)
• 约束上声明的一个ConstraintValidator支持声明的目标类型，或者在跨参数的情况下，存在一个跨参数的ConstraintValidator(参阅ConstraintValidator解析算法以了解ConstraintValidator解析)
• 在容器元素约束的情况下，存在相应的值提取器（有关值提取器解析的详细信息，请参阅ValueExtractor解析）

约束声明可以应用于同一对象类型的字段和属性。 但是，不应在字段及其关联属性之间重复相同的约束（约束验证将应用两次），遵循单一状态策略。

作用于字段：

@NotNull
private String name;

作用于属性：需要满足JavaBeans规范，即存在无参的getxx()方法（对于boolean也可以是isxxx()方法）

@NotNull
public String getName(){
    return name;
}

约束可以应用于通用容器的元素，例如List，Map或Optional。这是通过将约束注解添加到此类容器的类型参数来完成的。

容器元素约束可以在以下声明中使用：

• 字段 field
• 属性 properties
• 方法或构造方法的参数
• 方法的返回值

private List<@Email String> emails;

public Optional<@Email String> getEmail() {
    [...]
}

public Map<@NotNull String, @ValidAddress Address> getAddressesByType() {
    [...]
}

public List<@NotBlank String> getMatchingRecords(List<@NotNull @Size(max=20) String> searchTerms) {
    [...]
}

 
容器元素约束可以应用于嵌套容器类型:

private Map> addressesByType;

 
不支持在泛型类型或方法的类型参数上声明容器元素约束。 也不支持在类型定义的extendsorimplements子句中声明对类型参数的容器元素约束：

public class NonNullList<@NotNull T> {
    [...]
}

public class ContainerFactory {
    <@NotNull T> Container instantiateContainer(T wrapped) { [...] }
}

public class NonNullSet extends Set<@NotNull T> {
    [...]
}

除了在类型参数上指定容器元素约束之外，还可以在非通用容器类型上声明容器元素约束。

这是通过隐式解包完成的，即约束不适用于带注释的容器本身，而是应用于其元素。比如：java.util.OptionalInt，OptionalLong和OptionalDouble以及JavaFX的的非通用的属性类型，例如StringProperty或IntegerProperty。

@Min(1)
private OptionalInt optionalNumber;

@Negative
private LongProperty negativeLong;

@Positive
private IntegerProperty positiveInt;

private final ListProperty<@NotBlank StringProperty> notBlankStrings;

以上注解都不是作用于对象本身，而是作用于被包装的数字和字符串值。

为此，必须定义一个明确可解析的值提取器（请参阅将容器级约束应用于容器元素的 ValueExtractor 解析算法），它带有@UnwrapByDefault注释（请参阅@UnwrapByDefault）

如果需要，可以通过Unwrap和Skip有效负载定义明确指定在容器上声明的约束的目标（容器或容器元素）,两者不可同时定义，否则抛出ConstraintDeclarationException异常：

public interface Unwrapping {

    
    public interface Unwrap extends Payload {
    }

    
    public interface Skip extends Payload {
    }

}

 
例如：

@NotNull约束应用于StringProperty容器：

@NotNull(payload = Unwrapping.Skip.class)
private StringProperty name;

 
@Email 作用于List容器中的元素

@Email(payload = Unwrapping.Unwrap.class)
List emails;

等价于
List<@Email String> emails; //直接标注在类型参数上更好

验证会忽略static 静态方法。对静态方法施加约束是不可移植的。对BeanValidation2.0来说，对方法不存在其他限制，但是与方法验证相结合的技术可能会对应用验证的方法施加进一步的限制。例如，某些集成技术可能要求要验证的方法必须具有public可见性和/或不能final。

为了对方法或构造函数参数使用约束注解，它们的元素类型必须是ElementType.PARAMETER。 为了在跨参数验证或方法或构造函数的返回值上使用约束注解(请参阅下面几节)，它们的元素类型必须是ElementType.METHOD、ElementType.CONSTRUCTOR。 所有内置约束都支持这些元素类型，对于自定义约束，最好也这样做。

参数约束是通过在方法或构造函数参数上放置约束注解（下例中的NotNull）来声明。

public class OrderService {

    public OrderService(@NotNull CreditCardProcessor creditCardProcessor) {
        [...]
    }

    public void placeOrder(
        @NotNull @Size(min=3, max=20) String customerCode,
        @NotNull Item item,
        @Min(1) int quantity) {
        [...]
    }
}

交叉参数约束是通过在方法或构造函数上放置交叉参数约束注解（下例中的@ConsistentDateParameters）来声明。
 

public class CalendarService {

    @ConsistentDateParameters
    public void createEvent(
        String title,
        @NotNull Date startDate,
        @NotNull Date endDate) {
        [...]
    }
}

注意：

一些约束注解可以针对可执行文件的返回值及其参数数组，此时如果存在歧义就需要约束注解上标注validationAppliesTo的属性值为ConstraintTarget.PARAMETERS。（上面的那个并不会发生歧义，因为该方法返回值为void，根据ConstraintTarget.IMPLICIT它选择的就是作用目标就是参数数组）

返回值约束是通过将约束注解直接放在方法或构造函数上来声明的，同样类似于方法参数验证需要在约束注解上标注validationAppliesTo为ConstraintTarget.RETURN_VALUE

public class OrderService {

    private CreditCardProcessor creditCardProcessor;

    @ValidonlineOrderService
    public OrderService(onlineCreditCardProcessor creditCardProcessor) {
        this.creditCardProcessor = creditCardProcessor;
    }

    @ValidBatchOrderService
    public OrderService(BatchCreditCardProcessor creditCardProcessor) {
        this.creditCardProcessor = creditCardProcessor;
    }

    @NotNull
    @Size(min=1)
    public Set getCreditCardProcessors() { [...] }

    @NotNull
    @Future
    public Date getNextAvailableDeliveryDate() { [...] }
}

在继承层次结构中定义方法约束（即通过扩展基类的类继承和通过实现或扩展接口的接口继承）时，必须遵守Liskov 替换原则，该原则要求：

• 不能在子类型中加强方法的前提条件（由参数约束表示）
• 不能在子类型中削弱方法的后置条件（由返回值约束表示）

仅适用于一般方法，验证构造函数约束时不适用，因为构造函数不会相互重写。

 
非法示例：

1、非法声明的参数约束：

public interface OrderService {

    void placeOrder(String customerCode, Item item, int quantity);
}

public class SimpleOrderService implements OrderService {

    @Override
    public void placeOrder(
        @NotNull @Size(min=3, max=20) String customerCode,
        @NotNull Item item,
        @Min(1) int quantity) {
        [...]
    }
}

约束SimpleOrderService是非法的，因为它们加强了placeOrder()由接口构成的方法的先决条件OrderService。

 
2、对并行类型非法声明的参数约束

public interface OrderService {

    void placeOrder(String customerCode, Item item, int quantity);
}

public interface OrderPlacementService {

    public void placeOrder(
        @NotNull @Size(min=3, max=20) String customerCode,
        @NotNull Item item,
        @Min(1) int quantity);
}

public class SimpleOrderService implements OrderService, OrderPlacementService {

    @Override
    public void placeOrder(String customerCode, Item item, int quantity) {
        [...]
    }
}

在这里，类SimpleOrderService实现了两个接口OrderService和OrderPlacementService，这两个接口彼此不相关，但都定义了一个具有相同签名的方法placeOrder()。 这个层次结构对于参数约束是不合法的，因为SimpleOrderService的客户端必须满足在OrderPlacementService接口上定义的约束，即使客户端只期望OrderService。

 
正确示例：

1、正确声明子类的返回值约束

public class OrderService {

    Order placeOrder(String customerCode, Item item, int quantity) {
        [...]
    }
}

public class SimpleOrderService extends OrderService {

    @Override
    @NotNull
    @Valid
    public Order placeOrder(String customerCode, Item item, int quantity) {
        [...]
    }
}

 
2、正确的子类参数约束

public interface OrderService {

    void placeOrder(@NotNull @Size(min=3, max=20) String customerCode,
        @NotNull Item item,
        @Min(1) int quantity);
}

public class SimpleOrderService implements OrderService {

    @Override
    public void placeOrder(
        String customerCode,
        Item item,
        int quantity) {
        [...]
    }
}

Jakarta Bean Validation API 不仅允许验证单个类实例，还允许验证完整的对象图（级联验证）。

可以通过@Valid来标记，用于验证级联的属性、方法参数或方法返回类型。当验证属性、方法参数或方法返回类型时，将验证在对象及其属性上定义的约束。此行为以递归方式应用。

在级联验证期间会忽略null值。

public class Car {

    @NotNull
    @Valid
    private Person driver;

}
public class Person {

    @NotNull
    private String name;

}

• 对象数组
• java.util.Collection
• java.util.Set
• java.util.List
• java.util.Map

迭代器提供的每个对象都经过验证。 对于Map，每个的值（由 检索getValue）Map.Entry被验证（ Key 未被验证）

Jakarta Bean Validation 2.0 开始 @Valid还允许验证嵌套的通用容器的元素。@Valid必须放入该嵌套容器类型的类型参数，以触发对所有嵌套容器的元素的验证。

@Valid注释应该放在容器本身或容器的类型参数上，但不能同时放在两者上（以防止容器元素被验证两次）。

不支持放入@Valid泛型类型或方法的类型参数。 也不支持@Valid在类型定义的extendsorimplements子句中放入类型参数。

public class NonNullList<@Valid T> {
    [...]
}

public class ContainerFactory {
    <@Valid T> Container instantiateContainer(T wrapped) { [...] }
}

public class NonNullSet extends Set<@Valid T> {
    [...]
}

 
示例：

List

public class User {

    // Jakarta Bean Validation 2.0 首选风格
    private List<@Valid PhoneNumber> phoneNumbers;

    // 传统风格
    @Valid
    private List phoneNumbers;

    // 禁止，在容器本身与类型参数上放置@Valid注解
    @Valid
    private List<@Valid PhoneNumber> phoneNumbers;
}

 
map

public class User {

    // Jakarta Bean Validation 2.0 首选风格
    private Map addressesByType;

    // 传统风格
    @Valid
    private Map addressesByType;

    // 禁止，映射或映射值类型参数都应该用@Valid注释，但不能两者都用
    @Valid
    private Map addressesByType;
}

 
map的key与vaue进行级联验证

public class User {

    private Map<@Valid AddressType, @Valid Address> addressesByType;
}

 
嵌套列表元素的map进行级联验证

public class User {
    private Map> addressesByType;
}

 
嵌套map元素的map进行级联验证

public class User {
    private Map> addressesByUserAndType;
}

@Valid注解也可用于方法/构造函数参数或返回值执行级联验证。标记时，参数或返回值被认为是要验证的bean对象。

public class OrderService {

    @NotNull @Valid
    private CreditCardProcessor creditCardProcessor;

    @Valid
    public OrderService(@NotNull @Valid CreditCardProcessor creditCardProcessor) {
        this.creditCardProcessor = creditCardProcessor;
    }

    @NotNull @Valid
    public Order getOrderByPk(@NotNull @Valid OrderPK orderPk) { [...] }

    @NotNull
    public Set<@Valid Order> getOrdersByCustomer(@NotNull @Valid CustomerPK customerPk) { [...] }
}

下面的递归验证将在验证OrderService类的方法时发生:

• 对传递给构造函数的creditCardProcessor参数的对象的约束进行验证
• 对构造函数返回的新创建的OrderService实例的约束进行验证，即字段creditCardProcessor上的@NotNull约束和引用的creditCardProcessor实例上的约束(因为字段是用@Valid注释的)。
• 对传递给orderPk参数的对象和getOrderByPk()方法返回的Order对象的约束进行验证
• 验证传递给customerPk参数的对象上的约束，以及getOrdersByCustomer()方法返回的Set中包含的每个对象上的约束

有时我们需要在不同情况下才会对某个属性进行不同的验证，这是我们就可以采取分组验证。

如何分组？每一个约束注解都包含groups属性，可以通过指定groups属性来进行分组，如果没有明确声明组，则约束属于该Default组。

public interface Billable {
    
}

public interface BuyInOneClick {
}

public class User {
    @NotNull
    private String firstname;

    @NotNull(groups = Default.class)
    private String lastname;

    @NotNull(groups = {Billable.class, BuyInOneClick.class})
    private CreditCard defaultCreditCard;
}

在验证调用期间，将验证一个或多个组。在对象图上评估属于这组的所有约束。在将组分配给约束中，当Billable或BuyInOneClick组被验证时，将在defaultCreditCard上检查@NotNull。在验证Default组时，验证firstname和lastname上的@NotNull。提醒:父类和接口上的约束被考虑。

 
如何进行分组验证 ？

方式一：Validator的validate(T object, Class… groups)方法。

public class Driver {
  @Min(value = 18, groups = Minimal.class)
  int age;

  @AssertTrue
  Boolean passedDrivingTest;

  @Valid
  Car car;

  // setter/getters
}

public class Car {
  @NotNull
  String type;

  @AssertTrue(groups = Later.class)
  Boolean roadWorthy;

  // setter/getters
}


Validator validator = Validation.buildDefaultValidatorFactory().getValidator();
Driver driver = new Driver();
driver.setAge(16);
Car porsche = new Car();
driver.setCar(porsche);
Set> violations = validator.validate( driver, Minimal.class );

 
方式二：

使用Spring提供的@Validated注解，可以指定要验证的组

@Validated({IsMobileGroups.HUNAN.class, Default.class}
           
or
@GroupSequence(value = {IsMobileGroups.HUNAN.class,Default.class}) //有组序的概念，请查看下面解释
public interface  PhoneSequence{
    
}
@Validated({PhoneSequence.class}           

在某些情况下，一个组是一个或多个组的超集，一个组可以通过接口继承来继承一个或多个组。

public interface BuyInOneClick extends Default, Billable {
    
}

 
继承的组的验证规则：

public class User {
    @NotNull
    private String firstname;

    @NotNull(groups = Default.class)
    private String lastname;

    @NotNull(groups = Billable.class)
    private CreditCard defaultCreditCard;
}

在验证组BuyInOneClick将导致以下约束检查：

• @NotNull在firstname和lastname
• @NotNull 在 defaultCreditCard

因为Default和Billable是 的超接口BuyInOneClick，属于BuyInOneClick的一部分。

默认情况下，无论约束属于哪个组，都不会按特定顺序评估约束（比如你指定了验证组序列为：Default、Billable，但并不一定会按照这个顺序）。然而，在某些情况下控制约束评估的顺序很有用，比如：

• 第二组依赖于稳定状态才能正常运行。这种稳定状态由第一组验证。
• 第二组是时间、CPU 或内存的大量消耗者，应尽可能避免对其进行评估。

Bean Validation使用@GroupSequence来定义组序列，从左往右排序（需要特别注意的是，当标注在class类上时有所不同）。

@Target({ TYPE })
@Retention(RUNTIME)
@documented
public @interface GroupSequence {

    Class[] value();
}

规则：

1、组序列中存在多个组（例如：@GroupSequence(value = {IsMobileGroups.HUNAN.class,Default.class})），会按照顺序一组一组的评估约束，只有当一组约束评估有效时才会评估下一组约束。

 
2、定义序列的组和组成序列的组不得参与循环依赖：

• 直接或间接
• 通过级联序列定义或组继承

如果对包含此类循环的组求值，则会引发GroupDefinitionException异常。

定义序列的组不应该直接继承其他组。换句话说，承载组序列的接口不应该有任何超级接口。

 @GroupSequence(value = {IsMobileGroups.HUNAN.class,Default.class})
 public interface  PhoneSequence extends OttherInterface{
     
 }

定义序列的组不应该在约束声明中直接使用。换句话说，承载组序列的接口不应该在约束声明中使用。

 @GroupSequence(value = {IsMobileGroups.HUNAN.class,Default.class})
 public interface  PhoneSequence{ 
     
 }
public class User {
    @NotNull(group={PhoneSequence.class})
    private String firstname;
	。。。
}

 
示例：

@ZipCodeCoherenceChecker(groups = Address.HighLevelCoherence.class)
public class Address {
    @NotNull @Size(max = 50)
    private String street1;

    @NotNull @ZipCode
    private String zipCode;

    @NotNull @Size(max = 30)
    private String city;

    public interface HighLevelCoherence {}

    @GroupSequence({Default.class, HighLevelCoherence.class})
    public interface Complete {}
}

当Address.Complete组被验证时，属于该Default组的所有约束都被验证。如果其中任何一个失败，验证将跳过该HighLevelCoherence组。如果所有Default约束都通过，HighLevelCoherence则会被评估约束。

可以通过在类上标注@GroupSequence注解来重定义默认组，但这个默认组就是所标注类A的 A.class，且之前的Default.class不得在出现在该组序列中声明。

托管在类A并属于Default组（默认或显式）的约束注解的groups属性都隐式属于组A。

@GroupSequence({Address.class, HighLevelCoherence.class})
@ZipCodeCoherenceChecker(groups = Address.HighLevelCoherence.class)
public class Address {
    @NotNull @Size(max = 50)
    private String street1;

    @NotNull @ZipCode
    private String zipCode;

    @NotNull @Size(max = 30)
    private String city;
    
    public interface HighLevelCoherence {}
}

在为Address重新定义默认组中，当为Default组验证地址对象时，将评估属于Default组并承载在Address上的所有约束。如果没有失败，将评估Address上的所有HighLevelCoherence约束。换句话说，当为Address验证Default组时，将使用在Address类上定义的组序列。

bean Validation 2.0新特性之一，在执行级联验证时，可以使用与最初使用组转换特性请求的组不同的组。组转换是通过使用@ConvertGroup注释声明的。

@Target({ METHOD, FIELD, CONSTRUCTOR, PARAMETER, TYPE_USE })
@Retention(RUNTIME)
@Repeatable(List.class)
@documented
public @interface ConvertGroup {

	Class from() default Default.class;


	Class to();

	@Target({ METHOD, FIELD, CONSTRUCTOR, PARAMETER, TYPE_USE })
	@Retention(RUNTIME)
	@documented
	public @interface List {

		ConvertGroup[] value();
	}
}

 
规则：

• @ConvertGroup需要搭配@Valid使用，则会引发一个ConstraintDeclarationException。
• 当一个元素被@Valid注释时，验证将被传播。除非使用@ConvertGroup注释，否则组将原样传递给嵌套的元素。
• 如果期望传递给嵌套元素验证的组被定义为@ConvertGroup注释的from属性，那么用于有效验证嵌套元素的组就是定义在to属性中的对应组。
• 如果未指定from属性的值，则Default.class将被用作转换的源组。
• 规则不会递归执行。如果找到匹配的规则，则不再计算后续规则。特别是，如果一组@ConvertGroup声明链A到B, B到C，则A组将被转换为B，而不是C。这将使规则更清晰。
• 有多个转换规则包含相同的from值是不合法的。在这种情况下，将引发一个ConstraintDeclarationException。
• 与常规约束声明一样，from属性不能引用组序列。在这种情况下会引发ConstraintDeclarationException。to属性可以。然后在验证关联对象之前展开组序列。
• 当存在继承层次的方法约束时，同样,如果子类重写了在两个不同接口或者一个类和一个接口中一摸一样的方法，则不能为该方法的返回值声明组转换规则。这也是为了避免向调用者保证的后置条件的意外更改。（请查看 示例三）

 
示例：

简单示例：

public interface Complete extends Default {}
public interface BasicPostal {}
public interface FullPostal extends BasicPostal {}

public class Address {
    @NotNull(groups=BasicPostal.class)
    String street1;

    String street2;

    @ZipCode(groups=BasicPostal.class)
    String zipCode;

    @CodeChecker(groups=FullPostal.class)
    String doorCode;
}

public class User {
    @Valid
    @ConvertGroup(from=Default.class, to=BasicPostal.class)
    @ConvertGroup(from=Complete.class, to=FullPostal.class)
    Set
 getAddresses() { [...] }
}

当User使用Default组验证实例时，关联的地址将通过BasicPostal组进行验证。当User使用Complete组验证实例时，关联的地址将通过FullPostal组进行验证。

 
容器元素验证的组转换：

public class User {
    Set<
        @Valid
        @ConvertGroup(from=Default.class, to=BasicPostal.class)
        @ConvertGroup(from=Complete.class, to=FullPostal.class)
        Address
    > getAddresses() { [...] }
}

 
非法组转换：

public interface BasicPostal {}

public class Order { [...] }

public interface RetailOrderService {

    @Valid
    Order placeOrder(String itemNo, int quantity);
}

public interface B2BOrderService {

    @Valid
    @ConvertGroup(from=Default.class, to=BasicPostal.class)
    Order placeOrder(String itemNo, int quantity);
}

public class OrderService implements RetailOrderService, B2BOrderService {

    @Override
    public Order placeOrder(String itemNo, int quantity) {
        [...]
    }
}

@Valid为Bean Validation规范定义的注解，用于级联验证，可以标注在级联的属性、方法参数或方法返回类型上。

@Validated为Spring官方定义的，支持验证组的规范，通过value指定组，作用对象：

• SpringMvc方法参数 。

• 标注在特定类上，与方法级验证一起使用（可以指定组），当标注在特定类上时，该类中的某些标注了校验注解的方法将会被验证（作为相应验证拦截器的切入点）；注意： 不能再次将该注解标注在校验方法上，无效。

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Phone {

    private String type;

    @IsMobileWithStart(mobileStart = "134")
    private String mobile;

}
-----------------------------------------------------------
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    @NotNull
    private String name;

    @NotNull
    private Integer age;

    @Valid
    private Phone phone;
}
------------------------------------------------------------
@RequestMapping(value = "validation")
@RestController
@Validated
public class PhoneController {

    @Autowired
    private PhoneService phoneService;

    
    @GetMapping(value = "/simplevalid")
    public ResponseData simplevalid(@Validated(value = {Default.class}) User user, BindingResult resultError){
       [。。。。]
    }
}    

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Phone {

    @NotNull(groups = Groups.GROUP1.class)
    private String type;

    @IsMobileWithStart(mobileStart = "134",type = IsMobileWithStart.Type.CHINATELECOM)
    private String mobile;

}

--------------
    
@Validated(value = {Groups.GROUP1.class})
public interface PhoneService {

    void insertPhone(@Valid Phone phone);
}

@Service
public class PhoneServiceImpl implements PhoneService {
    @Override
    public void insertPhone(Phone phone) {
        if (phone != null) {
            //插入逻辑
            System.out.println("插入成功");
        } else {
            System.out.println("插入失败");

        }
    }
}

--------------
@GetMapping("/exceptionHandler")
public ResponseData ExceptonHandler(User user){
    Phone phone = user.getPhone();
    phone.setType(null);
    phoneService.insertPhone(phone);
    return ResponseData.success();
}    

 
解析：

Phone中的type字段用@NotNull注解标注，且指定了group为Groups.GROUP1，mobile字段则使用了自定义的@IsMobileWithStart标注，默认为Default组。

PhoneService接口上标注了@Validated且指定了校验组Groups.GROUP1，且对insertPhone方法的Phone属性添加了@Valid，因为这会对Phone中满足Groups.GROUP1组的校验注解标注的目标进行校验。

ontroller层的ExceptonHandler方法，接受请求，并将Phone的type属性设置为null，用于@NotNull注解的验证。

 
错误情况：

@Validated(value = {Groups.GROUP1.class})
public interface PhoneService {

    void insertPhone(@Validated Phone phone);
}

对于错误消息的获取可以在方法参数中加入BindingResult参数

@GetMapping(value = "/simplevalid")
public ResponseData simplevalid(@Validated(value = {Default.class}) User user, BindingResult resultError){
    if (resultError.hasErrors()) {
        return ResponseData
            	.error(resultError.getAllErrors()
                       .stream()
                       .map(e -> e.getDefaultMessage())
                       .collect(Collectors.joining(",")));
    }
    phoneService.insertPhone(user.getPhone());
    return ResponseData.success();
}

在一个一个的Controller方法中获取BindingResult对象，再进行相应的处理似乎有点单调且重复，那么就使用全局的异常处理来解决吧。主要是这两个异常：

BindException：对SpringMVC的参数进行校验是会出现该异常。

ValidationException：@Validated标注在特定类上，对某些方法上需要校验的Bean，出现校验失败时会出现该异常。

@RestControllerAdvice
public class ValidatorExceptionHandler {


    

    @ExceptionHandler(value = {BindException.class})
    private ResponseData handlerError(BindException bindException) {
        String errFields = bindException.getBindingResult().getFieldErrors().stream().map(e -> e.getField()).collect(Collectors.joining(","));
        String errorMsg = bindException.getAllErrors().stream().map(e ->e.getDefaultMessage()).collect(Collectors.joining(","));
        return ResponseData.error("属性 = " + errFields + ", errorMsg =  " + errorMsg).status(false);
    }


    
    @ExceptionHandler(value = {ValidationException.class})
    private ResponseData handlerError(ValidationException exception){
        return ResponseData.error("数据校验错误：" + exception.getMessage()).status(false);
    }

}

用于在不用的情况下进行不同的校验，关于分组校验，组继承、组序列、重定义默认组、以及组的转换可查看上面的介绍。
 

注意：对于自定义注解也同样适用

@Data
@NoArgsConstructor
@AllArgsConstructor
public class GroupPhone {

    @Pattern(regexp = "联通")
    private String type;

    @Max(10)
    private Integer money;

    @IsMobileWithStart(mobileStart = "134",type = IsMobileWithStart.Type.CHINATELECOM, groups = Groups.GROUP1.class)
    private String mobile;
}



@Data
@NoArgsConstructor
@AllArgsConstructor
public class GroupUser {
    @Pattern(regexp = "zc",groups = Groups.GROUP1.class)
    private String name;

    @Max(value = 12,groups = Groups.GROUP1.class)
    private Integer age;

    @Valid
    private GroupPhone phone;
}


-------------------
    
@RestController
@RequestMapping("/user")
public class GroupPhoneController {

    @GetMapping("/simpleGroup")
    public ResponseData simpleGroup(@Validated(value = {Groups.GROUP1.class}) GroupUser user){
        // 。。。
        return ResponseData.success();
    }
}    

仅仅会校验所属组为Groups.GROUP1的校验注解所标注的数据，此处为GroupUser的name、agetype，GroupPhone的mobile。

localhost:8080/user/simpleGroup?name=zc&age=12&phone.type=联&phone.money=11&phone.mobile=132
 
注意： 此处的校验过程是递归的，且会校验@Valid标注Bean下所有的校验注解标注的属性，而不是只要一个不满足就报错。

将@Validated分组校验修改为Default.class，结果如下：

{
    "success": false,
    "code": 500,
    "message": "属性 = phone.type,phone.money, errorMsg =  需要匹配正则表达式"联通",最大不能超过10",
    "data": null
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Phone {

    @Pattern(regexp = "联通")
    private String type;

    @IsMobileWithStart(mobileStart = "134",type = IsMobileWithStart.Type.CHINATELECOM,groups = Group.GROUP2.class)
    private String mobile;
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    @Pattern(regexp = "zc")
    private String name;

    @Max(value = 23,groups = Group.GROUP1.class)
    private Integer age;

    @Valid
    private Phone phone;
}
---------------------------------
@GroupSequence(value = {Group.GROUP1.class,Default.class, Group.GROUP2.class})
public interface GroupSeq{

}
--------------------------------
@RequestMapping("/set")
public ResponseData setDefaultValidation(@Validated(value = GroupSeq.class) User user){
    System.out.println(user);
    return ResponseData.success();
}

会按照GroupSeq指定的顺序依次对元素进行校验，一旦前一个不满足后续的组就不会再校验，比如：（GROUP1组校验不过，Default，GROUP2的元素就不会进行校验）。

只验证Default组时，无法验证GROUP1组、GROUP2组，为了确保完整的验证，用户必须在@Validated中使用该GroupSeq组，这破坏了可以预期的一些封装。可以通过重新定义Default组对给定类的含义来解决此问题。
 
示例一：

@Data
@NoArgsConstructor
@AllArgsConstructor
@GroupSequence(value = {Group.GROUP2.class,Phone.class})
public class Phone {

    @Pattern(regexp = "联通")
    private String type;

    @IsMobileWithStart(mobileStart = "134",type = IsMobileWithStart.Type.CHINATELECOM,groups = Group.GROUP2.class)
    private String mobile;
}

@Data
@NoArgsConstructor
@AllArgsConstructor
@GroupSequence(value = {Group.GROUP1.class,User.class})
public class User {
    @Pattern(regexp = "zc")
    private String name;

    @Max(value = 23,groups = Group.GROUP1.class)
    private Integer age;

    @Valid
    private Phone phone;
}
------------------------------------
@RequestMapping("/set")
public ResponseData setDefaultValidation(@Validated User user){
    System.out.println(user);
    return ResponseData.success();
}

localhost:8081/user/set?name=z&age=24&phone.type=联&phone.money=11&phone.mobile=132

{
    "success": false,
    "code": 500,
    "message": "属性 = phone.mobile,age, errorMsg =  132不是以134开头-中国电信,最大不能超过23",
    "data": null
}

User -> 校验age失败

Phone -> mobile校验失败

 
示例二：

@GroupSequence({ Minimal.class, Driver.class })
public class Driver {
  @Min(value = 18, groups = Minimal.class)
  int age;

  @AssertTrue
  Boolean passedDrivingTest;

  @Valid
  Car car;

  // setter/getters
}

@GroupSequence({ Car.class, Later.class })
public class Car {
  @NotNull
  String type;

  @AssertTrue(groups = Later.class)
  Boolean roadWorthy;

  // setter/getters
}

--------------------------
@GroupSequence({ Minimal.class, Later.class })
public interface SequencedGroups {
}

Validator validator = Validation.buildDefaultValidatorFactory().getValidator();

Driver driver = new Driver();
driver.setAge(16);
Car porsche = new Car();
driver.setCar(porsche);


Set> violations = validator.validate( driver );

assert violations.size() == 2;

violations = validator.validate( driver, SequencedGroups.class );

assert violations.size() == 1;

未指定SequencedGroups时：

两个错误：Driver的age、Car的type

指定SequencedGroups时：

一个错误：Driver的age，属于Later组的约束直到所有属于Minimal组的约束都得到验证才会进行验证。

此处针对校验注解进行国际化，且会重定义约束消息，以及自定义属性，如下：

Bean Validation 校验器注解的元注解 - @javax.validation.Constraint

作用：

• 标注在目标校验注解上，并指定Bean Validation 校验器的实现。

Bean Validation 校验器 - ConstraintValidator接口

作用：

• 实现该接口，定义Bean Validation 校验器校验逻辑，包含需要指定两个泛型：第一个为注解类型，第二个为处理参数类型

方法：

• 初始化方法 - #initialize 通过注解方法获取相关的元信息

• 校验方法 - #isValid 通过对象传入，并且控制 ConstraintValidatorContext

@Target({TYPE,ANNOTATION_TYPE,FIELD,CONSTRUCTOR,PARAMETER,METHOD})
@Retention(RUNTIME)
@Constraint(validatedBy = {IsMobilevalidator.class})
@Repeatable(IsMobileWithStart.List.class)
public @interface IsMobileWithStart {

    String message() default "{mobile.mobileIsNotStart}";

    Class[] groups() default {};

    Class[] payload() default {};

    Type type() default Type.CHINAMOBILE;

    String mobileStart();


    @Target({TYPE,ANNOTATION_TYPE,FIELD,CONSTRUCTOR,PARAMETER,METHOD})
    @Retention(RUNTIME)
    public @interface List{
        IsMobileWithStart[] value();
    }


    enum  Type{

        CHINAMOBILE("中国移动"),
        CHINATELECOM("中国电信"),
        CHINAUNICOM("中国联通");

        
        private String cnName;

        Type(String cnName){
            this.cnName = cnName;
        }

        public String getCnName(){
            return cnName;
        }
    }
}

public class IsMobilevalidator implements ConstraintValidator {
    private String mobileStart;
    private IsMobileWithStart.Type type;

    private String mobileIsEmpty = "";
    private String mobileIsNotStart = "";

    @Override
    public void initialize(IsMobileWithStart constraintAnnotation) {
       this.mobileStart = constraintAnnotation.mobileStart();
       this.type = constraintAnnotation.type();
    }

    @Override
    public boolean isValid(String s, ConstraintValidatorContext constraintValidatorContext) {
        // 自定义属性值，可以通过{typeStr}获取
        HibernateConstraintValidatorContext unwrap = 		constraintValidatorContext.unwrap(HibernateConstraintValidatorContext.class);
        unwrap.addMessageParameter("typeStr",type.getCnName());
		
        //重定义约束消息
        constraintValidatorContext.disableDefaultConstraintViolation();
        // 此处之所以这样是在重定义约束消息后，无法通过${validatedValue}取到要验证的值，当然也可以通过自定义属性来取
        mobileIsEmpty = s + "{mobile.mobileIsEmpty}";
        mobileIsNotStart = s + "{mobile.mobileIsNotStart}";
        if (s == null || "".equals(s)) {
            constraintValidatorContext
                    .buildConstraintViolationWithTemplate(mobileIsEmpty)
                    .addConstraintViolation();
            return false;
        }
        if(!s.startsWith(mobileStart)){
            constraintValidatorContext
                    .buildConstraintViolationWithTemplate(mobileIsNotStart)
                    .addConstraintViolation();
            return false;
        }

        return true;
    }

}

此处介绍默认情况下的国际化，要求：只需要国际化文件名称必须为ValidationMessages即可

mobile.mobileIsEmpty=mobile is NULL
mobile.mobileIsNotStart=don't start with {mobileStart} - {typeStr}

mobile.mobileIsEmpty=电话号码为空
mobile.mobileIsNotStart=不是以{mobileStart}开头-{typeStr}

注意：可以通过${validatedValue}取到要校验的值，但如果发生了重定义约束消息后就无法取到。

此处介绍通过配置MessageResolver与LocaleResolver来自定义的国际化，并不需要国际化文件名必须为 ValidationMessages。

LocaleResolver： 解析Request中的语言标志参数或者head中的Accept-Language参数， 并将解析后的参数保存到指定的LocaleContextHolder域中。

SpringMVC默认提供了四种实现了接口的类：cookieLocaleResolver, AcceptHeaderLocalResolver,FixdLocaleResolver,SessionLocaleResolver。

 
MessageResolver：国际化消息处理的顶层接口，存在两个实现类：ResourceBundleMessageResolver、PropertiesMessageResolver，当然你也可以实现AbstractMessageResolver来自定义MessageResolver
 
MessageSource：以用于支持信息的国际化和包含参数的信息的替换。

主要流程是通过配置springboot的LocaleResolver解析器，当请求打到springboot的时候对请求的所需要的语言进解析，并保存在LocaleContextHolder中。

MessageResolver解析器从MessageSource中获取到key对应的message，而locale值是从LocaleContextHolder获取的。

 
1、定义LocaleResolver，并注册bean

@Configuration
public class LocaleResolverConfig {

    @Bean
    public LocaleResolver localeResolver() {
        AcceptHeaderLocaleResolver acceptHeaderLocaleResolver = new AcceptHeaderLocaleResolver();
        acceptHeaderLocaleResolver.setDefaultLocale(Locale.SIMPLIFIED_CHINESE);
        return  acceptHeaderLocaleResolver;
    }
}

 
2、定义 MessageResolver

@RequiredArgsConstructor
public class MessageResolverConfig extends AbstractMessageResolver {

    private final MessageSource messageSource;

    @Override
    protected String getMessage(String key) {
        return messageSource.getMessage(key,null, LocaleContextHolder.getLocale());
    }
}

 
3、将自定义的MessageResolver注册为bean

@RequiredArgsConstructor
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {

    private final MessageSource messageSource;


    
    @Bean
    public MessageResolver messageResolver() {
        return new MessageResolverConfig(messageSource);
    }

    
    @Bean
    @Override
    public LocalValidatorFactoryBean getValidator() {
        LocalValidatorFactoryBean bean = new LocalValidatorFactoryBean();
        bean.setValidationMessageSource(messageSource);
        return bean;
    }
}

 
4、配置国际化文件的位置

spring.messages.basename=message # 多个文件用逗号分隔，使用/表示层级