Java对比对象修改前与修改后字段发生的变化

傷城~ 2023-10-16 12:53 68阅读 0赞

1.  开发过程中，我们通常会对系统操作人对系统的操作进行记录，记录操作前后某个字段的变化，如下图 ![cdb9daee5ecc46f88744e4c4d1bbfb39.png][]

2. 提供一个工具类，可以比较一个对象里面，源对象，与修改后的对象，有哪些字段发生了改变， 第一步

/**
     * @author qiankun.hu
     * @version 1.0.0
     * @createTime 2023年09月20日 17:00:00
     * @Description TODO
     */
    @Target({ElementType.FIELD})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface ColumnInfo {
    
        /**
         * 字段code
         */
        String columnCode() default "";
    
        /**
         * 字段名称
         */
        String columnName() default "";
    
        /**
         * 字段类型
         */
        String columnType() default "";
    }

工具类代码

import com.example.demo.config.ColumnInfo;
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.beans.BeanUtils;
    
    import java.beans.Introspector;
    import java.beans.PropertyDescriptor;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    import java.sql.Timestamp;
    import java.util.*;
    
    /**
     * @author qiankun.hu
     * @version 1.0.0
     * @createTime 2023年09月20日 17:00:00
     * @Description TODO
     */
    public class MyBeanUtils extends BeanUtils {
    
        /**
         * 比较两个实体属性值，返回一个map以有差异的属性名为key，value为一个list分别存obj1,obj2此属性名的值
         *
         * @param obj1      源值
         * @param obj2      最新值
         * @param ignoreArr 选择忽略比较的属性数组
         * @return 属性差异比较结果map
         * <p>
         * 后面考虑添加注解字段名和中文名称，已达到提示对应的中文信息
         */
        public static Map<String, List<Object>> compareFields(Object obj1, Object obj2, String[] ignoreArr) {
            try {
                Map<String, List<Object>> map = new HashMap<String, List<Object>>();
                List<String> ignoreList = null;
                if (ignoreArr != null && ignoreArr.length > 0) {
                    // array转化为list
                    ignoreList = Arrays.asList(ignoreArr);
                }
                if (obj1 == null) {
                    Class clazz = obj2.getClass();
                    // 获取object的属性描述
                    PropertyDescriptor[] pds = Introspector.getBeanInfo(clazz,
                            Object.class).getPropertyDescriptors();
                    // 这里就是所有的属性了
                    for (PropertyDescriptor pd : pds) {
                        // 属性名
                        String name = pd.getName();
                        // 如果当前属性选择忽略比较，跳到下一次循环
                        if (ignoreList != null && ignoreList.contains(name)) {
                            continue;
                        }
                        // Field field = clazz.getDeclaredField(name);
                        Field field;
                        try {
                            field = clazz.getDeclaredField(name);
                        } catch (NoSuchFieldException e) {
                            try {
                                //此处用于解决继承导致的getDeclaredField不能直接获取父类属性的问题
                                field = clazz.getSuperclass().getDeclaredField(name);
                            } catch (NoSuchFieldException ee) {
                                //此处用于解决继承导致的getDeclaredField不能直接获取父类属性的问题
                                field = clazz.getSuperclass().getSuperclass().getDeclaredField(name);
                            }
                        }
                        ColumnInfo columnInfo = field.getAnnotation(ColumnInfo.class);
                        if (columnInfo != null) {
                            String columName = columnInfo.columnName();
                            String columnCode = columnInfo.columnCode();
                            String columnType = columnInfo.columnType();
                            name = name + "_" + columName + "_" + columnCode + "_" + columnType;
                        } else {
                            continue;
                        }
                        // get方法
                        Method readMethod = pd.getReadMethod();
                        Object o2 = readMethod.invoke(obj2);
                        if (o2 != null) {
                            List<Object> list = new ArrayList<Object>();
                            list.add(null);
                            list.add(o2);
                            map.put(name, list);
                        }
                    }
                } else {
                    // 只有两个对象都是同一类型的才有可比性
                    if (obj1.getClass() == obj2.getClass()) {
                        Class clazz = obj1.getClass();
                        // 获取object的属性描述
                        PropertyDescriptor[] pds = Introspector.getBeanInfo(clazz,
                                Object.class).getPropertyDescriptors();
                        // 这里就是所有的属性了
                        for (PropertyDescriptor pd : pds) {
                            // 属性名
                            String name = pd.getName();
                            // 如果当前属性选择忽略比较，跳到下一次循环
                            if (ignoreList != null && ignoreList.contains(name)) {
                                continue;
                            }
                            //Field field = clazz.getDeclaredField(name);
                            Field field;
                            try {
                                field = clazz.getDeclaredField(name);
                            } catch (NoSuchFieldException e) {
                                try {
                                    //此处用于解决继承导致的getDeclaredField不能直接获取父类属性的问题
                                    field = clazz.getSuperclass().getDeclaredField(name);
                                } catch (NoSuchFieldException ee) {
                                    //此处用于解决继承导致的getDeclaredField不能直接获取父类属性的问题
                                    field = clazz.getSuperclass().getSuperclass().getDeclaredField(name);
                                }
    
                            }
                            ColumnInfo columnInfo = field.getAnnotation(ColumnInfo.class);
                            if (columnInfo != null) {
                                String columName = columnInfo.columnName();
                                String columnCode = columnInfo.columnCode();
                                String columnType = columnInfo.columnType();
                                name = name + "_" + columName + "_" + columnCode + "_" + columnType;
                            } else {
                                continue;
                            }
                            // get方法
                            Method readMethod = pd.getReadMethod();
                            // 在obj1上调用get方法等同于获得obj1的属性值
                            Object o1 = readMethod.invoke(obj1);
                            // 在obj2上调用get方法等同于获得obj2的属性值
                            Object o2 = readMethod.invoke(obj2);
                            if (o1 instanceof Timestamp) {
                                o1 = new Date(((Timestamp) o1).getTime());
                            }
                            if (o2 instanceof Timestamp) {
                                o2 = new Date(((Timestamp) o2).getTime());
                            }
                            if (o1 == null && o2 == null) {
                                continue;
                            } else if (o1 == null && o2 != null) {
                                List<Object> list = new ArrayList<Object>();
                                list.add(o1);
                                list.add(o2);
                                if (o2 instanceof String && StringUtils.isBlank(String.valueOf(o2))) {
                                    o2 = null;
                                }
                                if (o2 != null) {
                                    map.put(name, list);
                                }
                                continue;
                            }
                            // 比较这两个值是否相等,不等就可以放入map了
                            if (!o1.equals(o2)) {
                                List<Object> list = new ArrayList<Object>();
                                list.add(o1);
                                list.add(o2);
                                if(o2!=null){
                                    o1 = o1 instanceof String && StringUtils.isBlank(String.valueOf(o1)) ? "" : o1;
                                    Object info = (o2 instanceof String && StringUtils.isBlank(String.valueOf(o2)) ? "" : o2);
                                    o2 = o2 == null ? "" : info;
                                    if(!o1.equals(o2)){
                                        map.put(name, list);
                                    }
                                }
    
                            }
                        }
                    }
                }
                return map;
            } catch (Exception e) {
                return null;
            }
        }
    }

3 进行测试

import com.alibaba.fastjson.JSON;
    import com.example.demo.config.ColumnInfo;
    import com.example.demo.util.MyBeanUtils;
    import java.util.*;
    
    
    /**
     * @author qiankun.hu
     * @version 1.0.0
     * @createTime 2022年10月14日 13:35:00
     * @Description TODO
     */
    public class StudentDto {
    
        @ColumnInfo(columnCode = "name", columnName = "名称")
        private String name;
        @ColumnInfo(columnCode = "name", columnName = "名称")
        private String age;
        @ColumnInfo(columnCode = "studentNum", columnName = "学号")
        private Integer studentNum;
        @ColumnInfo(columnCode = "classNum", columnName = "班级号")
        private String classNum;
    
        public static void main(String[] args) {
            //老数据
            StudentDto s1 = new  StudentDto();
            s1.setName("张三");
            s1.setAge("18");
            s1.setStudentNum(9001);
            s1.setClassNum("高一二班");
    
            //修改后的数据
            StudentDto s2 = new  StudentDto();
            s2.setName("张三");
            s2.setAge("19");
            s2.setStudentNum(9002);
            s2.setClassNum("高一三班");
    
            //忽略对比的字段
            String[] arr = new String[1];
            arr[0] = "studentNum";
    
            //对比哪些字段发生改变，K 是发生改变的字段  value 是字段前后的变化
            Map<String, List<Object>> stringListMap = MyBeanUtils.compareFields(s1, s2, null);
    
            System.out.println( JSON.toJSONString(stringListMap) );
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAge() {
            return age;
        }
    
        public void setAge(String age) {
            this.age = age;
        }
    
        public Integer getStudentNum() {
            return studentNum;
        }
    
        public void setStudentNum(Integer studentNum) {
            this.studentNum = studentNum;
        }
    
        public String getClassNum() {
            return classNum;
        }
    
        public void setClassNum(String classNum) {
            this.classNum = classNum;
        }
    }

输出结果如下：  
\{  
"age\_名称\_name\_": \["18", "19"\],  
"studentNum\_学号\_studentNum\_": \[9001, 9002\],  
"classNum\_班级号\_classNum\_": \["高一二班", "高一三班"\]  
\}

我们可以看到，对象修改后与修改后，相关字段产生的变化，如果有不需要对比的字段，传入相同的参数既可

[cdb9daee5ecc46f88744e4c4d1bbfb39.png]: https://img-blog.csdnimg.cn/cdb9daee5ecc46f88744e4c4d1bbfb39.png