播放地址

13、解读Hibernate-Validator官方文档- 方法参数校验API http://v.youku.com/v_show/id_XMzk1Njg2Njg5Mg==.html

3. 声明和验证方法约束（Declaring and validating method constraints）

As of Bean Validation 1.1，约束不仅可以应用于JavaBeans及其属性，还可以应用于任何Java类型的方法和构造函数的参数和返回值。这样可以使用bean验证约束来指定

调用方法或构造函数之前调用方必须满足的先决条件（通过对可一次方法执行的参数应用约束）
在方法或构造函数调用返回之后向调用方保证的后置条件（通过对可对一次方法执行的返回值应用约束）

对于本参考指南的目的，术语方法约束指的是方法和构造函数约束（如果没有另外说明）。有时，在引用方法和构造函数时使用术语“可执行”。(For the purpose of this reference guide, the term method constraint refers to both, method and constructor constraints, if not stated otherwise. Occasionally, the term executable is used when referring to methods and constructors.)

与传统的检查参数和返回值的正确性的方法相比，这种方法有几个优点：

检查不必手动执行（e.g. by throwing IllegalArgumentException or similar），从而减少了编写和维护的代码
方法执行的前置和后置条件不必在其文档中再次表达，因为约束注释将自动包括在生成的JavaDoc中。这避免了冗余，并减少了实现和文档之间不一致的可能性。

NOTE: 为了使注释显示在带注释元素的JavaDoc中，注释类型本身必须用元注释@Documented进行注释。这是所有内置约束的情况，并且被认为是任何自定义约束的最佳实践。

在本章的剩余部分中，您将学习如何声明参数和返回值约束，以及如何使用ExecutableValidator API验证它们。

3.1. Declaring method constraints

3.1.1. Parameter constraints(参数约束)

您可以通过向其参数添加约束注释来指定方法或构造函数的先决条件，如示例3.1“声明方法和构造函数参数约束”中所示。
Example 3.1: Declaring method and constructor parameter constraints

package org.hibernate.validator.referenceguide.chapter03.parameter;public class RentalStation {public RentalStation(@NotNull String name) {//...}public void rentCar(@NotNull Customer customer,@NotNull @Future Date startDate,@Min(1) int durationInDays) {//...}
}

这里声明如下先决条件：

The name passed to the RentalCar constructor must not be null
When invoking the rentCar() method, the given customer must not be null, the rental’s start date must not be null as well as be in the future and finally the rental duration must be at least one day

注意，声明方法或构造函数约束本身不会在调用可执行文件时自动导致它们的验证。相反，必须使用ExecutableValidator API（参见3.2节，“验证方法约束”）来执行验证，这通常使用方法拦截工具（如AOP、代理对象等）完成。

约束只能应用于实例方法，即不支持对静态方法声明约束。根据用于触发方法验证的拦截工具，可能应用其他限制，例如，关于作为拦截目标支持的方法的可见性。查阅拦截技术的文档，了解是否存在此类限制。

3.1.1.1 Cross-parameter constraints 交叉参数约束

有时，验证不仅依赖于单个参数，还依赖于方法或构造函数的几个甚至所有参数。在交叉参数约束的帮助下，可以满足这种要求。

交叉参数约束可以被认为是等价于类级约束的方法验证。两者都可以用来实现基于多个元素的验证要求。当类级约束应用于bean的几个属性时，交叉参数约束应用于可执行文件的多个参数。(Cross-parameter constraints can be considered as the method validation equivalent to class-level constraints. Both can be used to implement validation requirements which are based on several elements. While class-level constraints apply to several properties of a bean, cross-parameter constraints apply to several parameters of an executable)

与单参数约束不同，交叉参数约束在方法或构造函数上声明，如示例3.2“声明交叉参数约束”所示。这里，在load()方法上声明的交叉参数约束@LuggageCountMatchesPassengerCount用于确保没有乘客拥有超过两件行李。

Example 3.2: Declaring a cross-parameter constraint

package org.hibernate.validator.referenceguide.chapter03.crossparameter;public class Car {@LuggageCountMatchesPassengerCount(piecesOfLuggagePerPassenger = 2)public void load(List<Person> passengers, List<PieceOfLuggage> luggage) {//...}
}

正如您将在下一节中了解到的，返回值约束也在方法级别声明。为了区分交叉参数约束和返回值约束，在ConstraintValidator实现中使用@SupportedValidationTarget注解配置约束目标。您可以在第6.3节“交叉参数约束”中找到详细信息，该节展示了如何实现自己的交叉参数约束。

在某些情况下，约束可以应用于可执行方法的参数（即，它是交叉参数约束），也可以应用于返回值。一个例子是自定义约束或者是脚本语言指定验证规则。（One example for this are custom constraints which allow to specify validation rules using expression or script languages.）

此类约束必须定义成员validationAppliesTo()，成员validationAppliesTo()可以在声明时用于指定约束目标。如示例3.3所示，“指定约束的目标”通过指定validationAppliesTo=ConstraintTarget.PARAMETERS将约束应用于可执行文件的参数，而ConstraintTarget.RETURN_VALUE用于将约束应用于可执行文件的返回值。
Example 3.3: Specifying a constraint’s target

package org.hibernate.validator.referenceguide.chapter03.crossparameter.constrainttarget;public class Garage {@ELAssert(expression = "...", validationAppliesTo = ConstraintTarget.PARAMETERS)public Car buildCar(List<Part> parts) {//...return null;}@ELAssert(expression = "...", validationAppliesTo = ConstraintTarget.RETURN_VALUE)public Car paintCar(int color) {//...return null;}
}

尽管这种约束适用于方法的参数和返回值，但是通常可以自动推断目标。如果声明了约束，情况就是这样。

带参数的空洞方法（约束适用于参数）
具有返回值但没有参数（可应用于返回值的约束）的方法
既不是方法，也不是构造函数，而是字段、参数等（约束应用于带注释的元素）

在这些情况下，您不必指定约束目标。如果它增加了源代码的可读性，仍然建议这样做。如果不能在不能自动确定约束目标的情况下指定约束目标，则引发ConstraintDeclarationException。

3.1.2. Return value constraints

方法或构造函数的后置条件是通过向方法中添加约束注释来声明的，如示例3.4所示，“声明方法和构造函数返回值约束”。
Example 3.4: Declaring method and constructor return value constraints

package org.hibernate.validator.referenceguide.chapter03.returnvalue;public class RentalStation {@ValidRentalStationpublic RentalStation() {//...}@NotNull@Size(min = 1)public List<@NotNull Customer> getCustomers() {//...return null;}
}

下面的约束适用于RealalStand的方法或者构造：

任何新创建的RealalStand对象都必须满足@ ValueRealTalStand约束
The customer list returned by getCustomers() must not be null and must contain at least on element
The customer list returned by getCustomers() must no contain null objects

NOTE: 如上例所示，在方法返回值上支持容器元素约束。它们还支持方法参数

3.1.3. 级联验证 Cascaded validation

类似于JavaBeans属性的级联验证（参见第2.1.6节，“对象图”），可以使用@Valid注释标记可执行参数和级联验证的返回值。当验证@Valid注释的参数或返回值时，对参数或返回值对象声明的约束也会进行验证。（Similar to the cascaded validation of JavaBeans properties (see Section 2.1.6, “Object graphs”), the @Valid annotation can be used to mark executable parameters and return values for cascaded validation. When validating a parameter or return value annotated with @Valid, the constraints declared on the parameter or return value object are validated as well.）

在示例3.5“为级联验证标记可执行参数和返回值”，Garage#checkCar()方法的car参数以及Garage构造函数的返回值被标记为级联验证。

Example 3.5: Marking executable parameters and return values for cascaded validation

package org.hibernate.validator.referenceguide.chapter03.cascaded;public class Garage {@NotNullprivate String name;@Validpublic Garage(String name) {this.name = name;}public boolean checkCar(@Valid @NotNull Car car) {//...return false;}
}

package org.hibernate.validator.referenceguide.chapter03.cascaded;public class Car {@NotNullprivate String manufacturer;@NotNull@Size(min = 2, max = 14)private String licensePlate;public Car(String manufacturer, String licencePlate) {this.manufacturer = manufacturer;this.licensePlate = licencePlate;}//getters and setters ...
}

在验证checkCar()方法的参数时，还对传递的Car对象的属性进行约束。类似地，在验证Garage构造函数的返回值时，检查Garage名称字段上的@NotNull约束。

通常，级联验证对可执行文件的工作方式与JavaBeans属性完全相同。（Generally, the cascaded validation works for executables in exactly the same way as it does for JavaBeans properties.）

特别地，在级联验证期间忽略空值（这在构造函数返回值验证期间自然不会发生），并且递归地执行级联验证，即，如果标记为级联验证的参数或返回值对象本身具有属性marKED与@Valid，在引用元素上声明的约束也将被验证。（In particular, null values are ignored during cascaded validation (naturally this can’t happen during constructor return value validation) and cascaded validation is performed recursively, i.e. if a parameter or return value object which is marked for cascaded validation itself has properties marked with @Valid, the constraints declared on the referenced elements will be validated as well.）

与字段和属性一样，级联验证也可以在返回值和参数的容器元素（例如，集合、映射或自定义容器的元素）上声明。

在这种情况下，容器所包含的每个元素都得到验证。因此，当验证示例3.6中的checkCars()方法的参数“标记为级联验证的方法参数的Container元素”时，传递列表的每个元素实例都将被验证，并且当任何包含的Car实例无效时创建ConstraintViolation。

Example 3.6: Container elements of method parameter marked for cascaded validation

package org.hibernate.validator.referenceguide.chapter03.cascaded.containerelement;public class Garage {public boolean checkCars(@NotNull List<@Valid Car> cars) {//...return false;}
}

3.1.4. (继承层次中的方法约束)Method constraints in inheritance hierarchie

当在继承层次结构中声明方法约束时，需要注意以下规则：

一个方法的调用者要满足的先决条件不能在子类型中得到加强。（The preconditions to be satisfied by the caller of a method may not be strengthened in subtypes）
方法调用方保证的后置条件不会在子类型中被削弱。
这些规则是由行为子类型的概念驱动的，该概念要求无论在哪里使用类型T，都可以在不改变程序行为的情况下使用T的子类型S。

举个例子，考虑一个调用静态类型为T的对象上的方法的类。如果该对象的运行时类型是S，并且S强加了额外的先决条件，那么客户机类可能不能满足这些先决条件，因为它们不知道这些先决条件。行为子类型的规则也被称为Liskov substitution principle.

Bean验证规范通过禁止对覆盖或实现在超类型（超类或接口）中声明的方法的参数约束来实现第一条规则。示例3.7，“子类型中的非法方法参数约束”显示违反此规则。

Example 3.7: Illegal method parameter constraint in subtype

package org.hibernate.validator.referenceguide.chapter03.inheritance.parameter;public interface Vehicle {void drive(@Max(75) int speedInMph);
}

package org.hibernate.validator.referenceguide.chapter03.inheritance.parameter;public class Car implements Vehicle {@Overridepublic void drive(@Max(55) int speedInMph) {//...}
}

Car#drive()上的@Max约束是非法的，因为这个方法实现了接口方法Vehicle#drive(). 。注意，如果超类型方法本身没有声明任何参数约束，则也不允许对重写方法进行参数约束。

此外，如果一个方法重写或实现在几个并行超类型中声明的方法（例如，两个不互相扩展的接口或一个类和一个不由该类实现的接口），那么可以在任何涉及的类型中为该方法指定参数约束。示例3.8“层次结构的并行类型中的非法方法参数约束”中的类型演示了违反该规则的情况。. The method RacingCar#drive() overrides Vehicle#drive() as well as Car#drive(). Therefore the constraint on Vehicle#drive() is illegal.

Example 3.8: Illegal method parameter constraint in parallel types of a hierarchy

package org.hibernate.validator.referenceguide.chapter03.inheritance.parallel;public interface Vehicle {void drive(@Max(75) int speedInMph);
}

package org.hibernate.validator.referenceguide.chapter03.inheritance.parallel;public interface Car {void drive(int speedInMph);
}

package org.hibernate.validator.referenceguide.chapter03.inheritance.parallel;public class RacingCar implements Car, Vehicle {@Overridepublic void drive(int speedInMph) {//...}
}

前面描述的限制仅适用于参数约束。相反，可以在方法覆盖或实现任何超类型方法中添加返回值约束。

在这种情况下，所有方法的返回值约束都适用于子类型方法，即在子类型方法本身上声明的约束以及重写/实现的超类型方法的任何返回值约束。这是合法的，因为将额外的返回值约束放在适当的位置可能永远不会表示向方法的调用者保证的后置条件的弱化。(In this case, all the method’s return value constraints apply for the subtype method, i.e. the constraints declared on the subtype method itself as well as any return value constraints on overridden/implemented supertype methods. This is legal as putting additional return value constraints in place may never represent a weakening of the postconditions guaranteed to the caller of a method.)

因此，当验证示例3.9中所示的方法Car#getPassengers()的返回值时，“对超类型和子类型方法的返回值约束”，对方法本身的@Size约束以及对实现的接口方法Vehicle#getPassengers()的@NotNull约束。
Example 3.9: Return value constraints on supertype and subtype method

package org.hibernate.validator.referenceguide.chapter03.inheritance.returnvalue;public interface Vehicle {@NotNullList<Person> getPassengers();
}

package org.hibernate.validator.referenceguide.chapter03.inheritance.returnvalue;public class Car implements Vehicle {@Override@Size(min = 1)public List<Person> getPassengers() {//...return null;}
}

如果验证引擎检测到违反了上述任何规则，将引发ConstraintDeclarationException。

NOTE :本节中描述的规则仅适用于方法，而不适用于构造函数。根据定义，构造函数从不重写超类型构造函数。因此，在验证构造函数调用的参数或返回值时，只应用构造函数本身声明的约束，而不应用超类型构造函数上声明的任何约束。

通过在创建Validator实例之前设置HibernateValidatorConfiguration的ModValidationConfiguration属性中包含的配置参数，可以放松这些规则的执行。请参见第12.3节，“在类层次结构中方法验证要求的放宽”。(Enforcement of these rules may be relaxed by setting the configuration parameters contained in the MethodValidationConfiguration property of the HibernateValidatorConfiguration before creating the Validator instance. See also Section 12.3, “Relaxation of requirements for method validation in class hierarchies”.)

3.2. Validating method constraints

方法约束的验证是使用ExecutableValidator接口完成的。

与直接从应用程序代码中调用ExecutableValidator方法不同，它们通常通过方法拦截技术（如AOP、代理对象等）调用。这导致可执行约束在方法或构造函数调用时自动且透明地进行验证。阳离子。通常，在违反任何约束的情况下，集成层将引发ConstraintViolationException。

3.2.1. Obtaining an ExecutableValidator instance

Example 3.10: Obtaining an ExecutableValidator instance

ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
executableValidator = factory.getValidator().forExecutables();

在这个示例中，可执行验证器是从缺省验证器工厂检索的，但如果需要，您还可以引导特定配置的工厂，如第9章“Bootstrapping”所述，(see Section 9.2.4, “ParameterNameProvider”).

3.2.2. ExecutableValidator methods

The ExecutableValidator interface 一共提供了四个方法：

validateParameters() and validateReturnValue() for method validation
validateConstructorParameters() and validateConstructorReturnValue() for constructor validation

正如Validator上的方法一样，所有这些方法都返回一个Set，它包含每个违反的约束的ConstraintViolation实例，如果验证成功，则该实例为空。此外，所有方法都有一个var-args groups参数，通过这个参数，您可以传递要考虑进行验证的验证组。（Just as the methods on Validator, all these methods return a Set which contains a ConstraintViolation instance for each violated constraint and which is empty if the validation succeeds. Also all the methods have a var-args groups parameter by which you can pass the validation groups to be considered for validation.）

Example 3.11: Class Car with constrained methods and constructors

package org.hibernate.validator.referenceguide.chapter03.validation;public class Car {public Car(@NotNull String manufacturer) {//...}@ValidRacingCarpublic Car(String manufacturer, String team) {//...}public void drive(@Max(75) int speedInMph) {//...}@Size(min = 1)public List<Passenger> getPassengers() {//...return Collections.emptyList();}
}

3.2.2.1. ExecutableValidator#validateParameters()

Example 3.12: Using ExecutableValidator#validateParameters()

Car object = new Car( "Morris" );
Method method = Car.class.getMethod( "drive", int.class );
Object[] parameterValues = { 80 };
Set<ConstraintViolation<Car>> violations = executableValidator.validateParameters(object,method,parameterValues
);assertEquals( 1, violations.size() );
Class<? extends Annotation> constraintType = violations.iterator().next().getConstraintDescriptor().getAnnotation().annotationType();
assertEquals( Max.class, constraintType );

注意，validateParameters()验证方法的所有参数约束，即对单个参数的约束以及交叉参数约束。

3.2.2.2. ExecutableValidator#validateReturnValue()

Example 3.13: Using ExecutableValidator#validateReturnValue()

Car object = new Car( "Morris" );
Method method = Car.class.getMethod( "getPassengers" );
Object returnValue = Collections.<Passenger>emptyList();
Set<ConstraintViolation<Car>> violations = executableValidator.validateReturnValue(object,method,returnValue
);assertEquals( 1, violations.size() );
Class<? extends Annotation> constraintType = violations.iterator().next().getConstraintDescriptor().getAnnotation().annotationType();
assertEquals( Size.class, constraintType );

3.2.2.3. ExecutableValidator#validateConstructorParameters()

Constructor<Car> constructor = Car.class.getConstructor( String.class );
Object[] parameterValues = { null };
Set<ConstraintViolation<Car>> violations = executableValidator.validateConstructorParameters(constructor,parameterValues
);assertEquals( 1, violations.size() );
Class<? extends Annotation> constraintType = violations.iterator().next().getConstraintDescriptor().getAnnotation().annotationType();
assertEquals( NotNull.class, constraintType );

3.2.2.4. ExecutableValidator#validateConstructorReturnValue()

Example 3.15: Using ExecutableValidator#validateConstructorReturnValue()

//constructor for creating racing cars
Constructor<Car> constructor = Car.class.getConstructor( String.class, String.class );
Car createdObject = new Car( "Morris", null );
Set<ConstraintViolation<Car>> violations = executableValidator.validateConstructorReturnValue(constructor,createdObject
);assertEquals( 1, violations.size() );
Class<? extends Annotation> constraintType = violations.iterator().next().getConstraintDescriptor().getAnnotation().annotationType();
assertEquals( ValidRacingCar.class, constraintType );

3.2.3 ConstraintViolation methods for method validation方法验证的约束违反方法

除了第2.2.3节“ConstraintViolation”中介绍的方法之外，ConstraintViolation还提供了另外两种专门用于验证可执行参数和返回值的方法。

constraintViolation#getExecutableParameters()在方法或构造函数参数验证的情况下返回已验证的参数数组，而ConstraintViolation#getExecutableReturnValue()在返回值验证的情况下提供对已验证对象的访问。

所有其他ConstraintViolation方法通常以与bean验证相同的方式用于方法验证。请参考JavaDoc，以了解在bean和方法验证期间各个方法的行为及其返回值的更多信息。

注意，getPropertyPath()对于获得关于已验证参数或返回值的详细信息（例如，用于日志记录）非常有用。特别是，您可以从路径节点检索有关方法的名称和参数类型以及有关参数的索引。如何做到这一点在示例3.16中显示，“检索方法和参数信息”。
Example 3.16: Retrieving method and parameter information

Car object = new Car( "Morris" );
Method method = Car.class.getMethod( "drive", int.class );
Object[] parameterValues = { 80 };
Set<ConstraintViolation<Car>> violations = executableValidator.validateParameters(object,method,parameterValues
);assertEquals( 1, violations.size() );
Iterator<Node> propertyPath = violations.iterator().next().getPropertyPath().iterator();MethodNode methodNode = propertyPath.next().as( MethodNode.class );
assertEquals( "drive", methodNode.getName() );
assertEquals( Arrays.<Class<?>>asList( int.class ), methodNode.getParameterTypes() );ParameterNode parameterNode = propertyPath.next().as( ParameterNode.class );
assertEquals( "speedInMph", parameterNode.getName() );
assertEquals( 0, parameterNode.getParameterIndex() );

使用当前ParameterNameProvider确定参数名称（参见9.2.4节，“ParameterNameProvider”）。

3.3.(内建方法约束) Built-in method constraints

其他的实现Bean 2.0 可能没有这个注解哦！
除了在第2.3节“内置约束”中讨论的内置bean和属性级约束之外，Hibernate Validator当前还提供了一个方法级约束@ParameterScriptAssert。这是一个通用的交叉参数约束，它允许使用任何JSR 223兼容（“JavaTM平台脚本”）脚本语言实现验证例程，只要这种语言的引擎在类路径上可用。

要从表达式中引用可执行文件的参数，使用从活动参数名称提供程序获得的参数（参见9.2.4节，“ParameterNameProvider”）。示例3.17，“使用@ParameterScriptAssert”显示了示例3.2“声明跨参数约束”中的@LuggageCountMatchesPassengerCount约束的验证逻辑如何在@ParameterScriptAssert的帮助下表达。

package org.hibernate.validator.referenceguide.chapter03.parameterscriptassert;public class Car {@ParameterScriptAssert(lang = "javascript", script = "luggage.size() <= passengers.size() * 2")public void load(List<Person> passengers, List<PieceOfLuggage> luggage) {//...}
}

Hibernate Validator 6.0.13 声明和验证方法约束（Declaring and validating method constraints）相关推荐

【图片去重工具】【Duplicate Cleaner】Duplicate Cleaner Pro_5.0.13 下载链接使用方法
一大堆文件,如何去重? 你可以选择Duplicate Cleaner Pro: 链接:https://pan.baidu.com/s/1Xsd7J95Sd7PqtSLS-KOIzA 提取码:nhna ...
Spring Validation（使用Hibernate Validator）
1.需要的jar包 hibernate-validator.5.1.3.Final.jar validation-api.1.1.0.Final.jar 2.springsevlet-config.x ...
springboot使用hibernate validator校验
回到顶部一.参数校验在开发中经常需要写一些字段校验的代码,比如字段非空,字段长度限制,邮箱格式验证等等,写这些与业务逻辑关系不大的代码个人感觉有两个麻烦: 验证代码繁琐,重复劳动方法内代码显得冗 ...
Hibernate Validator用法
2019独角兽企业重金招聘Python工程师标准>>> 一.Hibernate ValiDator介绍 Bean Validation是JSR303的定义,Hibernate Val ...
hibernate.validator验证参数
前言在接口开发中,经常是需要对传入参数完整性进行验证的,或者对手机号格式进行验证等,而一般不了解@Valid注解之前,都是通过自己封装方法来验证,都是一堆if else集合,这样判断对于代码结构很不 ...
Springmvc的服务端数据验证-----Hibernate Validator
导入Hibernate validator的Jar包 hibernate-validator-4.3.0.Final.jar jboss-logging-3.1.0.CR2.jar validatio ...
SpringMVC集成Hibernate Validator进行注解式的参数校验——让代码更少、更加专注于业务逻辑
SpringMVC集成Hibernate Validator进行注解式的参数校验 --让代码更少.更加专注于业务逻辑 1 问题背景: 参数验证是一个常见的问题,例如验证用户输入的密码是否为空.邮箱是否 ...
Spring Boot集成Hibernate Validator
废话不多说,直接开始集成环境. 一.环境集成在项目中hibernate-Validator包在spring-boot-starter-web包里面有,不需要重复引用 .(整个Demo都是用PostM ...
Springboot2参数校验： Hibernate Validator自定义注解
1.Hibernate Validator介绍 Hibernate Validator 提供了 JSR 303 规范中所有内置 constraint 的实现,除此之外还有一些附加的 constrain ...

Hibernate Validator 6.0.13 声明和验证方法约束（Declaring and validating method constraints）