自定义注解进行入参校验，附代码及原理浅析

不念不忘少年蓝@ 2023-02-23 08:43 41阅读 0赞

## 自定义注解 ##

项目开放接口的时候通常需要对接口入参进行一定的校验，此文章拿最常见的非空验证进行举例。

--------------------

大致的原理如下：定义一个自定义注解，对自定义注解进行拦截进行校验，不满足条件抛出自定义异常，捕获自定义异常进行处理并返回错误信息给调用者。

--------------------

首先定义一个Dto进行入参的接收

public class WingzingDto implements Serializable {
    
        private String userId;
    
        private String userName;
    
        //get set
    
    }

配置一个自定义注解类

/**
     * 接口参数非空校验注解
     */
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    public @interface ApiParamValidate {
        String value();
    }

然后编写一个切面类，对此注解进行拦截。

/**
     * 接口入参非空验证，切面处理类
     *
     */
    @Aspect
    public class ApiParamValidateAspect {
    
        @Pointcut("@annotation(com.xx.xx.ApiParamValidate)")
        public void apiParamValidatePointCut() {
    
        }
    
        @Around("apiParamValidatePointCut()")
        public Object around(ProceedingJoinPoint point) throws Throwable {
            MethodSignature signature = (MethodSignature) point.getSignature();
            Method method = signature.getMethod();
    
            ApiParamValidate apiParamValidate = method.getAnnotation(ApiParamValidate.class);
            if (apiParamValidate != null) {
                String requestParam = apiParamValidate.value();
                if(requestParam.length()>0){
                    String [] paramArray = requestParam.split(",");//注解配置的所需校验参数
                    Object[] paramValues = point.getArgs();//api接口定义的参数
                    String[] paramValuesNames = signature.getParameterNames();//api接口定义的参数名称
                    if(paramValues.length>0){
                        for(String needParamName : paramArray){
                            validate(needParamName,paramValues,paramValuesNames);
                        }
                    }else{
                        //参数为空
                        throw new RRException("参数与api接口不匹配！");
                    }
                }else{
                    throw new RRException("api接口若不需要校验参数，请不要使用此注解！");
                }
            }
            return point.proceed();
        }
    
        private static boolean isJavaClass(Class<?> clz) {
            return clz != null && clz.getClassLoader() == null;
        }
    
        private static void validate(String needParamName,Object[] objs,String[] objNames){
            if(objs!=null&&objs.length>0){
                boolean b = false;
                for(int i=0;i<objs.length;i++){
                    if(objs[i]!=null){
                        if(!isJavaClass(objs[i].getClass())){//参数是自定义对象
                            //自定义类
                            Class clz = objs[i].getClass();
                            try{
                                Method mt = clz.getMethod("get"+needParamName.substring(0,1).toUpperCase()+needParamName.substring(1));
                                Object ret = mt.invoke(objs[i]);
                                if(ret==null||ret.toString().equals("")){
                                    throw new RRException("参数 "+needParamName+" 为空");
                                }else{
                                    b = true;//在参数中找到了必填参数，且值不为空
                                }
                            }catch (NoSuchMethodException e){
                                System.out.println("没有在此对象中找到参数 "+needParamName+" 的getter setter方法");
                            }catch(Exception e){
                                System.out.println("没有在此对象中找到参数 "+needParamName+" 的getter setter方法");
                            }
                        }else{//参数是系统类
                            if(objNames[i].equals(needParamName)){
                                if(objs[i]==null||objs[i].toString().equals("")){
                                    throw new RRException("参数 "+needParamName+" 为空");
                                }else{
                                    //在参数中找到了必填参数，且值不为空
                                    b = true;
                                }
                            }
                        }
                    }
                }
                if(!b){
                    //没有找到必填参数
                    throw new RRException("参数 "+needParamName+" 为空");
                }
            }else{
                throw new RRException("api接口入参未定义！请联系管理员！");
            }
        }
    
    }

>     @Aspect 用来标识此类是一个切面供容器进行读取
> 
>     @Pointcut 切点 用于标识什么时候进行拦截,后面的@annotation标识了具体拦截的类 即我定义的自定注解
> 
>     @Around 环绕增强,与@AfterReturning，@Before，@AfterThrowing，@After等等类似。

这里实现的效果就是对自定义注解进行拦截，然后在 around方法中进行了参数循环调用validate方法，通过反射的方式进行调用get方法，然后判断是否为空(这里也可以进行各种各样的校验)。

我选择抛出自定义的异常RRException，来提示调用接口方错误信息。

附上RRException，以及对应的捕获该异常的类。

/**
     * 自定义异常
     *
     */
    public class RRException extends RuntimeException {
        private static final long serialVersionUID = 1L;
    
        private String msg;
        private int code = 500;
    
        public RRException(String msg) {
            super(msg);
            this.msg = msg;
        }
    
        public RRException(String msg, Throwable e) {
            super(msg, e);
            this.msg = msg;
        }
    
        public RRException(String msg, int code) {
            super(msg);
            this.msg = msg;
            this.code = code;
        }
    
        public RRException(String msg, int code, Throwable e) {
            super(msg, e);
            this.msg = msg;
            this.code = code;
        }
    
        public String getMsg() {
            return msg;
        }
    
        public void setMsg(String msg) {
            this.msg = msg;
        }
    
        public int getCode() {
            return code;
        }
    
        public void setCode(int code) {
            this.code = code;
        }
    
    
    }

/**
     * 异常处理器
     *
     */
    @ControllerAdvice
    public class RRExceptionHandler {
        private Logger logger = LoggerFactory.getLogger(getClass());
    
        /**
         * 处理自定义异常
         */
        @ExceptionHandler(RRException.class)
        @ResponseBody
        public String handleRRException(RRException e){
            logger.debug(e.getMessage(), e);
            System.out.println(e.toString());
            return BackResult.error(e.getMsg()).toJson();
        }
    
        @ExceptionHandler(NoHandlerFoundException.class)
        @ResponseBody
        public String handlerNoFoundException(NoHandlerFoundException e) {
            logger.error(e.getMessage(), e);
            e.printStackTrace();
            return BackResult.error("路径不存在，请检查路径是否正确").toJson();
        }
    
        @ExceptionHandler(Exception.class)
        @ResponseBody
        public String handleException(Exception e){
            logger.error(e.getMessage(), e);
            e.printStackTrace();
            return BackResult.error("未知异常，请联系管理员").toJson();
        }
    }

>     @ControllerAdvice 增强型controller，使用此注解可以使得整个项目的异常都可以被此捕获。
> 
>     @ExceptionHandler 异常捕获，后面的参数代表拦截什么类型的异常。

使用postman调用看一下大概的效果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dJTkdaSU5HTElV_size_16_color_FFFFFF_t_70][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dJTkdaSU5HTElV_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200706180245669.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dJTkdaSU5HTElV,size_16,color_FFFFFF,t_70