自定义注解--校验前端参数不为空

 /**
 *   校验 String、对象、集合类型参数是否为 null或空字符串 , 配合 ValidateUtil 类使用
 *         1.用在类上，校验类中所有属性
 *         2.用在属性上，校验有注解的属性
 **/
@Target({ElementType.FIELD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface NotAllowEmpty {
    String msg() default "不能为空";
    String code() default "07";
}

import lombok.extern.slf4j.Slf4j;
import org.junit.Assert;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collection;

/**
 * @Description:  校验参数
 **/
@Slf4j
public class ValidateUtil {

    /**
     * 适用范围：
     *      校验 String、对象、集合、数组类型属性是否为 null,空字符串
     * 使用方式：
     *      1.在属性或者类上加注解 @NotAllowEmpty  2.需要校验参数时调用此方法
     * @param t   实体类对象
     * @return FAIL:   String、集合、数组、对象类型属性，校验失败则抛异常，返回对应错误信息給前端;
     *         SUCCESS:则继续执行后续代码
     */
    @SafeVarargs
    public static <T> void isNotEmpty(T... t) {

        for (T objSource : t) {
            if (!isObjcetType(objSource.getClass())){
                Assert.fail(objSource + "不是一个对象");
            }
            try {
                Class<?> clazz = objSource.getClass();
                Field[] fields = clazz.getDeclaredFields();
                classIsNotEmpty(clazz, objSource, fields);
                fieldsIsNotEmpty(objSource, clazz, fields);
            } catch (IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
                log.error(e.getMessage(), e);
            }
        }
    }

    /**
     * 类的所有属性不能为空
     * @param clazz  反射类
     * @param obj    反射类实例
     * @param fields 反射类属性数组
     * @throws IllegalAccessException   
     */
    private static <T> void classIsNotEmpty(Class<?> clazz, T obj, Field[] fields) throws IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        NotAllowEmpty objAnnotation = clazz.getAnnotation(NotAllowEmpty.class);
        if(objAnnotation != null){
            for (Field f : fields){
                f.setAccessible(true);
                Class<?> fieldType = f.getType();
                String fieldName = f.getName();
                Object fieldValue = f.get(obj);
                judgeFieldsType(obj, clazz, objAnnotation, fieldType, fieldName,fieldValue);
            }
        }
    }

    /**
     * 类中包含 @NotAllowEmpty注解的属性不能为空
     * @param obj   实体类对象
     * @param clazz       反射类
     * @param fields      反射类属性数组
     * @throws IllegalAccessException
     * 
     */
    private static <T> void fieldsIsNotEmpty(T obj, Class<?> clazz, Field[] fields) throws IllegalAccessException,, NoSuchMethodException, InvocationTargetException {
        for (Field f : fields) {
            f.setAccessible(true);
            Class<?> fieldType = f.getType();
            String fieldName = f.getName();
            Object fieldValue = f.get(obj);
            if (isObjcetType(fieldType)){
                Object invoke = getGetMethod(obj, clazz, fieldName);
                if (invoke != null){
                    isNotEmpty(invoke);
                }
            }
            NotAllowEmpty fieldAnnotation = f.getAnnotation(NotAllowEmpty.class);
            if (fieldAnnotation != null) {
                judgeFieldsType(obj, clazz, fieldAnnotation, fieldType, fieldName, fieldValue);
            }
        }
    }

    /**
     * 根据属性类型，返回不同报错信息给前端
     * @param obj    实体类对象
     * @param clazz  反射类
     * @param annotation  NotAllowEmpty 注解类
     * @param fieldType   反射类属性类型
     * @param fieldName   反射类属性名
     * 
     */
    private static <T> void judgeFieldsType(T obj, Class<?> clazz, NotAllowEmpty annotation, Class<?> fieldType, String fieldName, Object fieldValue) throws  NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        if(isStringType(fieldType)){
            if (StringUtils.isEmpty(fieldValue)){
                throw new MyException(annotation.code(), fieldName + "属性"+ annotation.msg());
            }
        }else if(isObjcetType(fieldType)){
            if (fieldValue == null){
                throw new MyException(annotation.code(), fieldName + "对象属性"+ annotation.msg());
            }
        }else if (isCollectionType(fieldType)){
            Object invoke = getGetMethod(obj, clazz, fieldName);
            boolean flag = CollectionUtils.isEmpty((Collection<?>) invoke);
            if (flag){
                throw new MyException(annotation.code(), fieldName + "集合属性" + annotation.msg());
            }
        }else if (isArrayType(fieldType)){
            Object invoke = getGetMethod(obj, clazz, fieldName);
            if (invoke == null || Array.getLength(invoke) == 0){
                throw new MyException(annotation.code(), fieldName + "数组属性" + annotation.msg());
            }
        }
    }

    /**
     * 反射调用get方法，得到对应的属性
     * @param obj   实例对象
     * @param clazz 反射类
     * @param fieldName 属性名
     * @param   返回 get得到的属性
     * @throws NoSuchMethodException
     * @throws IllegalAccessException
     * @throws InvocationTargetException
     */
    private static <T> Object getGetMethod(T obj, Class<?> clazz, String fieldName) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        StringBuilder sb = new StringBuilder();
        sb.append("get");
        sb.append(fieldName.substring(0, 1).toUpperCase());
        sb.append(fieldName.substring(1));
        Method method = clazz.getDeclaredMethod(sb.toString());
        method.setAccessible(true);
        return method.invoke(obj);
    }

    private static boolean isStringType(Class<?> clazz){
        return CharSequence.class.isAssignableFrom(clazz) || Character.class.isAssignableFrom(clazz);
    }

    private static boolean isCollectionType(Class<?> clazz){
        return Collection.class.isAssignableFrom(clazz);
    }

    private static boolean isArrayType(Class<?> clazz){
        return clazz.isArray();
    }

    private static boolean isObjcetType(Class<?> clazz){
        return clazz.getClassLoader() != null;
    }



}