`
kanpiaoxue
  • 浏览: 1781450 次
  • 性别: Icon_minigender_1
  • 来自: 北京
文章分类
社区版块
存档分类
最新评论

java对象变对比工具javers

 
阅读更多
public static <T> DifferenceResult diff(T oldInstance, T newInstance) {
        LOGGER.debug("start to diff. oldInstance:{},newInstance:{}", oldInstance, newInstance);
        Preconditions.checkNotNull(oldInstance, "oldInstance is null");
        Preconditions.checkNotNull(newInstance, "newInstance is null");
        Stopwatch sw = Stopwatch.createStarted();
        // given
        Javers javers = JaversBuilder.javers().build();
        // when
        Diff diff = javers.compare(oldInstance, newInstance);
        List<ValueChange> changes = diff.getChangesByType(ValueChange.class);
        if (CollectionUtils.isEmpty(changes)) {
            LOGGER.debug("diff. nothing changed. oldInstance:{},newInstance:{}", oldInstance, newInstance);
            return DifferenceResult.builder().withDiff(false).withMessage(StringUtils.EMPTY).build();
        }

        String message = changes.stream().map(change -> {
            Object leftMsg = formatDate(change.getLeft());
            Object rightMsg = formatDate(change.getRight());
            return String.format("%s:[%s]->[%s]", change.getPropertyName(), leftMsg, rightMsg);
        }).collect(Collectors.joining(","));
        DifferenceResult result = DifferenceResult.builder().withDiff(true).withMessage(message).build();
        LOGGER.debug("diff. {} changed. it consume {}. oldInstance:{},newInstance:{}", result, sw,
                oldInstance, newInstance);
        return result;
    }

 

如果要忽略一些字段的比较,可以采用下面的注解的方式:

@DiffIgnore
private Date modifiedTime;
@DiffIgnore
private Date createTime;

   

 

javers: https://javers.org/documentation/diff-examples/#compare-entities

参考: https://www.baeldung.com/javers

 

一个简单的方法:

 

 

下面的是简单示例:

 

public class JaVers {

    /**
     * @param args
     * @author kanpiaoxue
     * @CreateTime: 2020/04/20 17:09:05
     * @Description:
     */
    public static void main(String[] args) {
        // given
        Javers javers = JaversBuilder.javers().build();

        SimplePerson oldPerson = SimplePerson.builder().withId(1).withName("hello").build();
        SimplePerson newPerson = SimplePerson.builder().withId(1).withName("hello1").build();

        // when
        Diff diff = javers.compare(oldPerson, newPerson);

        // then
        List<ValueChange> changes = diff.getChangesByType(ValueChange.class);
        System.out.println(changes);
        // output: [ValueChange{ 'name' value changed from 'hello' to 'hello1'
        // }]

        changes.stream().forEach(change -> {
            System.out.println(change.prettyPrint(PrettyValuePrinter.getDefault()));
            System.out.println(String.format("%s:%s->%s", change.getPropertyName(), change.getLeft(),
                    change.getRight()));
            // name:hello->hello1
        });

    }

}

 

 

 

public class SimplePerson {
    /**
     * Builder to build {@link SimplePerson}.
     */
    public static final class Builder {
        private Integer id;
        private String name;

        private Builder() {
        }

        /**
         * Builder method of the builder.
         * 
         * @return built class
         */
        public SimplePerson build() {
            return new SimplePerson(this);
        }

        /**
         * Builder method for id parameter.
         * 
         * @param id
         *            field to set
         * @return builder
         */
        public Builder withId(Integer id) {
            this.id = id;
            return this;
        }

        /**
         * Builder method for name parameter.
         * 
         * @param name
         *            field to set
         * @return builder
         */
        public Builder withName(String name) {
            this.name = name;
            return this;
        }
    }

    private Integer id;
    private String name;

    /**
     *
     */
    public SimplePerson() {
        super();
    }

    private SimplePerson(Builder builder) {
        this.id = builder.id;
        this.name = builder.name;
    }

    /**
     * Creates builder to build {@link SimplePerson}.
     * 
     * @return created builder
     */
    public static Builder builder() {
        return new Builder();
    }

    /*
     * (non-Javadoc)
     * @see java.lang.Object#equals(java.lang.Object)
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        SimplePerson other = (SimplePerson) obj;
        if (id == null) {
            if (other.id != null) {
                return false;
            }
        } else if (!id.equals(other.id)) {
            return false;
        }
        if (name == null) {
            if (other.name != null) {
                return false;
            }
        } else if (!name.equals(other.name)) {
            return false;
        }
        return true;
    }

    /**
     * @return the id
     */
    public Integer getId() {
        return id;
    }

    /**
     * @return the name
     */
    public String getName() {
        return name;
    }

    /*
     * (non-Javadoc)
     * @see java.lang.Object#hashCode()
     */
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((id == null) ? 0 : id.hashCode());
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    /**
     * @param id
     *            the id to set
     */
    public void setId(Integer id) {
        this.id = id;
    }

    /**
     * @param name
     *            the name to set
     */
    public void setName(String name) {
        this.name = name;
    }

    /*
     * (non-Javadoc)
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        return "SimplePerson [id=" + id + ", name=" + name + "]";
    }

}

 

 

 

public class DifferenceResult {
    /**
     * Builder to build {@link DifferenceResult}.
     */
    public static final class Builder {
        private boolean diff;
        private String message;

        private Builder() {
        }

        /**
         * Builder method of the builder.
         * 
         * @return built class
         */
        public DifferenceResult build() {
            return new DifferenceResult(this);
        }

        /**
         * Builder method for diff parameter.
         * 
         * @param diff
         *            field to set
         * @return builder
         */
        public Builder withDiff(boolean diff) {
            this.diff = diff;
            return this;
        }

        /**
         * Builder method for message parameter.
         * 
         * @param message
         *            field to set
         * @return builder
         */
        public Builder withMessage(String message) {
            this.message = message;
            return this;
        }
    }

    private boolean diff;
    private String message;

    /**
     *
     */
    public DifferenceResult() {
        super();
    }

    private DifferenceResult(Builder builder) {
        this.diff = builder.diff;
        this.message = builder.message;
    }

    /**
     * Creates builder to build {@link DifferenceResult}.
     * 
     * @return created builder
     */
    public static Builder builder() {
        return new Builder();
    }

    /*
     * (non-Javadoc)
     * @see java.lang.Object#equals(java.lang.Object)
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        DifferenceResult other = (DifferenceResult) obj;
        if (diff != other.diff) {
            return false;
        }
        if (message == null) {
            if (other.message != null) {
                return false;
            }
        } else if (!message.equals(other.message)) {
            return false;
        }
        return true;
    }

    /**
     * @return the message
     */
    public String getMessage() {
        return message;
    }

    /*
     * (non-Javadoc)
     * @see java.lang.Object#hashCode()
     */
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + (diff ? 1231 : 1237);
        result = prime * result + ((message == null) ? 0 : message.hashCode());
        return result;
    }

    /**
     * @return the diff
     */
    public boolean isDiff() {
        return diff;
    }

    /**
     * @param diff
     *            the diff to set
     */
    public void setDiff(boolean diff) {
        this.diff = diff;
    }

    /**
     * @param message
     *            the message to set
     */
    public void setMessage(String message) {
        this.message = message;
    }

    /*
     * (non-Javadoc)
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        return CommonUtils.toJSONString(this);
    }
}

 

分享到:
评论

相关推荐

    java文件对比工具

    Java文件对比工具是一种用于比较两个或多个文件之间差异的实用程序,特别适用于编程环境中检查代码间的相似性或差异。在Java开发中,这样的工具能够帮助开发者有效地定位代码修改的地方,协同工作时解决合并冲突,...

    实用小工具:Java实体类对比、Json对比、字符串动态拼接等功能

    标题中的“实用小工具:Java实体类对比、Json对比、字符串动态拼接等功能”涉及到的是在软件开发过程中常用的几个技术点,主要集中在Java后端和前端Vue.js的应用上。这里我们将详细探讨这些知识点: 1. **Java实体...

    JAVA对象序列化保存为XML文件的工具类

    这两个工具使得在XML和Java对象之间进行序列化和反序列化变得更加简单。 以下是一个简单的示例,展示了如何使用`ObjectToXMLUtil`工具类将Java对象序列化到XML文件以及从XML文件中反序列化: ```java public class...

    对象字段变化比较工具

    总的来说,“对象字段变化比较工具”是一个实用的开发辅助工具,它简化了对象状态对比的过程,帮助开发者更高效地定位和解决问题。通过理解其核心原理和技术细节,我们可以更好地利用它来提升工作效率。

    java对比工具

    Java对比工具是一款专门用于比较Java源代码文件差异的实用程序,它可以帮助开发者高效地识别和理解两个版本之间代码的修改之处。在这个分享中,我们主要关注的是"Bcompare-zh-3.3.10.17762.exe"这个文件,这是一款名...

    Java对象属性数据比较,返回变化数据

    `ObjectCompareUtil.java`很可能就是一个工具类,提供了静态方法来比较两个对象的属性差异。 在`ObjectCompareUtil`中,可能会有如下的核心方法: ```java public static &lt;T&gt; Map, DiffResult&gt; compareObjects(T ...

    JAVA-JSON工具转换类

    可能包含的方法有`toJson()`(将Java对象转换为JSON字符串)、`fromJson()`(将JSON字符串解析为Java对象)、`convertToMap()`(将JSON字符串转换为Map)以及`convertToList()`(将JSON字符串转换为List)等。...

    Excel列表转化成java对象

    这些工具可以将Java对象序列化为CSV或Excel格式,反之亦然,使得数据交换变得更加方便。 在实际开发中,将Excel或CSV数据转化为Java对象集合通常涉及到以下步骤: 1. **读取文件**:使用Apache POI或CSV库打开并...

    java转js工具

    综上所述,"java转js工具"是一个重要的开发辅助工具,它帮助开发者在Java和JavaScript之间架起桥梁,使得跨平台开发变得更加便捷。然而,使用时需要注意语言特性的差异,以及转换过程中可能出现的问题和挑战。

    xml报文和java对象互相转换 相关jar包和测试代码

    xml报文和java对象互相转换 相关jar包和测试代码,可以与castor插件java对象和XML自动绑定maping文件生成和java对象一键生成工具1.2(https://download.csdn.net/download/kemoing/10864595)完美配合使用

    阿里云对象存储静态工具类(AliOSSUtils.java)快速上手!!!

    根据官网和网上分享的代码自己整理了一个阿里云OSS工具类,自动创建标准公开权限的存储空间,支持上传图片,音频,视频,PDF各种文件,批量上传,上传后支持在线预览,文件路径处理,浏览器文件下载(支持源文件中文...

    java 对象是否为空的判断

    java 判断对象是否为空.如String,Character,Object[]

    java2python--java代码转python工具

    Java使用类和对象来组织代码,而Python则支持多种面向对象的特性,包括类、对象、以及函数式编程元素。此外,Java的控制流程(如if-else,for循环)和异常处理与Python也有所不同。 在实际的转换过程中,工具可能会...

    很强大的java代码混淆工具 Jocky

    Jockey跟其他混淆工具不同的是:它是直接对编译过程做文章,也就是在把java文件编译为class文件的过程中对代码进行混淆,混淆后的代码中包含很多JVM 指令,大家知道JVM指令是面向机器的,人类一般很难看懂!...

    java判断参数是否为空工具类 java判断对象属性是否全部为空

    java判空工具类 可以判断字符串数组,字符串类型,List对象集合,Map集合map,object&gt;,map和多个String参数,对象类型,是否为空。 java判断对象属性是否全部为空,只要有一个属性不为空,那么就不是所有的属性值都...

    C++代码转java工具

    3. **结构转换**:处理C++的类和对象到Java的类和对象的转换,包括构造函数、继承、多态等面向对象特性。 4. **异常处理**:将C++的错误处理机制(如返回错误码)转换为Java的异常处理机制。 5. **内存管理**:C++...

    30个java工具类

    [工具类] CookieCounter .java.txt [工具类] 验证码img .jsp.txt [工具类] Java中计算任意两个日期之间的工作天数 .java.txt [工具类] java抓取网页 .java.txt [工具类] MD5 .java.txt [工具类] MD5强化版 .java.txt...

    Java 面向对象 练习题与答案

    Java 面向对象编程练习题与答案 本资源摘要信息涵盖了 Java 面向对象编程的多个知识点,包括 Font 类、Toolkit 类、包机制、抽象类、数组操作等。 1. Font 类: Font 类是 Java 中的一个类,用于设置程序中的字体...

    C转java工具

    《C语言到Java语法转换工具解析》 在编程领域,跨语言转换工具是开发者们解决代码迁移、兼容性问题的有效手段。"C转Java工具"就是这样一个工具,它能够将大部分C语言的语法转化为等效的Java语法,使得C语言编写的...

Global site tag (gtag.js) - Google Analytics