java代码实现对比分析对象是否有变化

在项目中大家应该遇到过这种问题，需要分析对象是否发生变化，发生变化后，具体是哪个字段发生变化

针对这个常见的开发痛点，下面提供一个可以直接“开箱即用”的工具类，帮你快速定位对象的变化细节。

package com.eternal.base.utils;

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

import com.eternal.framework.utils.KLog;

import ja va.lang.reflect.Field;
import ja va.util.Objects;

import io.reactivex.Observable;

/**
 * 用于分析对象是否发生变化，发生变化后，具体是哪个字段发生变化
 */
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. 快速预检：通过 Hash 判断是否有变化
        if (newHash == this.lastHash) {
            KLog.d(tag, "Hash 值一致，对象无变化。");
            return;
        }

        // 2. Hash 变化了，进行详细对比
        KLog.d(tag, "Hash 值变化 (" + this.lastHash + " -> " + newHash + ")，开始分析差异...");
        if (this.lastObject != null) {
            // 使用上面介绍的 JSON 或 Ja vers 方法进行 Diff
            compareObjects(this.lastObject, newObject);
        }
        // 3. 更新状态
        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);
                // 获取静态字段的值
                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());
            }
        }
    }
}

知识扩展

其实，在 Ja va 开发中，“对比分析对象是否有变化”是个高频需求，但具体含义可能略有不同。它通常指两种情况：一是判断对象的当前状态与之前状态是否一致；二是更精细地探查对象的哪些字段值发生了改变。根据不同的应用场景，业内其实有几种主流的实现思路。

1.基础方法：重写 equals() 与 hashCode()

这算是最经典、最通用的方案了。核心思路是通过重写 equals() 方法来定义对象“相等”的逻辑（通常是逐一比较所有关键字段），然后直接调用 oldObj.equals(newObj) 来判断是否有变化。

public class User {
    private String name;
    private int age;
    
    // 构造器、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 && 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

优点：完全符合 Ja va 对象比较规范，能够被各种集合类（如 HashSet, HashMap）正确使用。

缺点：需要手动维护 equals 和 hashCode 方法，而且它只能给出一个“是或否”的结论，无法告诉你具体是哪个字段动了手脚。

2.利用工具库进行字段级差异检测

如果你需要精确知道哪些字段被修改了（比如用于生成审计日志或数据同步），那么专门的对比工具库会是更好的选择。

方案一：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);
// 对比字符串差异

优点：无需手动编写冗长的 equals 方法，通过反射就能自动比较所有字段，非常省事。

缺点：反射操作会带来一定的性能开销，并且无法灵活地忽略某些不需要比较的字段。

方案二：Ja vers – 专门的对象变化审计库

Ja vers 是这个领域的专业选手，它能深入对比复杂的对象图（比如包含嵌套对象、集合），并返回一份详细的变更日志，明确告诉你哪个字段从什么值变成了什么值。

    org.ja vers
    ja vers-core
    7.4.0

import org.ja vers.core.Ja vers;
import org.ja vers.core.Ja versBuilder;
import org.ja vers.core.diff.Diff;

Ja vers ja vers = Ja versBuilder.ja vers().build();
Diff diff = ja vers.compare(oldUser, newUser);

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

优点：功能极其强大，支持集合、嵌套对象对比，还能自定义比较策略，适合企业级审计需求。

缺点：需要引入额外的依赖，并且有一定的学习成本。

3.反射对比工具（轻量自制）

如果项目不想引入庞大的第三方库，自己动手写一个轻量的反射对比工具也是个不错的选择，它可以返回发生变化的字段名列表。

public static List findChangedFields(Object oldObj, Object newObj) throws IllegalAccessException {
    List changedFields = new ArrayList<>();
    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;
}

优点：代码完全自主可控，没有外部依赖。

缺点：功能相对基础，无法处理继承的字段和复杂的嵌套对象；同样，反射操作对性能有一定影响。

4.基于版本号的简单变化跟踪（适用于 ORM 场景）

在数据库持久化场景中，一种非常经典的做法是利用版本号（version）字段来实现乐观锁，同时也能快速判断对象是否被修改过。

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

每次更新前，只需要比较一下 version 字段的值是否发生变化，就能知道这个对象是否被其他事务修改过。这种方法简单高效，但仅限于有版本号字段的实体类。

5.序列化对比（深拷贝对比）

这是一种比较“重”但很彻底的方法：将对象序列化为字节数组或 JSON 字符串，然后直接比较序列化后的内容是否一致。

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

优点：能够进行深层次的对比，对象图里任何嵌套部分的变化都无所遁形。

缺点：序列化和反序列化的开销很大，不适合在需要高频调用的性能敏感场景中使用。

6.单元测试场景中的对象对比

在编写单元测试时，我们常常需要断言对象的状态是否符合预期。这时，像 AssertJ 或 Hamcrest 这样的断言库提供了非常优雅的对象对比方式。

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);

这些库的语法非常直观，并且支持忽略特定字段、递归比较等高级功能，是测试代码中的利器。

总结：如何选择？

方法这么多，到底该怎么选？其实关键在于匹配你的具体需求。下面这张表可以帮你快速决策：