hibernate Validator 6.X 的学习，bean的约束（字段，get方法上的验证）

一：背景说明

 　　验证数据是一个常见的任务，它贯穿于所有应用层，从呈现到持久层。通常在每个层中都执行相同的验证逻辑，耗时且容易出错。为了避免这些验证的重复，开发商往往把验证逻辑直接进入的领域模型，在领域类的验证码，这真是对类本身的元数据。

　　只需要一个domain进行添加注解，然后在想要使用数据的层使用验证即可。

　　

　　

二：Bean的注解说明

1.说明

　　在Bean验证约束是通过java注释表示。在本节中，您将学习如何使用这些注释增强对象模型。有四种类型的bean约束：

  • field constraints：在使用字段级约束时，字段访问策略用于访问要验证的值。这意味着验证引擎直接访问实例变量和不调用属性访问器方法，即使这样一个访问器的存在。

    • 注意点虽然支持private或者public，是不支持static的字段

  • property constraints：如果你的模型类遵循JavaBeans规范，也可以放在领域类的属性上标注，就是get方法上

    • 注意点，不包括set方法

  • container element constraints：容器元素的约束

  • class constraints：类约束

附件一：bean约束

　　适用于field/property的约束

　　@AssertFalse

　　被注释的元素必须为 false

　　@AssertTrue

　　被注释的元素必须为 true

　　@DecimalMax(value=, inclusive=)

　　当包含inclusive= false时，检查带注释的值是否小于指定的最大值。否则值是否小于或等于指定的最大值。

　　参数值是根据BigDecimal的字符串表示的最大值的字符串表示形式。

　　@DecimalMin(value=, inclusive=)

　　当包含inclusive= false时，检查带注释的值是否大于指定的最小值。

　　否则值是否大于或等于指定的最小值。

　　参数值是根据BigDecimal字符串表示的值的字符串表示形式。

　　@Digits(integer=, fraction=)

　　检查带注释的值是否是具有整数位数和小数位数的数字

　　@Email

　　被注释的元素必须是电子邮箱地址

　　@Future

　　被注释的元素必须是一个将来的日期

　　@FutureOrPresent

　　被注释的元素必须是一个将来的日期或者现在

　　@Max(value=)

　　被注释的元素必须是一个数字，其值必须小于等于指定的最大值

　　@Min(value=)

　　被注释的元素必须是一个数字，其值必须大于等于指定的最小值

　　@NotBlank

　　被注释的字符串的必须非空，同时，长度大于0

　　@NotEmpty

　　被注释的字符串的必须非空，非null

　　@NotNull

　　被注释的字符串的必须非空

　　@Negative

　　检查元素是否严格负。零值被认为是无效的。

　　@NegativeOrZero

　　注释的检查元素是负或者零值。

　　@Null

　　注释的元素必须是null

　　@Past

　　注释的元素时间必须是过去的时间

　　@PastOrPresent

　　注释的元素时间必须是过去或者当前

　　@Pattern(regex=, flags=)

　　被注释的元素必须符合指定的正则表达式

　　@Positive

　　被注释的元素必须是严格的正值，不包括零值

　　@PositiveOrZero

　　被注释的元素是正值或者零

　　@Size(min=, max=)

　　被注释的元素的大小必须在指定的范围内，包含最大值

 

附件二：附加的约束

　　除了由Bean验证API定义的约束，Hibernate Validator提供一些有用的自定义约束条件如下。适用于field/property的约束，只有“scriptassert是class级约束。

　　@CreditCardNumber(ignoreNonDigitCharacters=)

　　这个验证旨在检查用户的错误，而不是信用卡的有效性

　　@Currency(value=)

　　验证货币单位

　　@EAN

　　检查注释字符序列是一个有效的EAN条码

　　@Length(min=, max=)

　　被注释的字符串的大小必须在指定的范围内

　　@Range(min=, max=)

　　被注释的元素必须在合适的范围内

　　@SafeHtml(whitelistType= , additionalTags=, additionalTagsWithAttributes=, baseURI=)

　　classpath中要有jsoup包

　　@URL(protocol=, host=, port=, regexp=, flags=)

　　被注释的字符串必须是一个有效的url

　　@ScriptAssert(lang=, script=, alias=, reportOn=)

　　要有Java Scripting API

 

三：案例一（field的验证）

 1.pom

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <project xmlns="http://maven.apache.org/POM/4.0.0"
 3          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 5     <modelVersion>4.0.0</modelVersion>
 6 
 7     <groupId>com.caojun.it</groupId>
 8     <artifactId>hibernateValidator</artifactId>
 9     <version>1.0-SNAPSHOT</version>
10 
11     <!--hibernate validator-->
12     <dependencies>
13         <dependency>
14             <groupId>org.hibernate.validator</groupId>
15             <artifactId>hibernate-validator</artifactId>
16             <version>6.0.5.Final</version>
17         </dependency>
18         <dependency>
19             <groupId>org.glassfish</groupId>
20             <artifactId>javax.el</artifactId>
21             <version>3.0.1-b08</version>
22         </dependency>
23         <dependency>
24             <groupId>org.hibernate.validator</groupId>
25             <artifactId>hibernate-validator-cdi</artifactId>
26             <version>6.0.5.Final</version>
27         </dependency>
28         <dependency>
29             <groupId>junit</groupId>
30             <artifactId>junit</artifactId>
31             <version>4.11</version>
32         </dependency>
33     </dependencies>
34 
35 </project>

2.Car.java

 1 package org.hibernate.validator.referenceguide.chapter01;
 2 
 3 import javax.validation.constraints.Min;
 4 import javax.validation.constraints.NotNull;
 5 import javax.validation.constraints.Size;
 6 
 7 /**
 8  * 对car的约束条件：
 9  * manufacturer不为空
10  * licensePlate长度是2，14之间
11  * seatCount最小值是2
12  */
13 public class Car {
14     @NotNull
15     private String manufacturer;
16 
17     @NotNull
18     @Size(min = 2, max = 14)
19     private String licensePlate;
20 
21     @Min(2)
22     private int seatCount;
23 
24     public Car(){}
25 
26     public Car(String manufacturer, String licencePlate, int seatCount) {
27         this.manufacturer = manufacturer;
28         this.licensePlate = licencePlate;
29         this.seatCount = seatCount;
30     }
31 
32     public String getManufacturer() {
33         return manufacturer;
34     }
35 
36     public void setManufacturer(String manufacturer) {
37         this.manufacturer = manufacturer;
38     }
39 
40     public String getLicensePlate() {
41         return licensePlate;
42     }
43 
44     public void setLicensePlate(String licensePlate) {
45         this.licensePlate = licensePlate;
46     }
47 
48     public int getSeatCount() {
49         return seatCount;
50     }
51 
52     public void setSeatCount(int seatCount) {
53         this.seatCount = seatCount;
54     }
55 }

3.测试案例

 1 package org.hibernate.validator.referenceguide.chapter01;
 2 
 3 import org.junit.BeforeClass;
 4 import org.junit.Test;
 5 
 6 import javax.validation.ConstraintViolation;
 7 import javax.validation.Validation;
 8 import javax.validation.Validator;
 9 import javax.validation.ValidatorFactory;
10 import java.util.Iterator;
11 import java.util.Set;
12 
13 import static org.junit.Assert.assertEquals;
14 
15 /**
16  * 对car的测试类
17  */
18 public class CarTest {
19     private static Validator validator;
20 
21     /**
22      * 生成validator校验器
23      */
24     @BeforeClass
25     public static void setUpValidator() {
26         ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
27         validator = factory.getValidator();
28     }
29 
30     /**
31      * 验证整个Car
32      */
33     @Test
34     public void test() {
35         Car car = new Car( null, "DD-AB-123", 1);
36         //如果有不符合的在validate后，会将错误信息存放到Set中
37         Set<ConstraintViolation<Car>> constraintViolations = validator.validate( car );
38         //如果ite中没有信息，就是正确的
39         Iterator<ConstraintViolation<Car>> ite = constraintViolations.iterator();
40         while(ite.hasNext()) {
41             System.out.println(ite.next().getMessage());
42         }
43     }
44 
45     /**
46      * 单独验证Car对象中的某一个属性，例如licensePlate
47      */
48     @Test
49     public void licensePlateTooShort() {
50         Car car = new Car( "Morris", "D", 4 );
51 
52         Set<ConstraintViolation<Car>> constraintViolations = validator.validate( car );
53 
54         //这里使用junit中的断言，断言会出现一个exception
55         assertEquals( 1, constraintViolations.size() );
56 
57     }
58 
59 
60 }

四：案例二（property的验证）

1.Car.java

 1 package org.hibernate.validator.referenceguide.chapter02.propertylevel;
 2 
 3 import javax.validation.constraints.AssertTrue;
 4 import javax.validation.constraints.NotNull;
 5 
 6 public class Car {
 7     private String manufacturer;
 8 
 9     private boolean isRegistered;
10 
11     public Car(String manufacturer, boolean isRegistered) {
12         this.manufacturer = manufacturer;
13         this.isRegistered = isRegistered;
14     }
15 
16     @NotNull
17     public String getManufacturer() {
18         return manufacturer;
19     }
20 
21     public void setManufacturer(String manufacturer) {
22         this.manufacturer = manufacturer;
23     }
24 
25     @AssertTrue
26     public boolean getIsRegistered() {
27         return isRegistered;
28     }
29 
30     public void setRegistered(boolean isRegistered) {
31         this.isRegistered = isRegistered;
32     }
33     public Car(){}
34 
35 }

2.CarTest.java

 1 package org.hibernate.validator.referenceguide.chapter02.propertylevel;
 2 import static org.junit.Assert.assertEquals;
 3 
 4 import org.junit.BeforeClass;
 5 import org.junit.Test;
 6 
 7 import javax.validation.ConstraintViolation;
 8 import javax.validation.Validation;
 9 import javax.validation.Validator;
10 import javax.validation.ValidatorFactory;
11 import java.util.Iterator;
12 import java.util.Set;
13 
14 public class CarTest {
15     private static Validator validator;
16 
17     /**
18      * 生成validator校验器
19      */
20     @BeforeClass
21     public static void setUpValidator() {
22         ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
23         validator = factory.getValidator();
24     }
25     /**
26      * 验证整个Car
27      */
28     @Test
29     public void test() {
30         Car car=new Car("asaas",true);
31         //如果有不符合的在validate后，会将错误信息存放到Set中
32         Set<ConstraintViolation<Car>> constraintViolations = validator.validate( car );
33         //如果ite中没有信息，就是正确的
34         Iterator<ConstraintViolation<Car>> ite = constraintViolations.iterator();
35         while(ite.hasNext()) {
36             System.out.println(ite.next().getMessage());
37         }
38     }
39 }

 

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/juncaoit/p/7872959.html