一种简化操作日志记录方案

一、背景：

后台系统配置越来越多的出现需要进行日志记录的功能，且当前已有日志记录不可复用，需要统一日志记录格式，提高日志记录开发效率。
二、预期效果展示：

新建动作：

修改动作：

删除动作：

三、数据存储：

注：可以选择其他存储方式，这里只简单举个例子

1. `biz_id` bigint(20) NOT NULL DEFAULT 0 COMMENT '业务id',
2. `biz_type` tinyint(4) NOT NULL DEFAULT 0 COMMENT '业务类型',
3. `operator_id` varchar(128) NOT NULL DEFAULT '' COMMENT '操作人',
4. `operate_content` text COMMENT '操作内容',
5. `change_before` text COMMENT '修改前',
6. `change_after` text COMMENT '修改后',
7. `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间'

复制代码

四、原理简述：

日志构建关注两个对象，一个是修改前，修改后：
修改前：null + 修改后：X = 新建
修改前：Y + 修改后：X = 更新
修改前：Y + 修改后：null = 删除
修改内容判断依据传入的两个对象，对两个对象的每个属性进行逐一对比，如果发生变化则是需要进行日志记录字段；关注的属性使用注解进行标注。
五、具体实现：

注解：

1. @Target(ElementType.FIELD)
2. @Retention(RetentionPolicy.RUNTIME)
3. @Inherited
4. @Documented
5. public @interface LogField {
7.     String name() default "";
9.     String valueFun() default "";
11.     boolean spliceValue() default true;
12. }

复制代码

name: name值表示该字段如果被修改，应在日志中记录的字段名；默认取字段名
valueFun: 表示获取改变字段内容的获取方法；默认取字段值，若valueFun方法不存在，则取默认值
spliceValue: 日志是否需要拼接变更内容，默认拼接
注解处理：

1. @Service
2. @Slf4j
3. public class OperateLogService {
4.     @Resource
5.     private CommonOperateLogService commonOperateLogService;
7.     enum ActionEnum{
8.         ADD("新建"),
9.         UPDATE("修改"),
10.         DELETE("删除");
12.         ActionEnum(String desc) {
13.             this.desc = desc;
14.         }
15.         public String desc;
16.     }
18.     private int insertLog(CommonOperatorLog commonOperatorLog){
19.         String result = commonOperateLogService.insertLog(JSON.toJSONString(commonOperatorLog));
20.         Response response = JSON.parseObject(result, Response.class);
21.         return Objects.isNull(response) || ApiResponse.Status.fail.equals(response.getStatus()) ? 0 : (int) response.getContent();
22.     }
24.     public PageOutput<CommonOperatorLog> queryList(Long bizId, Integer bizType, Integer pageNum, Integer pageSize){
25.         String result = commonOperateLogService.queryLog(bizId, bizType, pageNum, pageSize);
26.         PageOutput pageOutput = JSON.parseObject(result, new TypeReference<PageOutput<CommonOperatorLog>>() {});
27.         return pageOutput;
28.     }
30.     public <T> void saveLog(String operatorId,Long bizId, Integer bizType, T target, T original){
31.         if(StringUtils.isBlank(operatorId) || (Objects.isNull(target) && Objects.isNull(original))){
32.             throw new IllegalArgumentException();
33.         }
34.         if(Objects.nonNull(target) && Objects.nonNull(original) && !target.getClass().isAssignableFrom(original.getClass())){
35.             throw new IllegalArgumentException();
36.         }
37.         ActionEnum action = getAction(target, original);
38.         List<Triple<String, String, LogField>> changeInfos = getChangeInfoList(target, original);
39.         List<String> changeInfoList = new ArrayList<>();
40.         if(CollectionUtils.isEmpty(changeInfos) && !ActionEnum.UPDATE.equals(action)){
41.             changeInfoList.add(0, action.desc);
42.         }else if (CollectionUtils.isEmpty(changeInfos)){
43.             return;
44.         }else {
45.             changeInfoList = changeInfos.stream().map(i -> i.getRight().spliceValue() ?
46.                             action.desc + StringUtils.joinWith("为:", i.getLeft(), i.getMiddle()) :
47.                             action.desc + StringUtils.join("了", i.getLeft()))
48.                     .collect(Collectors.toList());
49.         }
51.         String operateContext = StringUtils.join(changeInfoList, "\n");
52.         operateContext = operateContext.replaceAll(""","")
53.                 .replaceAll("\\[","").replaceAll("\\]","");
54.         CommonOperatorLog operatorLog = new CommonOperatorLog();
55.         operatorLog.setBizId(bizId);
56.         operatorLog.setBizType(bizType);
57.         operatorLog.setOperateContent(operateContext);
58.         operatorLog.setOperatorId(operatorId);
59.         operatorLog.setChangeBefore(JSON.toJSONString(original));
60.         operatorLog.setChangeAfter(JSON.toJSONString(target));
61.         this.insertLog(operatorLog);
62.     }
64.     private ActionEnum getAction(Object target, Object original){
65.         ActionEnum action = ActionEnum.ADD;
66.         if(Objects.nonNull(target) && Objects.nonNull(original)){
67.             action = ActionEnum.UPDATE;
68.         }else if(Objects.nonNull(target)){
69.             action = ActionEnum.ADD;
70.         }else if (Objects.nonNull(original)){
71.             action = ActionEnum.DELETE;
72.         }
73.         return action;
74.     }
77.     private<T> List<Triple<String, String, LogField>> getChangeInfoList(T target, T original){
78.         if(Objects.isNull(target) || Objects.isNull(original)){
79.             return new ArrayList<>();
80.         }        
81.         List<Pair<Field, Object>> targetFields = allFields(target);
82.         List<Pair<Field, Object>> originalFields = allFields(original);
83.         if(targetFields.size() != originalFields.size()){
84.             //理论上不可能执行到这
85.             throw new IllegalArgumentException();
86.         }
88.         List<Triple<String, String, LogField>> result = new ArrayList<>();
89.         for (int i = 0; i < targetFields.size(); i++) {
90.             Pair<Field, Object> targetField = targetFields.get(i);
91.             Pair<Field, Object> originalField = originalFields.get(i);
92.             ReflectionUtils.makeAccessible(targetField.getKey());
93.             ReflectionUtils.makeAccessible(originalField.getKey());
94.             Object targetValue = ReflectionUtils.getField(targetField.getKey(), targetField.getValue());
95.             Object originalValue = ReflectionUtils.getField(originalField.getKey(), originalField.getValue());
96.                if(targetValue != originalValue && (Objects.isNull(targetValue) ||
97.                         (!targetValue.equals(originalValue) &&
98.                         compareTo(Pair.of(targetField.getKey(), targetValue), Pair.of(originalField.getKey(), originalValue)) &&
99.                         !JSON.toJSONString(targetValue).equals(JSON.toJSONString(originalValue))))){
100.                 result.add(Triple.of(getFieldName(targetField.getKey()), getFieldValue(targetField.getKey(), targetField.getValue()), targetField.getKey().getAnnotation(LogField.class)));
101.             }
102.         }
103.         return result;
104.     }
106.     private boolean compareTo(Pair<Field, Object> targetField, Pair<Field, Object> originalField){
107.         Field field = targetField.getKey();
108.         Object targetValue = targetField.getValue();
109.         Object originalValue = originalField.getValue();
110.         boolean canCompare = Arrays.stream(field.getType().getInterfaces()).anyMatch(i -> Comparable.class.getName().equals(i.getName()));
111.         if(canCompare && Objects.nonNull(targetValue) && Objects.nonNull(originalValue)){
112.             Method compareTo = ReflectionUtils.findMethod(field.getType(), "compareTo", field.getType());
113.             if(Objects.isNull(compareTo)){
114.                 return true;
115.             }
116.             Object compared = ReflectionUtils.invokeMethod(compareTo, targetValue, originalValue);
117.             return (int)compared != 0 ;
118.         }
119.         return true;
120.     }
122.     private <T> List<Pair<Field, Object>> allFields(T obj){
123.         List<Triple<Field, Object, Boolean>> targetField = findField(obj);
124.         List<Triple<Field, Object, Boolean>> allField = Lists.newArrayList(targetField);
125.         List<Triple<Field, Object, Boolean>> needRemove = new ArrayList<>();
126.         for (int i = 0; i < allField.size(); i++) {
127.             Triple<Field, Object, Boolean> fieldObjectDes = allField.get(i);
128.             if(!fieldObjectDes.getRight()){
129.                 ReflectionUtils.makeAccessible(fieldObjectDes.getLeft());
130.                 Object fieldV = ReflectionUtils.getField(fieldObjectDes.getLeft(), fieldObjectDes.getMiddle());
131.                 List<Triple<Field, Object, Boolean>> fieldList = findField(fieldV);
132.                 if(CollectionUtils.isNotEmpty(fieldList)){
133.                     allField.addAll(fieldList);
134.                     needRemove.add(fieldObjectDes);
135.                 }
136.             }
137.         }
139.         if(CollectionUtils.isNotEmpty(needRemove)){
140.             allField.removeAll(needRemove);
141.         }
142.         return allField.stream().map(i->Pair.of(i.getLeft(), i.getMiddle())).collect(Collectors.toList());
143.     }
145.     private <T> List<Triple<Field, Object, Boolean>> findField(T obj){
146.         Class<?> objClass = obj.getClass();
147.         Field[] declaredFields = objClass.getDeclaredFields();
148.         List<Field> allFields = Lists.newArrayList(declaredFields);
149.         if(Objects.nonNull(objClass.getSuperclass())){
150.             Field[] superClassFields = objClass.getSuperclass().getDeclaredFields();
151.             allFields.addAll(Arrays.asList(superClassFields));
152.         }
153.         List<Triple<Field, Object, Boolean>> result = new ArrayList<>();
154.         for (Field declaredField : allFields) {
155.             LogField annotation = declaredField.getAnnotation(LogField.class);
156.             if(Objects.nonNull(annotation)){
157.                 result.add(Triple.of(declaredField, obj, declaredField.getType().getPackage().getName().startsWith("java")));
158.             }
159.         }
160.         return result;
161.     }
164.     private String getFieldName(Field field){
165.         LogField annotation = field.getAnnotation(LogField.class);
166.         String name = annotation.name();
167.         if(StringUtils.isBlank(name)){
168.             name = field.getName();
169.         }
170.         return name;
171.     }
173.     private <T> String getFieldValue(Field field, T targetObj){
174.         LogField annotation = field.getAnnotation(LogField.class);
175.         if(!annotation.spliceValue()){
176.             return "";
177.         }
178.         String valueFun = annotation.valueFun();
179.         if(StringUtils.isBlank(valueFun)){
180.             Object fieldValue = ReflectionUtils.getField(field, targetObj);
181.             return getStrValue(fieldValue);
182.         }else {
183.             Method valueMethod = ReflectionUtils.findMethod(targetObj.getClass(), valueFun);
184.             if(Objects.isNull(valueMethod)){
185.                 Object fieldValue = ReflectionUtils.getField(field, targetObj);
186.                 return getStrValue(fieldValue);
187.             }else {
188.                 ReflectionUtils.makeAccessible(valueMethod);
189.                 Object invokeMethodRes = ReflectionUtils.invokeMethod(valueMethod, targetObj);
190.                 return getStrValue(invokeMethodRes);
191.             }
192.         }
193.     }
195.     private String getStrValue(Object fieldValue){
196.         List<String> emptyStr = ImmutableList.of("""", "{}","[]");
197.         String value = Objects.isNull(fieldValue) ? "无" : JSON.toJSONString(fieldValue);
198.         return emptyStr.contains(value) ? "无" : value;
199.     }
200. }

复制代码

六、使用示例：

1、使用的日志记录对象（这个对象只为日志服务）

1. public class SubsidyRateLog {
3.     @LogField(name = "补贴率名称")
4.     private String name;
6.     @LogField(name = "适用城市", valueFun = "getCityNames")
7.     private List<Integer> cityIds;
9.     private List<String> cityNames;
10. }

复制代码

name是直接展示字段，所以修改值即name本身的值；cityIds 是我们关心比较字段，当它值不一样时进行 字段value 值获取，这个值是展示在前端的，所以可以根据需要进行格式定义，默认是将取到的值进行toJSON；当前例子中获取的是getCityNames方法返回的值；
2、无专用日志对象（大多数时候我们有自己的实体对象，但不包含具体日志描述字段），需要进行继承

1. public class SubsidyRate {
3.     @LogField(name = "补贴率名称")
4.     private String name;
6.     @LogField(name = "适用城市", valueFun = "getCityNames")
7.     private List<Integer> cityIds;
8. }
10. @Data
11. public class SubsidyRateLog extends SubsidyRate{
12.    
13.     private List<String> cityNames;
14. }

复制代码

此方式适用于兼容现有对象，而不去破坏现有对象的完整性
3、对象包含子对象（比较复杂的大对象，如Task中的券信息）

1. public class SubsidyRateLog {
3.     @LogField(name = "补贴率名称")
4.     private String name;
6.     @LogField
7.     private Address address;
8. }
10. public class Address {
11.     @LogField(name = "省份")
12.     private String province;
13.     @LogField(name = "城市")
14.     private String city;
15. }

复制代码

此情况下会将所有信息平铺，如果 Address 中 没有_LogField_ 注解，那么会直接使用将获取address值，如果存在注解，那么将忽略address本身，只关注注解字段。

作者：京东零售 祁伟
来源：京东云开发者社区 转载请注明来源

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！