java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > java分析对象是否有变化

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

作者：IT乐手

在项目中大家应该遇到过这种问题,需要分析对象是否发生变化,发生变化后,具体是哪个字段发生变化,本文为大家整理了一些方法,希望对大家有所帮助

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

下面提供相关的工具类，大家拿来用就行了

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;

/**
 * 用于分析对象是否发生变化，发生变化后，具体是哪个字段发生变化
 */
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 或 Javers 方法进行 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());
            }
        }
    }
}

知识扩展

在 Java 中“对比分析对象是否有变化”，通常指的是比较两个对象当前状态与之前状态是否一致，或者对象的字段值是否发生了改变。根据场景不同，有几种主流的实现方式。

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 &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

优点：符合 Java 规范，可被集合类正确使用。

缺点：需要手动维护 equals/hashCode，且只能判断“是否相等”，无法得知哪些字段发生了变化。

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

优点：无需手动编写 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 }
}

优点：功能强大，支持集合、嵌套对象、自定义比较策略。

缺点：引入额外依赖，学习曲线稍高。

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

优点：完全可控，无需第三方库。

缺点：无法处理继承字段、嵌套对象；性能一般。

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

总结：如何选择？

需求场景推荐方案
简单判断两个对象是否相等（如单元测试）重写 equals() / Objects.equals()
业务上需要记录详细修改日志Javers 或自写反射工具
不想写 equals，只想知道是否改变EqualsBuilder.reflectionEquals()
针对数据库实体乐观锁使用 @Version 注解
深拷贝对比（不常用）序列化对比
高性能、大对象频繁对比使用字段级差值缓存（如 MD5 摘要）

到此这篇关于java代码实现对比分析对象是否有变化的文章就介绍到这了,更多相关java分析对象是否有变化内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文