pom 文件引入

使用 Validation 前，要先在 pom 中引入相关依赖：

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

创建分组

在很多时候，同一个模型可能会在多处被用到，但每处的校验场景又不一定相同。如：新增信息 和 修改信息，参数可能都是 user 模型，在新增时 user 中 name 字段不能为空；在修改时 user 中 name 字段可以为空。这样我们可以用 groups 来实现，同一个模型在不同场景下，动态校验模型中的不同字段。因此先创建 Insert 和 Update 两个分组

  1. package com.test.tools.validation;
  3. public interface Insert {}
  1. package com.test.tools.validation;
  3. public interface Update {}

在实体类中添加校验信息

  1. package com.test.tools.entity;
  3. import com.test.tools.validation.Insert;
  4. import lombok.Data;
  5. import javax.validation.constraints.Email;
  6. import javax.validation.constraints.NotBlank;
  7. import javax.validation.constraints.NotNull;
  9. @Data
  10. public class DiffyEntity implements java.io.Serializable{
  12.     @NotBlank(message = "稳定版本的ip地址不能为空",groups = Insert.class)
  13.     protected String primaryIp;
  15.     @NotBlank(message = "稳定版本的端口不能为空",groups = Insert.class)
  16.     protected String primaryPort;
  18.     @NotBlank(message = "候选版本的ip地址不能为空",groups = Insert.class)
  19.     protected String candidateIp;
  21.     @NotBlank(message = "候选版本的端口不能为空",groups = Insert.class)
  22.     protected String candidatePort;
  24.     @NotBlank(message = "邮箱不能为空",groups = Insert.class)
  25.     @Email(message = "邮箱地址不合法")
  26.     protected String email;
  27. }

通过约束性的注解，可以对参数进行验证，并通过 groups 进行分组校验。

  • groups = Insert.class 则当前验证规则作用于 Insert 分组
  • groups = Update.class 则当前验证规则作用于 Update 分组

    约束性注解说明

    | 注解 | 作用 | 使用方法 | | —- | —- | —- | | @NotNull | 不能为null，可以是空 | @NotNull(message=””) | | @Null | 必须是null | @Null(message=””) | | @Email | 必须是email格式 | @Email(message=””) | | @Length | 长度必须在指定范围内 | @Length(min = 5, max = 10, message=””) | | @NotBlank | 字符串不能为null
    字符串trim()后也不能等于”” | @NotBlank(message=””) | | @NotEmpty | 不能为null
    集合、数组、map等size()不能为0；
    字符串trim()后可以等于”” | @NotEmpty(message=””) | | @Range | 值必须在指定范围内 | @Range(min = 100, max = 200, message=””) | | @URL | 必须是一个URL | @URL(message=””) | | @Pattern | 必须满足指定的正则表达式 | @Pattern(regexp = “\\d+”, message=””) | | @Max | 最大不得超过此最大值 | @Max(value = 200, message=””) | | @Min | 最大不得小于此最小值 | @Min(value = 200, message=””) | | @Future | 日期必须在当前日期的未来 | @Future(message=””) | | @Past | 日期必须在当前日期的过去 | @Past(message=””) | | @Digits | 设置必须是数字且数字整数的位数和小数的位数必须在指定范围内 | @Digits(integer = 5, fraction = 3, message=””) | | @DecimalMax | 设置不能超过最大值 | @DecimalMax(value = “12.3”,message=””) | | @DecimalMin | 设置不能超过最小值 | @DecimalMax(value = “12.3”,message=””) | | @AssertFalse | 可以为null，如果不为null的话必须为false | @AssertFalse(message=””) | | @AssertTrue | 可以为null，如果不为null的话必须为true | @AssertTrue(message=””) |

在Controller中使用@Validated注解

在 Controller 接口方法参数之前使用 @Validated 注解启用参数验证，可以赋值不同的分组名称进行分组验证，比如上面的 Insert.class 和 Update.class，分组验证可以用来处理不同接口需要校验不同参数的情况。验证不通过会返回前端 JSON 数据，处理方式有两种：使用 BindingResult 和 全局异常处理

BindingResult 处理

  1. @PostMapping("/post/diffy")
  2. public JsonResult save(@Validated(Insert.class) @RequestBody DiffyEntity diffyEntity, BindingResult bindingResult) {
  3.     if (bindingResult.hasErrors()) {
  4.         return JsonResult.fail(bindingResult.getFieldErrors().get(0).getDefaultMessage());
  5.     }
  6.     return diffyService.save(diffyEntity);
  7. }

全局异常处理

我用的是全局的异常处理，且接口返回的是json数据，因此先创建一个JsonResult，用于返回统一格式给到前端

  1. package com.test.tools.vo;
  3. public class JsonResult {
  4.     private int code;
  5.     private Object data;
  6.     private String msg;
  8.     public JsonResult() {
  9.     }
  11.     public JsonResult(int code, Object data) {
  12.         this.code = code;
  13.         this.data = data;
  14.     }
  16.     public JsonResult(int code, Object data, String msg) {
  17.         this.code = code;
  18.         this.data = data;
  19.         this.msg = msg;
  20.     }
  22.     public static JsonResult buildSuccess(Object data){
  23.         return new JsonResult(200,data);
  24.     }
  26.     public static JsonResult warn(String msg){
  27.         return new JsonResult(-1,"",msg);
  28.     }
  30.     public static JsonResult fail(String msg){
  31.         return new JsonResult(-1,"",msg);
  32.     }
  35.     public String getMsg() {
  36.         return msg;
  37.     }
  39.     public void setMsg(String msg) {
  40.         this.msg = msg;
  41.     }
  43.     public int getCode() {
  44.         return code;
  45.     }
  47.     public void setCode(int code) {
  48.         this.code = code;
  49.     }
  51.     public Object getData() {
  52.         return data;
  53.     }
  55.     public void setData(Object data) {
  56.         this.data = data;
  57.     }
  58. }

然后再创建一个全局异常处理的类 GlobalExceptionHandler，处理一些通用的异常

  1. package com.test.tools.exception;
  3. import com.test.tools.vo.JsonResult;
  4. import org.apache.catalina.connector.ClientAbortException;
  5. import org.springframework.dao.DataAccessResourceFailureException;
  6. import org.springframework.dao.EmptyResultDataAccessException;
  7. import org.springframework.dao.InvalidDataAccessApiUsageException;
  8. import org.springframework.http.converter.HttpMessageNotReadableException;
  9. import org.springframework.transaction.CannotCreateTransactionException;
  10. import org.springframework.web.HttpRequestMethodNotSupportedException;
  11. import org.springframework.web.bind.MethodArgumentNotValidException;
  12. import org.springframework.web.bind.MissingServletRequestParameterException;
  13. import org.springframework.web.bind.annotation.ControllerAdvice;
  14. import org.springframework.web.bind.annotation.ExceptionHandler;
  15. import org.springframework.web.bind.annotation.ResponseBody;
  16. import javax.servlet.http.HttpServletRequest;
  17. import javax.validation.UnexpectedTypeException;
  18. import java.sql.SQLTransientConnectionException;
  20. @ControllerAdvice
  21. public class GlobalExceptionHandler {
  22.     // 声明要捕获的异常
  23.     @ExceptionHandler(Error.class)
  24.     @ResponseBody
  25.     public JsonResult defaultError(HttpServletRequest request, Error e) {
  26.         if (e instanceof NoClassDefFoundError) {
  27.             return JsonResult.fail("找不到类错误" + e.getMessage());
  28.         }
  29.         // 未知错误
  30.         e.printStackTrace();
  31.         return JsonResult.fail("项目运行异常, 请联系技术人员...");
  32.     }
  34.     // 声明要捕获的异常
  35.     @ExceptionHandler(Exception.class)
  36.     @ResponseBody
  37.     public JsonResult defaultException(HttpServletRequest request, Exception e) {
  38.         // 请求方式有误
  39.         if (e instanceof HttpRequestMethodNotSupportedException) {
  40.             return JsonResult.warn("请求方式POST/GET有误");
  41.         }
  43.         /**
  44.          * @Validated 进行接口参数校验统一处理
  45.          */
  46.         if (e instanceof MethodArgumentNotValidException) {
  47.             MethodArgumentNotValidException exception = (MethodArgumentNotValidException)e;
  48.             return JsonResult.warn(exception.getBindingResult().getFieldErrors().get(0).getDefaultMessage());
  49.         }
  51.         /**
  52.          * 缺少参数异常
  53.          */
  54.         if (e instanceof MissingServletRequestParameterException) {
  55.             return JsonResult.warn("缺少请求参数");
  56.         }
  58.         /**
  59.          * 接口请求不对
  60.          */
  61.         if (e instanceof InvalidDataAccessApiUsageException) {
  62.             return JsonResult.warn("请检查接口请求是否缺少参数");
  63.         }
  65.         // 参数格式有误，比如int类型输入了abc
  66.         if (e instanceof HttpMessageNotReadableException) {
  67.             return JsonResult.warn("参数格式异常：" + e.getMessage());
  68.         }
  70.         if (e instanceof NumberFormatException) {
  71.             return JsonResult.warn("参数格式异常" + e.getMessage());
  72.         }
  74.         /**
  75.          * 没有匹配到的数据
  76.          */
  77.         if (e instanceof EmptyResultDataAccessException) {
  78.             return JsonResult.warn("数据不存在, 请检查参数是否正确");
  79.         }
  81.         /**
  82.          * 前面的都是警告，不输出错误信息
  83.          */
  84.         e.printStackTrace();
  86.         // id用了@NotBlank
  87.         if (e instanceof UnexpectedTypeException) {
  88.             return JsonResult.fail("请求参数类型异常" + e.getMessage());
  89.         }
  91.         // 数据库异常
  92.         if (e instanceof DataAccessResourceFailureException) {
  93.             return JsonResult.fail("数据库连接异常");
  94.         }
  95.         if (e instanceof SQLTransientConnectionException) {
  96.             return JsonResult.fail("数据库连接异常");
  97.         }
  98.         if (e instanceof CannotCreateTransactionException) {
  99.             return JsonResult.fail("数据库连接异常");
  100.         }
  102.         if (e instanceof ClientAbortException) {
  103.             return JsonResult.fail("中止了一个已建立的连接");
  104.         }
  106.         // 空指针异常
  107.         if (e instanceof NullPointerException) {
  108.             e.printStackTrace();
  109.             return JsonResult.fail("空指针异常");
  110.         }
  112.         // 未知错误
  113.         return JsonResult.fail("服务器处理异常, 请联系技术人员...");
  114.     }
  116. }

最后在 Controller 中，使用 @Validated 注解启用参数验证

  1. @PostMapping(path = "/post/diffy")
  2.     public JsonResult add(@Validated(Insert.class) @RequestBody DiffyEntity diffyEntity,Exception e){
  3.         // 异常处理，包括参数异常
  4.         if (e instanceof MethodArgumentNotValidException) {
  5.             MethodArgumentNotValidException exception = (MethodArgumentNotValidException)e;
  6.             return JsonResult.warn(exception.getBindingResult().getFieldErrors().get(0).getDefaultMessage());
  7.         }
  9.         // 保存提交记录
  10.         diffyService.addCommitLog(diffyEntity);
  11.         // 返回启动命令
  12.         JsonResult jsonResult = new JsonResult(200,diffyService.getStartCommand(),"success");
  13.         return jsonResult;
  14.     }

利用 postman 验证一下效果
1646563151(1).jpg