Java对比两个实体的差异分析

对比两个实体的差异

对比2个实体的值是否一致

可以用与一下方法

package com.xx;
import java.beans.introspector;
import java.beans.propertydescriptor;
import java.lang.reflect.method;
import java.sql.timestamp;
import java.util.*; 
 
public class comparefileds { 
    /**
     * 比较两个实体属性值，返回一个map以有差异的属性名为key，value为一个list分别存obj1,obj2此属性名的值
     * @param obj1 进行属性比较的对象1
     * @param obj2 进行属性比较的对象2
     * @param comparearr 选择要比较的属性数组
     * @return 属性差异比较结果map
     */
    public static map<string, map> comparefields(object obj1, object obj2, string[] comparearr) {
        try {
            //装返回值得
            map<string, map> map = new linkedhashmap<>();
            //需要对比的字段list
            list<string> ignorelist = null;
            if (comparearr != null && comparearr.length > 0) {
                // array转化为list
                ignorelist = arrays.aslist(comparearr);
            }
            // 只有两个对象都是同一类型的才有可比性
            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)) {
                        // get方法
                        method readmethod = pd.getreadmethod();
                        // 在obj1上调用get方法等同于获得obj1的属性值
                        object objbefore = readmethod.invoke(obj1);
                        // 在obj2上调用get方法等同于获得obj2的属性值
                        object objafter = readmethod.invoke(obj2);
                        if (objbefore instanceof timestamp) {
                            objbefore = new date(((timestamp) objbefore).gettime());
                        }
                        if (objafter instanceof timestamp) {
                            objafter = new date(((timestamp) objafter).gettime());
                        }
                        if (objbefore == null && objafter == null) {
                            continue;
                        } else if (objbefore == null && objafter != null) {
                            map m = new linkedhashmap();
                            m.put("objbefore",objbefore);
                            m.put("objafter",objafter);
                            map.put(name, m);
                            continue;
                        }
                        // 比较这两个值是否相等,不等则放入map
                        if (!objbefore.equals(objafter)) {
                            map m = new linkedhashmap();
                            m.put("objbefore",objbefore);
                            m.put("objafter",objafter);
                            map.put(name, m);
                        }
                    }
                }
            }else {
                system.out.println("对象类型不一致，不能完成对比");
            }
            return map;
        } catch (exception e) {
            system.out.println("错误");
            return null;
        }
    }
}

结果：

比较两个实体类及属性差异工具类(简版)

通过反射技术获取所有属性并进行对比

思路

通过反射技术获取所有属性并进行对比，详细步骤如下：

package com.app.business.utils;
import java.beans.introspector;
import java.beans.propertydescriptor;
import java.lang.reflect.method;
import java.sql.timestamp;
import java.util.date;
import java.util.hashmap;
import java.util.list;
import java.util.map;
/**
 * created by mj·j on 2019-11-08
 */
public class classcompareutil {
    /**
     * 比较两个实体属性值，返回一个boolean,true则表时两个对象中的属性值无差异
     * @param oldobject 进行属性比较的对象1
     * @param newobject 进行属性比较的对象2
     * @return 属性差异比较结果boolean
     */
    public static boolean compareobject(object oldobject, object newobject) {
        map<string, map<string,object>> resultmap=comparefields(oldobject,newobject);
        if(resultmap.size()>0) {
            return true;
        }else {
            return false;
        }
    }
    /**
     * 比较两个实体属性值，返回一个map以有差异的属性名为key，value为一个map分别存oldobject,newobject此属性名的值
     * @param oldobject 进行属性比较的对象1
     * @param newobject 进行属性比较的对象2
     * @return 属性差异比较结果map
     */
    @suppresswarnings("rawtypes")
    public static map<string, map<string,object>> comparefields(object oldobject, object newobject) {
        map<string, map<string, object>> map = null;
        try{
            /**
             * 只有两个对象都是同一类型的才有可比性
             */
            if (oldobject.getclass() == newobject.getclass()) {
                map = new hashmap<string, map<string,object>>();
                class clazz = oldobject.getclass();
                //获取object的所有属性
                propertydescriptor[] pds = introspector.getbeaninfo(clazz,object.class).getpropertydescriptors();
                for (propertydescriptor pd : pds) {
                    //遍历获取属性名
                    string name = pd.getname();
                    //获取属性的get方法
                    method readmethod = pd.getreadmethod();
                    // 在oldobject上调用get方法等同于获得oldobject的属性值
                    object oldvalue = readmethod.invoke(oldobject);
                    // 在newobject上调用get方法等同于获得newobject的属性值
                    object newvalue = readmethod.invoke(newobject);
                    if(oldvalue instanceof list){
                        continue;
                    }
                    if(newvalue instanceof list){
                        continue;
                    }
                    if(oldvalue instanceof timestamp){
                        oldvalue = new date(((timestamp) oldvalue).gettime());
                    }
                    if(newvalue instanceof timestamp){
                        newvalue = new date(((timestamp) newvalue).gettime());
                    }
                    if(oldvalue == null && newvalue == null){
                        continue;
                    }else if(oldvalue == null && newvalue != null){
                        map<string,object> valuemap = new hashmap<string,object>();
                        valuemap.put("oldvalue",oldvalue);
                        valuemap.put("newvalue",newvalue);
                        map.put(name, valuemap);
                        continue;
                    }
                    if (!oldvalue.equals(newvalue)) {// 比较这两个值是否相等,不等就可以放入map了
                        map<string,object> valuemap = new hashmap<string,object>();
                        valuemap.put("oldvalue",oldvalue);
                        valuemap.put("newvalue",newvalue);
                        map.put(name, valuemap);
                    }
                }
            }
        }catch(exception e){
            e.printstacktrace();
        }
        return map;
    }
}

结果集及效果如图：

以上为个人经验，希望能给大家一个参考，也希望大家多多支持。