java代碼實現(xiàn)對比分析對象是否有變化

更新時間：2026年04月20日 08:44:10 作者：IT樂手

在項目中大家應(yīng)該遇到過這種問題,需要分析對象是否發(fā)生變化,發(fā)生變化后,具體是哪個字段發(fā)生變化,本文為大家整理了一些方法,希望對大家有所幫助

在項目中大家應(yīng)該遇到過這種問題，需要分析對象是否發(fā)生變化，發(fā)生變化后，具體是哪個字段發(fā)生變化

下面提供相關(guān)的工具類，大家拿來用就行了

package com.eternal.base.utils;

import androidx.databinding.ObservableBoolean;
import androidx.databinding.ObservableField;
import androidx.databinding.ObservableInt;

import com.eternal.framework.utils.KLog;

import java.lang.reflect.Field;
import java.util.Objects;

import io.reactivex.Observable;

/**
 * 用于分析對象是否發(fā)生變化，發(fā)生變化后，具體是哪個字段發(fā)生變化
 */
public class ObjectChangeDetector {

    private String tag = "ObjectChangeDetector";
    private int lastHash = 0;
    private Object lastObject = null;

    public ObjectChangeDetector(Object object) {
        this.lastObject = object;
        this.lastHash = Objects.hashCode(object);
    }

    public void checkAndReport(Object newObject) {
        int newHash = Objects.hashCode(newObject);

        // 1. 快速預(yù)檢：通過 Hash 判斷是否有變化
        if (newHash == this.lastHash) {
            KLog.d(tag, "Hash 值一致，對象無變化。");
            return;
        }

        // 2. Hash 變化了，進行詳細對比
        KLog.d(tag, "Hash 值變化 (" + this.lastHash + " -> " + newHash + ")，開始分析差異...");
        if (this.lastObject != null) {
            // 使用上面介紹的 JSON 或 Javers 方法進行 Diff
            compareObjects(this.lastObject, newObject);
        }
        // 3. 更新狀態(tài)
        this.lastHash = newHash;
        this.lastObject = newObject;
    }

    private void compareObjects(Object a, Object b) {
        Field[] fieldsA = a.getClass().getDeclaredFields();
        Field[] fieldsB = b.getClass().getDeclaredFields();
        for (Field field : fieldsA) {
            field.setAccessible(true);
            String fieldName = field.getName();
            try {
                Field fieldFromB = Observable.fromArray(fieldsB).filter(it->fieldName.contentEquals(it.getName())).blockingFirst();
                if (fieldFromB == null) {
                    KLog.d(tag, b.getClass().getSimpleName() + " 的字段 " + fieldName + " 不存在");
                    continue;
                }
                fieldFromB.setAccessible(true);
                // 獲取靜態(tài)字段的值
                Object valueA = field.get(a);
                Object valueB = fieldFromB.get(b);
                KLog.d(tag, b.getClass().getSimpleName() + " 的字段 " + fieldName + ", 類型:" + valueA.getClass().getSimpleName());
                if (valueA instanceof Integer && valueB instanceof Integer) {
                    if ((int)valueA != (int)valueB) {
                        String msg = a.getClass().getSimpleName() + "." + fieldName + ": " + valueA + " -> " + valueB;
                        KLog.d(tag, msg);
                    }
                }
                else if (valueA instanceof ObservableInt && valueB instanceof ObservableInt) {
                    if (((ObservableInt)valueA).get() != ((ObservableInt)valueB).get()) {
                        String msg = a.getClass().getSimpleName() + "." + fieldName + ": " + ((ObservableInt) valueA).get() + " -> " + ((ObservableInt) valueB).get();
                        KLog.d(tag, msg);
                    }
                }
                else if (valueA instanceof ObservableBoolean && valueB instanceof ObservableBoolean) {
                    if (((ObservableBoolean)valueA).get() != ((ObservableBoolean)valueB).get()) {
                        String msg = a.getClass().getSimpleName() + "." + fieldName + ": " + ((ObservableBoolean) valueA).get() + " -> " + ((ObservableBoolean) valueB).get();
                        KLog.d(tag, msg);
                    }
                }
                else if (valueA instanceof ObservableField && valueB instanceof ObservableField) {
                    valueA = ((ObservableField<?>) valueA).get();
                    valueB = ((ObservableField<?>) valueB).get();
                    if (valueA instanceof String && valueB instanceof String) {
                        if (!((String) valueA).contentEquals((String)valueB)) {
                            String msg = a.getClass().getSimpleName() + "." + fieldName + ": " + valueA + " -> " + valueB;
                            KLog.d(tag, msg);
                        }
                    } else if (valueA.getClass().getSimpleName().contentEquals("PortItem") && valueB.getClass().getSimpleName().contentEquals("PortItem")) {
                        compareObjects(valueA, valueB);
                    }
                }
            } catch (Exception e) {
                KLog.e(tag,e + ", field name:" + field.getName());
            }
        }
    }
}

知識擴展

在 Java 中“對比分析對象是否有變化”，通常指的是比較兩個對象當前狀態(tài)與之前狀態(tài)是否一致，或者對象的字段值是否發(fā)生了改變。根據(jù)場景不同，有幾種主流的實現(xiàn)方式。

1.基礎(chǔ)方法：重寫 equals() 與 hashCode()

這是最直接、最通用的方案。通過重寫 equals() 定義對象“相等”的邏輯（通常是比較所有關(guān)鍵字段），然后調(diào)用 oldObj.equals(newObj) 判斷是否有變化。

public class User {
    private String name;
    private int age;
    
    // 構(gòu)造器、getter/setter 省略
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return age == user.age &amp;&amp; Objects.equals(name, user.name);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

// 使用
User oldUser = new User("Alice", 25);
User newUser = new User("Alice", 26);
boolean changed = !oldUser.equals(newUser); // true

優(yōu)點：符合 Java 規(guī)范，可被集合類正確使用。

缺點：需要手動維護 equals/hashCode，且只能判斷“是否相等”，無法得知哪些字段發(fā)生了變化。

2.利用工具庫進行字段級差異檢測

如果你需要精確知道哪些字段改變了（例如用于審計日志），可以使用專門的對象對比庫。

1. Apache Commons Lang3 – EqualsBuilder & ReflectionToStringBuilder

import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.ReflectionToStringBuilder;

public boolean isChanged(Object oldObj, Object newObj) {
    return !EqualsBuilder.reflectionEquals(oldObj, newObj);
}

// 查看具體差異字段（配合 toString）
String oldStr = ReflectionToStringBuilder.toString(oldObj);
String newStr = ReflectionToStringBuilder.toString(newObj);
// 對比字符串差異

優(yōu)點：無需手動編寫 equals，通過反射自動比較所有字段。

缺點：性能略差（反射），且無法忽略特定字段。

2. Javers – 專門的對象變化審計庫

Javers 可以深入對比對象圖，并返回詳細的變更日志（如新增、刪除、修改的字段）。

<dependency>
    <groupId>org.javers</groupId>
    <artifactId>javers-core</artifactId>
    <version>7.4.0</version>
</dependency>

import org.javers.core.Javers;
import org.javers.core.JaversBuilder;
import org.javers.core.diff.Diff;

Javers javers = JaversBuilder.javers().build();
Diff diff = javers.compare(oldUser, newUser);

if (diff.hasChanges()) {
    System.out.println(diff.getChanges()); 
    // 輸出類似：Change{ 'age' changed from 25 to 26 }
}

優(yōu)點：功能強大，支持集合、嵌套對象、自定義比較策略。

缺點：引入額外依賴，學(xué)習(xí)曲線稍高。

3.反射對比工具（輕量自制）

如果你不想引入大庫，可以自己寫一個簡單的反射對比工具，返回差異字段列表。

public static List&lt;String&gt; findChangedFields(Object oldObj, Object newObj) throws IllegalAccessException {
    List&lt;String&gt; changedFields = new ArrayList&lt;&gt;();
    Field[] fields = oldObj.getClass().getDeclaredFields();
    for (Field field : fields) {
        field.setAccessible(true);
        Object oldVal = field.get(oldObj);
        Object newVal = field.get(newObj);
        if (!Objects.equals(oldVal, newVal)) {
            changedFields.add(field.getName());
        }
    }
    return changedFields;
}

優(yōu)點：完全可控，無需第三方庫。

缺點：無法處理繼承字段、嵌套對象；性能一般。

4.基于版本號的簡單變化跟蹤（適用于 ORM 場景）

在數(shù)據(jù)庫實體中，常通過版本號（version）字段判斷是否被修改。

@Entity
public class Product {
    @Version
    private Long version;  // 每次更新自動遞增
    // ...
}

每次更新前比較 version 是否改變即可知道對象是否被其他事務(wù)修改過。

5.序列化對比（深拷貝對比）

將對象序列化為字節(jié)數(shù)組或 JSON 字符串，然后比較字符串內(nèi)容。

byte[] oldBytes = serialize(oldObj);
byte[] newBytes = serialize(newObj);
boolean changed = !Arrays.equals(oldBytes, newBytes);

優(yōu)點：能夠?qū)Ρ韧暾膶ο髨D（包括嵌套對象）。

缺點：開銷較大，不適合高頻調(diào)用。

6.單元測試場景中的對象對比

在測試中，常用 AssertJ 或 Hamcrest 來斷言對象是否滿足預(yù)期變化。

import static org.assertj.core.api.Assertions.assertThat;
User original = new User("Bob", 30);
User updated = new User("Bob", 31);
assertThat(updated)
    .usingRecursiveComparison()
    .ignoringFields("updateTime")
    .isNotEqualTo(original);

總結(jié)：如何選擇？

需求場景	推薦方案
簡單判斷兩個對象是否相等（如單元測試）	重寫 `equals()` / `Objects.equals()`
業(yè)務(wù)上需要記錄詳細修改日志	Javers 或自寫反射工具
不想寫 `equals`，只想知道是否改變	`EqualsBuilder.reflectionEquals()`
針對數(shù)據(jù)庫實體樂觀鎖	使用 `@Version` 注解
深拷貝對比（不常用）	序列化對比
高性能、大對象頻繁對比	使用字段級差值緩存（如 MD5 摘要）