Java工具类：CompareUtils（比较对象字段值变化）

已于 2022-05-07 09:27:18 修改
阅读量1.1w 收藏 89
点赞数 18
分类专栏： Java 开发工具 文章标签： java 开发语言
于 2022-05-06 13:49:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunnyzyq/article/details/124603360
版权

目录

前言

示例引入

工具文件

CompareUtils

Compare 

CompareNode 

前言

我们在工作中，可能会在日志中记录数据的变化情况，这样可以有助于运维人员对问题排查。

或者在公共处理的数据增加一个日志页面，记录每次修改的变化。比如：小王在 2022-05-05 23:58:27 时间点修改了年龄，把 28 改为了 18）， 这样也可以方便用户的数据追踪，这样公共数据一旦出了问题，我们从日志进行跟踪，那么最后是谁造成的，也就一目了然。

可见，展示字段值的变化，是一个较为实用的功能。

示例引入

那么，我们既然要记录每次保存前后的字段值变化，则肯定需要进行字段值的比较。

比如，我们下面有一个 User 对象：

@Data
public class User {

    private String name;
    private int age;

}

我们如果要记录每次 User 对象保存的前后变化，可能大家最容易想到的，就是对每个字段依次进行比较，获取结果，具体操作如下：

@Data
public class User {

    private String name;
    private int age;

    /**
     * 获取比较结果
     * tips: 这里我们做演示，先忽略比较对象和比较值为 null 的情况
     *
     * @param u 待比较对象
     * @return 比较结果
     */
    public String compare(User u) {
        StringBuilder sb = new StringBuilder();
        if (!u.getName().equals(this.name)) {
            sb.append(String.format("[姓名：%s -> %s], ", u.getName(), this.name));
        }
        if (u.getAge() != this.age) {
            sb.append(String.format("[年龄：%d -> %d], ", u.getAge(), this.age));
        }
        return sb.toString();
    }

}

 我们不妨来写个示例测试一下：

public class Test {

    public static void main(String[] args) {
        // 模拟一个保存前的数据对象
        User u1 = new User();
        u1.setName("大乔");
        u1.setAge(24);
        // 模拟一个保存后的数据对象
        User u2 = new User();
        u2.setName("小乔");
        u2.setAge(22);
        // 获取保存前后的字段变化情况
        String result = u2.compare(u1);
        System.out.println(result);
    }

}

 我们运行程序，可以发现，已经成功获取到了每个字段的数据变化情况：

设想下，如果随着业务的拓展，当我们的 2 个字段增加到多个字段的时候。

如果这个时候，我们再依次去比较每个字段，是不是就显得有点繁琐了。并且逻辑性也高度重合，这时的代码就会显得十分的臃肿，那么，这个时候，我们就不妨考虑写一个通用的方法了。

工具文件

在写这个通用方法时，我们应该考虑到以下几点：

（1）可以接收任何对象的比较，但比较的对象应该是同个对象；

（2）可以给字段进行一个备注，因为我们看到的最终内容，应该是一个中文名称；

（3）一个对象中，可以忽略某些字段进行比较，只要我需要的字段进行比较。

于是，针对上面的需求，我写了一个通用的比较方法，具体包含下面三个文件：

CompareUtils

package com.zyqok.utils.compare;

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

/**
 * 使用须知： <br>
 * （1）该工具类主要用于两个同类对象的属性值比较； <br>
 * （2）使用本工具类前，请将对应的类属性上打上 @Compare("xxx") 注解，其中xxx为字段的表达名称；<br>
 * （3）为了比较灵活，只有打了该注解才会进行比较，不打的字段则不会进行比较 <br>
 * （4）比较后，只会返回有变化的字段，无变化的字符则不返回 <br>
 *
 * @author zyqok
 * @since 2021/05/05
 */
public class CompareUtils<T> {

    private static final String COMMA = "，";

    /**
     * 属性比较
     *
     * @param source 源数据对象
     * @param target 目标数据对象
     * @return 对应属性值的比较变化
     */
    public String compare(T source, T target) {
        return compare(source, target, null);
    }


    /**
     * 属性比较
     *
     * @param source 源数据对象
     * @param target 目标数据对象
     * @param ignoreCompareFields 忽略比较的字段
     * @return 对应属性值的比较变化
     */
    public String compare(T source, T target, List<String> ignoreCompareFields) {
        if (Objects.isNull(source) && Objects.isNull(target)) {
            return "";
        }
        Map<String, CompareNode> sourceMap = this.getFiledValueMap(source);
        Map<String, CompareNode> targetMap = this.getFiledValueMap(target);
        if (sourceMap.isEmpty() && targetMap.isEmpty()) {
            return "";
        }
        // 如果源数据为空，则只显示目标数据，不显示属性变化情况
        if (sourceMap.isEmpty()) {
            return doEmpty(targetMap, ignoreCompareFields);
        }
        // 如果源数据为空，则显示属性变化情况
        String s = doCompare(sourceMap, targetMap, ignoreCompareFields);
        if (!s.endsWith(COMMA)) {
            return s;
        }
        return s.substring(0, s.length() - 1);
    }

    private String doEmpty(Map<String, CompareNode> targetMap, List<String> ignoreCompareFields) {
        StringBuilder sb = new StringBuilder();
        Collection<CompareNode> values = targetMap.values();
        int size = values.size();
        int current = 0;
        for (CompareNode node : values) {
            current++;
            Object o = Optional.ofNullable(node.getFieldValue()).orElse("");
            if (Objects.nonNull(ignoreCompareFields) && ignoreCompareFields.contains(node.getFieldKey())) {
                continue;
            }
            if (o.toString().length() > 0) {
                sb.append("[" + node.getFieldName() + "：" + o + "]");
                if (current < size) {
                    sb.append(COMMA);
                }
            }
        }
        return sb.toString();
    }

    private String doCompare(Map<String, CompareNode> sourceMap, Map<String, CompareNode> targetMap, List<String> ignoreCompareFields) {
        StringBuilder sb = new StringBuilder();
        Set<String> keys = sourceMap.keySet();
        int size = keys.size();
        int current = 0;
        for (String key : keys) {
            current++;
            CompareNode sn = sourceMap.get(key);
            CompareNode tn = targetMap.get(key);
            if (Objects.nonNull(ignoreCompareFields) && ignoreCompareFields.contains(sn.getFieldKey())) {
                continue;
            }
            String sv = Optional.ofNullable(sn.getFieldValue()).orElse("").toString();
            String tv = Optional.ofNullable(tn.getFieldValue()).orElse("").toString();
            // 只有两者属性值不一致时, 才显示变化情况
            if (!sv.equals(tv)) {
                sb.append(String.format("[%s：%s -> %s]", sn.getFieldName(), sv, tv));
                if (current < size) {
                    sb.append(COMMA);
                }
            }
        }
        return sb.toString();
    }

    private Map<String, CompareNode> getFiledValueMap(T t) {
        if (Objects.isNull(t)) {
            return Collections.emptyMap();
        }
        Field[] fields = t.getClass().getDeclaredFields();
        if (Objects.isNull(fields) || fields.length == 0) {
            return Collections.emptyMap();
        }
        Map<String, CompareNode> map = new LinkedHashMap();
        for (Field field : fields) {
            Compare compareAnnotation = field.getAnnotation(Compare.class);
            if (Objects.isNull(compareAnnotation)) {
                continue;
            }
            field.setAccessible(true);
            try {
                String fieldKey = field.getName();
                CompareNode node = new CompareNode();
                node.setFieldKey(fieldKey);
                node.setFieldValue(field.get(t));
                node.setFieldName(compareAnnotation.value());
                map.put(field.getName(), node);
            } catch (IllegalArgumentException | IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return map;
    }

}

Compare 

package com.zyqok.utils.compare;


import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 字段标记注解
 *
 * @author zyqok
 * @since 2022/05/05
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Compare {

    /**
     * 字段名称
     */
    String value();
}

CompareNode 

package com.zyqok.utils.compare;

/**
 * @author zyqok
 * @since 2022/05/05
 */
public class CompareNode {

    /**
     * 字段
     */
    private String fieldKey;

    /**
     * 字段值
     */
    private Object fieldValue;

    /**
     * 字段名称
     */
    private String fieldName;

    public String getFieldKey() {
        return fieldKey;
    }

    public void setFieldKey(String fieldKey) {
        this.fieldKey = fieldKey;
    }

    public Object getFieldValue() {
        return fieldValue;
    }

    public void setFieldValue(Object fieldValue) {
        this.fieldValue = fieldValue;
    }

    public String getFieldName() {
        return fieldName;
    }

    public void setFieldName(String fieldName) {
        this.fieldName = fieldName;
    }
}

那么，我们在使用的时候，只需要将这三个文件复制在工程中即可：

我们去掉原比较方法，然后在对应字段上打上 @Compare 注解，写上对应字段名称。

最后测试，调用 CompareUtils 类中的 compare 方法即可，示例如下：

public class Test {

    public static void main(String[] args) {
        // 模拟一个保存前的数据对象
        User u1 = new User();
        u1.setName("大乔");
        u1.setAge(24);
        // 模拟一个保存后的数据对象
        User u2 = new User();
        u2.setName("小乔");
        u2.setAge(22);
        // 获取保存前后的字段变化情况
        String result = new CompareUtils<User>().compare(u1, u2);
        System.out.println(result);
    }

}

运行结果如下：可以看到，和我们之前的比较结果是一致的。

如果不想比较某个字段，则把对应的字段传入到参数中即可，比如，这里我不想比较 name 这个字段。

该场景适用于一个对象用于多个比较场景的时候，可以把不需要进行比较的字段进行过滤。

比如，对象中有 ABCD 四个字段，场景一只比较 ABC 字段，场景二只比较 BCD 字段，但两个场景都想共用一个实体，那么场景一进行比较的时候，就可以过滤 D 字段，场景二进行比较的时候，就可以过滤 A 字段。

zyqok
关注
  • 18
    点赞
  • 踩
  • 89
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
腾讯云对象存储静态工具类（CosUtils.java），快速上手！！！
06-28
腾讯云对象存储静态工具类，满足日常工作使用，每个方法都有注释，快速上手！记得先引入Maven依赖，在配置文件中配置对象存储所属参数！
基于java中两个对象属性的比较
08-29
下面小编就为大家带来一篇基于java中两个对象属性的比较。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
java常用BeanCompareUtil 注解 + 反射实现 (实例说明)
wangrui1605的博客
12-24 1111
文章目录背景使用实例说明使用方式执行效果 背景 在开发过程中经常会使用到一种场景就是比较内存中的两个bean 数据有什么同。其实这种功能算是一个非常常用的场景。 使用实例说明 一共需要以下的几个模块 FieldComparison 自定义注解，主要是标识需要比较的bean 中的字段。 BeanCompareUtil 核心util 主要是实现compare 方法。 FieldMapping 字段映射关系，选用可以对特定的字段进行转义。 DefaultFieldMapping fieldMapping的
java后端比较同类的两个对象的字段差异的项目内的三种实现的比较
qq_38127559的博客
02-21 711
项目内有个需求，对导入的数据行，通过流程将数据下发到具体的业务人员端，由业务人员进行核对，然后由移动端APP，将核对后的前后差异的数据挂载到流程中去。需要提交的信息格式为“[{"fieldDesc":"姓名","newValue":"李四","fieldName":"cnName","oldValue":"张三"}]”，将每个不同的字段信息对比信息，包装到数组中统一挂载到流程中。本例介绍了项目内对象对比的三种实现方式，并对比了其中的实现差异，流程的相关操作不在本例介绍范围内。
一个Java反射工具类，可以完成查询字段值以及设置字段值的功能
03-08
一个Java反射工具类，可以完成查询字段值以及设置字段值的功能。
java 对比两个实体类字段变化
最新发布
木辰風的博客
03-20 219
我们在工作中，可能会在日志中记录数据的变化情况或者在公共处理的数据增加一个日志页面，记录每次修改的变化。我们可以根据CompareUtils工具类比较数据前后发生了怎样的变化, 这样我们就可以知道数据做了哪些改变。/*** 对比注解*/@Target(value = {ElementType.TYPE, ElementType.FIELD}) // 允许被修饰的注解作用在类、接口和枚举上 // 允许作用在属性字段上。
java - 比对两个对象字段值，并且返回值不一致的字段名称
叽叽叽叽叽叽叽叽叽叽叽叽叽叽叽叽
04-06 2067
需求： 对比两个版本的详情，对出现修改的地方进行标注表示此处有修改。 PART 1： 改良自org.springframework.beans.BeanUtils下的copyProperties方法 /** * 比较两个对象的不同字段 * @return */ public static List<String> checkDiffFiled(Object source, Object target){ List<String&gt
比较2个实体对象——CompareUtil工具类
leomoon
06-01 2104
package com.lmp.utils; import java.beans.Introspector; import java.beans.PropertyDescriptor; import java.lang.reflect.Method; import java.sql.Timestamp; import java.util.*; public class CompareUtil { /** * 比较两个实体属性值(同一对象类型)，返回一个boolean,true则
java 工具类: CompareUtils（比较对象字段值变化）
m0_61682705的博客
12-03 943
我们在工作中，可能会在日志中记录数据的变化情况或者在公共处理的数据增加一个日志页面，记录每次修改的变化。我们可以根据CompareUtils工具类比较数据前后发生了怎样的变化, 这样我们就可以知道数据做了哪些改变./*** 字段标记注解*//*** 字段名称*/
保存业务的修改记录(对象字段差异对比）
小流至江河的博客
11-04 2687
数据库保存业务修改记录
Java笔记【持续更新中】
qq_18303753的博客
06-06 92
Java内存 堆区 存放new的对象和数组 可以被所有的线程共享，不会存放别的对象引用 栈区 存放基本变量类型（会包含这个具体变量的数值） 引用对象的变量（会存放这个引用在堆里面的具体地址） 方法区 可以被所有的线程共享 包含了所有的class和static变量 面向对象 本质 以类的形式组织代码，以对象的形式封装数据 三大特性 封装 继承 多态 高内聚：类的内部数据操作细节自己完成，不允许外部干涉 低耦合：仅暴露少量的方法给外部使用 封装 通常应禁止直接访问一个对象中数据的实际表示，而应.
Java自定义注解判断修改后两个对象的指定字段变化情况，并展示出对应的中文名和对应的值
zbh1957282580的博客
03-22 1773
注解标注，则获取该注解的值作为字段的中文名，然后获取该字段的旧值和新值，并比较它们是否相等，如果不相等，则将字段名和值添加到结果中。方法，用于比较两个对象的指定字段是否发生变化。该方法首先通过反射获取对象的所有字段，然后遍历所有字段，如果字段被。接下来，我们需要定义一个工具类来比较两个对象的指定字段是否发生变化，如下所示。然后，在需要比较两个对象的指定字段是否发生变化的地方，调用。最后，我们可以在需要比较的类的字段上添加。属性，用于存储需要比较的字段的中文名。这个工具类定义了一个。
java对象实体类属性字段对比变化过程
11-13
Java对象实体类属性字段对比变化过程是指在一个Java对象实体类的生命周期中，其属性字段的变化情况。这种变化过程通常涉及到对象的创建、使用和销毁等阶段。 在对象的创建阶段，Java对象实体类会根据预设的属性字段和初始值进行初始化。这些属性字段通常定义在类的声明中，并使用关键字进行描述。在实例化一个对象时，Java虚拟机会根据类的定义分配相应的内存空间，并将属性字段的值设置为初始值。 在使用对象的过程中，属性字段的值可能会发生改变。这些改变可能是通过直接访问属性字段的方式进行的，也可能是通过调用相应的方法来修改的。当属性字段的值发生改变时，对象的内部状态也会相应地更新。 当对象不再被使用时，Java虚拟机会自动回收其占用的内存空间。在这个过程中，对象的属性字段的值将被释放，以便为其他对象所使用。 在对比变化过程方面，Java对象实体类通常会使用版本控制的方式来记录属性字段的变化情况。这种版本控制机制可以帮助开发人员更好地追踪和管理对象的状态变化。同时，Java对象实体类还可以提供相应的工具和方法来获取和比较对象的不同版本，以便更好地理解和管理对象的生命周期。
SQL字段拆分优化
12-15
今天看到一条用函数处理连接的SQL，是群里某位网友的，SQL语句如下： SELECT SO_Order.fdate , SO_Order.fsn FROM so_order INNER JOIN so_orderitem ON CHARINDEX(so_Orderitem.fid, SO_Order.fid) >= 1 WHERE so_order.FOrderDate = '2015-09-06' 语句不算复杂，只是执行比较慢，下面是关于这SQL语句的一些信息： –1.SQL执行203条数据 –2.耗时12秒 –3.so_order表的fid字段是字符串集合， –由1-2个
Java实体类字段生成工具类-将数据库表列字段转为Java实体类驼峰字段
05-29
为了解决这个问题，开发了这个Java实体类字段生成工具类。 2、该工具类可以将数据库表列字段转化为对应的Java实体类字段。生成的实体类字段格式清晰易读，且符合Java命名规范。通过使用该工具类，可以大大提高开发...
对象字段变化比较工具
07-26
对象更改比较工具类，用于比较字段变化值，抛砖引玉，欢迎指正。
Java 8 ：List 转 Map 之 Collectors.toMap()
热门推荐
小白一个
09-17 4万+
【前言】 在很多编码时候，我们需要将我们的 List 对象集合，转成为简单的 Map 集合，从而方便很多后续操作。 比如：我们现在有一个用户类 User 如下： public class User { // 用户ID private long id; // 用户名称 private String name; // 相关constrator,getter,setter,toString()方法已省略 ｝ 那么，我们可以简单的初始化得到一个 List<User> 的数
IDEA 如何快速创建 Springboot 项目
小白一个
09-18 2万+
（1）打开IDEA，左上角选择：File -> New -> Project （2）首选选择弹窗左侧的Spring Initializr，然后选好择你的 JDK，点击 Next。 （3）填写并选择： 1，2 处：是 Maven 工程的两个属性唯一标识，随意填。 3处：类型选择Maven 项目 4处：语言选择 Java 5处：打包方式选择 Jar 6处：Java版本选择 8 1-6处确定好后，选择 Next。 （4）左侧选择 Web 后，勾选 Spring We...
百度敏感词安全检测
小白一个
05-06 2万+
官方平台：http://ai.baidu.com/tech/textcensoring （1）登录百度账号，加入百度智能云。 （2）进入后，选择对应的安全检测服务，点击【开通】。 （3）勾选对应的审核服务，如果没有实名认证，需要进行实名认证。 （4）实名认证后，再次回到页面刷新，点击【确认开通】 （5）进入该页面后，直接点击【去支付】 （6）开通成功界面 （7...
java动态代理使用场景
07-27
Java动态代理的使用场景有很多，以下是一些常见的场景： 1. AOP（面向切面编程）：动态代理可以在方法执行前后加入一些通用的逻辑，如日志记录、性能监控等。通过动态代理，可以将这些通用的逻辑从业务逻辑中解耦出来，提高代码的可维护性和复用性。 2. 事务管理：动态代理可以在方法执行前后进行事务的开启、提交或回滚等操作，实现声明式事务管理。 3. 缓存代理：动态代理可以在方法执行前检查缓存中是否存在结果，如果存在则直接返回缓存中的数据，避免重复计算或查询数据库。 4. 延迟加载：动态代理可以在需要时才真正创建对象，延迟加载对应的资源。 5. 远程方法调用（RPC）：动态代理可以通过网络将方法调用传递到远程服务器，并将结果返回给调用方。 6. 日志记录：动态代理可以在方法执行前后记录方法的输入参数和返回结果，便于调试和排查问题。 需要注意的是，动态代理主要是基于接口进行代理，对于没有实现接口的类，可以使用CGLIB等第三方库实现基于类的动态代理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值