【SpringBoot】SpringBoot 中使用自定义注解来实现接口参数校验

爱被打了一巴掌 2023-10-01 11:03 15阅读 0赞

在后台接口做参数校验，一般有两种方案：

  • hibernate-validator
  • AOP + 自定义注解 实现方法级的参数校验

开发环境：

JDK：1.8
SpringBoot：2.1.1.RELEASE
IDEA：2019.1.1

1. hibernate-validator

hibernate-validator 是 Hibernate 项目中的一个数据校验框架，是 Bean Validation 的参考实现。

使用 hibernate-validator 能够将数据校验从业务代码中脱离出来，增加代码可读性。同时，也让数据校验变得更加方便、简单。

添加 hibernate-validator 依赖：

  1. <dependency>
  2.     <groupId>org.hibernate</groupId>
  3.     <artifactId>hibernate-validator</artifactId>
  4.     <version>4.3.1.Final</version>
  5. </dependency>

【注意】：在 SpringBoot 2.1.1.RELEASE 中 不需要引入 Hibernate Validator ， 因为 在引入的 spring-boot-starter-web（springbootweb启动器）依赖的时候中，内部已经依赖了 hibernate-validator 依赖包。

待校验的Vo：

  1. public class ValidatorVo {
  4.     @NotEmpty(message = "用户名不能为空")
  5.     private String sName;
  7.     @NotEmpty(message = "手机号不能为空")
  8.     @Pattern(regexp = "^1[3|4|5|7|8][0-9]\\d{8}$", message = "手机号格式不正确")
  9.     private String sPhone;
  11.     @NotNull(message = "age 不能为空")
  12.     private Integer age;
  14.     //getter/setter
  15. }

说明：

  • @NotEmpty：使用 hibernate-validator 校验规则

定义一个控制器：

  1. @RestController
  2. @RequestMapping("/param")
  3. public class ParamController {
  6.     @PostMapping("/validator")
  7.     public String validator(@RequestBody @Valid ValidatorVo validatorVo) {
  9.         return "TEST VALIDATOR";
  10.     }
  12. }

说明：

  • @Valid：对其参数启用验证

定义一个全局异常类：

  1. @Slf4j
  2. @RestControllerAdvice
  3. public class GlobalExceptionHandler {
  6.     private static final String logExceptionFormat = "Capture Exception By GlobalExceptionHandler: Code: %s Detail: %s";
  8.     @ExceptionHandler(value = {
  9.     BindException.class, MethodArgumentNotValidException.class})
  10.     public Object validationExceptionHandler(Exception ex) {
  12.         return validationResult(1001, ex);
  13.     }
  15.     private <T extends Throwable> ResultVo validationResult(Integer code, T exception) {
  17.         // 做日志记录处理
  18.         doLog(code, exception);
  20.         BindingResult bindResult = null;
  21.         if (exception instanceof BindException) {
  23.             bindResult = ((BindException) exception).getBindingResult();
  24.         } else if (exception instanceof MethodArgumentNotValidException) {
  26.             bindResult = ((MethodArgumentNotValidException) exception).getBindingResult();
  27.         }
  28.         String msg = null;
  29.         if (null != bindResult && bindResult.hasErrors()) {
  31.             msg = bindResult.getAllErrors().get(0).getDefaultMessage();
  32.             if (msg.contains("NumberFormatException")) {
  34.                 msg = "参数类型错误！";
  35.             }
  36.         } else {
  38.             msg = "系统繁忙，请稍后重试...";
  39.         }
  40.         return ResultVoUtil.error(code, msg);
  41.     }
  43.     private <T extends Throwable> void doLog(Integer status, T exception) {
  45.         exception.printStackTrace();
  46.         log.error(String.format(logExceptionFormat, status, exception.getMessage()));
  47.     }
  49. }

ResultVoUtil：返回前端对象信息工具类

  1. public class ResultVoUtil {
  4.     public static ResultVo success() {
  6.         return success(null);
  7.     }
  8.     public static ResultVo success(Object object) {
  10.         ResultVo result = new ResultVo();
  11.         result.setCode(ResultCodeEnum.SUCCESS.getCode());
  12.         result.setMsg("成功");
  13.         result.setData(object);
  14.         return result;
  15.     }
  16.     public static ResultVo success(Integer code, Object object) {
  18.         return success(code, null, object);
  19.     }
  20.     public static ResultVo success(Integer code, String msg, Object object) {
  22.         ResultVo result = new ResultVo();
  24.         result.setCode(code);
  25.         result.setMsg(msg);
  26.         result.setData(object);
  27.         return result;
  28.     }
  30.     public static ResultVo error(String msg) {
  32.         ResultVo result = new ResultVo();
  33.         result.setCode(ResultCodeEnum.ERROR.getCode());
  34.         result.setMsg(msg);
  35.         return result;
  36.     }
  37.     public static ResultVo error(Integer code, String msg) {
  39.         ResultVo result = new ResultVo();
  40.         result.setCode(code);
  41.         result.setMsg(msg);
  42.         return result;
  43.     }
  45. }
  47. @Data
  48. public class ResultVo<T> {
  51.     // 错误码
  52.     private Integer code;
  54.     // 提示信息
  55.     private String msg;
  57.     // 返回的数据
  58.     private T data;
  60.     public boolean checkSuccess() {
  62.         return ResultCodeEnum.SUCCESS.getCode().equals(this.code);
  63.     }
  65. }

好了，这就是使用了 hibernate-validator 校验。

2. AOP + 自定义注解 实现方法级的参数校验

hibernate-validator 是在实体类上添加注解；但对于不同的方法，所应用的校验规则也是不一样的，这样子可能就会需要创建多个实体类或者组，甚至于一些接口根本就没实体类参数；所以实际应用过程中还是有一定的困难；

所以，这里简单地实现了一套基于 自定义注解 + AOP 的方式实现接口参数校验框架。在方法体上使用@CheckParam 或者 @CheckParams 注解标注需要校验的参数

步骤一：自定义注解

自定义注解，给需要校验的方法进行注解。分为：单参数校验 @MyCheckParam 和多参数校验 @MyCheckParams

MyCheckParam：

  1. @Target(ElementType.METHOD)
  2. @Retention(RetentionPolicy.RUNTIME)
  3. public @interface MyCheckParam {
  6.     // 字段校验规则
  7.     MyCheckParamEnum value() default MyCheckParamEnum.NOT_NULL;
  8.     // 参数名称。用"."表示层级。最多支持2级。如：userVo.userName
  9.     String argName();
  10.     // 表达式。多个值用","分割。跟argName有关。
  11.     String express() default "";
  12.     // 自定义提示信息
  13.     String msg() default "";
  15. }

【注意】：MyCheckParamEnum 是一个枚举类哈。

MyCheckParams：

  1. @Target(ElementType.METHOD)
  2. @Retention(RetentionPolicy.RUNTIME)
  3. public @interface MyCheckParams {
  6.     // 多个MyCheckParam，由上至下校验
  7.     MyCheckParam[] value();
  9. }

可以校验多个参数。

步骤二：自定义枚举校验类

  1. @Getter
  2. public enum MyCheckParamEnum {
  5.     NULL("参数必须为 null", MyCheckParamUtil::isNull),
  6.     NOT_NULL("参数必须不为 null", MyCheckParamUtil::isNotNull),
  7.     EMPTY("参数的必须为空", MyCheckParamUtil::isEmpty),
  8.     NOT_EMPTY("参数必须非空", MyCheckParamUtil::isNotEmpty),
  9.     LENGTH("参数长度必须在指定范围内", MyCheckParamUtil::inLength),
  10.     GE("参数必须大于等于指定值", MyCheckParamUtil::isGreaterThanEqual),
  11.     LE("参数必须小于等于指定值", MyCheckParamUtil::isLessThanEqual),
  12.     ;
  14.     private String msg;
  16.     // 接收字段值(Object)和 表达式(String)，返回是否符合规则(Boolean)
  17.     private BiFunction<Object, String, Boolean> fun;
  19.     MyCheckParamEnum(String msg, BiFunction<Object, String, Boolean> fun) {
  21.         this.msg = msg;
  22.         this.fun = fun;
  23.     }
  25. }

说明：

  1. 此枚举类是用于参数校验的。它有两个属性：msg、fun。msg：参数校验不通过时的默认报错信息；fun：进行参数校验时，需要执行的方法，位于 MyCheckParamUtil 类中。一个枚举实例对应一个 fun

步骤三：自定义枚举校验工具类

校验时，会调用此类中的方法。根据校验规则不同，调用的方法不同。如：

校验规则是 NULL，则它调用的方法是：MyCheckParamUtil::isNull

  1. public class MyCheckParamUtil {
  4.     // 判断对象是否不为 null
  5.     public static Boolean isNotNull(Object value, String express) {
  7.         if (null == value) {
  9.             return Boolean.FALSE;
  10.         }
  11.         return Boolean.TRUE;
  12.     }
  14.     public static Boolean isNull(Object value, String express) {
  16.         return !isNotNull(value, express);
  17.     }
  19.     // 判断value !=null && length、size > 0
  20.     public static Boolean isNotEmpty(Object value, String express) {
  22.         if(isNull(value, express)) {
  24.             return Boolean.FALSE;
  25.         }
  26.         if(value instanceof String && "".equals(((String) value).trim())) {
  28.             return Boolean.FALSE;
  29.         }
  30.         if(value instanceof Collection && CollectionUtils.isEmpty((Collection) value)) {
  32.             return Boolean.FALSE;
  33.         }
  34.         if (value instanceof Map && ((Map) value).isEmpty()) {
  36.             return Boolean.FALSE;
  37.         }
  38.         return Boolean.TRUE;
  39.     }
  41.     public static Boolean isEmpty(Object value, String express) {
  43.         return !isNotEmpty(value, express);
  44.     }
  46.     // 判断某个值的长度是否在某个范围
  47.     public static Boolean inLength(Object value, String express) {
  49.         if(isNull(value, express)) {
  51.             return Boolean.FALSE;
  52.         }
  53.         if(null == express || "".equals(express)) {
  55.             return Boolean.FALSE;
  56.         }
  57.         String[] split = express.split(",");
  58.         if (null == split || split.length != 2) {
  60.             return Boolean.FALSE;
  61.         }
  62.         if (value instanceof String) {
  64.             Integer begin = Integer.valueOf(split[0].trim());
  65.             Integer end = Integer.valueOf(split[1].trim());
  66.             Integer length = ((String) value).length();
  67.             return begin <= length && length <= end;
  68.         }
  69.         return Boolean.FALSE;
  70.     }
  72.     // 判断是否大于等于某个值
  73.     public static Boolean isGreaterThanEqual(Object value, String express) {
  75.         if (value == null) {
  77.             return Boolean.FALSE;
  78.         }
  79.         if(value instanceof Integer) {
  81.             return ((Integer) value) >= Integer.valueOf(express);
  82.         }
  83.         if(value instanceof Long) {
  85.             return ((Long) value) >= Long.valueOf(express);
  86.         }
  87.         if(value instanceof Short) {
  89.             return ((Short) value) >= Short.valueOf(express);
  90.         }
  91.         if(value instanceof Float) {
  93.             return ((Float) value) >= Float.valueOf(express);
  94.         }
  95.         if(value instanceof Double) {
  97.             return ((Double) value) >= Double.valueOf(express);
  98.         }
  99.         if(value instanceof String) {
  101.             return ((String) value).length() >= Integer.valueOf(express);
  102.         }
  103.         if(value instanceof Collection) {
  105.             return  ((Collection) value).size() >= Integer.valueOf(express);
  106.         }
  107.         return Boolean.FALSE;
  108.     }
  110.     // 判断是否大于等于某个值
  111.     public static Boolean isLessThanEqual(Object value, String express) {
  113.         if (value == null) {
  115.             return Boolean.FALSE;
  116.         }
  117.         if(value instanceof Integer) {
  119.             return ((Integer) value) <= Integer.valueOf(express);
  120.         }
  121.         if(value instanceof Long) {
  123.             return ((Long) value) <= Long.valueOf(express);
  124.         }
  125.         if(value instanceof Short) {
  127.             return ((Short) value) <= Short.valueOf(express);
  128.         }
  129.         if(value instanceof Float) {
  131.             return ((Float) value) <= Float.valueOf(express);
  132.         }
  133.         if(value instanceof Double) {
  135.             return ((Double) value) <= Double.valueOf(express);
  136.         }
  137.         if(value instanceof String) {
  139.             return ((String) value).length() <= Integer.valueOf(express);
  140.         }
  141.         if(value instanceof Collection) {
  143.             return  ((Collection) value).size() <= Integer.valueOf(express);
  144.         }
  145.         return Boolean.FALSE;
  146.     }
  148. }

步骤四：自定义 AOP

在 AOP 中，对注解进行解析、处理。主要逻辑在方法 doCheckParam() 中

MyCheckParamAspect：

  1. @Slf4j
  2. @Aspect
  3. @Component
  4. public class MyCheckParamAspect {
  7.     // 单个参数校验切入点
  8.     @Pointcut("@annotation(com.tinady.annotation.MyCheckParam)")
  9.     public void doMyCheckParam() {
  10.     }
  12.     // 多个参数校验切入点
  13.     @Pointcut("@annotation(com.tinady.annotation.MyCheckParams)")
  14.     public void doMyCheckParams() {
  15.     }
  17.     // 单参数校验
  18.     @Around("doMyCheckParam()")
  19.     public Object doMyCheckParamAround(ProceedingJoinPoint joinPoint) throws Throwable {
  21.         String msg = doCheckParam(joinPoint, false);
  22.         // 参数校验未通过，则直接抛出自定义异常
  23.         if (null != msg) {
  25.             throw new MyCheckParamException(msg);
  26.         }
  27.         // 参数校验通过，则继续执行原来方法
  28.         Object proceed = joinPoint.proceed();
  29.         return proceed;
  30.     }
  32.     // 多参数校验
  33.     @Around("doMyCheckParams()")
  34.     public Object doMyCheckParamsAround(ProceedingJoinPoint joinPoint) throws Throwable {
  36.         String msg = doCheckParam(joinPoint, true);
  37.         // 参数校验未通过，则直接抛出自定义异常
  38.         if (null != msg) {
  40.             throw new MyCheckParamException(msg);
  41.         }
  42.         // 参数校验通过，则继续执行原来方法
  43.         Object proceed = joinPoint.proceed();
  44.         return proceed;
  45.     }
  47.     /**
  48.     *
  49.     * 功能描述: 参数校验
  50.     *
  51.     * @param joinPoint 切点
  52.     * @param isMulti 是否是多参数校验
  53.     * @return java.lang.String 错误信息
  54.     * @date 2022-01-01 14:25
  55.     */
  56.     private String doCheckParam(ProceedingJoinPoint joinPoint, boolean isMulti) {
  58.         Method method = this.getMethod(joinPoint);
  59.         String[] paramNames = this.getParamNames(joinPoint);
  60.         // 获取前端传递后台接口的所有入参对应的入参值
  61.         Object[] arguments = joinPoint.getArgs();
  63.         Boolean isValid = Boolean.TRUE;
  64.         String msg = null;
  66.         // 单参数校验
  67.         if (!isMulti) {
  69.             // AOP监听带注解的方法，所以不用判断注解是否为空
  70.             MyCheckParam myCheckParam = method.getAnnotation(MyCheckParam.class);
  71.             String argName = myCheckParam.argName();
  72.             Object value = getParamValue(arguments, paramNames, argName);
  74.             // 通过执行fun来校验value
  75.             isValid = myCheckParam.value().getFun().apply(value, myCheckParam.express());
  77.             msg = myCheckParam.msg();
  78.             if (null == msg || "".equals(msg)) {
  80.                 msg = argName + ": " + myCheckParam.value().getMsg() + " " + myCheckParam.express();
  81.             }
  82.         } else {
  84.             MyCheckParams myCheckParams = method.getAnnotation(MyCheckParams.class);
  85.             MyCheckParam[] checkParams = myCheckParams.value();
  86.             for (MyCheckParam checkParam : checkParams) {
  88.                 String argName = checkParam.argName();
  89.                 Object value = this.getParamValue(arguments, paramNames, argName);
  90.                 isValid = checkParam.value().getFun().apply(value, checkParam.express());
  91.                 // 只要有一个参数判断不通过，立即返回
  92.                 if (!isValid) {
  94.                     msg = checkParam.msg();
  95.                     if(null == msg || "".equals(msg)) {
  97.                         msg = argName + ": " + checkParam.value().getMsg() + " " + checkParam.express();
  98.                     }
  99.                     break;
  100.                 }
  101.             }
  102.         }
  104.         if (!isValid) {
  106.             log.error("校验未通过");
  107.             return msg;
  108.         }
  109.         log.info("校验通过");
  110.         return null;
  111.     }
  112. }

说明：

  1. isValid = myCheckParam.value().getFun().apply(value, myCheckParam.express());：获取自定义注解中的 value，它是个枚举类。枚举类中有两个属性：msg、fun。然后获取枚举中的 fun 方法，传入入参：value 和 自定义注解中的 express，然后执行此方法，获取其返回值

MyCheckParamAspect#getMethod()：获取当前正在执行的方法

  1. private Method getMethod(JoinPoint joinPoint) {
  3.     MethodSignature methodSignature = (MethodSignature)joinPoint.getSignature();
  4.     Method method = methodSignature.getMethod();
  5.     if (method.getDeclaringClass().isInterface()) {
  7.         try {
  9.             method = joinPoint.getTarget().getClass().getDeclaredMethod(joinPoint.getSignature().getName(), method.getParameterTypes());
  10.         } catch (NoSuchMethodException e) {
  12.             e.printStackTrace();
  13.         }
  14.     }
  15.     return method;
  16. }

MyCheckParamAspect#getParamNames()：获取当前正在执行的方法的入参

  1. private String[] getParamNames(JoinPoint joinPoint) {
  3.     MethodSignature methodSignature = (MethodSignature)joinPoint.getSignature();
  4.     String[] parameterNames = methodSignature.getParameterNames();
  5.     return parameterNames;
  6. }

MyCheckParamAspect#getParamValue()：获取参数对应的值

  1. private Object getParamValue(Object[] arguments, String[] paramNames, String argName) {
  3.     Object value = null;
  4.     String name = argName;
  5.     // 从对象中取值
  6.     if (argName.contains(".")) {
  8.         name = argName.split("\\.")[0];
  9.     }
  10.     int index = 0;
  11.     for (String s : paramNames) {
  13.         if (s.equals(name)) {
  15.             value = arguments[index];
  16.             break;
  17.         }
  18.         index++;
  19.     }
  20.     if (argName.contains(".")) {
  22.         argName = argName.split("\\.")[1];
  23.         JSONObject jsonObject = (JSONObject)JSONObject.toJSON(value);
  24.         value = jsonObject.get(argName);
  25.     }
  26.     return value;
  27. }

步骤五：自定义异常类

当参数校验不通过时，立即抛出异常。中断执行。

  1. @Data
  2. public class MyCheckParamException extends RuntimeException {
  5.     // 错误码
  6.     private Integer code;
  8.     // 错误消息
  9.     private String msg;
  11.     public MyCheckParamException() {
  13.         this(303, "参数错误");
  14.     }
  16.     public MyCheckParamException(String msg) {
  18.         this(300, msg);
  19.     }
  21.     public MyCheckParamException(Integer code, String msg) {
  23.         super(msg);
  24.         this.code = code;
  25.         this.msg = msg;
  26.     }
  28. }

步骤六：自定义统一异常处理类

抛出异常后，经过统一异常处理，然后返回给前台

  1. @RestControllerAdvice
  2. public class GlobalExceptionHandler {
  5.     @ExceptionHandler(MyCheckParamException.class)
  6.     public Object MyCheckParamException(MyCheckParamException myCheckParamException) {
  8.         return ResultVoUtil.error(myCheckParamException.getCode(), myCheckParamException.getMsg());
  9.     }
  11. }

【注意】：ResultVoUtil 类上文有啊。这里就不再贴出了。

步骤七：使用自定义注解

在 Controller 中，哪个方法需要校验，就在哪个方法上加自定义注解 @MyCheckParam、@MyCheckParams

  1. @RestController
  2. @RequestMapping("/param")
  3. public class ParamController {
  6.     @PostMapping("/oneChechNotNull")
  7.     @MyCheckParam(value = MyCheckParamEnum.NOT_EMPTY, argName = "userName", msg = "草,这个是必填参数!")
  8.     public String oneChechNotNull(String userName) {
  10.         return "oneChechNotNull";
  11.     }
  13.     @PostMapping("/oneChechObjectAttrNotNull")
  14.     @MyCheckParam(value = MyCheckParamEnum.NOT_EMPTY, argName = "userVo.name")
  15.     public String oneChechObjectAttrNotNull(@RequestBody UserVo userVo) {
  17.         return "oneChechObjectAttrNotNull";
  18.     }
  20.     @PostMapping("/oneChechLengthIn")
  21.     @MyCheckParam(value = MyCheckParamEnum.LENGTH, argName = "password", express = "6,18", msg = "密码length必须在6-18位之间！")
  22.     public String oneChechLengthIn(String password) {
  24.         return "oneChechLengthIn";
  25.     }
  27.     @PostMapping("/multiCheckLengthIn")
  28.     @MyCheckParams({
  30.             @MyCheckParam(value = MyCheckParamEnum.GE, argName = "password", express = "6"),
  31.             @MyCheckParam(value = MyCheckParamEnum.LE, argName = "password", express = "18"),
  32.     })
  33.     public String multiCheckLengthIn(String password) {
  35.         return "multiCheckLengthIn";
  36.     }
  37. }

使用 AOP 实现接口参数校验就到这了。可以自己运行代码看看。

发表评论

表情：
评论列表 （有 0 条评论，15人围观）

还没有评论，来说两句吧...

相关阅读