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 進(jìn)行屬性比較的對象1
     * @param obj2 進(jìn)行屬性比較的對象2
     * @param compareArr 選擇要比較的屬性數(shù)組
     * @return 屬性差異比較結(jié)果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轉(zhuǎn)化為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();
                    // 如果當(dāng)前屬性選擇進(jìn)行比較，跳到下一次循環(huán)
                    if (ignoreList != null && ignoreList.contains(name)) {
                        // get方法
                        Method readMethod = pd.getReadMethod();
                        // 在obj1上調(diào)用get方法等同于獲得obj1的屬性值
                        Object objBefore = readMethod.invoke(obj1);
                        // 在obj2上調(diào)用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;
        }
    }
}

結(jié)果：

比較兩個實體類及屬性差異工具類(簡版)

通過反射技術(shù)獲取所有屬性并進(jìn)行對比

思路

通過反射技術(shù)獲取所有屬性并進(jìn)行對比，詳細(xì)步驟如下：

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 進(jìn)行屬性比較的對象1
     * @param newObject 進(jìn)行屬性比較的對象2
     * @return 屬性差異比較結(jié)果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 進(jìn)行屬性比較的對象1
     * @param newObject 進(jìn)行屬性比較的對象2
     * @return 屬性差異比較結(jié)果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上調(diào)用get方法等同于獲得oldObject的屬性值
                    Object oldValue = readMethod.invoke(oldObject);
                    // 在newObject上調(diào)用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;
    }
}

結(jié)果集及效果如圖：