SpringValidation

一、概述：

JSR 303中提出了Bean Validation，表示JavaBean的校验，Hibernate Validation是其具体实现，并对其进行了一些扩展，添加了一些实用的自定义校验注解。

Spring中集成了这些内容，你可以在Spring中以原生的手段来使用校验功能，当然Spring也对其进行了一点简单的扩展，以便其更适用于Java web的开发。

在开发中，我们经常遇到参数校验的需求，比如用户注册的时候，要校验用户名不能为空、用户名长度不超过20个字符、手机号是合法的手机号格式等等。如果使用普通方式，我们会把校验的代码和真正的业务处理逻辑耦合在一起，而且如果未来要新增一种校验逻辑也需要在修改多个地方。而spring validation允许通过注解的方式来定义对象校验规则，把校验和业务逻辑分离开，让代码编写更加方便。Spring Validation其实就是对Hibernate Validator进一步的封装，方便在Spring中使用。在Spring中有多种校验的方式。

注：之前在controller中用if进行参数校验，现在可以换成springValidation框架来进行参数校验(只需要在Controller的方法参数上和实体类上加上对应的注解就行)

1.1、Spring 校验使用场景：

Spring 常规校验（Validator）：通过实现org.springframework.validation.Validator接口，然后在代码中调用这个类

Spring 数据绑定（DataBinder）：按照Bean Validation方式来进行校验，即通过注解的方式。

Spring Web 参数绑定（WebDataBinder）：按照Bean Validation方式来进行校验，即通过注解的方式。

Spring WebMVC/WebFlux 处理方法参数校验：基于方法实现校验

下边列出了几种使用场景：

（1）SpringMVC输入参数校验

（2）Spring管理的bean方法执行参数校验

（3）Spring初始化过程验证bean的属性

1.2、JSR 303 Bean Validation

JSR 303中提供了诸多实用的校验注解，这里简单罗列：

//校验类型(message="错误提示")
//1、@Null                       校验对象是否为null
//2、@NotNull                    校验对象是否不为null
//3、@NotBlank                   校验字符串去头尾空格后的长度是否大于0或是否为null
//4、@NotEmpty                   校验字符串是否为null或是否为empty
//
//5、@AssertTrue                 校验Boolean是否为true
//6、@AssertFalse                校验Boolean是否为false
//
//7、@UniqueElements             校验数组/集合的元素是否唯一
//8、@Size(min,max)              校验数组/集合/字符串长度是否在范围之内
//9、@Length(min,max)            校验数组/集合/字符串长度是否在范围之内
//10、@Range(min,max)            校验Integer/Short/Long是否在范围之内
//11、@Min(number)               校验Integer/Short/Long是否大于等于value
//12、@Max(number)               校验Integer/Short/Long是否小于等于value
//13、@Positive                  校验Integer/Short/Long是否为正整数
//14、@PositiveOrZero            校验Integer/Short/Long是否为正整数或0
//15、@Negative                  校验Integer/Short/Long是否为负整数
//16、@NogativeOrZero            校验Integer/Short/Long是否为负整数或0
//
//17、@DecimalMin(decimal)       校验Float/Double是否大于等于value
//18、@DecimalMax(decimal)       校验Float/Double是否小于等于value
//19、@Digits(integer,fraction)  校验数字是否符合整数位数精度和小数位数精度
//
//20、@Past(date)                校验Date/Calendar是否在当前时间之前
//21、@PastOrPresent(date)       校验Date/Calendar是否在当前时间之前或当前时间
//22、@Future(date)              校验Date/Calendar是否在当前时间之后
//23、@FutureOrPresent(date)     校验Date/Calendar是否在当前时间之后或当前时间
//
//24、@Email                     校验字符串是否符合电子邮箱格式
//25、@URL(protocol,host,port)   校验字符串是否符合URL地址格式
//26、@CreditCardNumber          校验字符串是否符合信用卡号格式
//
//27、@Pattern(regexp)           校验字符串是否符合正则表达式的规则
//
//除此之外，我们还可以自定义一些数据校验规则

举例:

@size (min=3, max=20,message="用户名长度只能在3-20之间")

@size (min=6, max=20,message="密码长度只能在6-20之间")

@pattern(regexp="[a-za-z0-9._%+-]+@[a-za-z0-9.-]+\\.[a-za-z]{2,4}",message="邮件格式错误")

@Length(min =5, max =20, message ="用户名长度必须位于5到20之间")

@Email(message ="比如输入正确的邮箱")

@NotNull(message ="用户名称不能为空")

@Max(value =100, message ="年龄不能大于100岁")

@Min(value=18,message="必须年满18岁！")

@AssertTrue(message ="bln4 must is true")

@AssertFalse(message ="blnf must is falase")

@DecimalMax(value="100",message="decim最大值是100")

@DecimalMin(value="100",message="decim最小值是100")

@NotNull(message ="身份证不能为空")

@Pattern(regexp="^(\\d{18,18}|\\d{15,15}|(\\d{17,17}[x|X]))$", message="身份证格式错误")

✈ 空值检查

注解	说明
@NotBlank	用于字符串，字符串不能为null 也不能为空字符串
@NotEmpty	字符串同上，对于集合（Map,List,Set）不能为空，必须有元素
@NotNull	不能为 null
@Null	必须为 null

✈ 数值检查

注解	说明
@DecimalMax(value)	被注释的元素必须为数字，其值必须小于等于指定的值
@DecimalMin(value)	被注释的元素必须为数字，其值必须大于等于指定的值
@Digits(integer, fraction)	被注释的元素必须为数字，其值的整数部分精度为 integer，小数部分精度为 fraction
@Positive	被注释的元素必须为正数
@PositiveOrZero	被注释的元素必须为正数或 0
@Max(value)	被注释的元素必须小于等于指定的值
@Min(value)	被注释的元素必须大于等于指定的值
@Negative	被注释的元素必须为负数
@NegativeOrZero	被注释的元素必须为负数或 0

✈ Boolean 检查

注解	说明
@AssertFalse	被注释的元素必须值为 false
@AssertTrue	被注释的元素必须值为 true

✈ 长度检查

注解	说明
@Size(min,max)	被注释的元素长度必须在 min 和 max 之间，可以是 String、Collection、Map、数组

✈ 日期检查

注解	说明
@Future	被注释的元素必须是一个将来的日期
@FutureOrPresent	被注释的元素必须是现在或者将来的日期
@Past	被注释的元素必须是一个过去的日期
@PastOrPresent	被注释的元素必须是现在或者过去的日期

✈ 其他检查

注解	说明
@Email	被注释的元素必须是电子邮箱地址
@Pattern(regexp)	被注释的元素必须符合正则表达式

更简洁的参数校验，使用 SpringBoot Validation 对参数进行校验-腾讯云开发者社区-腾讯云

1.3、SpringValidation核心API

二、测试案例：

2.1、需要的依赖：

<!--  Spring Validation 校验框架 -->
<!-- validator校验相关依赖 -->
<dependency><groupId>org.hibernate.validator</groupId><artifactId>hibernate-validator</artifactId><!--<version>7.0.5.Final</version>--><version>6.2.5.Final</version>
</dependency>
<dependency><groupId>org.glassfish</groupId><artifactId>jakarta.el</artifactId><version>4.0.1</version>
</dependency>
<dependency><groupId>jakarta.validation</groupId><artifactId>jakarta.validation-api</artifactId><version>2.0.2</version>
</dependency>

或者直接使用springBoot的启动器依赖这些内容：

<!--校验组件-->
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-validation</artifactId><version>${spring-boot.version}</version>
</dependency>
<!--web组件-->
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId><version>${spring-boot.version}</version>
</dependency>

2.1.实体类：

package com.zyq.validation.pojo.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.constraints.*;
import java.util.Date;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {@NotNull(message = "用户名不能为null") //SpringValidation框架提供的检测注解@NotBlank(message="名字不能为空")//SpringValidation框架提供的检测注解@Size(min=2,max=5,message = "名字字符过多")private String  userName;@Min(value = 0, message = "年龄不能小于0") //SpringValidation框架提供的检测注解@Max(value = 150,message = "年龄不能大于150") //SpringValidation框架提供的检测注解private int age;private String pwd;@Pattern(regexp = "^1(3\\d|4[5-9]|5[0-35-9]|6[567]|7[0-8]|8\\d|9[0-35-9])\\d{8}$", message = "手机号格式错误")private String phone;@Email(message = "邮箱格式错误") //SpringValidation框架提供的检测注解private String email;@Past(message = "生日必须早于当前时间") //SpringValidation框架提供的检测注解private Date birth;@PositiveOrZero(message = "余额必须大于等于0") //SpringValidation框架提供的检测注解private Double money;public User(String userName, String pwd) {this.userName = userName;this.pwd = pwd;}
}

2.2.TestController

package com.zyq.validation.controller;
import com.zyq.validation.pojo.entity.User;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;@RestController
public class TestController {@PostMapping(value = "/reg")public User test(@Validated User user){//index.html访问出来后提交数据就会报400的异常，提示名字字符过多，年龄超过限制return user;}
}
//@RequestBody注解解释：
//@RequestBody主要用来接收前端传递给后端的json字符串中的数据的(请求体中的数据的,所以只能接收post方式数据)；
//在后端的同一个接收方法里，@RequestBody与@RequestParam()可以同时使用，@RequestBody最多只能有一个，而@RequestParam()可以有多个。
//注：一个请求，只有一个RequestBody；一个请求，可以有多个RequestParam。
//注：当同时使用@RequestParam（）和@RequestBody时，@RequestParam（）指定的参数可以是普通元素、
//数组、集合、对象等等(即:当，@RequestBody 与@RequestParam()可以同时使用时，原SpringMVC接收
//参数的机制不变，只不过RequestBody 接收的是请求体里面的数据；而RequestParam接收的是key-value
//里面的参数，所以它会被切面进行处理从而可以用普通元素、数组、集合、对象等接收)。
//即：如果参数时放在请求体中，传入后台的话，那么后台要用@RequestBody才能接收到；如果不是放在
//请求体中的话，那么后台接收前台传过来的参数时，要用@RequestParam来接收，或则形参前什么也不写也能接收。
//注：如果参数前写了@RequestParam(xxx)，那么前端必须有对应的xxx名字才行(不管其是否有值，当然可以通
//过设置该注解的required属性来调节是否必须传)，如果没有xxx名的话，那么请求会出错，报400。
//
//注：如果参数前不写@RequestParam(xxx)的话，那么就前端可以有可以没有对应的xxx名字才行，如果有xxx名/的话，那么就会自动匹配；没有的话，
/请求也能正确发送。

2.3.index.html:

<html xmlns="http://www.w3.org/1999/html">
<body>
<h1>hello word!!!</h1>
<p>this is a html zyq-page</p>
<meta http-equiv="Content-Type" content="application/json; charset=utf-8">
<!--<meta http-equiv="Content-Type" content="text/html; charset=utf-8">-->
<form action="/reg" method="post"><label for="un">用户名：</label> <input id="un" name="userName" type="text" value="zy_qqq1"/><br/><label for="age">年龄：</label> <input id="age" name="age" type="text" value="167"/><br/><label for="pwd">密码：</label> <input id="pwd" name="pwd" type="password" value="123456"/><br/><label for="phone">电话：</label> <input id="phone" name="phone" type="text" value="13367904423"/><br/><input type="submit" value="注册">
</form>
</body>
</html>

2.4.用浏览器测试：

测试地址： localhost:8080

三、给案例添加Junit

3.1..ValidationConfig：

package com.zyq.validation.configuration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;//有些案例没有这个配置类
@Configuration
@ComponentScan("com.zyq.validation")
public class ValidationConfig {@Beanpublic LocalValidatorFactoryBean validator() {return new LocalValidatorFactoryBean();}}

3.2.UserService1.java

package com.zyq.validation.service;
import com.zyq.validation.pojo.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.validation.BindException;
import org.springframework.validation.Validator;
@Service
public class UserService1 {@Autowiredprivate Validator validator;public boolean validateUserByValidator(User user){BindException bindException=new BindException(user, user.getUserName());        validator.validate(user, bindException);//进行用户属性的验证return bindException.hasErrors();}}

3.3.测试类：

package com.zyq.validation.test;
import com.zyq.validation.configuration.ValidationConfig;
import com.zyq.validation.pojo.entity.User;
import com.zyq.validation.service.UserService1;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
@SpringBootTest
public class TestValidation {public static void main(String[] args) {test1();}private static void test1() {ApplicationContext context = new AnnotationConfigApplicationContext(ValidationConfig.class);UserService1 myService = context.getBean(UserService1.class);User user = new User();user.setAge(-1);boolean validator = myService.validateUserByValidator(user);System.out.println(validator);}//Exception in thread "main" java.lang.IllegalArgumentException: Object name must not be null// at com.zyq.validation.service.UserService.validateUserByValidator(UserService.java:16)// at com.zyq.validation.test.testValidation.main(testValidation.java:17)}

3.4.jakarta.validator测试

A.UserService2:

package com.zyq.validation.service;
import com.zyq.validation.pojo.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.validation.ConstraintViolation;
import java.util.Set;
//import jakarta.validation.Validator;@Service
public class UserService2 {//javax.validation.Validator这种方式对于初学者不建议了解// (建议先了解UserService1中的org.springframework.validation.Validator)@Autowired//private jakarta.validation.Validator validator;private javax.validation.Validator validator;public boolean validateUserByJavaXValidator(User user){Set<ConstraintViolation<User>> sets=validator.validate(user);for(ConstraintViolation c:sets){System.err.println("------------------");System.err.println(c.getMessage());System.err.println("------------------");}return sets.isEmpty();}
}

B.TestValidation

四、用apifox测试：

4.1.TestController

给TestController添加方法

4.2. apifox：

给edge浏览器安装apifox插件之后根据下边方式测试：

测试结果：

4.3.统一异常处理

给项目中添加统一异常处理类：

@ControllerAdvice
@Slf4j
public class GlobalException {//用本类GlobalException的catchMethodArgumentNotValidException处理所有controller类的MethodArgumentNotValidException//编写完后测试，好像没效果//catchMethodArgumentNotValidException@ExceptionHandler(MethodArgumentNotValidException.class)//捕获所有controller的MethodArgumentNotValidException异常@ResponseBodypublic ResponseEntity<Object> exception(MethodArgumentNotValidException e, HttpServletRequest request) {Map<String, String> result = new HashMap<>();BindingResult bindingResult = e.getBindingResult();//获取异常结果信息//request.getMethod():请求方式，request.getRequestURI() 请求路径 //比如:  post    /reg2log.error("请求[ {} ] {} 的参数校验发生错误", request.getMethod(), request.getRequestURL());for (ObjectError objectError : bindingResult.getAllErrors()) {FieldError fieldError = (FieldError) objectError;//验证失败后，Spring会生成一个FieldError对象，其中包含了错误的详细信息//fieldError.getField():获取引发FieldError的被拒绝的key(方法返回的是导致FieldError的那个字段的字段名)//fieldError.getRejectedValue():获取引发FieldError的被拒绝的value(方法返回的是导致FieldError的那个字段的值，即那个无法通过验证的值。)//fieldError.getDefaultMessage(): 获取到错误提示log.error("参数 {} = {} 校验错误：{}", fieldError.getField(), fieldError.getRejectedValue(), fieldError.getDefaultMessage());result.put(fieldError.getField(), fieldError.getDefaultMessage());}// 一般项目都会有自己定义的公共返回实体类，这里直接使用现成的 ResponseEntity 进行返回，同时设置 Http 状态码为 400return ResponseEntity.badRequest().body(result);}
}

测试结果如下：

五、ajax测试：

5.1.下载jquery脚本

下载jquery脚本文件放到resources/static文件夹中。

用index2.html测试TestController中的test2方法: test2方法比test1方法多了一个@RequestBody

5.2.编写index2.html:

<!DOCTYPE html>
<html>
<head>    <meta http-equiv="Content-Type" content="application/json;charset=utf-8">   <meta charset="UTF-8"><script src="https://apps.bdimg.com/libs/jquery/2.1.4/jquery.min.js"></script>
</head>
<body>
<h1>hello word!!!</h1>
<p>this is a html zyq-page</p>
<!-- [org.springframework.web.bind.MethodArgumentNotValidException: Validation failed for argument [0] in public
com.zyq.validation.pojo.entity.User com.zyq.validation.controller.TestController.test2(com.zyq.validation.pojo.entity.User):
[Field error in object 'user' on field 'userName': rejected value [zyq_34324];
codes [Size.user.userName,Size.userName,Size.java.lang.String,Size];
arguments [org.springframework.context.support.DefaultMessageSourceResolvable:
codes [user.userName,userName]; arguments []; default message [userName],5,2]; default message [名字字符过多(2到5个字符)]] ]-->
<!--application/json不起作用--><!--<form action="/reg2"  id="myForm" method="post" enctype="application/json">-->
<form onsubmit="return false" method="post" id="myForm"><label for="un">用户名：</label> <input id="un" name="userName" type="text" value="zyq_34324"/><br/><label for="age">年龄：</label> <input id="age" name="age" type="text" value="16"/><br/><label for="pwd">密码：</label> <input id="pwd" name="pwd" type="password" value="123"/><br/><label for="phone">电话：</label> <input id="phone" name="phone" type="text" value="13367904423"/><br/><input type="submit" id="sub"  value="注册2">
</form>
</body>
<script>//定义serializeObject方法，序列化表单$.fn.serializeObject = function () {var o = {};var a = this.serializeArray();$.each(a, function () {if (o[this.name]) {if (!o[this.name].push) {o[this.name] = [o[this.name]];}o[this.name].push(this.value || '');} else {      o[this.name] = this.value || '';   }});return o;}//表单序列化：//第一种: 序列化提交 $(’#form’).serialize()  //这种方式是将表单数据 格式化为  k=v&k=v&k=v&k=v//第二种：引入  jquery.serializeExtend-1.0.1.js     $('#form').getJsonData()//JSON.stringify()的作用是将 JavaScript 对象(json对象)转换为 JSON 字符串，//而JSON.parse()可以将JSON字符串转为一个JavaScript 对象(json对象)。$('#myForm').submit(function(e) {   var temp = $("#myForm").serializeObject();e.preventDefault(); // 阻止表单默认提交行为$.ajax({url: 'http://localhost:8080/reg2', // 假设表单有action属性type: 'post',contentType: 'application/json',dataType: 'json',data: JSON.stringify(temp) ,//$(this).serialize()： 是一些k-v字符串(serialize() 方法通过序列化表单值，创建 URL 编码文本字符串。)//JSON.stringify( $(this).serialize() )success: function(response) {// 成功回调函数console.log('Form submitted:', response);//alert("成功"+response.userName);alert("成功"+JSON.stringify(response));},error: function(xhr, status, error) {// 失败回调函数console.error('Submission failed:', status, error);}});});
</script>
</html>

5.3.编写TestController:

package com.zyq.validation.controller;
import com.zyq.validation.pojo.entity.User;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class TestController {@PostMapping(value = "/reg")public User test(@Validated User user){//index.html访问出来后提交数据就会报400的异常，提示名字字符过多，年龄超过限制return user;}//test2方法需要用postman或apifox 或者ajax的方式提交数据来访问(不能用html的form表单的action提交参数)//因为html的form表单的action提交方式的Content-type的值是'application/x-www-form-url (而且无法修改<我目前掌握的知识无法修改它>)//可以将form表单的数据改用ajax方式提交数据@PostMapping(value = "/reg2", produces = "application/json;charset=UTF-8")public User test2(@RequestBody @Validated User user){//index.html访问出来后提交数据就会报400的异常，提示名字字符过多，年龄超过限制return user;}
}
//@RequestBody注解解释：
//@RequestBody主要用来接收前端传递给后端的json字符串中的数据的(请求体中的数据的,所以只能接收post方式数据)；
//在后端的同一个接收方法里，@RequestBody与@RequestParam()可以同时使用，@RequestBody最多只能有一个，而@RequestParam()可以有多个。
//注：一个请求，只有一个RequestBody；一个请求，可以有多个RequestParam。
//注：当同时使用@RequestParam（）和@RequestBody时，@RequestParam（）指定的参数可以是普通元素、//数组、集合、对象等等(即:当，@RequestBody 与@RequestParam()可以同时使用时，原SpringMVC接收参数的机制不变，只不过RequestBody 接收的是请求体里面的数据；而RequestParam接收的是key-value
//里面的参数，所以它会被切面进行处理从而可以用普通元素、数组、集合、对象等接收)。
//即：如果参数时放在请求体中，传入后台的话，那么后台要用@RequestBody才能接收到；如果不是放在//请求体中的话，那么后台接收前台传过来的参数时，要用@RequestParam来接收，或则形参前什么也不写也能接收。
//注：如果参数前写了@RequestParam(xxx)，那么前端必须有对应的xxx名字才行(不管其是否有值，当然可以通
//过设置该注解的required属性来调节是否必须传)，如果没有xxx名的话，那么请求会出错，报400。
//
//注：如果参数前不写@RequestParam(xxx)的话，那么就前端可以有可以没有对应的xxx名字才行，如果有xxx名
//的话，那么就会自动匹配；没有的话，请求也能正确发送。

5.4.浏览器测试：

执行结果：

六、传递校验：

在一个Customer顾客类中定义一个成员变量 User user来引用用户类对象，并用@Valid注解进行属性验证。

6.1.Customer顾客类

package com.zyq.validation.pojo.entity;
import lombok.Data;
import javax.validation.Valid;
import javax.validation.constraints.NotBlank;
import java.io.Serializable;
@Data
public class Customer  implements Serializable {@NotBlank(message = "会员卡不能为空")private String idCardNo;@Validprivate User user;
}

再比如某个类中有一个成员变量为： private List<User> users; 此时也可以给这个成员变量上边加@Valid 来校验users中的元素。

6.2.TestController

TestController控制器类中添加如下方法

@PostMapping(value = "/reg3", produces = "application/json;charset=UTF-8")
public Customer test3(@RequestBody @Validated Customer customer){return customer;
}//https://app.apifox.com/project/4524520

6.3.apifox进行测试

七、分组检测：

7.1.将User复制为User2

7.2.TestController加方法

7.3.测试：

分组1 group1的测试

分组2 group2的测试

八、自定义校验：

8.1.自定义注解：

package com.zyq.validation.annotation;
import com.zyq.validation.validator.CannotBlankValidator;
import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.*;//此注解可用在方法上， 成员变量上， 注解上， 构造方法上， 方法参数上
@Target({ElementType.METHOD, ElementType.FIELD, ElementType.ANNOTATION_TYPE, ElementType.CONSTRUCTOR, ElementType.PARAMETER})
//在运行时生效
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Constraint(validatedBy = {CannotBlankValidator.class})
public @interface CannotBlank {//默认错误信息String  message() default "不能包含空格";//分组Class<?>[] groups() default {};//负载Class <? extends Payload>[]   payload() default{};//指定多个时使用@Target({ElementType.METHOD, ElementType.FIELD, ElementType.ANNOTATION_TYPE,ElementType.CONSTRUCTOR, ElementType.PARAMETER})@Retention(RetentionPolicy.RUNTIME)@Documented@interface List {CannotBlank[] value();}
}

8.2.自定义校验器：

package com.zyq.validation.validator;
import com.zyq.validation.annotation.CannotBlank;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
public class CannotBlankValidator implements ConstraintValidator<CannotBlank, String> {public boolean isValid(String value, ConstraintValidatorContext context) {//null时不进行校验if(value != null  &&  value.contains(" ")){//如果value包含空格就不能通过验证。//获取默认提示信息String defaultConstraintMessgeTemplate=context.getDefaultConstraintMessageTemplate();System.out.println("default message :"+defaultConstraintMessgeTemplate);//禁用默认提示信息context.disableDefaultConstraintViolation();//设置提示语context.buildConstraintViolationWithTemplate("can not contains blank-不能包含空格").addConstraintViolation();return false;}return true;}
}

8.3.统一异常处理：

统一异常处理类中将exception方法复制一份儿，然后将异常类型改为BindException

8.4.Student:

package com.zyq.validation.pojo.entity;
import com.zyq.validation.annotation.CannotBlank;
import lombok.Data;
@Data
public class Student {@CannotBlank(message = "名字不能包含空格")private String stuName;
}

8.5.TestController:

8.6.apifox测试：

控制台显示：

九、让字段逐个校验：

9.1.写配置类：

package com.zyq.validation.configuration;
import org.hibernate.validator.HibernateValidator;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.validation.beanvalidation.SpringConstraintValidatorFactory;
import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;
@Configuration
public class ValidatorConfiguration {//本配置类可以让需要校验的字段一个一个校验，而不是全部字段一次性都校验@Beanpublic Validator validator(AutowireCapableBeanFactory springBeanFactory){ValidatorFactory factory= Validation.byProvider(HibernateValidator.class).configure()//快速失败.failFast(true)//解决springboot依赖注入的问题.constraintValidatorFactory(new SpringConstraintValidatorFactory(springBeanFactory)).buildValidatorFactory();return factory.getValidator();}
}

9.2.配置文件

application.properties

9.3.测试：

localhost:8080/index2.html

十.依赖校验：

一个字段的校验依赖另一个字段，比如姓名：中国姓名:姓如果一个字或两个的话，名字基本是1-4个字之间。

外国姓名：:姓如果超过两字的话，名字基本是3-17个字之间

案例中的校验规则是(User3GroupSequenceProvider中指定)：

姓如果一个字或两个的话，采用第一组校验规则(名字基本是1-4个字之间)

姓如果超过两字的话，采用第二组校验规则(名字基本是3-17个字之间)

10.1.删ValidatorConfiguration

10.2.校验分组：

package com.zyq.validation.configuration;
import java.util.ArrayList;
import java.util.List;
import com.zyq.validation.pojo.entity.User3;
import lombok.extern.slf4j.Slf4j;
import org.hibernate.validator.spi.group.DefaultGroupSequenceProvider;
//本类用于：根据lastName判断firstName(firstName为0时lastName是一种校验方式，不为0时是另一种校验方式)
//如果account为空,密码也就不能有数据(用第一组校验规则)
//如果account不为空就判断密码字符个数(用第二组校验规则)
@Slf4j
public class User3GroupSequenceProvider implements DefaultGroupSequenceProvider<User3> {public List<Class<?>> getValidationGroups(User3 user3) {List<Class<?>>  defaultGroupSequence=new ArrayList<>();defaultGroupSequence.add(User3.class);if(user3!=null){String firstName=user3.getFirstName();log.info("账号{}.",firstName);if(firstName!=null&&1<=firstName.length() && firstName.length()<=2 )//如果姓的长度在1到3之间，其他字段可以采用分组1进行校验defaultGroupSequence.add(User3.group1.class);elsedefaultGroupSequence.add(User3.group2.class);/*String acc=user3.getAccount();log.info("账号{}",acc);if(acc==null||acc.equals(""))//如果用户名不存在，其他字段可以采用分组1进行校验defaultGroupSequence.add(User3.group1.class);elsedefaultGroupSequence.add(User3.group2.class);*/}return defaultGroupSequence;}
}

10.3.编写User3

package com.zyq.validation.pojo.entity;
import com.zyq.validation.configuration.User3GroupSequenceProvider;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.hibernate.validator.constraints.Length;
import org.hibernate.validator.group.GroupSequenceProvider;
import javax.validation.constraints.*;
import java.util.Date;
@GroupSequenceProvider(User3GroupSequenceProvider.class)
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User3 {  //根据lastName判断firstName(firstName为0时lastName是一种校验方式，不为0时是另一种校验方式)@NotNull(message = "firstName不能为null")@Size(min=1,max=15,message = "用户名字符数不符合规范(1到15个字符)") //SpringValidation框架提供的检测注解private String  firstName;//如果account不为空就判断密码字符个数(用第2组校验规则)@Size(min=1,max=3,message = "中国名字字符数不符合规范(1到3个字符)" , groups = {User3.group1.class})     
@Size(min=3,max=17,message = "英文名字字符数不符合规范(3到17个字符)" , groups = {User3.group2.class}) private String  lastName;//名public interface  group1{}//如果account为空,密码也就不能有数据(用第一组校验规则)public interface  group2{}//如果account不为空就判断密码字符个数(用第2组校验规则)
}

10.4TestController:

@RequestMapping(value = "/reg7", produces = "application/json;charset=UTF-8")
public User3 test7(@RequestBody @Validated User3 user){return user;
}//https://app.apifox.com/project/4524520

10.5.apifox测试：

A.英文姓,中文名:

控制台：

B.中文姓,英文名:

控制台信息：

11、自定义校验器2

11.1.注释ValidatorConfiguration：

注释掉ValidatorConfiguration中所有

11.2.编写User1：

package com.zyq.validation.pojo.entity;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User1 {@NotNull(message = "用户名不能为null") //SpringValidation框架提供的检测注解@NotBlank(message="名字不能为空") //SpringValidation框架提供的检测注解@CannotBlank(message = "名字不能包含空格")@Size(min=2,max=5,message = "名字字符过多(2到5个字符)") //SpringValidation框架提供的检测注解private String  userName;private int age;
}

11.3.AgeOutOfRangeException

package com.zyq.validation.exception;
import lombok.Data;
@Data
public class AgeOutOfRangeException extends  RuntimeException{private String key;private String val;public AgeOutOfRangeException(String message) {    super(message);       }public AgeOutOfRangeException(String message,String key,String val) {super(message);this.key=key;this.val=val;}public AgeOutOfRangeException(String message, Throwable cause) {   super(message, cause);     }public AgeOutOfRangeException(Throwable cause) {   super(cause);      }public AgeOutOfRangeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {super(message, cause, enableSuppression, writableStackTrace);}
}

11.4.GlobalException

GlobalException统一异常处理类中添加如下方法：

@ExceptionHandler(AgeOutOfRangeException.class)//捕获所有controller的BindException异常
@ResponseBody
public ResponseEntity<Object> exception(AgeOutOfRangeException e, HttpServletRequest request) {Map<String, String> result = new HashMap<>();//request.getMethod():请求方式，request.getRequestURI() 请求路径 //比如:  post    /reg2log.error("请求[ {} ] {} 的参数校验发生错误", request.getMethod(), request.getRequestURL());log.error("参数 {} = {} 校验错误：{}", e.getKey(), e.getVal(), e.getMessage());result.put(e.getKey(), e.getMessage());return ResponseEntity.badRequest().body(result);
}

11.5.AgeBetweenValidator:

package com.zyq.validation.validator;
import com.zyq.validation.pojo.entity.User1;
import org.springframework.validation.Errors;
import org.springframework.validation.ValidationUtils;
import org.springframework.validation.Validator;public class AgeBetweenValidator implements Validator{public boolean supports(Class<?> aClass) {//参数是否是User1的字节码对象return User1.class.equals(aClass);//判断参数aClass是否为User1.class}public void validate(Object objTarget, Errors errors) {ValidationUtils.rejectIfEmpty(errors,"age","age can not empty年龄不能为空");User1 u1=(User1)objTarget;if(0>=u1.getAge()){errors.rejectValue("age","age<=0, 年龄不能小于等于0");}else if( u1.getAge() >=239){errors.rejectValue("age","age>=239, 年龄不能大于等于239");}}}

11.6.TestController

TestController中添加如下方法

@InitBinder
protected void initBinder(WebDataBinder binder) {binder.addValidators(new AgeBetweenValidator());
}@RequestMapping(value = "/reg1", produces = "application/json;charset=UTF-8")
public User1 test1(@RequestBody @Validated User1 user, BindingResult result){// 参数校验if (result.hasErrors()) {List<FieldError> fieldErrors = result.getFieldErrors();fieldErrors.forEach(e -> {System.out.println(e.getField() + e.getCode());});throw new AgeOutOfRangeException("年龄数值超范围异常[1,239]","age",user.getAge()+"");}return user;
}//https://app.apifox.com/project/4524520

统一异常处理类GlobalException中有两个统一异常处理方法， apifox进行测试如果账号和年龄都不能通过校验的话，则网页中只能接收到年龄的校验结果(接收不到用户名的校验结果)，原因应该就是统一异常处理类的两个方法的问题，改进方案待以后研究。