3.0.2 object list dev #97

yifocus · 2022-10-12T04:21:12Z

支持对象数组的更新

wulangcode · 2022-10-12T13:50:40Z

应当提供给用户去支持多个字段的分组，比如下面的 UserDO ，通过userId与userName当作UNIQUE

    @Data
    public static class UserDO {
        @DiffLogField(name = "用户ID")
        private Long userId;
        @DiffLogField(name = "用户姓名")
        private String userName;
    }

wulangcode · 2022-10-12T15:12:54Z

输出的格式需要调整下。
配置了 @DiffLogField 注解，优先使用注解中的值

wulangcode · 2022-10-12T15:21:04Z

    @Test
    @Sql(scripts = "/sql/clean.sql", executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD)
    public void testCondition_对象数组修改() {
        Order order = new Order();
        order.setOrderId(99L);
        order.setOrderNo("MT0000099");
        order.setProductName("超值优惠红烧肉套餐");
        order.addAuditor(1L,"张三");

        Order order1 = new Order();
        order1.setOrderId(99L);
        order1.setOrderNo("MT0000099");
        order1.setProductName("麻辣烫套餐");
        order1.addAuditor(1L,"李四");
        orderService.diff(order, order1);

        List<LogRecord> logRecordList = logRecordService.queryLog(order.getOrderNo(), LogRecordType.ORDER);
        Assert.assertEquals(1, logRecordList.size());
        LogRecord logRecord = logRecordList.get(0);
        System.out.println(logRecord.getAction());
        Assert.assertEquals(logRecord.getAction(), "更新了订单审核人列表：List内部的数据更新如下： {[CompareId:{用户ID=1，}]:	【用户姓名】从【张三】修改为【李四】，}");
        Assert.assertNotNull(logRecord.getExtra());
        Assert.assertEquals(logRecord.getOperator(), "111");
        Assert.assertEquals(logRecord.getBizNo(), order1.getOrderNo());
        logRecordService.clean();
    }

这里输出的action应该和前面的输出文档格式差不多。

更新了订单审核人列表：List内部的数据更新如下： {[CompareId:{用户ID=1，}]:	【用户姓名】从【张三】修改为【李四】，}

这样给用户就是很乱的感觉。

yifocus · 2022-10-13T09:58:44Z

应当提供给用户去支持多个字段的分组，比如下面的 UserDO ，通过userId与userName当作UNIQUE

    @Data
    public static class UserDO {
        @DiffLogField(name = "用户ID")
        private Long userId;
        @DiffLogField(name = "用户姓名")
        private String userName;
    }

在代码实现上是支持多个字段进行分组的

yifocus · 2022-10-13T10:00:54Z

输出的格式需要调整下。配置了 @DiffLogField 注解，优先使用注解中的值

这一块的东西我们有做修改和改动，这是之前数组操作的就显示的内容。我主要改动的点还是在元素内部的对象做比较。这块要一起显示的用户体验的话是可以看看配置上的文案怎么搞比较好

yifocus · 2022-10-13T10:01:30Z

应当提供给用户去支持多个字段的分组，比如下面的 UserDO ，通过userId与userName当作UNIQUE

    @Data
    public static class UserDO {
        @DiffLogField(name = "用户ID")
        private Long userId;
        @DiffLogField(name = "用户姓名")
        private String userName;
    }

多个字段组合，就每个字段上都写上CompareId 就是支持多个字段组合的。

yifocus · 2022-10-13T10:02:41Z

    @Test
    @Sql(scripts = "/sql/clean.sql", executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD)
    public void testCondition_对象数组修改() {
        Order order = new Order();
        order.setOrderId(99L);
        order.setOrderNo("MT0000099");
        order.setProductName("超值优惠红烧肉套餐");
        order.addAuditor(1L,"张三");

        Order order1 = new Order();
        order1.setOrderId(99L);
        order1.setOrderNo("MT0000099");
        order1.setProductName("麻辣烫套餐");
        order1.addAuditor(1L,"李四");
        orderService.diff(order, order1);

        List<LogRecord> logRecordList = logRecordService.queryLog(order.getOrderNo(), LogRecordType.ORDER);
        Assert.assertEquals(1, logRecordList.size());
        LogRecord logRecord = logRecordList.get(0);
        System.out.println(logRecord.getAction());
        Assert.assertEquals(logRecord.getAction(), "更新了订单审核人列表：List内部的数据更新如下： {[CompareId:{用户ID=1，}]:	【用户姓名】从【张三】修改为【李四】，}");
        Assert.assertNotNull(logRecord.getExtra());
        Assert.assertEquals(logRecord.getOperator(), "111");
        Assert.assertEquals(logRecord.getBizNo(), order1.getOrderNo());
        logRecordService.clean();
    }

这里输出的action应该和前面的输出文档格式差不多。

更新了订单审核人列表：List内部的数据更新如下： {[CompareId:{用户ID=1，}]:	【用户姓名】从【张三】修改为【李四】，}

这样给用户就是很乱的感觉。

这块是可以讨论下的。

更新了订单审核人列表：List内部的数据更新如下： {[CompareId:{用户ID=1，}]: 【用户姓名】从【张三】修改为【李四】，}

这里面的 {[CompareId:{用户ID=1，}]: 是指定了修改了那个具体的对象，后面是具体对象的更新内容，比如若是有多个对象都修改了会变成这样。

{
[CompareId:{用户ID=1，}]: 【用户姓名】从【张三】修改为【李四】，
[CompareId:{用户ID=2，}]: 【用户姓名】从【张三】修改为【李四】
[CompareId:{用户ID=3，}]: 【用户姓名】从【张三】修改为【李四】
}

wulangcode · 2022-10-13T13:21:13Z

应当提供给用户去支持多个字段的分组，比如下面的 UserDO ，通过userId与userName当作UNIQUE
    @Data
    public static class UserDO {
        @DiffLogField(name = "用户ID")
        private Long userId;
        @DiffLogField(name = "用户姓名")
        private String userName;
    }
在代码实现上是支持多个字段进行分组的

    /**
     * 两个对象之间的比较是否相等
     */
    protected boolean compare(Object source, Object target) {

        if (!isContainsCompareId(source)) {
            return source.equals(target);
        }

        Map<String, Object> sourceFieldValueMap = getCompareIdFieldValueMap(source);
        Map<String, Object> targetFieldValueMap = getCompareIdFieldValueMap(target);

        for (Map.Entry<String, Object> entry : sourceFieldValueMap.entrySet()) {
            String key = entry.getKey();
            Object value = entry.getValue();

            if (!Objects.equals(value, targetFieldValueMap.get(key))) {
                return false;
            }
        }

        return true;
    }

前面代码是没有依赖属性的hashcode和equals，在这里直接依赖比较想等，是否值得商榷。

存在的情况是，list中的值有可能也存在list对象。

wulangcode · 2022-10-13T13:29:59Z

输出的格式需要调整下。配置了 `@DiffLogField` 注解，优先使用注解中的值

这一块的东西我们有做修改和改动，这是之前数组操作的就显示的内容。我主要改动的点还是在元素内部的对象做比较。这块要一起显示的用户体验的话是可以看看配置上的文案怎么搞比较好

配置了 @DiffLogField 就使用这个，也应该是做到向前兼容性

yifocus · 2022-10-13T13:31:08Z

应当提供给用户去支持多个字段的分组，比如下面的 UserDO ，通过userId与userName当作UNIQUE
    @Data
    public static class UserDO {
        @DiffLogField(name = "用户ID")
        private Long userId;
        @DiffLogField(name = "用户姓名")
        private String userName;
    }
在代码实现上是支持多个字段进行分组的

    /**
     * 两个对象之间的比较是否相等
     */
    protected boolean compare(Object source, Object target) {

        if (!isContainsCompareId(source)) {
            return source.equals(target);
        }

        Map<String, Object> sourceFieldValueMap = getCompareIdFieldValueMap(source);
        Map<String, Object> targetFieldValueMap = getCompareIdFieldValueMap(target);

        for (Map.Entry<String, Object> entry : sourceFieldValueMap.entrySet()) {
            String key = entry.getKey();
            Object value = entry.getValue();

            if (!Objects.equals(value, targetFieldValueMap.get(key))) {
                return false;
            }
        }

        return true;
    }

前面代码是没有依赖属性的hashcode和equals，在这里直接依赖比较想等，是否值得商榷。

存在的情况是，list中的值有可能也存在list对象。

一般来讲标识一个是否是同一个对象来讲，一般不会说通过一个不确定的List 是否相等来标识同一个对象。多数情况是类似唯一主键来标识的如 userId, orderNo 这种

yifocus · 2022-10-13T13:32:37Z

输出的格式需要调整下。配置了 `@DiffLogField` 注解，优先使用注解中的值

这一块的东西我们有做修改和改动，这是之前数组操作的就显示的内容。我主要改动的点还是在元素内部的对象做比较。这块要一起显示的用户体验的话是可以看看配置上的文案怎么搞比较好

配置了 @DiffLogField 就使用这个，也应该是做到向前兼容性

这个应该默认输出的是toString 方法里面的东西的。看下是否可以调整的时候调整下toString的实现

wulangcode · 2022-10-13T13:38:23Z

    @Test
    @Sql(scripts = "/sql/clean.sql", executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD)
    public void testCondition_对象数组修改() {
        Order order = new Order();
        order.setOrderId(99L);
        order.setOrderNo("MT0000099");
        order.setProductName("超值优惠红烧肉套餐");
        order.addAuditor(1L,"张三");

        Order order1 = new Order();
        order1.setOrderId(99L);
        order1.setOrderNo("MT0000099");
        order1.setProductName("麻辣烫套餐");
        order1.addAuditor(1L,"李四");
        orderService.diff(order, order1);

        List<LogRecord> logRecordList = logRecordService.queryLog(order.getOrderNo(), LogRecordType.ORDER);
        Assert.assertEquals(1, logRecordList.size());
        LogRecord logRecord = logRecordList.get(0);
        System.out.println(logRecord.getAction());
        Assert.assertEquals(logRecord.getAction(), "更新了订单审核人列表：List内部的数据更新如下： {[CompareId:{用户ID=1，}]:	【用户姓名】从【张三】修改为【李四】，}");
        Assert.assertNotNull(logRecord.getExtra());
        Assert.assertEquals(logRecord.getOperator(), "111");
        Assert.assertEquals(logRecord.getBizNo(), order1.getOrderNo());
        logRecordService.clean();
    }

这里输出的action应该和前面的输出文档格式差不多。

更新了订单审核人列表：List内部的数据更新如下： {[CompareId:{用户ID=1，}]:	【用户姓名】从【张三】修改为【李四】，}

这样给用户就是很乱的感觉。

这块是可以讨论下的。

更新了订单审核人列表：List内部的数据更新如下： {[CompareId:{用户ID=1，}]: 【用户姓名】从【张三】修改为【李四】，}

这里面的 {[CompareId:{用户ID=1，}]: 是指定了修改了那个具体的对象，后面是具体对象的更新内容，比如若是有多个对象都修改了会变成这样。

{ [CompareId:{用户ID=1，}]: 【用户姓名】从【张三】修改为【李四】， [CompareId:{用户ID=2，}]: 【用户姓名】从【张三】修改为【李四】 [CompareId:{用户ID=3，}]: 【用户姓名】从【张三】修改为【李四】 }

list比较我想了一下，怎样我们框架为他们拼接key都是不妥的，因为key可能是一个 object对象，所以是不是可以定义一个接口，就类似于

public interface DiffUnique {
    /**
     * 输出list比对文案
     */
    String docs();

    /**
     * 唯一ket的字段
     */
    List<Field> key();
}

这样用户可控制，代码也好写。后面的就可以用单对象的diff方式

wulangcode · 2022-10-13T13:41:31Z

应当提供给用户去支持多个字段的分组，比如下面的 UserDO ，通过userId与userName当作UNIQUE
    @Data
    public static class UserDO {
        @DiffLogField(name = "用户ID")
        private Long userId;
        @DiffLogField(name = "用户姓名")
        private String userName;
    }
在代码实现上是支持多个字段进行分组的

    /**
     * 两个对象之间的比较是否相等
     */
    protected boolean compare(Object source, Object target) {

        if (!isContainsCompareId(source)) {
            return source.equals(target);
        }

        Map<String, Object> sourceFieldValueMap = getCompareIdFieldValueMap(source);
        Map<String, Object> targetFieldValueMap = getCompareIdFieldValueMap(target);

        for (Map.Entry<String, Object> entry : sourceFieldValueMap.entrySet()) {
            String key = entry.getKey();
            Object value = entry.getValue();

            if (!Objects.equals(value, targetFieldValueMap.get(key))) {
                return false;
            }
        }

        return true;
    }

前面代码是没有依赖属性的hashcode和equals，在这里直接依赖比较想等，是否值得商榷。
存在的情况是，list中的值有可能也存在list对象。

一般来讲标识一个是否是同一个对象来讲，一般不会说通过一个不确定的List 是否相等来标识同一个对象。多数情况是类似唯一主键来标识的如 userId, orderNo 这种

我其实想表达的是这里的比对可以依旧依赖底层的 java-object-diff 是不是就可以做到统一

wulangcode · 2022-10-13T13:45:28Z

输出的格式需要调整下。配置了 `@DiffLogField` 注解，优先使用注解中的值

这一块的东西我们有做修改和改动，这是之前数组操作的就显示的内容。我主要改动的点还是在元素内部的对象做比较。这块要一起显示的用户体验的话是可以看看配置上的文案怎么搞比较好

配置了 @DiffLogField 就使用这个，也应该是做到向前兼容性

这个应该默认输出的是toString 方法里面的东西的。看下是否可以调整的时候调整下toString的实现

实现这个list diff，本质上应该是递归的调用相同的方法

yifocus · 2022-10-13T14:25:25Z

输出的格式需要调整下。配置了 `@DiffLogField` 注解，优先使用注解中的值

这一块的东西我们有做修改和改动，这是之前数组操作的就显示的内容。我主要改动的点还是在元素内部的对象做比较。这块要一起显示的用户体验的话是可以看看配置上的文案怎么搞比较好

配置了 @DiffLogField 就使用这个，也应该是做到向前兼容性

这个应该默认输出的是toString 方法里面的东西的。看下是否可以调整的时候调整下toString的实现

实现这个list diff，本质上应该是递归的调用相同的方法
是的

yifocus · 2022-10-14T04:26:12Z

    @Test
    @Sql(scripts = "/sql/clean.sql", executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD)
    public void testCondition_对象数组修改() {
        Order order = new Order();
        order.setOrderId(99L);
        order.setOrderNo("MT0000099");
        order.setProductName("超值优惠红烧肉套餐");
        order.addAuditor(1L,"张三");

        Order order1 = new Order();
        order1.setOrderId(99L);
        order1.setOrderNo("MT0000099");
        order1.setProductName("麻辣烫套餐");
        order1.addAuditor(1L,"李四");
        orderService.diff(order, order1);

        List<LogRecord> logRecordList = logRecordService.queryLog(order.getOrderNo(), LogRecordType.ORDER);
        Assert.assertEquals(1, logRecordList.size());
        LogRecord logRecord = logRecordList.get(0);
        System.out.println(logRecord.getAction());
        Assert.assertEquals(logRecord.getAction(), "更新了订单审核人列表：List内部的数据更新如下： {[CompareId:{用户ID=1，}]:	【用户姓名】从【张三】修改为【李四】，}");
        Assert.assertNotNull(logRecord.getExtra());
        Assert.assertEquals(logRecord.getOperator(), "111");
        Assert.assertEquals(logRecord.getBizNo(), order1.getOrderNo());
        logRecordService.clean();
    }
这里输出的action应该和前面的输出文档格式差不多。
更新了订单审核人列表：List内部的数据更新如下： {[CompareId:{用户ID=1，}]:	【用户姓名】从【张三】修改为【李四】，}
这样给用户就是很乱的感觉。
这块是可以讨论下的。
更新了订单审核人列表：List内部的数据更新如下： {[CompareId:{用户ID=1，}]: 【用户姓名】从【张三】修改为【李四】，}
这里面的 {[CompareId:{用户ID=1，}]: 是指定了修改了那个具体的对象，后面是具体对象的更新内容，比如若是有多个对象都修改了会变成这样。
{ [CompareId:{用户ID=1，}]: 【用户姓名】从【张三】修改为【李四】， [CompareId:{用户ID=2，}]: 【用户姓名】从【张三】修改为【李四】 [CompareId:{用户ID=3，}]: 【用户姓名】从【张三】修改为【李四】 }
list比较我想了一下，怎样我们框架为他们拼接key都是不妥的，因为key可能是一个 object对象，所以是不是可以定义一个接口，就类似于
public interface DiffUnique {
    /**
     * 输出list比对文案
     */
    String docs();

    /**
     * 唯一ket的字段
     */
    List<Field> key();
}
这样用户可控制，代码也好写。后面的就可以用单对象的diff方式

意思是这个注解是可以写到 List 属性的上面，来让用户自定义他的文案，和定义那个对象的标识之类的？

yifocus · 2022-10-14T04:28:02Z

    @Test
    @Sql(scripts = "/sql/clean.sql", executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD)
    public void testCondition_对象数组修改() {
        Order order = new Order();
        order.setOrderId(99L);
        order.setOrderNo("MT0000099");
        order.setProductName("超值优惠红烧肉套餐");
        order.addAuditor(1L,"张三");

        Order order1 = new Order();
        order1.setOrderId(99L);
        order1.setOrderNo("MT0000099");
        order1.setProductName("麻辣烫套餐");
        order1.addAuditor(1L,"李四");
        orderService.diff(order, order1);

        List<LogRecord> logRecordList = logRecordService.queryLog(order.getOrderNo(), LogRecordType.ORDER);
        Assert.assertEquals(1, logRecordList.size());
        LogRecord logRecord = logRecordList.get(0);
        System.out.println(logRecord.getAction());
        Assert.assertEquals(logRecord.getAction(), "更新了订单审核人列表：List内部的数据更新如下： {[CompareId:{用户ID=1，}]:	【用户姓名】从【张三】修改为【李四】，}");
        Assert.assertNotNull(logRecord.getExtra());
        Assert.assertEquals(logRecord.getOperator(), "111");
        Assert.assertEquals(logRecord.getBizNo(), order1.getOrderNo());
        logRecordService.clean();
    }
这里输出的action应该和前面的输出文档格式差不多。
更新了订单审核人列表：List内部的数据更新如下： {[CompareId:{用户ID=1，}]:	【用户姓名】从【张三】修改为【李四】，}
这样给用户就是很乱的感觉。
这块是可以讨论下的。
更新了订单审核人列表：List内部的数据更新如下： {[CompareId:{用户ID=1，}]: 【用户姓名】从【张三】修改为【李四】，}
这里面的 {[CompareId:{用户ID=1，}]: 是指定了修改了那个具体的对象，后面是具体对象的更新内容，比如若是有多个对象都修改了会变成这样。
{ [CompareId:{用户ID=1，}]: 【用户姓名】从【张三】修改为【李四】， [CompareId:{用户ID=2，}]: 【用户姓名】从【张三】修改为【李四】 [CompareId:{用户ID=3，}]: 【用户姓名】从【张三】修改为【李四】 }
list比较我想了一下，怎样我们框架为他们拼接key都是不妥的，因为key可能是一个 object对象，所以是不是可以定义一个接口，就类似于
public interface DiffUnique {
    /**
     * 输出list比对文案
     */
    String docs();

    /**
     * 唯一ket的字段
     */
    List<Field> key();
}
这样用户可控制，代码也好写。后面的就可以用单对象的diff方式
意思是这个注解是可以写到 List 属性的上面，来让用户自定义他的文案，和定义那个对象的标识之类的？
我之前也这么想过，这里有一个取舍就是需要在List 上面识别到他里面的泛型是什么，和手动填写这个key的值。这个我有选择犹豫，因为在每个list 上标记这也是挺烦的。

yifocus · 2022-10-14T04:31:40Z

应当提供给用户去支持多个字段的分组，比如下面的 UserDO ，通过userId与userName当作UNIQUE
    @Data
    public static class UserDO {
        @DiffLogField(name = "用户ID")
        private Long userId;
        @DiffLogField(name = "用户姓名")
        private String userName;
    }
在代码实现上是支持多个字段进行分组的
    /**
     * 两个对象之间的比较是否相等
     */
    protected boolean compare(Object source, Object target) {

        if (!isContainsCompareId(source)) {
            return source.equals(target);
        }

        Map<String, Object> sourceFieldValueMap = getCompareIdFieldValueMap(source);
        Map<String, Object> targetFieldValueMap = getCompareIdFieldValueMap(target);

        for (Map.Entry<String, Object> entry : sourceFieldValueMap.entrySet()) {
            String key = entry.getKey();
            Object value = entry.getValue();

            if (!Objects.equals(value, targetFieldValueMap.get(key))) {
                return false;
            }
        }

        return true;
    }
前面代码是没有依赖属性的hashcode和equals，在这里直接依赖比较想等，是否值得商榷。
存在的情况是，list中的值有可能也存在list对象。
一般来讲标识一个是否是同一个对象来讲，一般不会说通过一个不确定的List 是否相等来标识同一个对象。多数情况是类似唯一主键来标识的如 userId, orderNo 这种
我其实想表达的是这里的比对可以依旧依赖底层的 java-object-diff 是不是就可以做到统一

这个判断对象是否是标识的同一个对象，我可能对‘java-object-diff` 用的比较少，所以就自己写了一套了，要是有的话用他会更好些。它上面有这种类似的比较api吗？

yifocus added 5 commits October 12, 2022 11:57

添加在集合比较时，标识为同一个对象的标识注解

ac01776

处理对象数组，比较每个数据对象的比较逻辑

028288b

添加对象数组相关的文案模板

87069ab

新增Order 审批人的pojo 用于测试用例

499486b

添加对象数组的单元测试，测试用例

bed6539

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

3.0.2 object list dev #97

3.0.2 object list dev #97

yifocus commented Oct 12, 2022

wulangcode commented Oct 12, 2022

wulangcode commented Oct 12, 2022

wulangcode commented Oct 12, 2022

yifocus commented Oct 13, 2022

yifocus commented Oct 13, 2022

yifocus commented Oct 13, 2022

yifocus commented Oct 13, 2022 •

edited

Loading

wulangcode commented Oct 13, 2022

wulangcode commented Oct 13, 2022

yifocus commented Oct 13, 2022

yifocus commented Oct 13, 2022 •

edited

Loading

wulangcode commented Oct 13, 2022

wulangcode commented Oct 13, 2022

wulangcode commented Oct 13, 2022

yifocus commented Oct 13, 2022

yifocus commented Oct 14, 2022

yifocus commented Oct 14, 2022

yifocus commented Oct 14, 2022

3.0.2 object list dev #97

Are you sure you want to change the base?

3.0.2 object list dev #97

Conversation

yifocus commented Oct 12, 2022

wulangcode commented Oct 12, 2022

wulangcode commented Oct 12, 2022

wulangcode commented Oct 12, 2022

yifocus commented Oct 13, 2022

yifocus commented Oct 13, 2022

yifocus commented Oct 13, 2022

yifocus commented Oct 13, 2022 • edited Loading

wulangcode commented Oct 13, 2022

wulangcode commented Oct 13, 2022

yifocus commented Oct 13, 2022

yifocus commented Oct 13, 2022 • edited Loading

wulangcode commented Oct 13, 2022

wulangcode commented Oct 13, 2022

wulangcode commented Oct 13, 2022

yifocus commented Oct 13, 2022

yifocus commented Oct 14, 2022

yifocus commented Oct 14, 2022

yifocus commented Oct 14, 2022

yifocus commented Oct 13, 2022 •

edited

Loading

yifocus commented Oct 13, 2022 •

edited

Loading