Hibernate-validator

校验介绍

Java API规范了（JSR303）定义了Bean校验的标准validation-api，但没有提供实现。hibernate validation是对这个规范的实现，并增加了校验注解如：@Email、@Length等

Spring Validation是对hibernate validation的二次封装，用于支持spring mvc参数的自动校验。

引入依赖

如果spring-boot版本小于2.3.x，spring-boot-starter-web会自动依赖hibernate-validator。
如果spring-boot版本大于2.3.x，则需要手动引入依赖

implementation group: 'org.hibernate.validator', name: 'hibernate-validator', version: '6.2.4.Final'

注意由于java EE 在2018年命名空间全面迁移，由javax--> jakarta 则validation的api也由 javax-validation 迁移到了jakarta.validation，导致使用7版本会不生效，可以看官方7版本集成教程：7.0 series - Hibernate Validator

演示代码及学习网址

演示代码：spring-boot-demo -> tool-demo -> validator
学习网址：Spring Validation最佳实践及其实现原理，参数校验没那么简单！ - 掘金 (juejin.cn)

前言

对于web服务来说，为防止非法参数对业务造成影响，在controller层一定要做参数校验，而请求参数分为如下两种形式：

POST、PUT请求，参数放在body，使用RequestBody接收参数
GET请求，使用RequestParam、PathVariable接收参数

ReuqestBody参数校验

POST、PUT请求一般会使用@RequestBody DTO对象进行接收，只要给DTO对象加载@Validated注解就能实现自动参数校验。比如：UserDTO，要求username长度是2-10，account和password字段长度是6-20。如果校验失败，会抛出MethodArgumentNotValidException异常，spring默认会将其转为400状态的（Bad Request）请求

DTO表示数据传输对象（Data Transfer Object），用于服务器和客户端之间交互传输使用的，在spring-web项目中可以表示用于接收请求参数的Bean对象

这种情况下@Valid和@Validated一样

在DTO字段上生命约束注解

DTO类

package com.huangjiliang.validator.dto;

import lombok.Data;
import lombok.ToString;
import org.hibernate.validator.constraints.Length;

import javax.validation.constraints.NotNull;

@Data
@ToString
public class UserDTO {

    private Long userId;
    
    @NotNull
    @Length(min = 2, max = 10)
    private String username;

    @NotNull
    @Length(min = 6, max = 20)
    private String account;

    @NotNull
    @Length(min = 6, max = 20)
    private String password;

}

控制层接口

package com.huangjiliang.validator.controller;

import com.huangjiliang.validator.dto.UserDTO;
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.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("user")
public class UserController {

    @PostMapping("create")
    public String create(@RequestBody @Validated UserDTO userDTO) {
        System.out.println(userDTO);
        return "新增成功";
    }

}

抛出异常：org.springframework.web.bind.MethodArgumentNotValidException

RequestParam/PathVariable参数校验

GET请求一般会使用RequestParam/PathVariable接收参数。如果参数超过6个，推荐使用DTO对象接收；否则推荐一个个参数平铺到方法入参中。在这种情况下必须在Controller类上标注@Validated注解，并在入参上生命约束注解如（@Min等），如果参数校验失败，会抛出ContrainViolationException异常。

控制层接口(PathVariable)

package com.huangjiliang.validator.controller;

import com.huangjiliang.validator.dto.UserDTO;
import org.hibernate.validator.constraints.Length;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("user")
@Validated
public class UserController {
    @GetMapping("/getByUserId/{userId}")
    public String detail(@PathVariable("userId") @Length(min = 10, max = 20) String userId) {
        System.out.println(userId);
        return "查询成功";
    }
}

抛出异常，返回500状态码：javax.validation.ConstraintViolationException: detail.userId: 长度需要在10和20之间

控制层接口(RequestParam)

package com.huangjiliang.validator.controller;

import com.huangjiliang.validator.dto.UserDTO;
import org.hibernate.validator.constraints.Length;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import javax.validation.constraints.NotNull;

@RestController
@RequestMapping("user")
@Validated
public class UserController {

    @GetMapping("getByAccount")
    public String getByAccount(@Length(min = 6, max = 20) @NotNull String account) {
        System.out.println(account);
        return "查询成功";
    }
}

返回500状态码，抛出异常：javax.validation.ConstraintViolationException: getByAccount.account: 长度需要在6和20之间

异常时自定义返回信息

从以上抛出的信息，可以看到抛出的异常会是：javax.validation.ConstraintViolationException和org.springframework.web.bind.MethodArgumentNotValidException。

在实际项目开发中，通常会用同意异常处理来返回一个更友好的提示。比如我们系统要求无论发送什么异常，http的状态码必须返回200，由业务去区分系统的异常情况

自定义异常代码

package com.huangjiliang.validator.exception;

import com.alibaba.fastjson.JSONObject;
import org.springframework.http.HttpStatus;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import javax.validation.ConstraintViolationException;
import java.util.StringJoiner;

@RestControllerAdvice
public class CommonExceptionHandler {

    @ExceptionHandler(MethodArgumentNotValidException.class)
    @ResponseStatus(HttpStatus.OK)
    @ResponseBody
    public JSONObject handleMethodArgumentNotValidException(MethodArgumentNotValidException ex) {
        BindingResult bindingResult = ex.getBindingResult();
        StringJoiner joiner = new StringJoiner(";");
        for (FieldError fieldError : bindingResult.getFieldErrors()) {
            joiner.add(fieldError.getField() + "：" + fieldError.getDefaultMessage());
        }
        JSONObject result = new JSONObject();
        result.put("code", "400");
        result.put("msg", joiner.toString());
        return result;
    }

    @ExceptionHandler(ConstraintViolationException.class)
    @ResponseStatus(HttpStatus.OK)
    @ResponseBody
    public JSONObject handleConstraintViolationException(ConstraintViolationException ex) {
        JSONObject result = new JSONObject();
        result.put("code", "400");
        result.put("msg", ex.getMessage());
        return result;
    }

}

加上异常捕获之后，重新执行异常接口方法：

分组校验

在实际项目开发中，可能多个方法需要使用同一个DTO类来接收参数，而不同方法的校验规则很可能是一样的。这个时候，简单地在DTO类字段上加约束注解无法解决这个问题，因此，spring-validation支持了分组功能，专门用来解决类似这个的问题。

比如：新增User时，userId是可为空，而更新User时，userId是必传的；其他字段的校验规则在新增和更新两种情况下不一样，这个时候就分组校验就排上用场了。

DTO类（分组改造后的DTO）

package com.huangjiliang.validator.dto;

import lombok.Data;
import lombok.ToString;
import org.hibernate.validator.constraints.Length;

import javax.validation.constraints.NotNull;

@Data
@ToString
public class UserDTO {

    @NotNull(groups = Update.class)
    private Long userId;

    @NotNull(groups = {Save.class, Update.class})
    @Length(min = 2, max = 10)
    private String username;

    @NotNull(groups = {Save.class, Update.class})
    @Length(min = 6, max = 20)
    private String account;

    @NotNull(groups = {Save.class, Update.class})
    @Length(min = 6, max = 20)
    private String password;

    /**
     * 新增时候校验分组
     */
    public interface Save{}

    /**
     * 更新的时候校验分组
     */
    public interface Update{}

}

控制层接口

package com.huangjiliang.validator.controller;

import com.huangjiliang.utils.ValidatedForSaveGroup;
import com.huangjiliang.utils.ValidatedForUpdateGroup;
import com.huangjiliang.validator.dto.UserDTO;
import org.hibernate.validator.constraints.Length;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import javax.validation.constraints.NotNull;

@RestController
@RequestMapping("user")
@Validated
public class UserController {


    @PostMapping("create")
    public String create(@RequestBody @Validated(ValidatedForSaveGroup.class) UserDTO userDTO) {
        System.out.println(userDTO);
        return "新增成功";
    }
    
    @PostMapping("update")
    public String update(@RequestBody @Validated(value = ValidatedForUpdateGroup.class) UserDTO userDTO) {
        System.out.println(userDTO);
        return "新增成功";
    }
}

新增时可以不穿userId，但是更新时，返回userId不能为null

嵌套校验

前面的实例中，DTO类里面的字段那都是基本数据类型和String类型，但是在实际场景中，有可能某个字段也是一个对象，这种情况可以使用嵌套校验

比如：保存User信息的时候，同时还保存Dept信息，需要注意：此时DTO类对应字段必须标记@Valid注解

DTO类（嵌套校验改造）

package com.huangjiliang.validator.dto;

import com.huangjiliang.utils.ValidatedForSaveGroup;
import com.huangjiliang.utils.ValidatedForUpdateGroup;
import lombok.Data;
import lombok.ToString;
import org.hibernate.validator.constraints.Length;

import javax.validation.Valid;
import javax.validation.constraints.NotNull;

@Data
@ToString
public class UserDTO {

    @NotNull(groups = ValidatedForUpdateGroup.class)
    private Long userId;

    @NotNull(groups = {ValidatedForSaveGroup.class, ValidatedForUpdateGroup.class})
    @Length(min = 2, max = 10)
    private String username;

    @NotNull(groups = {ValidatedForSaveGroup.class, ValidatedForUpdateGroup.class})
    @Length(min = 6, max = 20)
    private String account;

    @NotNull(groups = {ValidatedForSaveGroup.class, ValidatedForUpdateGroup.class})
    @Length(min = 6, max = 20)
    private String password;

    @NotNull(groups = {ValidatedForSaveGroup.class, ValidatedForUpdateGroup.class})
    @Valid
    private DeptDTO deptDTO;

}

package com.huangjiliang.validator.dto;

import com.huangjiliang.utils.ValidatedForSaveGroup;
import com.huangjiliang.utils.ValidatedForUpdateGroup;
import lombok.Data;
import lombok.ToString;
import org.hibernate.validator.constraints.Length;

import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;

@Data
@ToString
public class DeptDTO {

    @Min(value = 1, groups = ValidatedForUpdateGroup.class)
    @NotNull(groups = ValidatedForUpdateGroup.class)
    private Long deptId;

    @NotNull(groups = {ValidatedForSaveGroup.class, ValidatedForUpdateGroup.class})
    private String deptName;

    @NotNull(groups = {ValidatedForSaveGroup.class, ValidatedForUpdateGroup.class})
    @Length(min = 4, max = 6)
    private String deptCode;

}

从以上分析可知，已经嵌套校验到DeptDTO类了

集合校验

如果请求体直接传递了json数组给后台，并希望对数组中的每一项都进行参数校验。此时，如果我们直接使用java.util.Collection的list或者Set来接收数据，参数校验并不会生效。

但是我们可以使用自定义List或者Set来接收参数

包装List类型

package com.huangjiliang.utils;

import lombok.experimental.Delegate;

import javax.validation.Valid;
import java.util.ArrayList;
import java.util.List;

public class ValidationList<E> implements List<E> {

    // @Delegate是lombok注解：作用于容器变量，为该变量生成一堆常用的方法，这些方法都是容器中的方法；
    // 受lombok版本限制，1.18.6以上版本可支持。如果校验不通过，会抛出NotReadablePropertyException，同样可以使用统一异常进行处理。
    @Delegate
    @Valid // 一定要家@Valid注解
    public List<E> list = new ArrayList<>();

    @Override
    public String toString() {
        return super.toString();
    }
}

捕获异常类新增捕获NotReadablePropertyException异常

@ExceptionHandler(NotReadablePropertyException.class)
    @ResponseStatus(HttpStatus.OK)
    @ResponseBody
    public JSONObject handleConstraintViolationException(NotReadablePropertyException ex) {
        JSONObject result = new JSONObject();
        result.put("code", "400");
        result.put("msg", ex.getMessage());
        return result;
    }

控制层

package com.huangjiliang.validator.controller;

import com.huangjiliang.utils.ValidatedForSaveGroup;
import com.huangjiliang.utils.ValidatedForUpdateGroup;
import com.huangjiliang.utils.ValidationList;
import com.huangjiliang.validator.dto.UserDTO;
import org.hibernate.validator.constraints.Length;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import javax.validation.constraints.NotNull;

@RestController
@RequestMapping("user")
@Validated
public class UserController {

    @PostMapping("saveBatch")
    public String createBatch(@RequestBody @Validated(ValidatedForSaveGroup.class) ValidationList<UserDTO> userList) {
        System.out.println(userList);
        return "新增成功";
    }
}

从以上两张图分析，缺少了deptName之后，校验失败会抛出异常：org.springframework.beans.NotReadablePropertyException 后进入异常捕获，返回400状态码

自定义校验

业务总是比框架提供的这些简单校验要复杂得多，我们可以自定义校验来满足我们的需求。

自定义spring-calidation非常简单，假设我们自定义加密id（由数字或者a-f的字母组成，32-256长度）校验，主要分为两部

1.自定义约束注解

package com.huangjiliang.validator.annotation;

import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

@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 {};
    
}

2.实现`ConstraintValidator`接口编写约束校验器

package com.huangjiliang.validator.annotation;

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

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;
    }
}

编程式校验

以上实例都是基于注解来实现自动校验的，在某些情况下，我们可以希望以编程方式调用验证

这个时候可以注入javax.validation.Validator对象，然后再调用其api

package com.huangjiliang.validator.controller;

import com.huangjiliang.validator.utils.ValidatedForSaveGroup;
import com.huangjiliang.validator.utils.ValidatedForUpdateGroup;
import com.huangjiliang.validator.utils.ValidationList;
import com.huangjiliang.validator.dto.UserDTO;
import org.hibernate.validator.constraints.Length;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import javax.validation.ConstraintViolation;
import javax.validation.constraints.NotNull;
import java.util.Set;

@RestController
@RequestMapping("user")
@Validated
public class UserController {

    @Autowired
    private javax.validation.Validator globalValidator;

    /**
     * 编程式校验
     * @param userDTO
     * @return
     */
    @PostMapping("/saveWithCodingValidate")
    public String saveWithCodingValidate(@RequestBody UserDTO userDTO) {
        Set<ConstraintViolation<UserDTO>> validate = globalValidator.validate(userDTO, ValidatedForSaveGroup.class);
        // 如果校验通过，validate为空；否则，validate包含未校验通过项
        if (validate.isEmpty()) {
            // 校验通过，才会执行业务逻辑处理

        } else {
            for (ConstraintViolation<UserDTO> userDTOConstraintViolation : validate) {
                // 校验失败，做其它逻辑
                System.out.println(userDTOConstraintViolation);
            }
        }
        return "新增成功";
    }
}

快速失败

spring-validation默认会校验玩所有字段，然后才抛出异常

可以通过一些简单的配置，开启Fail Fast模式，一旦校验失败就立即返回

@Bean
public Validator validator() {
    ValidatorFactory validatorFactory = Validation.byProvider(HibernateValidator.class)
            .configure()
            // 快速失败模式
            .failFast(true)
            .buildValidatorFactory();
    return validatorFactory.getValidator();
}

@Valid和@Validated区别

类别	@Valid	@Validated
提供者	JSR-303规范	Spring
是否支持分组	不支持	支持
标注位置	METHOD、FIELED、CONSTRUCTOR, PARAMETER, TYPE_USE	TYPE, METHOD, PARAMETER
嵌套校验	支持	不支持

Hibernate-validator ​

校验介绍 ​

引入依赖 ​

演示代码及学习网址 ​

前言 ​

ReuqestBody参数校验 ​

在DTO字段上生命约束注解 ​

DTO类 ​

控制层接口 ​

RequestParam/PathVariable参数校验 ​

控制层接口(PathVariable) ​

控制层接口(RequestParam) ​

异常时自定义返回信息 ​

自定义异常代码 ​

分组校验 ​

DTO类（分组改造后的DTO） ​

控制层接口 ​

嵌套校验 ​

DTO类（嵌套校验改造） ​

集合校验 ​

包装List类型 ​

捕获异常类新增捕获NotReadablePropertyException异常 ​

控制层 ​

自定义校验 ​

1.自定义约束注解 ​

2.实现ConstraintValidator接口编写约束校验器 ​

编程式校验 ​

快速失败 ​

@Valid和@Validated区别 ​

内置限制注解 ​

Hibernate-validator

校验介绍

引入依赖

演示代码及学习网址

前言

ReuqestBody参数校验

在DTO字段上生命约束注解

DTO类

控制层接口

RequestParam/PathVariable参数校验

控制层接口(PathVariable)

控制层接口(RequestParam)

异常时自定义返回信息

自定义异常代码

分组校验

DTO类（分组改造后的DTO）

控制层接口

嵌套校验

DTO类（嵌套校验改造）

集合校验

包装List类型

捕获异常类新增捕获NotReadablePropertyException异常

控制层

自定义校验

1.自定义约束注解

2.实现`ConstraintValidator`接口编写约束校验器

编程式校验

快速失败

@Valid和@Validated区别

内置限制注解