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

更新时间：2026年04月20日 08:44:10 作者：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分析对象是否有变化内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

使用SpringBoot+nmap4j获取端口信息的代码详解
这篇文章主要介绍了使用 SpringBoot + nmap4j 获取端口信息,包括需求背景、nmap4j 的相关介绍、代码说明（含测试代码、改造后的代码及参数说明）,还提到了文件读取方式和依赖引入方式,最终请求能获取到数据,需要的朋友可以参考下
2025-01-01
Springboot @Configuration @bean注解作用解析
这篇文章主要介绍了springboot @Configuration @bean注解作用解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2020-02-02
SpringBoot整合Javamail实现邮件发送功能
邮件发送是一个很普遍的功能,springboot整合了相关的starter,本文给大家介绍了可以实现一个简单的邮件发送功能的实例,文中通过代码给大家介绍的非常详细,感兴趣的朋友可以参考下
2023-12-12
Java中启动jar包的方式汇总
Java 命令执行 JAR 包是一种常见的应用场景,在实际开发中,我们经常需要执行 JAR 包文件,那么,如何使用 Java 命令执行 JAR 包呢？本文将为大家介绍八种不同的方法,需要的朋友可以参考下
2025-09-09
Java8 自定义CompletableFuture的原理解析
这篇文章主要介绍了Java8 自定义CompletableFuture的原理解析，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2021-11-11
maven资源过滤打包后文件变大的处理方法
maven目前在web上面的使用方式很普遍，而打包的方式也存在很多方式，下面这篇文章主要给大家介绍了关于maven资源过滤打包后文件变大的处理方法，文中通过示例代码介绍的非常详细，需要的朋友可以参考下
2018-07-07
java实时监控文件行尾内容的实现
这篇文章主要介绍了java实时监控文件行尾内容的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2020-02-02
Java wait和notifyAll实现简单的阻塞队列
这篇文章主要介绍了Java wait和notifyAll实现简单的阻塞队列,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2019-10-10
Java date format时间格式化操作示例
这篇文章主要介绍了Java date format时间格式化操作,结合具体实例形式分析了java针对日期时间进行格式化操作的相关实现技巧,需要的朋友可以参考下
2017-03-03
SpringBoot中的多RabbitMQ数据源配置实现
本篇博客将介绍如何在 Spring Boot 中配置和管理多个 RabbitMQ 数据源,以满足不同的应用需求,具有一定的参考价值,感兴趣的可以了解一下
2023-09-09

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

相关文章

最新评论

大家感兴趣的内容

最近更新的内容

常用在线小工具