mouzt / mzt-biz-log

支持Springboot，基于注解的可使用变量、可以自定义函数的通用操作日志组件

Apache License 2.0

2.06k stars 483 forks source link

3.0.2 object list dev #97

Open yifocus opened 2 years ago

yifocus commented 2 years ago

94

支持对象数组的更新

wulangcode commented 2 years ago

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

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

wulangcode commented 2 years ago

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

wulangcode commented 2 years ago

    @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 commented 2 years ago

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

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

yifocus commented 2 years ago

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

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

yifocus commented 2 years ago

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

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

yifocus commented 2 years ago

    @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，}: 是指定了修改了那个具体的对象，后面是具体对象的更新内容，比如若是有多个对象都修改了会变成这样。

{

}

wulangcode commented 2 years ago

应当提供给用户去支持多个字段的分组，比如下面的 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 commented 2 years ago

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

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

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

yifocus commented 2 years ago

应当提供给用户去支持多个字段的分组，比如下面的 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 commented 2 years ago

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

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

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

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

wulangcode commented 2 years ago

    @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 commented 2 years ago

应当提供给用户去支持多个字段的分组，比如下面的 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 commented 2 years ago

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

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

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

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

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

yifocus commented 2 years ago

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

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

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

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

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

yifocus commented 2 years ago

    @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 commented 2 years ago

    @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 commented 2 years ago

应当提供给用户去支持多个字段的分组，比如下面的 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吗？