通过AOP+注解来实现参数的校验

在实际的java开发中，参数校验是个比较零碎繁琐的事情，但是却必不可少，本文通过aop来实现对参数的校验，可以节省大量的时间和提交代码的可读性与整洁性，方便更加集中的编写业务逻辑。

代码：

ParamCheckAop:

package com.yzs.plat.process.common.aop;

import com.yzs.plat.process.common.annotation.ValidateFiled;
import com.yzs.plat.process.common.annotation.ValidateGroup;
import com.yzs.plat.process.common.utils.oConvertUtils;
import com.yzs.plat.process.common.vo.Result;
import com.yzs.plat.process.modules.process.entity.SUserinfo;
import com.yzs.plat.process.modules.process.service.ISUserinfoService;
import lombok.extern.slf4j.Slf4j;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.history.HistoricTaskInstance;
import org.activiti.engine.task.Task;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * 参数检查AOP
 */
@Aspect
@Component
@Slf4j
public class ParamCheckAop {
    @Autowired
    private ISUserinfoService userinfoService;
    @Autowired
    private ProcessEngine processEngine;
    @Around("@annotation(com.yzs.plat.process.common.annotation.ValidateGroup)")
    public Object validateAround(ProceedingJoinPoint joinPoint) throws Throwable {
        Result<?> result = null ;
        ValidateGroup an;
        Object[] args ;
        Method method;
        Object target;
        String methodName;
        boolean flag = false; // 是否发生异常
        try{
            methodName = joinPoint.getSignature().getName();
            target = joinPoint.getTarget();
            method = getMethodByClassAndName(target.getClass(), methodName);    //得到拦截的方法
            args = joinPoint.getArgs();     //方法的参数
            an = (ValidateGroup)getAnnotationByMethod(method ,ValidateGroup.class );
            result = validateFiled(an.fileds() , args);
        }catch(Exception e){
            flag = true;
        }finally{
            if(result == null && !flag){
                log.info("参数校验---------验证通过-------------");
                return joinPoint.proceed();
            }
            else{
                log.info("参数校验---------验证未通过-----------");
                return result;
            }
        }
    }

    /**
     * 验证参数是否合法
     */
    public Result<?> validateFiled(ValidateFiled[] valiedatefiles , Object[] args) throws SecurityException, IllegalArgumentException, NoSuchMethodException, IllegalAccessException, InvocationTargetException{
        for (ValidateFiled validateFiled : valiedatefiles) {
            Object arg;
            if("".equals(validateFiled.filedName()) ){
                arg = args[validateFiled.index()];
            }else{
                arg = getFieldByObjectAndFileName(args[validateFiled.index()] ,
                        validateFiled.filedName() );
            }
            if(validateFiled.notNull()){        //判断参数是否为空
                if(arg == null )
                    return Result.error(validateFiled.msg());
            }else{      //如果该参数能够为空，并且当参数为空时，就不用判断后面的了 ，直接返回true
                if(arg == null )
                    return null;
            }
            if(validateFiled.maxLen() > 0){      //判断字符串最大长度
                if(((String)arg).length() > validateFiled.maxLen())
                    return Result.error(validateFiled.msg());
            }

            if(validateFiled.minLen() > 0){      //判断字符串最小长度
                if(((String)arg).length() < validateFiled.minLen())
                    return Result.error(validateFiled.msg());
            }

            if(validateFiled.maxVal() != -1){   //判断数值最大值
                if( (Integer)arg > validateFiled.maxVal())
                    return Result.error(validateFiled.msg());
            }

            if(validateFiled.minVal() != -1){   //判断数值最小值
                if((Integer)arg < validateFiled.minVal())
                    return Result.error(validateFiled.msg());
            }

            if(!"".equals(validateFiled.regStr())){ //判断正则
                if(arg instanceof String){
                    if(!((String)arg).matches(validateFiled.regStr()))
                        return Result.error(validateFiled.msg());
                }else{
                    return Result.error(validateFiled.msg());
                }
            }
            if(validateFiled.isUid()) { // 验证uid是否存在
                if(oConvertUtils.isEmpty(arg)){
                    return Result.error("uid不能为空!");
                }
                SUserinfo suid = userinfoService.query().eq("SUIID", arg).one();
                if(suid == null) {
                    return Result.error(validateFiled.msg());
                }
            }
            if(validateFiled.isTaskId()) { // 验证taskId是否存在
                HistoricTaskInstance historicTaskInstance = processEngine.getHistoryService().createHistoricTaskInstanceQuery().taskId(arg.toString()).singleResult();
                Task task = processEngine.getTaskService().createTaskQuery().taskId(arg.toString()).singleResult();
                if(historicTaskInstance == null && task == null) {
                    return Result.error(validateFiled.msg());
                }
            }
        }
        return null;
    }

    /**
     * 根据对象和属性名得到 属性
     */
    public Object getFieldByObjectAndFileName(Object targetObj , String fileName) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException, InvocationTargetException {
        String tmp[] = fileName.split("\\.");
        Object arg = targetObj ;
        for (int i = 0; i < tmp.length; i++) {
            Method methdo = arg.getClass().
                    getMethod(getGetterNameByFiledName(tmp[i]));
            arg = methdo.invoke(arg);
        }
        return arg ;
    }

    /**
     * 根据属性名 得到该属性的getter方法名
     */
    public String getGetterNameByFiledName(String fieldName){
        return "get" + fieldName.substring(0 ,1).toUpperCase() + fieldName.substring(1) ;
    }

    /**
     * 根据目标方法和注解类型  得到该目标方法的指定注解
     */
    public Annotation getAnnotationByMethod(Method method , Class annoClass){
        Annotation all[] = method.getAnnotations();
        for (Annotation annotation : all) {
            if (annotation.annotationType() == annoClass) {
                return annotation;
            }
        }
        return null;
    }

    /**
     * 根据类和方法名得到方法
     */
    public Method getMethodByClassAndName(Class c , String methodName){
        Method[] methods = c.getDeclaredMethods();
        for (Method method : methods) {
            if(method.getName().equals(methodName)){
                return method ;
            }
        }
        return null;
    }
}

ValidateGroup:

package com.yzs.plat.process.common.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;  
import java.lang.annotation.RetentionPolicy;  
import java.lang.annotation.Target;  
  
@Retention(RetentionPolicy.RUNTIME)  
@Target(ElementType.METHOD)  
public @interface ValidateGroup {  
    ValidateFiled[] fileds() ;
}  

ValidateFiled:

package com.yzs.plat.process.common.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ValidateFiled {

    /**
     * 提示信息
     */
    String msg() default "";
    /** 
     * 参数索引位置 
     */  
    int index() default -1 ;
      
    /** 
     * 如果参数是基本数据类型或String ，就不用指定该参数，如果参数是对象，要验证对象里面某个属性，就用该参数指定属性名 
     */  
    String filedName() default "" ;

    /**
     * 正则验证 
     */  
    String regStr() default "";
      
    /** 
     * 是否能为空  ， 为true表示不能为空 ， false表示能够为空 
     */  
    boolean notNull() default false;
      
    /** 
     * 是否能为空  ， 为true表示不能为空 ， false表示能够为空 
     */  
    int maxLen() default -1 ;
      
    /** 
     * 最小长度 ， 用户验证字符串 
     */  
    int minLen() default -1 ;
      
    /** 
     *最大值 ，用于验证数字类型数据 
     */  
    int maxVal() default -1 ;
      
    /** 
     *最小值 ，用于验证数值类型数据 
     */  
    int minVal() default -1 ;

    /**
     * 是否是uid
     * @return
     */
    boolean isUid() default false;

    /**
     * 是否是taskId
     * @return
     */
    boolean isTaskId() default false;
}

具体使用：

  /**
     * 个人-启动一个流程
     */
    @PostMapping("/startupProcess")
    @ApiOperation("个人-启动一个流程")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "delta", value = "增量", dataType = "BigDecimal"),
            @ApiImplicitParam(name = "name", value = "姓名", dataType = "String"),
            @ApiImplicitParam(name = "note", value = "注解", dataType = "String"),
            @ApiImplicitParam(name = "processDefinitionId", value = "流程定义Id", dataType = "String"),
            @ApiImplicitParam(name = "tenantId", value = "租户Id", dataType = "String"),
            @ApiImplicitParam(name = "uid", value = "用户id", dataType = "String"),
            @ApiImplicitParam(name = "attachment", value = "附件", dataType = "JSONObject")
    })
    @ValidateGroup(fileds = {
            @ValidateFiled(index=0, notNull=true,msg = "delta不能为空!"),
            @ValidateFiled(index=1, notNull=true,msg = "name不能为空!"),
            @ValidateFiled(index=2, notNull=true,msg = "note不能为空!"),
            @ValidateFiled(index=3, notNull=true,msg = "processDefinitionId不能为空!"),
            @ValidateFiled(index=4, notNull=true,msg = "tenantId不能为空!"),
            @ValidateFiled(index=5, notNull=true,msg = "uid不能为空!"),
            @ValidateFiled(index=5, isUid=true,msg = "uid(用户id)不存在!"),
    })
    public Result<?> startProcess(
            BigDecimal delta,
            String name,
            String note,
            String processDefinitionId,
            String tenantId,
            String uid,
            String attachment){

运行结果：