自定义一个自动校验对象的字段非空处理工具(注解加反射)

版权声明：转载请注明原创 https://blog.csdn.net/qq_42151769/article/details/89853930

自定义注解:

@NotEmpty

package com.hf.autocheck.annotation;

import java.lang.annotation.*;

/**
 * @Description: 非空注解
 * @Date: 2019/5/5
 * @Auther: 
 */
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface NotEmpty {
    String value();
}

@NotEmptyIn  改注解用来,属性是另外一个对象的时候,打上改注解,则自动渗透进入该小对象的类型,获取含有@NotEmpty注解的字段,可以无限渗透(也就是递归进入获取)

package com.hf.autocheck.annotation;

import java.lang.annotation.*;

/**
 * @Description: 用来渗透进入
 * @Date: 2019/5/5
 * @Auther:
 */
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface NotEmptyIn {
}

封装一个返回结果,统一返回结果

package com.hf.autocheck.result;

/**
 * @Description: 统一返回值
 * @Date: 2019/5/5
 * @Auther: 
 */
public class Response<T> {

    private Integer code;
    private String msg;
    private Boolean success;
    private T data;

    public Response(Integer code,Boolean success,String msg, T data) {
        this.msg = msg;
        this.data = data;
        this.code = code;
        this.success = success;
    }

    public Response() {
    }

    public static <T> Response createSuccess(String msg, T data){
        return new Response(200,true,msg,data);
    }

    public static Response createSuccess(String msg){
        return new Response(200,true,msg,null);

    }
    public static <T> Response createError(String msg,T data){
        return new Response(500,false,msg,data);
    }

    public static  Response createError(String msg){
        return new Response(500,false,msg,null);
    }


    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public Boolean isSuccess() {
        return this.success;
    }

    public void setSuccess(Boolean success) {
        this.success = success;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

常量枚举类:

package com.hf.autocheck.enums;

import org.springframework.util.CollectionUtils;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Description:
 * @Date: 2019/5/5
 * @Auther: 
 */
public enum ResultEnum {

    PROPERTIES_CHECK_SUCCESS(10000,"字段校验成功"),
    PROPERTIES_CHECK_ERROR(10001,"字段校验失败")
    ;


    ResultEnum(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    private Integer code;
    private String msg;

    public String getMsg(){
        return this.msg;
    }

    public String getMsg(Integer code){
        List<ResultEnum> list = Arrays.stream(ResultEnum.values()).filter((ResultEnum var) -> null != code
                && var.code == code).limit(1).collect(Collectors.toList());
        return CollectionUtils.isEmpty(list) ? null:list.get(0).getMsg();
    }




}

处理注解的工具类:

package com.hf.autocheck.utils;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @Description: 字段反射工具类
 * @Date: 2019/5/5
 * @Auther: 
 */
public class FeildReflectUtil {

    public static Field[] getAllFields(Class<?> clzz){
        if(null == clzz){
            return null;
        }
        List<Field> resultList = new ArrayList<>();

        while(null != clzz){
            resultList.addAll(new ArrayList<>(Arrays.asList(clzz.getDeclaredFields())));
            //是否有继承类
            clzz = clzz.getSuperclass();
        }
        Field[] resultArr = new Field[resultList.size()];
         return  resultList.toArray(resultArr);
    }
}

package com.hf.autocheck.utils;

import com.hf.autocheck.annotation.NotEmpty;
import com.hf.autocheck.annotation.NotEmptyIn;
import com.hf.autocheck.enums.ResultEnum;
import com.hf.autocheck.result.Response;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.StringUtils;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Description: 校验字段非空
 * @Date: 2019/4/30
 * @Auther:
 */
public class PropertiesCheckUtil {

    private static final Logger log = LoggerFactory.getLogger(PropertiesCheckUtil.class);

    public static Response<String> autoCheck(Object target){
        if(null == target){
            return Response.createSuccess(ResultEnum.PROPERTIES_CHECK_ERROR.getMsg());
        }
        Class<?> clzz = target.getClass();
        Field[] fields = FeildReflectUtil.getAllFields(clzz);
        //过滤字段
        List<Field> list = Arrays.stream(fields).filter((Field var) -> !Modifier.isStatic(var.getModifiers()) && !Modifier.isFinal(var.getModifiers())).collect(Collectors.toList());
        for (Field field : list) {
            try {
                Response<String> response = doCheck(field, target);
                if(!response.isSuccess()){
                    return response;
                }
            } catch (Exception e) {
                log.error("<autoCheck> check properties not empty error....{}" + e.getMessage(),e);
            }
        }
        return Response.createSuccess(ResultEnum.PROPERTIES_CHECK_SUCCESS.getMsg());

    }


    private static Response<String> doCheck(Field field,Object target) throws Exception {
        if(field.isAnnotationPresent(NotEmpty.class)){
            Response response = autoMatch(field,target);
            if(!response.isSuccess()){
                return response;
            }
        }else if(field.isAnnotationPresent(NotEmptyIn.class)){
            if(!field.isAccessible()){
                field.setAccessible(true);
            }
            Response<String> response = deepToCheck(field, field.get(target));
            if(!response.isSuccess()){
                return response;
            }
        }else{
            return Response.createSuccess(ResultEnum.PROPERTIES_CHECK_SUCCESS.getMsg());
        }
        return Response.createSuccess(ResultEnum.PROPERTIES_CHECK_SUCCESS.getMsg());
    }

    private static Response<String> deepToCheck(Field field,Object target) throws Exception {
        if(null == target){
            return Response.createError("<deepToCheck> deep object .... " + field.toGenericString() + " cannot be null...{}");
        }
        if(field.isAnnotationPresent(NotEmptyIn.class)){
            //对有NotEmptyIn注解的字段层层深入,直到没有为止
            Class<?> clzz = field.getType().newInstance().getClass();
            Field[] fields = FeildReflectUtil.getAllFields(clzz);
            //过滤字段
            List<Field> list = Arrays.stream(fields).filter((Field var) -> !Modifier.isStatic(var.getModifiers()) && !Modifier.isFinal(var.getModifiers())).collect(Collectors.toList());
            for (Field var : list) {
                if(var.isAnnotationPresent(NotEmpty.class)){
                    Response response = autoMatch(var,target);
                    if(!response.isSuccess()){
                        return response;
                    }
                }else if(var.isAnnotationPresent(NotEmptyIn.class)){
                    Class<? extends Class> c = var.getType().getClass();
                    //获取小对象的值
                    if(!var.isAccessible()){
                        var.setAccessible(true);
                    }
                    Object o = var.get(target);
                    Field[] varFields = FeildReflectUtil.getAllFields(clzz);
                    List<Field> varList = Arrays.stream(fields).filter((Field var2) -> !Modifier.isStatic(var2.getModifiers()) && !Modifier.isFinal(var2.getModifiers())).collect(Collectors.toList());
                    //递归查找
                    for (Field var1 : varList) {
                        Response<String> response = deepToCheck(var1, o);
                        if(!response.isSuccess()){
                            return response;
                        }
                    }
                }
            }
        }
        return Response.createSuccess(ResultEnum.PROPERTIES_CHECK_SUCCESS.getMsg());
    }


    /**
     * 自动匹配对应的类型,用来做相应的处理
     * @param
     * @return
     */
    private static Response autoMatch(Field field,Object target){
       if(null == target){
           return Response.createError(field.toGenericString() + "can not be null...");
       }
        //获取字段的类型的名称,在获取到对应的字节码(也就是类型的字节码对象)
        Class clzz = field.getType().getName().getClass();
        String value = field.getAnnotation(NotEmpty.class).value();
        Object o = null;
        try {
            if(!field.isAccessible()){
                field.setAccessible(true);
            }
            o = field.get(target);
        } catch (IllegalAccessException e) {
           log.error("<autoMatch> error....{}" + e.getMessage(),e);
        }
        if(o == null){
          return Response.createError(value);
        }
        if(String.class == clzz){
            if(StringUtils.isEmpty(o)){
                return Response.createError(value);
            }
        }
        return Response.createSuccess(ResultEnum.PROPERTIES_CHECK_SUCCESS.getMsg());
    }
}

创建三个实体类,如下:

User.class

package com.hf.autocheck.model;

import com.hf.autocheck.annotation.NotEmpty;
import com.hf.autocheck.annotation.NotEmptyIn;

import java.io.Serializable;

/**
 * @Description:
 * @Date: 2019/5/5
 * @Auther: 
 */
public class User implements Serializable {
    private static final long serialVersionUID = -6946551306395077514L;

    @NotEmpty("姓名不能为空")
    private String name;
    @NotEmpty("性别不能为空")
    private String gender;
    @NotEmpty("年龄不能为空")
    private Integer age;

    @NotEmptyIn
    private Student student;



    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

Student.class:

package com.hf.autocheck.model;

import com.hf.autocheck.annotation.NotEmpty;
import com.hf.autocheck.annotation.NotEmptyIn;

import java.io.Serializable;

/**
 * @Description:
 * @Date: 2019/5/5
 * @Auther: 
 */
public class Student implements Serializable {
    private static final long serialVersionUID = 2622208368622944597L;
    @NotEmpty("学生姓名不能为空")
    private String name;
    @NotEmpty("学生班级不能为空")
    private String className;
    @NotEmpty("学生年龄不能为空")
    private Integer age;
    @NotEmptyIn
    private Teacher teacher;

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

Teacher.class:

package com.hf.autocheck.model;

import com.hf.autocheck.annotation.NotEmpty;

import java.io.Serializable;

/**
 * @Description:
 * @Date: 2019/5/5
 * @Auther: 
 */
public class Teacher implements Serializable {
    private static final long serialVersionUID = 3416746508578309442L;

    @NotEmpty("教师名称不能为空")
    private String name;
    @NotEmpty("教师班级不能为空")
    private String className;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }
}

其对于的关系在类中已经很明显的显示出来了:

下面开始测试,测试类如下:

package com.hf.autocheck.test;

import com.hf.autocheck.model.Student;
import com.hf.autocheck.model.Teacher;
import com.hf.autocheck.model.User;
import com.hf.autocheck.result.Response;
import com.hf.autocheck.utils.PropertiesCheckUtil;
import org.junit.Test;

/**
 * @Description:
 * @Date: 2019/5/5
 * @Auther: 
 */
public class CheckTest {


    @Test
    public void tt(){
        User user = new User(){{
            setName("yu");
            setGender("男");
            setAge(11);
            Student student = new Student();
            student.setAge(12);
            student.setClassName("3班");
            student.setName("yy");
            Teacher teacher = new Teacher();
            teacher.setClassName("5班");
            student.setTeacher(teacher);
            setStudent(student);
        }};
        Response<String> response = PropertiesCheckUtil.autoCheck(user);
        System.out.println(response.getMsg());

    }
}

结果如下:

好了,就先写到这里了.....