本文介绍SpringBoot中如何使用Hibernate-validate框架进行表单数据校验，包括实体类校验规则添加、Controller中校验开启、页面错误信息获取及各种校验场景处理。
目录
1.2.5 requestParam/PathVariable参数校验
1 SpringBoot 对表单做数据校验
1.1 SpringBoot 对表单数据校验的技术特点
SpringBoot 中使用了 Hibernate-validate 校验框架
需要引入得pom依赖，不然验证不会生效
<dependency>
<groupId>jakarta.validation</groupId>
<artifactId>jakarta.validation-api</artifactId>
<version>2.0.1</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
<version>6.0.13.Final</version>
</dependency>或者单独使用javax.validation包中的也可以，就需要引入如下依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>2.0.5.RELEASE</version>
</dependency>1.2 SpringBoot 表单数据校验步骤
1.2.1 在实体类中添加校验规则
public class Users {
@NotBlank //非空校验
private String name;
@NotBlank（message="自定义校验信息"） //非空校验
private String password;
private Integer age;
//省去get/set方法
}1.2.2 在 Controller 中开启校验
注意：@Valid是开启对前台传过来的对象进行校验；(使用@Valid和@Validated都可以)
BindingResult：是封装了校验的结果，把校验的结果按照对象的驼峰命名方式放到Model对象里面，因此前台要按照驼峰命名的形式取出
/**
* 完成用户添加
*@Valid 开启对 Users 对象的数据校验
*BindingResult:封装了校验的结果
*/
@RequestMapping("/save")
public String saveUser(@Valid Users users,BindingResult result){
if(result.hasErrors()){
return "add";
} S
ystem.out.println(users);
return "ok";
}1.2.3 在页面中获取提示信息
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>添加用户</title>
</head>
<body>
<form th:action="@{/save}" method="post">
用户姓名： <input type="text" name="name"/><font color="red"
th:errors="${users.name}"></font><br/>
用户密码： <input type="password" name="password" /><font
color="red" th:errors="${users.password}"></font><br/>
用户年龄： <input type="text" name="age" /><font color="red"
th:errors="${users.age}"></font><br/>
<input type="submit" value="OK"/>
</form>
</body>
</html>1.2.4 遇到异常
1.2.5 requestParam/PathVariable参数校验
GET请求一般会使用requestParam/PathVariable传参。如果参数比较多(比如超过6个)，还是推荐使用DTO对象接收。
否则，推荐将一个个参数平铺到方法入参中。在这种情况下，必须在Controller类上标注@Validated注解，并在入参上声明约束注解(如@Min等)。如果校验失败，会抛出ConstraintViolationException异常。
代码示例如下：
@RequestMapping("/api/user")
@RestController
@Validated
public class UserController {
// 路径变量
@GetMapping("{userId}")
public Result detail(@PathVariable("userId") @Min(10000000000000000L) Long userId) {
// 校验通过，才会执行业务逻辑处理
UserDTO userDTO = new UserDTO();
userDTO.setUserId(userId);
userDTO.setAccount("11111111111111111");
userDTO.setUserName("xixi");
userDTO.setAccount("11111111111111111");
return Result.ok(userDTO);
}
// 查询参数
@GetMapping("getByAccount")
public Result getByAccount(@Length(min = 6, max = 20) @NotNull String account) {
// 校验通过，才会执行业务逻辑处理
UserDTO userDTO = new UserDTO();
userDTO.setUserId(10000000000000003L);
userDTO.setAccount(account);
userDTO.setUserName("xixi");
userDTO.setAccount("11111111111111111");
return Result.ok(userDTO);
}
}1.3 解决数据校验时的异常问题
解决异常的方法， 在跳转页面的方法中注入一个对象， 来解决问题。 要求参数对象的变量名必须是对象的类名的全称首字母小写。
注意： 由于springmvc 会将该对象放入到 Model 中传递。 key 的名称会使用该对象的驼峰式的命名规则来作为 key。参数的变量名需要与对象的名称相同，将首字母小写。
1.3.1 controller层需要改写
/**
* 解决异常的方式。 可以在跳转页面的方法中注入一个 Uesrs 对象。
* 注意： 由于 springmvc 会将该对象放入到 Model 中传递。 key 的名称会使用
该对象的驼峰式的命名规则来作为 key。
* 参数的变量名需要与对象的名称相同。 将首字母小写。
* *
@param users
* @return
*/
@RequestMapping("/addUser")
public String showPage( Users users){
return "add";
}
/**
* 完成用户添加
*@Valid 开启对 Users 对象的数据校验
*BindingResult:封装了校验的结果
*/
@RequestMapping("/save")
public String saveUser( @Valid Users users,BindingResult result){
if(result.hasErrors()){
return "add";
}
System.out.println(users);
return "ok";
}1.3.2 如果参数的名称需要做改变
如果想为传递的对象更改名称， 可以使用@ModelAttribute("aa")这表示当前传递的对象的 key 为 aa。那么我们在页面中获取该对象的 key 也需要修改为 aa
/**
* *
如果想为传递的对象更改名称， 可以使用@ModelAttribute("aa")这表示当
前传递的对象的 key 为 aa。
* 那么我们在页面中获取该对象的 key 也需要修改为 aa
* @param users
* @return
*/
@RequestMapping("/addUser")
public String showPage(@ModelAttribute("aa") Users users){
return "add";
}
/**
* 完成用户添加
*@Valid 开启对 Users 对象的数据校验
*BindingResult:封装了校验的结果
*/
@RequestMapping("/save")
public String saveUser(@ModelAttribute("aa") @Valid Users
users,BindingResult result){
if(result.hasErrors()){
return "add";
} S
ystem.out.println(users);
return "ok";
}页面部分
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>添加用户</title>
</head>
<body>
<form th:action="@{/save}" method="post">
用户姓名： <input type="text" name="name"/><font color="red"th:errors="${aa.name}"></font><br/>
用户密码： <input type="password" name="password" /><font
color="red" th:errors="${aa.password}"></font><br/>
用户年龄： <input type="text" name="age" /><font color="red"
th:errors="${aa.age}"></font><br/>
<input type="submit" value="OK"/>
</form>
</body>
</html>1.4 高级校验
1.4.1 分组校验
在实际项目中，可能多个方法需要使用同一个DTO类来接收参数，而不同方法的校验规则很可能是不一样的。这个时候，简单地在DTO类的字段上加约束注解无法解决这个问题。因此，spring-validation支持了分组校验的功能，专门用来解决这类问题。
比如保存User的时候，UserId是可空的，但是更新User的时候，UserId的值必须>=10000000000000000L；其它字段的校验规则在两种情况下一样。这个时候使用分组校验的代码示例如下：
约束注解上声明适用的分组信息groups
@Data
public class UserDTO {
@Min(value = 10000000000000000L, groups = Update.class)
private Long userId;
@NotNull(groups = {Save.class, Update.class})
@Length(min = 2, max = 10, groups = {Save.class, Update.class})
private String userName;
@NotNull(groups = {Save.class, Update.class})
@Length(min = 6, max = 20, groups = {Save.class, Update.class})
private String account;
@NotNull(groups = {Save.class, Update.class})
@Length(min = 6, max = 20, groups = {Save.class, Update.class})
private String password;
/**
* 保存的时候校验分组
*/
public interface Save {
}
/**
* 更新的时候校验分组
*/
public interface Update {
}
}
或者使用继承分组接口，没有指明分组的属性都属于Default
继承Default和不继承Default，区别就是继承Default的分组就是使用当前分组的时候，默认分组下的校验都会生效，如@NotNull @NotBlank 类似这种
import javax.validation.groups.Default;
/**
* 保存的时候校验分组
*/
public interface UpdateElement {}
/**
* 更新的时候校验分组
*/
public interface Add extends Default{}
@Data
public class RegisterVO {
@NotBlank(message = "用户名不能为空",groups = {UpdateElement.class})
private String account;
@NotBlank
private String password;
}
@Validated使用的是默认分组，这时候不会对account属性进行校验，如下：
@PostMapping("/register")
public Resp register(@Validated @RequestBody RegisterVO registerVO) {
return userService.register(registerVO);
}
指定了UpdateElement分组，因为UpdateElement分组没有继承Default ,所以只会校验account，不会校验 password，如下：
@PostMapping("/register")
public Resp register(@Validated(UpdateElement.class) @RequestBody RegisterVO registerVO) {
return userService.register(registerVO);
}
@Validated注解上指定校验分组
@PostMapping("/save")
public Result saveUser(@RequestBody @Validated(UserDTO.Save.class) UserDTO userDTO) {
// 校验通过，才会执行业务逻辑处理
return Result.ok();
}
@PostMapping("/update")
public Result updateUser(@RequestBody @Validated(UserDTO.Update.class) UserDTO userDTO) {
// 校验通过，才会执行业务逻辑处理
return Result.ok();
}
1.4.2 嵌套校验
前面的示例中，DTO类里面的字段都是基本数据类型和String类型。但是实际场景中，有可能某个字段也是一个对象，这种情况先，可以使用嵌套校验。
比如，上面保存User信息的时候同时还带有Job信息。需要注意的是，此时DTO类的对应字段必须标记@Valid注解。
@Data
public class UserDTO {
@Min(value = 10000000000000000L, groups = Update.class)
private Long userId;
@NotNull(groups = {Save.class, Update.class})
@Length(min = 2, max = 10, groups = {Save.class, Update.class})
private String userName;
@NotNull(groups = {Save.class, Update.class})
@Length(min = 6, max = 20, groups = {Save.class, Update.class})
private String account;
@NotNull(groups = {Save.class, Update.class})
@Length(min = 6, max = 20, groups = {Save.class, Update.class})
private String password;
@NotNull(groups = {Save.class, Update.class})
@Valid
private Job job;
@Data
public static class Job {
@Min(value = 1, groups = Update.class)
private Long jobId;
@NotNull(groups = {Save.class, Update.class})
@Length(min = 2, max = 10, groups = {Save.class, Update.class})
private String jobName;
@NotNull(groups = {Save.class, Update.class})
@Length(min = 2, max = 10, groups = {Save.class, Update.class})
private String position;
}
/**
* 保存的时候校验分组
*/
public interface Save {
}
/**
* 更新的时候校验分组
*/
public interface Update {
}
}
嵌套校验可以结合分组校验一起使用。还有就是嵌套集合校验会对集合里面的每一项都进行校验，例如List<Job>字段会对这个list里面的每一个Job对象都进行校验
1.4.3 集合校验
如果请求体直接传递了json数组给后台，并希望对数组中的每一项都进行参数校验。此时，如果我们直接使用java.util.Collection下的list或者set来接收数据，参数校验并不会生效，我们可以使用自定义list集合来接收参数：
包装List类型，并声明@Valid注解
public class ValidationList<E> implements List<E> {
@Delegate // @Delegate是lombok注解
@Valid // 一定要加@Valid注解
public List<E> list = new ArrayList<>();
// 一定要记得重写toString方法
@Override
public String toString() {
return list.toString();
}
}
@Delegate注解受lombok版本限制，1.18.6以上版本可支持。如果校验不通过，会抛出NotReadablePropertyException，同样可以使用统一异常进行处理。比如，我们需要一次性保存多个User对象，Controller层的方法可以这么写：
@PostMapping("/saveList")
public Result saveList(@RequestBody @Validated(UserDTO.Save.class) ValidationList<UserDTO> userList) {
// 校验通过，才会执行业务逻辑处理
return Result.ok();
}
1.4.4 自定义校验
业务需求总是比框架提供的这些简单校验要复杂的多，我们可以自定义校验来满足我们的需求。自定义spring validation非常简单，假设我们自定义加密id（由数字或者a-f的字母组成，32-256长度）校验，主要分为两步：
自定义约束注解
@Target({METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER})
@Retention(RUNTIME)
@Documented
@Constraint(validatedBy = {EncryptIdValidator.class})
public @interface EncryptId {
// 默认错误消息
String message() default "加密id格式错误";
// 分组
Class<?>[] groups() default {};
// 负载
Class<? extends Payload>[] payload() default {};
}
实现ConstraintValidator接口编写约束校验器
public class EncryptIdValidator implements ConstraintValidator<EncryptId, String> {
private static final Pattern PATTERN = Pattern.compile("^[a-f\\d]{32,256}$");
@Override
public boolean isValid(String value, ConstraintValidatorContext context) {
// 不为null才进行校验
if (value != null) {
Matcher matcher = PATTERN.matcher(value);
return matcher.find();
}
return true;
}
}
这样我们就可以使用@EncryptId进行参数校验了！
1.4.5 编程式校验
上面的示例都是基于注解来实现自动校验的，在某些情况下，我们可能希望以编程方式调用验证。这个时候可以注入javax.validation.Validator对象，然后再调用其api。
@Autowired
private javax.validation.Validator globalValidator;
// 编程式校验
@PostMapping("/saveWithCodingValidate")
public Result saveWithCodingValidate(@RequestBody UserDTO userDTO) {
Set<ConstraintViolation<UserDTO>> validate = globalValidator.validate(userDTO, UserDTO.Save.class);
// 如果校验通过，validate为空；否则，validate包含未校验通过项
if (validate.isEmpty()) {
// 校验通过，才会执行业务逻辑处理
} else {
for (ConstraintViolation<UserDTO> userDTOConstraintViolation : validate) {
// 校验失败，做其它逻辑
System.out.println(userDTOConstraintViolation);
}
}
return Result.ok();
}
1.4.6 快速失败(Fail Fast)
Spring Validation默认会校验完所有字段，然后才抛出异常。可以通过一些简单的配置，开启Fail Fast模式，一旦校验失败就立即返回。
@Bean
public Validator validator() {
ValidatorFactory validatorFactory = Validation.byProvider(HibernateValidator.class)
.configure()
// 快速失败模式
.failFast(true)
.buildValidatorFactory();
return validatorFactory.getValidator();
}
1.4.7 @Valid和@Validated区别
在使用最后我们来对 @Valid 和 @Validated 两个注解进行总结下：
- @Valid 和 @Validated 两者都可以对数据进行校验，待校验字段上打的规则注解（@NotNull, @NotEmpty等）都可以对 @Valid 和 @Validated 生效；
- @Valid 和 @Validated：两种注释都会对标准bean验证
如果验证不通过会抛出BindException异常，并变成400（BAD_REQUEST）响应；或者可以通过Errors或BindingResult参数在控制器内本地处理验证错误。另外，如果参数前有@RequestBody注解，验证错误会抛出MethodArgumentNotValidException异常。
@Validated 是提示500错误，@Valid 提示400 错误 - @Valid
是JSR-303规范标准注解支持,是一个标记注解。
注解支持ElementType#METHOD,ElementType#FIELD,ElementType#CONSTRUCTOR,ElementType#PARAMETER,ElementType#TYPE_USE - @Validated
是Spring 做得一个自定义注解，增强了分组功能。
注解支持ElementType#TYPE,ElementType#METHOD,ElementType#PARAMETER @Validated和@Valid的主要区别在于：@Validated：主要用于类型级别的验证，通常用在控制器类上。@Valid：主要用于方法参数级别的验证，用于告诉 Spring 框架这个参数需要进行验证。list集合校验，直接在方法前使用@Validated或者@Valid无效，这时需要在控制器类上使用@Validated注解，它是用来启用方法级别的验证（Method-Level Validation），为了让这个验证生效，还需要在需要验证的方法参数前添加@Valid注解
1.4.8 复杂逻辑使用跨域验证
如果需要验证跨多个字段的复杂输入规则，可以使用跨字段验证来保持验证逻辑的组织性和可维护性。跨字段验证可确保所有输入值均有效且彼此一致，从而防止出现意外行为。
假设我们有一个表单，用户可以在其中输入任务的开始日期和结束日期，并且我们希望确保结束日期不早于开始日期。我们可以使用跨域验证来实现这一点。
首先，我们定义一个自定义验证注解 EndDateAfterStartDate：
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = EndDateAfterStartDateValidator.class)
public @interface EndDateAfterStartDate {
String message() default "End date must be after start date";
String pattern() default "yyyy-MM-dd";
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}
然后，我们创建验证器 EndDateAfterStartDateValidator：
public class EndDateAfterStartDateValidator implements ConstraintValidator<EndDateAfterStartDate, TaskForm> {
private String datePattern; // 存储注解的 pattern 属性
private DateTimeFormatter formatter;
@Override
public void initialize(ValidDatePattern constraintAnnotation) {
// 这里可以获取到注解的属性值
this.datePattern = constraintAnnotation.pattern();
this.formatter = DateTimeFormatter.ofPattern(datePattern);
}
@Override
public boolean isValid(TaskForm taskForm, ConstraintValidatorContext context) {
if (taskForm.getStartDate() == null || taskForm.getEndDate() == null) {
return true;
}
return taskForm.getEndDate().isAfter(taskForm.getStartDate());
}
}
最后，我们将EndDateAfterStartDate注释应用于我们的表单对象TaskForm：
@EndDateAfterStartDate
public class TaskForm {
@NotNull
@EndDateAfterStartDate（）
private LocalDate startDate;
@NotNull
@EndDateAfterStartDate
private LocalDate endDate;
}
现在，当用户提交表单时，验证框架将自动检查结束日期是否晚于开始日期，如果不是，则提供有意义的错误消息。
1.4.9 国际化消息验证
如果应用程序支持多种语言，则必须使用国际化 (i18n) 以用户首选语言显示错误消息。以下是在 Spring Boot 应用程序中使用 i18n 处理错误消息的示例
首先，在资源目录下创建一个包含默认错误消息的 messages.properties 文件
# messages.properties
user.name.required=Name is required.
user.email.invalid=Invalid email format.
user.age.invalid=Age must be a number between 18 and 99.
接下来，为每种支持的语言创建一个 messages_xx.properties 文件，例如，中文的 messages_zh_CN.properties。
user.name.required=名称不能为空.
user.email.invalid=无效的email格式.
user.age.invalid=年龄必须在18到99岁之间.
然后，更新您的验证注释以使用本地化的错误消息
public class User {
@NotNull(message = "{user.id.required}")
private Long id;
@NotBlank(message = "{user.name.required}")
private String name;
@Email(message = "{user.email.invalid}")
private String email;
@NotNull(message = "{user.age.required}")
@Min(value = 18, message = "{user.age.invalid}")
@Max(value = 99, message = "{user.age.invalid}")
private Integer age;
}
最后，在 Spring 配置文件中配置 MessageSource bean 以加载 i18n 消息文件
@Configuration
public class AppConfig {
@Bean
public MessageSource messageSource() {
ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
messageSource.setBasename("messages");
messageSource.setDefaultEncoding("UTF-8");
return messageSource;
}
@Bean
public LocalValidatorFactoryBean validator() {
LocalValidatorFactoryBean validatorFactoryBean = new LocalValidatorFactoryBean();
validatorFactoryBean.setValidationMessageSource(messageSource());
return validatorFactoryBean;
}
}
当发生验证错误时，错误消息将根据随请求发送的“Accept-Language”标头以用户的首选语言显示。
1.5 实现原理
1.5.1 requestBody参数校验实现原理
在spring-mvc中，RequestResponseBodyMethodProcessor是用于解析@RequestBody标注的参数以及处理@ResponseBody标注方法的返回值的。显然，执行参数校验的逻辑肯定就在解析参数的方法resolveArgument()中：
public class RequestResponseBodyMethodProcessor extends AbstractMessageConverterMethodProcessor {
@Override
public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {
parameter = parameter.nestedIfOptional();
//将请求数据封装到DTO对象中
Object arg = readWithMessageConverters(webRequest, parameter, parameter.getNestedGenericParameterType());
String name = Conventions.getVariableNameForParameter(parameter);
if (binderFactory != null) {
WebDataBinder binder = binderFactory.createBinder(webRequest, arg, name);
if (arg != null) {
// 执行数据校验
validateIfApplicable(binder, parameter);
if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
throw new MethodArgumentNotValidException(parameter, binder.getBindingResult());
}
}
if (mavContainer != null) {
mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult());
}
}
return adaptArgumentIfNecessary(arg, parameter);
}
}
可以看到，resolveArgument()调用了validateIfApplicable()进行参数校验。
protected void validateIfApplicable(WebDataBinder binder, MethodParameter parameter) {
// 获取参数注解，比如@RequestBody、@Valid、@Validated
Annotation[] annotations = parameter.getParameterAnnotations();
for (Annotation ann : annotations) {
// 先尝试获取@Validated注解
Validated validatedAnn = AnnotationUtils.getAnnotation(ann, Validated.class);
//如果直接标注了@Validated，那么直接开启校验。
//如果没有，那么判断参数前是否有Valid起头的注解。
if (validatedAnn != null || ann.annotationType().getSimpleName().startsWith("Valid")) {
Object hints = (validatedAnn != null ? validatedAnn.value() : AnnotationUtils.getValue(ann));
Object[] validationHints = (hints instanceof Object[] ? (Object[]) hints : new Object[] {hints});
//执行校验
binder.validate(validationHints);
break;
}
}
}
看到这里，大家应该能明白为什么这种场景下@Validated、@Valid两个注解可以混用。我们接下来继续看WebDataBinder.validate()实现。
@Override
public void validate(Object target, Errors errors, Object... validationHints) {
if (this.targetValidator != null) {
processConstraintViolations(
//此处调用Hibernate Validator执行真正的校验
this.targetValidator.validate(target, asValidationGroups(validationHints)), errors);
}
}
最终发现底层最终还是调用了Hibernate Validator进行真正的校验处理。
1.5.2 方法级别的参数校验实现原理
上面提到的将参数一个个平铺到方法参数中，然后在每个参数前面声明约束注解的校验方式，就是方法级别的参数校验。
实际上，这种方式可用于任何Spring Bean的方法上，比如Controller/Service等。其底层实现原理就是AOP，具体来说是通过MethodValidationPostProcessor动态注册AOP切面，然后使用MethodValidationInterceptor对切点方法织入增强。
public class MethodValidationPostProcessor extends AbstractBeanFactoryAwareAdvisingPostProcessorimplements InitializingBean {
@Override
public void afterPropertiesSet() {
//为所有`@Validated`标注的Bean创建切面
Pointcut pointcut = new AnnotationMatchingPointcut(this.validatedAnnotationType, true);
//创建Advisor进行增强
this.advisor = new DefaultPointcutAdvisor(pointcut, createMethodValidationAdvice(this.validator));
}
//创建Advice，本质就是一个方法拦截器
protected Advice createMethodValidationAdvice(@Nullable Validator validator) {
return (validator != null ? new MethodValidationInterceptor(validator) : new MethodValidationInterceptor());
}
}
接着看一下MethodValidationInterceptor：
public class MethodValidationInterceptor implements MethodInterceptor {
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
//无需增强的方法，直接跳过
if (isFactoryBeanMetadataMethod(invocation.getMethod())) {
return invocation.proceed();
}
//获取分组信息
Class<?>[] groups = determineValidationGroups(invocation);
ExecutableValidator execVal = this.validator.forExecutables();
Method methodToValidate = invocation.getMethod();
Set<ConstraintViolation<Object>> result;
try {
//方法入参校验，最终还是委托给Hibernate Validator来校验
result = execVal.validateParameters(
invocation.getThis(), methodToValidate, invocation.getArguments(), groups);
}
catch (IllegalArgumentException ex) {
...
}
//有异常直接抛出
if (!result.isEmpty()) {
throw new ConstraintViolationException(result);
}
//真正的方法调用
Object returnValue = invocation.proceed();
//对返回值做校验，最终还是委托给Hibernate Validator来校验
result = execVal.validateReturnValue(invocation.getThis(), methodToValidate, returnValue, groups);
//有异常直接抛出
if (!result.isEmpty()) {
throw new ConstraintViolationException(result);
}
return returnValue;
}
}
实际上，不管是requestBody参数校验还是方法级别的校验，最终都是调用Hibernate Validator执行校验，Spring Validation只是做了一层封装。
1.6 异常抓取处理
前面说过，如果校验失败，会抛出MethodArgumentNotValidException或者ConstraintViolationException异常，这里使用@ControllerAdvice+@ExceptionHandler 注解处理异常
import cn.hutool.core.collection.CollectionUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.validation.ObjectError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;
import java.util.stream.Collectors;
@Slf4j
@RestControllerAdvice
public class GlobalException {
//绑定参数异常
@ExceptionHandler(org.springframework.web.bind.MethodArgumentNotValidException.class)
public void bindArgumentExceptionHandler(MethodArgumentNotValidException e) throws IOException {
BindingResult exceptions = e.getBindingResult();
// 判断异常中是否有错误信息，如果存在就使用异常中的消息，否则使用默认消息
String errorMsg = null;
if (exceptions.hasErrors()) {
List<ObjectError> errorList = exceptions.getAllErrors();
if (CollectionUtil.isNotEmpty(errorList)) {
// 这里列出了全部错误参数，按正常逻辑，只需要第一条错误即可
// FieldError fieldError = (FieldError) errors.get(0);
// errorMsg = fieldError.getDefaultMessage();
errorMsg = errorList.stream().map(m->m.getDefaultMessage()).collect(Collectors.joining(","));
}
}
//打印异常错误信息
log.error(e.getMessage(),e);
return errorMsg ;
}
@ExceptionHandler({ConstraintViolationException.class})
@ResponseStatus(HttpStatus.OK)
@ResponseBody
public Result handleConstraintViolationException(ConstraintViolationException ex) {
return Result.fail(BusinessCode.参数校验失败, ex.getMessage());
}
}1.7 其他校验规则
| 分类 | 限制 | 说明 |
| 空和非空检查 | @Null | 限制只能为Null |
| @NotNull | 限制必须不为null | |
| @NotEmpty | 验证注解的元素值不为null且不为空(字符串长度不为0、集合大小不为0) | |
| @NotBlank | 验证注解的元素值不为空(不为null、去除首位空格后长度为0)，不同于@NotEmpty, | |
| Boolean值检查 | @AssertFalse | 限制必须为false |
| @AssertTrue | 限制必须为true | |
| 长度检查 | @Size(max,min) | 限制字符长度必须在min到max之间 |
| 日期检查 | @Past | 限制必须是一个过去的日期 |
| @Future | 验证日期为当前时间之后 | |
| @FutureOrPresent | 验证日期为当前时间或之后 | |
| @PastOrPresent | 限制日期为当前时间或之前 | |
| 数值检查 | @Max(value) | 限制必须为一个不大于指定值的数字 |
| @Min(value) | 限制必须为一个不小于指定值的数字 | |
| @DecimalMax(value) | 限制必须为一个不大于指定值的数字 | |
| @DecimalMin(value) | 限制必须为一个不小于指定值的数字 | |
| @Digits(integer,fraction) | 限制必须为一个小数，且整数部分的位数不能超过integer，小数部分的位数不能超过fraction | |
| @Negative | 限制必须为负整数 | |
| @NegativeOrZero | 限制必须为负整数或零 | |
| @Positive | 限制必须为正整数 | |
| @PositiveOrZero | 限制必须为正整数或零 | |
| 其它检查 | @Pattern(value) | 限制必须符合指定的正则表达式 |
| 限制必须为email格式 |
扫一扫
984
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
