<properties>
    <hibernate-validate.version>5.2.0.Final</hibernate-validate.version>
</properties>

  <!--jsr 303-->
<dependency>
    <groupId>javax.validation</groupId>
    <artifactId>validation-api</artifactId>
    <version>1.1.0.Final</version>
</dependency>
<!-- hibernate validator-->
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-validator</artifactId>
    <!-- 注意使用了版本控制 -->
    <version>${hibernate-validate.version}</version>
</dependency>

public class TestProduct {
    @NotBlank
    @Length(max = 7)
    @Pattern(regexp = "^(([1-9]{1}\\d*)|([0]{1}))(\\.(\\d){0,2})?$")
    private String tranAmount;
    @NotBlank
    @Length(max = 3,min = 3)
    @Pattern(regexp = "^[A-Z]{3}$")
    private String currency;
    @NotBlank
    @Length(max = 100)
    private String tranReason;
    @NotBlank
    @Length(max = 100)
    private String gatherName;
    @NotBlank
    @Length(max = 10)
    private String business_type;
    /
    @NotBlank
    @Length(max = 10)
    private String pay_channel;
    // .......其他校验
    // 过滤 get/set 方法
}

@Controller
@RequestMapping("/test")
public class TestController{
    @RequestMapping(value = "/test", method = RequestMethod.POST)
    @ResponseBody
    public Object create(@Validated @RequestBody Product requestString, BindingResult bindResult) {
        // 统一处理校验注解的错误信息
        Result stringBuilder = dealWithError(bindResult);
        if (stringBuilder != null){
            return stringBuilder;
        }
       // 自己的业务处理...
        return ....;
    }
}

{
    "timestamp": "2021-01-01T12:08:49.859+00:00",
    "status": 400,
    "error": "Bad Request",
    "trace": "org.springframework.validation.BindException: org.springframework.validation.BeanPropertyBindingResult: 1 errors\nField error in object 'product' on field 'name': rejected value [null]; codes [NotBlank.product.name,NotBlank.name,NotBlank.java.lang.String,NotBlank]; arguments [org.springframework.context.support.DefaultMessageSourceResolvable: codes [product.name,name]; arguments []; default message ......",
    "message": "Validation failed for object='product'. Error count: 1",
    "errors": [
        {
            "codes": [
                "NotBlank.product.name",
                "NotBlank.name",
                "NotBlank.java.lang.String",
                "NotBlank"
            ],
            "arguments": [
                {
                    "codes": [
                        "product.name",
                        "name"
                    ],
                    "arguments": null,
                    "defaultMessage": "name",
                    "code": "name"
                }
            ],
            "defaultMessage": "不能为空",
            "objectName": "product",
            "field": "name",
            "rejectedValue": null,
            "bindingFailure": false,
            "code": "NotBlank"
        }
    ],
    "path": "//test/valid"
}

/**
 * 日期格式校验注解
 */
import org.hibernate.validator.constraints.EAN;
import org.hibernate.validator.constraints.NotBlank;
import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.*;
// 注意这里有静态导入
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
// javadoc 文档标识
@Documented
// 可以注入的类型，字段和参数类型
@Target({PARAMETER, FIELD})
// 运行时生效
@Retention(RUNTIME)
// 触发校验的对象
@Constraint(validatedBy = {TimeValidator.class})
public @interface Time {
    // 必须
    String message() default "时间格式校验失败";
    // 必须
    Class<?>[] groups() default {};
    // 必须
    Class<? extends Payload>[] payload() default {};
    String value = "";
    // 下面部分可以忽略
    @Target({ FIELD, METHOD, PARAMETER, ANNOTATION_TYPE })
    @Retention(RUNTIME)
    @Documented
    @interface List {
        Time[] value();
    }
}

HV000074: com.xxx.xxx.valid.annotation.Time contains Constraint annotation, but does not contain a groups parameter.

private static final String getConstraintWithoutMandatoryParameterException = "HV000074: %2$s contains Constraint annotation, but does not contain a %1$s parameter.";

@Message(
     id = 74,
     value = "%2$s contains Constraint annotation, but does not contain a %1$s parameter."
 )
 ConstraintDefinitionException getConstraintWithoutMandatoryParameterException(String var1, String var2);

public class TimeValidator implements ConstraintValidator<Time, String> {
    /**
     * 初始化注解的校验内容
     * @param constraintAnnotation
     */
    @Override
    public void initialize(Time constraintAnnotation) {
        System.err.println("test" + constraintAnnotation);
    }
    /**
    具体校验代码
    */
    @Override
    public boolean isValid(String value, ConstraintValidatorContext constraintContext) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        simpleDateFormat.setLenient(false);
        boolean isValid = true;
        try {
            simpleDateFormat.parse(value);
        } catch (Exception e) {
            isValid = false;
        }
        // 如果校验失败，设置自定义错误信息
        if ( !isValid ) {
            constraintContext.disableDefaultConstraintViolation();
            constraintContext.buildConstraintViolationWithTemplate(
                    "{com.zxd.interview.valid.annotation." +
                            "Time.message}"
            )
            .addConstraintViolation();//很重要的一步，需要将自定义的信息提示模板加入
        }
        return isValid;
    }
}

public interface ConstraintValidator<A extends Annotation, T> {
  /**
        初始化验证器，为isValid(Object, ConstraintValidatorContext)调用做准备。传递给定约束声明的约束注释。
        保证在使用此实例进行验证之前调用此方法。
        默认的实现是no-op。
   */
  default void initialize(A constraintAnnotation) {
  }
  /**
   * 实现验证逻辑,值的状态不能被改变。
        该方法可以并发访问，实现必须确保线程安全。
        @value：被校验的值
        @ConstraintValidatorContext 校验上下文
   */
  boolean isValid(T value, ConstraintValidatorContext context);
}

public class Product {
    @NotBlank
    private String name;
  // 自己定义的注解
    @Time
    private String time;
    // 省略get/set
}

@Override
public void doSomething(Product product) {
    ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
    Validator validator = factory.getValidator();
    Set<ConstraintViolation<Product>> validate = validator.validate(product);
    Map<Object, Object> objectObjectMap = new HashMap<>();
    validate.forEach(item -> {
        //            System.err.println("item = "+ item);
        String message = item.getMessage();
        //            System.err.println("message " + message);
        objectObjectMap.put(item.getPropertyPath(), message);
    });
    objectObjectMap.forEach((k, v) -> {
        System.err.println("key = " + k + " value = " + v);
    });
}

public class ValidateUtils {
    private static Validator validator =
            Validation.byProvider(HibernateValidator.class)
            .configure()
            .failFast(true)
            .buildValidatorFactory()
            .getValidator();
    private static final SmartValidator validatorAdapter = new SpringValidatorAdapter(validator);
    public static Validator getValidator() {
        return validator;
    }
    private static SmartValidator getValidatorAdapter(Validator validator) {
        return validatorAdapter;
    }
    /**
     * 校验参数，用于普通参数校验 [未测试！]
     *
     * @param
     */
    public static void validateParams(Object... params) {
        Set<ConstraintViolation<Object>> constraintViolationSet = validator.validate(params);
        if (!constraintViolationSet.isEmpty()) {
            throw new ConstraintViolationException(constraintViolationSet);
        }
    }
    /**
     * 校验对象
     *
     * @param object
     * @param groups
     * @param <T>
     */
    public static <T> void validate(T object, Class<?>... groups) {
        Set<ConstraintViolation<T>> constraintViolationSet = validator.validate(object, groups);
        if (!constraintViolationSet.isEmpty()) {
            throw new ConstraintViolationException(constraintViolationSet);
        }
    }
    /**
     * 校验对象
     * 使用与 Spring 集成的校验方式。
     *
     * @param object 待校验对象
     * @param groups 待校验的组
     * @throws BindException
     */
    public static <T> void validateBySpring(T object, Class<?>... groups)
            throws BindException {
        DataBinder dataBinder = getBinder(object);
        dataBinder.validate((Object[]) groups);
        if (dataBinder.getBindingResult().hasErrors()) {
            throw new BindException(dataBinder.getBindingResult());
        }
    }
    private static <T> DataBinder getBinder(T object) {
        DataBinder dataBinder = new DataBinder(object, ClassUtils.getShortName(object.getClass()));
        dataBinder.setValidator(getValidatorAdapter(validator));
        return dataBinder;
    }
}

public interface GroupUpdate extends Default {
}

@NotBlank(groups = {GroupUpdate.class})
private String name;

// 更新接口
@RequestMapping("/test/update")
public Object update(@Validated(GroupUpdate.class) Product product) throws ParamException {
    System.err.println(product);
     //....
}
// 新增接口
@RequestMapping("/test/add")
public Object add(@Validated Product product) throws ParamException {
    System.err.println(product);
    //....
}

org.springframework.validation.BeanPropertyBindingResult: 2 errors
Field error in object 'product' on field 'name': .....
Field error in object 'product' on field 'time': .....
org.springframework.validation.BeanPropertyBindingResult: 1 errors
Field error in object 'product' on field 'time': .....

public class Bag extends Product {
  // 分组使用 GroupAdd
    @NotNull(message = "颜色不能为空",groups = {GroupAdd.class})
    private String color;
    // get/set省略
}

public interface GroupsOpration extends GroupUpdate,GroupDel,GroupAdd{
}
public interface GroupUpdate extends Default {
}
public interface GroupDel extends Default {
}
public interface GroupAdd extends Default {
}

 /**
     * 测试组继承
     * @param product
     * @return
     * @throws ParamException
     */
    @RequestMapping("/test/bag1")
    public Object bag1(@Validated(GroupsOpration.class) Bag product) throws ParamException {
        System.err.println(product);
        return null;
    }
    /**
     * 测试组继承
     * @param product
     * @return
     * @throws ParamException
     */
    @RequestMapping("/test/bag2")
    public Object bag2(@Validated Bag product) throws ParamException {
        System.err.println(product);
        return null;
    }

Resolved [org.springframework.validation.BindException: org.springframework.validation.BeanPropertyBindingResult: 2 errors
Resolved [org.springframework.validation.BindException: org.springframework.validation.BeanPropertyBindingResult: 1 error     

@ControllerAdvice -> @Controller
@RestControllerAdvice -> @RestController

@ExceptionHandler({Exception.class})//主要注解
@ResponseStatus(HttpStatus.OK)
@ResponseBody
public Object allError(Exception ex) {
    // ex 就是异常信息对象，mvc会帮我们做好这一切
    return HttpStatus.ACCEPTED;
}

@RestControllerAdvice //@ControllerAdvice 对应 @Controller
public class ExceptionDealHandler {
    /**
     * 拦截未知的运行时异常
     */
    @ExceptionHandler(IllegalStateException.class)
    public Object notFount(IllegalStateException e)
    {
        if (AnnotationUtils.findAnnotation(e.getClass(), ResponseStatus.class) != null)
        {
            throw e;
        }
        return HttpStatus.ACCEPTED;
    }
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public Object doSomethings(MethodArgumentNotValidException e){
        return HttpStatus.ACCEPTED;
    }
    @ExceptionHandler(BindException.class)
    public Object bindError(BindException bind){
        return HttpStatus.ACCEPTED;
    }
    @ExceptionHandler({ConstraintViolationException.class})
    @ResponseStatus(HttpStatus.OK)
    @ResponseBody
    public Object handleConstraintViolationException(ConstraintViolationException ex) {
        return HttpStatus.ACCEPTED;
    }
    @ExceptionHandler({Exception.class})
    @ResponseStatus(HttpStatus.OK)
    @ResponseBody
    public Object allError(Exception ex) {
        return HttpStatus.ACCEPTED;
    }
}

@RestController
public class TestValid {
    // 注解校验接口
    @RequestMapping("/test/valid")
    public Object test(@Validated Product product) throws ParamException {
        System.err.println(product);
        throw new ParamException("","","");
    }
    /**
    在控制器层处理异常信息，仅仅适用于当前控制器
    */
    @ExceptionHandler(Exception.class)
    public Object processException(Exception e){
        System.err.println(e.getMessage());
        return null;
    }
}

/**
* 测试组继承
* @param product
* @return
* @throws ParamException
*/
@RequestMapping("/test/bag1")
@ResponseBody
public Object bag1(@Validated(GroupsOpration.class) Bag product, BindingResult bindingResult) throws ParamException {
    // 异常信息处理
    if(bindingResult.hasErrors()){
        List<FieldError> fieldErrors = bindingResult.getFieldErrors();
        Map<Object, Object> objectObjectHashMap = new HashMap<>();
        for (FieldError fieldError : fieldErrors) {
            objectObjectHashMap.put(fieldError.getField(), fieldError.getRejectedValue());
        }
        return objectObjectHashMap;
    }
    System.err.println(product);
    return null;
}

{
    "color": null,
    "time": "222"
}

@ExceptionHandler(IllegalStateException.class)
public Object notFount(IllegalStateException e)
{
    // 处理异常结果
}

@ExceptionHandler()
public Object notFount(Exception e,BindException bindExce, RuntimeException run) { // 这里指定多个Exception将无法生效
    // 处理异常结果
      return null;
}

Could not resolve parameter [2] in public java.lang.Object com.zxd.interview.valid.ExceptionDealHandler.notFount(java.lang.Exception,org.springframework.validation.BindException,java.lang.RuntimeException): No suitable resolver

@ExceptionHandler()
public Object notFount(Exception e,BindException bindExce) {//BindException 正常拦截处理
    // 处理异常结果
    return null;
}

/**
自定义异常类1
*/
public class BusinessException extends Exception{
    BusinessException(String code1, String code2, int code3){
    // ......
    }
    // ......
}
/**
自定义异常类2
*/
public class ParamException extends Exception{
    public ParamException(String code, String message, String error){
    // ......
    }
    // ......
}

 @ExceptionHandler()
public Object errors(ParamException e, BusinessException busine){//错误的写法
    return HttpStatus.ACCEPTED;
}

@ExceptionHandler(ParamException.class)
public Object errors(ParamException e){//错误的写法
    return HttpStatus.ACCEPTED;
}

@RequestMapping(value = "/createBatch", method = RequestMethod.POST)
@ResponseBody
public Object createBatch(@RequestBody @Validated List<ApiPaymentMsgDto> list, BindingResult bindResult, HttpServletRequest httpServletRequest) {
    if (CollectionUtils.isEmpty(list)) {
        return Result.build(401, "请求参数为空");
    }
    //.....省略代码
}

Section 3.1.3 of the JSR-303 Specification says that:
In addition to supporting instance validation, validation of graphs of object is also supported. The result of a graph validation is returned as a unified set of constraint violations. Consider the situation where bean X contains a field of type Y. By annotating field Y with the @Valid annotation, the Validator will validate Y (and its properties) when X is validated. The exact type Z of the value contained in the field declared of type Y (subclass, implementation) is determined at runtime. The constraint definitions of Z are used. This ensures proper polymorphic behavior for associations marked @Valid.
Collection-valued, array-valued and generally Iterable fields and properties may also be decorated with the @Valid annotation. This causes the contents of the iterator to be validated. Any object implementing java.lang.Iterable is supported.

JSR-303规范的3.1.3节说:
除了支持实例验证外，还支持对象图形的验证。
图形验证的结果作为约束违反的统一集合返回。
考虑bean X包含一个类型为Y的字段的情况，通过使用@Valid注释字段Y，验证器将在验证X时验证Y(及其属性)。
类型Y(子类，实现)声明的字段中包含的值的确切类型Z是在运行时确定的。
使用Z的约束定义。
这确保标记为@Valid的关联具有正确的多态行为。
集合值、数组值以及通常可迭代的字段和属性也可以用@Valid注释进行装饰。
这将导致验证迭代器的内容。
任何实现java.lang的对象。
支持Iterable。

  /**
     * 校验集合bean内容是否符合校验规则
     * 
     返回样例：
         {
            "status": 401,
            "msg": "第 1 条信息：手机号必须为11位,币种必须是3位大写字母|第 2 条信息：币种必须是3位大写字母,手机号必须为11位",
            "data": null
         }
     * @param apiObj 接口传输对象
     * @return
     */
    public ZmtResult validListBean(List<ApiPaymentMsgDto> apiObj) {
        if (CollectionUtils.isEmpty(apiObj)) {
            return ZmtResult.build(401, "请求参数为空");
        }
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < apiObj.size(); i++) {
            ApiPaymentMsgDto apiPaymentMsgDto = apiObj.get(i);
            if (null == apiPaymentMsgDto) {
                return ZmtResult.build(400, "第 %s 条信息请求参数为空", i);
            }
            Validator validator = ValidatorUtil.getValidator();
            Set<ConstraintViolation<ApiPaymentMsgDto>> validate = validator.validate(apiPaymentMsgDto);
            // 如果不存在校验异常，则返回空信息
            if (org.apache.commons.collections.CollectionUtils.isEmpty(validate)) {
                continue;
            }
            builder.append(String.format("第 %s 条信息：", i + 1));
            for (ConstraintViolation<ApiPaymentMsgDto> apiPaymentMsgDtoConstraintViolation : validate) {
                builder.append(apiPaymentMsgDtoConstraintViolation.getMessage());
                builder.append(",");
            }
            builder.deleteCharAt(builder.length() - 1);
            builder.append("|");
        }
        // 如果存在错误信息，返回错误提示，否则返回空对象证明没有异常
        if (builder.length() > 0) {
            builder.deleteCharAt(builder.length() - 1);
            return ZmtResult.build(401, builder.toString());
        } else {
            return null;
        }
    }

/**
 * 为了兼容注解校验使用的一种设计
 * <p>{@link #{https://stackoverflow.com/questions/28150405/validation-of-a-list-of-objects-in-spring/36313615#36313615}</p>
 *
 * @author zhaoxudong
 * @version 1.0
 * @date 2021/1/3 23:39
 */
public class ValidatorList<E> implements List<E> {
    @Valid
    private List<E> list;
    /**
     * 关键
     * @return
     */
    public List<E> getList() {
        return list;
    }
    /**
     * 关键
     * @return
     */
    public void setList(List<E> list) {
        this.list = list;
    }
    public ValidatorList() {
        this.list = new ArrayList<E>();
    }
    public ValidatorList(List<E> list) {
        this.list = list;
    }
}

 /**
     * 测试stackflow 的一种优雅设计，可以实现对应的list 集合bean对象校验
     *
     * @param products      校验对象
     * @param bindingResult 异常绑定器
     * @return
     * @throws ParamException
     */
@RequestMapping("/test/testvalidList")
@ResponseBody
public Object testvalidList(@RequestBody @Validated ValidatorList<Product> products, BindingResult bindingResult) throws ParamException {
    if (bindingResult.hasErrors()) {
        List<FieldError> fieldErrors = bindingResult.getFieldErrors();
        fieldErrors.forEach(item -> {
            String defaultMessage = item.getDefaultMessage();
            System.err.println(defaultMessage);
        });
    }
    System.err.println(products);
    return null;
}