一、@Valid和@Validated的介绍

1.引入jar包

  1. <dependency>
  2.   <groupId>org.springframework.boot</groupId>
  3.   <artifactId>spring-boot-starter-validation</artifactId>
  4. </dependency>

2. @Valid和@Validated的作用

@Validated、@Valid 等校验注解来替代手动对参数进行校验，简单来说就是将参数校验和业务逻辑代码分开。

3.@Valid和@Validated的区别

  1. @Valid：没有分组的功能。
  2. @Valid：可以用在方法、构造函数、方法参数和成员属性（字段）上
  3. @Validated：提供了一个分组功能，可以在入参验证时，根据不同的分组采用不同的验证机制
  4. @Validated：可以用在类型、方法和方法参数上。但是不能用在成员属性（字段）上

4.常用的参数校验注解

6.@Valid和@Validated的使用 - 图1

二、@Valid和@Validated的使用

1. 捕获全局异常配置类

因为使用注解检验参数会抛出异常，而这个异常是在方法中捕获不到的所以需要全局捕获异常，再根据异常类型提示相应的提示。

  1. package com.fwy.corebasic.common.handlerexception;
  3. import com.fwy.common.help.DoResult;
  4. import com.fwy.common.help.DoResultType;
  5. import com.fwy.common.utils.CommonResponse;
  6. import com.fwy.common.utils.LogUtil;
  7. import org.apache.commons.lang3.StringUtils;
  8. import org.springframework.validation.BindException;
  9. import org.springframework.validation.FieldError;
  10. import org.springframework.web.HttpRequestMethodNotSupportedException;
  11. import org.springframework.web.bind.MethodArgumentNotValidException;
  12. import org.springframework.web.bind.annotation.ControllerAdvice;
  13. import org.springframework.web.bind.annotation.ExceptionHandler;
  14. import org.springframework.web.bind.annotation.ResponseBody;
  15. import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
  17. import javax.servlet.http.HttpServletRequest;
  18. import javax.servlet.http.HttpServletResponse;
  19. import javax.validation.ConstraintViolation;
  20. import javax.validation.ConstraintViolationException;
  21. import java.util.ArrayList;
  22. import java.util.Arrays;
  23. import java.util.List;
  24. import java.util.concurrent.atomic.AtomicBoolean;
  27. /**
  28.  * @author 前端接口和后台参数校验
  29.  */
  30. @ControllerAdvice
  31. public class MyExceptionHandler {
  33.     public final static String[] INTERFACE_PATH_ARRAY = {"api","wxApi"};
  35.     @ResponseBody
  36.     @ExceptionHandler(value = {BindException.class,MethodArgumentNotValidException.class})
  37.     public Object validated(Exception e,HttpServletRequest request) {
  39.         LogUtil.warn("参数校验提示:{}",request.getRequestURL(), e);
  40.         List<FieldError> fieldErrors = null;
  41.         if (e instanceof BindException){
  42.             BindException e1=(BindException) e;
  43.             fieldErrors= e1.getBindingResult().getFieldErrors();
  44.         }else {
  45.             MethodArgumentNotValidException e2= (MethodArgumentNotValidException) e;
  46.             fieldErrors =e2.getBindingResult().getFieldErrors();
  47.         }
  48.         List<String> validationResults = new ArrayList<>();
  49.         for (FieldError fieldError : fieldErrors) {
  50.             validationResults.add(fieldError.getDefaultMessage());
  51.         }
  52.         String messages = StringUtils.join(validationResults.toArray(), ";");
  53.         return returnMessage(request,messages);
  54.     }
  55.     @ResponseBody
  56.     @ExceptionHandler(ConstraintViolationException.class)
  57.     public Object paramException(ConstraintViolationException  e,HttpServletRequest request){
  58.         LogUtil.warn("参数校验提示:{}",e);
  59.         List<String> msgList = new ArrayList<>();
  60.         for (ConstraintViolation<?> constraintViolation : e.getConstraintViolations()) {
  61.             msgList.add(constraintViolation.getMessage());
  62.         }
  63.         String messages = StringUtils.join(msgList.toArray(), ";");
  64.         return returnMessage(request,messages);
  65.     }
  66.     /**
  67.      * 违反约束异常处理
  68.      * @param e
  69.      * @return
  70.      */
  71. //    @ExceptionHandler(ConstraintViolationException.class)
  72. //    @ResponseBody
  73. //    public Object  handConstraintViolationException(ConstraintViolationException e) {
  74. //        LogUtil.error(e.getMessage(), e);
  75. //        return e;
  76. //    }
  78. //    @ExceptionHandler(AbstractHandlerMethodExceptionResolver.class)
  79. //    @ResponseBody
  80. //    public Object methodWayHandle(ExceptionHandlerExceptionResolver e,HttpServletRequest request){
  81. //        LogUtil.error("前端传入{}参数不符合接口格式",e.getApplicationContext());
  82. //        return returnMessage(request,"错误");
  83. //    }
  86.     @ExceptionHandler(MethodArgumentTypeMismatchException.class)
  87.     @ResponseBody
  88.      public Object methodParamHand(MethodArgumentTypeMismatchException e, HttpServletRequest request){
  89.         LogUtil.error("前端传入{}参数不符合接口格式，提示信息{}",e.getName(),e.getMessage());
  90.         return returnMessage(request,"前端传入参数"+e.getName()+"不符合接口格式");
  91.      }
  94.     @ExceptionHandler(HttpRequestMethodNotSupportedException.class)
  95.     public Object handleHttpRequestMethodNotSupported(HttpRequestMethodNotSupportedException e,
  96.                                                           HttpServletRequest request) {
  97.         String requestURI = request.getRequestURI();
  98.         LogUtil.error("请求地址'{}',不支持'{}'请求", requestURI, e.getMethod());
  99.         return returnMessage(request,"请求地址'"+requestURI+"',不支持'"+e.getMethod()+"'请求");
  100.     }
  102.     @ExceptionHandler(Exception.class)
  103.     @ResponseBody
  104.     public Object exceptionHand(Exception e, HttpServletRequest request, HttpServletResponse response) {
  105.         LogUtil.error("发生异常的请求地址{}",request.getRequestURL(),e);
  106.         return returnMessage(request,"系统异常");
  107.     }
  110.     public static Object returnMessage(HttpServletRequest request,String message){
  111.         String url = request.getRequestURI();
  112.         AtomicBoolean flag = new AtomicBoolean(false);
  113.         Arrays.stream(INTERFACE_PATH_ARRAY).forEach(path -> {
  114.             if (url.contains(path)) {
  115.                 flag.set(true);
  116.             }
  117.         });
  118.         if(flag.get()){
  119.             DoResult result = new DoResult();
  120.             result.setStateMsg(message);
  121.             result.setStateType(DoResultType.fail);
  122.             return result;
  123.         }else {
  124.             CommonResponse result = new CommonResponse();
  125.             result.setMsg(message);
  126.             result.setCode(DoResultType.fail.getValue());
  127.             return result;
  128.         }
  129.     }
  132. }

2.单个接口参数校验

  1.    /****
  2.      * description: 获取学习试题数据接口
  3.      * version: 1.0 ->
  4.      * date: 2022/5/17 11:45
  5.      * author: xiaYZ
  6.      * iteration: 迭代说明
  7.      * @param deptId    部门id
  8.      * @param weiXinUserId   微信用户id
  9.      * @param businessId 业务id
  10.      * @return com.fwy.common.help.DoResult
  11.      */
  12.     @GetMapping("getStudyQuestionPaper")
  13.     @Validated
  14.     public DoResult getStudyQuestionPaper(@NotNull(message = "部门id不能为空") Long deptId,
  15.                                           @NotNull(message = "微信用户id不能空") Long weiXinUserId,
  16.                                           @NotNull(message = "业务id不能为空") Long businessId){
  17.         DoResult result = new DoResult();
  18.         return result;
  19.     }

如图展示，当业务id为空是提示参数校验信息
6.@Valid和@Validated的使用 - 图2

3.接口类参数校验提示

  1.     /***
  2.      * description: saveStageQuestion
  3.      * version: 1.0
  4.      * date: 2020/4/24 17:58
  5.      * author: objcat
  6.      * @param questionBank
  7.      * @return com.jrwp.common.help.CommonResponse
  8.      */
  9.     @ResponseBody
  10.     @RequestMapping("saveQuestion")
  11.     @Description("保存题库数据")
  12.     public CommonResponse saveQuestion(@Validated QuestionBank questionBank){
  13.         CommonResponse response = new CommonResponse();
  14.         return response;
  15.     }
  1. @TableName(value ="QUESTION_BANK")
  2. @KeySequence(value = "SEQ_QUESTION_BANK")
  3. @Data
  4. public class QuestionBank implements Serializable {
  7.     public static final String REDIS_KEY = "QUESTION_BANK";
  8.     /**
  9.      * 主键
  10.      */
  11.     @TableId
  12.     private Long id;
  14.     /**
  15.      * 知识体系id(数据字典中)
  16.      */
  17.     @TableField(value = "KNOWLEDGE_ID")
  18.     private Long knowledgeId;
  20.     /**
  21.      * 目类型(0单选题,1多选题)
  22.      */
  23.     @TableField(value = "QUESTION_TYPE")
  24.     private Integer questionType;
  26.     /**
  27.      * 是否启用(0否,1是)
  28.      */
  29.     @TableField(value = "IS_START")
  30.     private Integer isStart;
  32.     /**
  33.      * 题目标题
  34.      */
  35.     @TableField(value = "TITLE")
  36.     @Length(max = 500,message = "题目标题长度不能超过500")
  37.     private String title;
  39.     /**
  40.      * 题目答案
  41.      */
  42.     @TableField(value = "ANSWER")
  43.     @Length(max = 20,message = "题目答案长度不能超过20")
  44.     private String answer;
  46.     /**
  47.      * 说明
  48.      */
  49.     @TableField(value = "REMARKS")
  50.     @Length(max = 500,message = "说明长度不能超过500")
  51.     private String remarks;
  53.     /**
  54.      * 题目选项用|分割
  55.      */
  56.     @TableField(value = "OPTIONS")
  57.     @Length(max = 500,message = "题目选项长度不能超过500")
  58.     private String options;
  60.     /**
  61.      * 创建时间
  62.      */
  63.     @TableField(value = "CREATE_TIME")
  64.     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8",locale = "zh")
  65.     private Date createTime;
  67.     /**
  68.      * 知识体系名称
  69.      */
  70.     @TableField(value = "KNOWLEDGE_NAME")
  71.     private String knowledgeName;
  73.     /**
  74.      * 题目图片路径
  75.      */
  76.     @TableField(value = "PhOTO_URL")
  77.     private String photoUrl;
  79.     @TableField(exist = false)
  80.     private static final long serialVersionUID = 1L;
  81. }

如图提示：当数据字段长度超过注解中注释的则会提示信息
6.@Valid和@Validated的使用 - 图3

4.嵌套类注解提示

当我们需要校验嵌套类时，如A包含B，C两个类（A:{B,C}），需要检验B中b字段。

4.1. 实体类数据

  1. @Data
  2. public class SubmitStudyParam {
  4.     /**
  5.      * 学习记录
  6.      */
  7.     @Valid
  8.     @NotNull(message = "学习记录不能为空")
  9.     private StudyRecordApi studyRecordApi;
  11.     /**
  12.      * 业务名称
  13.      */
  14.     @NotEmpty(message = "业务名称不能为空")
  15.     private String businessName;
  17.     /**
  18.      * 部门id
  19.      */
  20.     @NotNull(message = "部门id不能为空")
  21.     private Long deptId;
  23.     /**
  24.      * 部门名称
  25.      */
  26.     @NotEmpty(message = "部门名称不能为空")
  27.     private String deptName;
  29.     /**
  30.      * 当前刷题id
  31.      */
  32.     private Long nowQuestionId;
  33. }
  1. @Data
  2. public class StudyRecordApi implements Serializable {
  3.     /**
  4.      * 主键
  5.      */
  6.     private Long id;
  8.     /**
  9.      * 注册用户id
  10.      */
  11.     @NotNull(message = "注册用户id不能为空")
  12.     private Long registerUserId;
  15.     /**
  16.      * 注册用户姓名
  17.      */
  18.     @NotEmpty(message = "注册用户姓名不能为空")
  19.     private String registerUserName;
  21.     /**
  22.      * 学习类型(0刷题学习,1文档学习,2视频学习)
  23.      */
  24.     @NotNull(message = "学习类型不能为空")
  25.     private Integer type;
  27.     /**
  28.      * 事件id,不同类型对应不同表,0时对应刷题学习表,1,2时对应文档表
  29.      */
  30.     private Long eventId;
  32.     /**
  33.      * 学习开始时间
  34.      */
  35.     private Date startTime;
  38.     /**
  39.      * 开始学习时间字符串
  40.      */
  41.     @NotEmpty(message = "开始学习时间不能为空")
  42.     private String startTimeStr;
  44.     /**
  45.      * 学习结束时间
  46.      */
  47.     private Date endTime;
  50.     /**
  51.      * 学习结束时间字符串
  52.      */
  53.     @NotEmpty(message = "学习结束时间不能为空")
  54.     private String endTimeStr;
  55.     /**
  56.      * 创建时间
  57.      */
  58.     private Date createTime;
  60.     /**
  61.      * 申请记录id
  62.      */
  63.     @NotNull(message = "申请记录id不能为空")
  64.     private Long applyId;
  66.     private static final long serialVersionUID = 1L;
  67. }

4.2.接口校验

  1.    /****
  2.      * description: 提交文档学习
  3.      * version: 1.0 ->
  4.      * date: 2022/5/18 11:50
  5.      * author: xiaYZ
  6.      * iteration: 迭代说明
  7.      * @param submitStudyParam
  8.      * @return com.fwy.common.help.DoResult
  9.      */
  10.     @ResponseBody
  11.     @PostMapping("submitStudyFile")
  12.     public DoResult submitStudyFile(@Validated @RequestBody SubmitStudyParam submitStudyParam){
  13.         DoResult result = new DoResult();
  14.         boolean flag = studyService.submitStudyFile(submitStudyParam);
  15.         if(flag){
  16.             result.setStateMsg("提交文档学习成功");
  17.             result.setStateType(DoResultType.success);
  18.         }else{
  19.             result.setStateMsg("提交文档学习失败");
  20.             result.setStateType(DoResultType.fail);
  21.         }
  22.         return result;
  23.     }

4.3. 接口调用

6.@Valid和@Validated的使用 - 图4

6.@Valid和@Validated的使用 - 图5

5. 分组校验

5.1 校验的实体类数据

  1. @Data
  2. public class SubmitStudyParam {
  4.     /**
  5.      * 练习题目
  6.      */
  7.     @NotNull(message = "练习题目不能为空",groups = {StudyService.class})
  8.     @Valid
  9.     private PracticePaper practicePaper;
  11.     /**
  12.      * 学习记录
  13.      */
  14.     @Valid
  15.     @NotNull(message = "学习记录不能为空")
  16.     private StudyRecordApi studyRecordApi;
  18.     /**
  19.      * 业务名称
  20.      */
  21.     @NotEmpty(message = "业务名称不能为空")
  22.     private String businessName;
  24.     /**
  25.      * 部门id
  26.      */
  27.     @NotNull(message = "部门id不能为空")
  28.     private Long deptId;
  30.     /**
  31.      * 部门名称
  32.      */
  33.     @NotEmpty(message = "部门名称不能为空")
  34.     private String deptName;
  36.     /**
  37.      * 当前刷题id
  38.      */
  39.     private Long nowQuestionId;
  40. }

注意：PracticePaper类注解中有一个group参数

5.2 接口校验

  1.   /****
  2.      * description: 提交文档学习
  3.      * version: 1.0 ->
  4.      * date: 2022/5/18 11:50
  5.      * author: xiaYZ
  6.      * iteration: 迭代说明
  7.      * @param submitStudyParam
  8.      * @return com.fwy.common.help.DoResult
  9.      */
  10.     @ResponseBody
  11.     @PostMapping("submitStudyFile")
  12.     public DoResult submitStudyFile(@Validated @RequestBody SubmitStudyParam submitStudyParam){
  13.         DoResult result = new DoResult();
  14.         boolean flag = studyService.submitStudyFile(submitStudyParam);
  15.         if(flag){
  16.             result.setStateMsg("提交文档学习成功");
  17.             result.setStateType(DoResultType.success);
  18.         }else{
  19.             result.setStateMsg("提交文档学习失败");
  20.             result.setStateType(DoResultType.fail);
  21.         }
  22.         return result;
  23.     }
  1.  /****
  2.      * description: 提交学习刷题试卷接口
  3.      * version: 1.0 ->
  4.      * date: 2022/5/18 10:26
  5.      * author: xiaYZ
  6.      * iteration: 迭代说明
  7.      * @param submitStudyParam 提交学习刷题试卷参数
  8.      * @return com.fwy.common.help.DoResult
  9.      */
  10.     @ResponseBody
  11.     @PostMapping("submitStudyPaper")
  12.     public DoResult submitStudyPaper(@Validated({StudyService.class}) @RequestBody SubmitStudyParam submitStudyParam){
  13.         DoResult result = new DoResult();
  14.         boolean flag = studyService.submitStudyPaper(submitStudyParam);
  15.         if(flag){
  16.             result.setStateMsg("提交学习试卷成功");
  17.             result.setStateType(DoResultType.success);
  18.         }else{
  19.             result.setStateMsg("提交学习试卷失败");
  20.             result.setStateType(DoResultType.fail);
  21.         }
  22.         return result;
  23.     }

两个接口都使用了SubmitStudyParam 作为接口参数，但是“提交学习刷题试卷接口”，我需要它校验“练习题目类”是否为空，但是“提交文档学习接口”则不需要，所以我使用了@Validated中的group参数

5.3 接口调用

1.提交学习刷题试卷接口演示

6.@Valid和@Validated的使用 - 图6
6.@Valid和@Validated的使用 - 图7

2.提交文档学习接口演示

6.@Valid和@Validated的使用 - 图8
6.@Valid和@Validated的使用 - 图9

6.分组校验和嵌套校验不能一起使用

换句话说当你使用@Valid做嵌套检验是，再使用group参数做分组校验时，它不能校验@Valid注解类中的字段

刷题学习类的校验提示

  1. @Data
  2. public class PracticePaper implements Serializable {
  3.     /**
  4.      * 主键
  5.      */
  6.     private Long id;
  8.     /**
  9.      * 注册用户id
  10.      */
  11.     @NotNull(message = "注册用户id不能为空")
  12.     private Long registerUserId;
  14.     /**
  15.      * 题目id列表
  16.      */
  17.     @NotEmpty(message = "题目id列表不能为空")
  18.     private String questionIdList;
  20.     /**
  21.      * 提交答案列表
  22.      */
  23.     @NotEmpty(message = "提交答案列表不能为空")
  24.     private String submitAnswerList;
  26.     /**
  27.      * 实际答案列表
  28.      */
  29.     @NotEmpty(message = "实际答案列表不能为空")
  30.     private String answerList;
  32.     /**
  33.      * 创建时间
  34.      */
  35.     private Date createTime;
  37.     private static final long serialVersionUID = 1L;
  38. }

解释：如图我这里的开始学习时间字段为空，但是提交接口后没有为空的提示，直接报错了
6.@Valid和@Validated的使用 - 图10
6.@Valid和@Validated的使用 - 图11