使用自定义注解+springAop实现参数非空校验方式

@Target(ElementType.METHOD)//枚举，表示注解可能出现在的地方
@Retention(RetentionPolicy.RUNTIME)//运行时保留注解
@Documented//生成api文档时会看到此注解，可加可不加
public @Interface ParamsVerify(){
//注解类修饰符必须是public 如果不写会默认public    
   String[] params() default "";//传入方法的参数
}

//这个切点定义为使用该注解的方法都可以执行该切面类里的通知
@Pointcut("@annotation(com.xy.utlis.annotations.TestA)")

@Aspect//声明该类是一个切面类
@Component//声明该类交由spring管理
public class testAImpl {
    
    /** 定义切点，使用该TestA注解的方法 */
    @Pointcut("@annotation(com.xy.utlis.annotations.TestA)")
    public void addAdvice(){
    }
   
    @Aroud("addAdvice")//环绕通知  另外还有@Before @After
    public Object test(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕方法开始执行....");
        //获取所有参数名
        String[] parameterNames = ((MethodSignature) joinPoint.getSignature()).getParameterNames();
        //获取所有参数值
        Object[] args = joinPoint.getArgs();
        //获取当前注解下的方法
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        //根据当前方法获取注解
        TestA annotation = signature.getMethod().getAnnotation(TestA.class);
        String[] names = annotation.params();//获得注解参数
        Map<String, Object> params = params(joinPoint);
        for (String name : names) {
            Object o = params.get(name);
            if(null==o||"".equals(o)){
                System.err.println(MessageFormat.format("参数名为{0}的值为null",name));
                return false;
            }
        }
        System.out.println("环绕方法结束执行....");
        return joinPoint.proceed();//继续正常执行方法
    }
}

@PostMapping("test")
@TestA(params={"name","age","sex"})//表明这三个参数是必填的
public void test(String name,String age,String sex){
 System.out.println("ok");
}

public class User { 
    @NonNull(content = "姓名不能为空", minLen = 2, maxLen = 100)
    private String name; 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}

@Documented
@Target(value = ElementType.FIELD)
@Retention(value = RetentionPolicy.RUNTIME)
public @interface NonNull { 
    String name() default ""; 
    String content() default ""; 
    int maxLen() default 50; 
    int minLen() default 1;
}

    public void test() {
        User user = new User();
        user.setName("老王");
        try {
            valid(user);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
 
    private <T> void valid(T user) throws IllegalAccessException, InvocationTargetException {
        Class<?> clazz = user.getClass();
        Field[] declaredFields = clazz.getDeclaredFields();
        Method[] methods = clazz.getMethods();
        for (Field field : declaredFields) {
            validParams(user, methods, field);
        }
        System.out.println("==========参数校验通过=========");
    }
 
    private <T> void validParams(T user, Method[] methods, Field field) throws IllegalAccessException, InvocationTargetException {
        NonNull annotation = field.getAnnotation(NonNull.class);
        String fieldName;
        if (StringUtils.isNotBlank(annotation.name())) {
            fieldName = annotation.name();
        } else {
            fieldName = field.getName();
        }
        for (Method method : methods) {
            if (("get" + fieldName).toLowerCase().equals(method.getName().toLowerCase())) {
                Object getMethodResult = method.invoke(user, null);
                if (getMethodResult == null) {
                    System.out.println("==========非Null校验失败=========");
                    throw new IllegalArgumentException("[" + annotation.content() + "]为null");
                }
                if (getMethodResult instanceof String) {
                    if (StringUtils.isBlank(String.valueOf(getMethodResult))) {
                        System.out.println("==========非空校验失败=========");
                        throw new IllegalArgumentException("[" + annotation.content() + "]为空");
                    }
                    System.out.println(fieldName + "长度:" + String.valueOf(getMethodResult).length());
                    if (String.valueOf(getMethodResult).length() > annotation.maxLen()) {
                        System.out.println("==========长度超出指定范围=========");
                        throw new IllegalArgumentException("[" + fieldName + "]长度超出");
                    }
                    if (String.valueOf(getMethodResult).length() < annotation.minLen()) {
                        System.out.println("==========长度小于指定范围=========");
                        throw new IllegalArgumentException("[" + fieldName + "]长度不够");
                    }
                }
            }
        }
    }