java/web/springboot数据修改历史记录设计

在一些领域，记录数据的变更历史是非常重要的。比如人力资源系统…
需要记录个人的成长历史。再比如一些非常注重安全的系统，希望在必要时可以对所有的历史操作追根溯源，有据可查。

1.前言
比如，修改一个人的姓名从“张三”变为了“李四”，那么在进行记录的时候，记录的信息可能如下：

姓名：（张三）=>（李四）

这样就很好的体现出了修改了哪个字段，修改前后的数据分别是什么。
关键的信息无论怎么修改都会有据可查，时间、人物、修改数据前后信息等。

2.实现方式(较low)：
直接做个工具类，调用传入对应的参数 即可：

package com.bonc.util;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class Test {
public String contrastObj(Object oldBean, Object newBean) {
String str="";
T pojo1 = (T) oldBean;
T pojo2 = (T) newBean;
try {
Class clazz = pojo1.getClass();
Field[] fields = pojo1.getClass().getDeclaredFields();
int i=1;
for (Field field : fields) {
if("serialVersionUID".equals(field.getName())){
continue;
}
PropertyDescriptor pd = new PropertyDescriptor(field.getName(), clazz);
Method getMethod = pd.getReadMethod();
Object o1 = getMethod.invoke(pojo1);
Object o2 = getMethod.invoke(pojo2);
if(o1==null || o2 == null){
continue;
}
if (!o1.toString().equals(o2.toString())) {
if(i!=1){
str+=";";
}
str+=i+"字段名称:"+field.getName()+",旧值:"+o1+",新值:"+o2;
i++;
}
}
} catch (Exception e) {
e.printStackTrace();
}
return str;
}

public static void main(String[] args) {
// 模拟旧数据
entity oldModel = new entity();
oldModel.setId("1");
oldModel.setName("张三");
// 模拟新数据
entity model = new entity();
model.setId("2");
model.setName("李四");
Test t= new Test<>();
String list = t.contrastObj(oldModel,model);
System.out.println("oldModel:"+oldModel);
System.out.println("model:"+model);
System.out.println("list:"+list);
}
}

当然需要建个实体类：

@Data
public class entity {
private String id;
private String name;
}

结果如图：

最后写个方法，插入到历史记录表中即可。

3.更优雅的方式（推荐）：
对应上面的方式，过于死板，我们更推荐更好的方式，那就是 通过java反射机制来实现。

JAVA反射机制就是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性。

设计如图：

设计思路：

获取到两个对象中属性列表，
遍历对比，
属性名相同属性值不同的把属性名及两个对象的属性值保存进Map里，
返回List对象
大致原理：

我们会自定义一个注解，用注解来标识，需要关注的字段，当字段变化时，就将其变化历史记录到对应的表中。

具体实现过程，源码如下。

1.新建FieldMeta 类：
底层就是利用的java反射机制，通过自定义注解实现。

新增自定义注解FieldMeta ：

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME) // 注解会在class字节码文件中存在，在运行时可以通过反射获取到
@Target({ElementType.FIELD,ElementType.METHOD})//定义注解的作用目标**作用范围字段、枚举的常量/方法
@Documented //说明该注解将被包含在javadoc中
public @interface FieldMeta {
String name() default "";
String description() default "";
}

在需要记录修改历史的字段上添加@FieldMeta注解，标识它，只要变化，就会记录它的信息。

2.新建CompareObjectUtils类：
用于 对比两个对象中同名属性的值是否相同。

源码：

package com.zoutao.web.entity;

import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Component
public class CompareObjectUtils{
private static CompareObjectUtils compareObjectUtils;

@PostConstruct
public void init() {
compareObjectUtils = this;
}

/**
* 获取两个对象同名属性内容不相同的列表
* @param class1 对象1
* @param class2 对象2
* @return
* @throws ClassNotFoundException
* @throws IllegalAccessException
*/
public static List> compareTwoClass(Object class1, Object class2) throws ClassNotFoundException, IllegalAccessException {
List> list = new ArrayList>();
//获取对象的class
Class<?> clazz1 = class1.getClass();
Class<?> clazz2 = class2.getClass();
//获取对象的属性列表
Field[] field1 = clazz1.getDeclaredFields();
Field[] field2 = clazz2.getDeclaredFields();
//遍历属性列表field1
for (int i = 0; i < field1.length; i++) {
if(field1[i].isAnnotationPresent(FieldMeta.class))
//遍历属性列表field2
for (int j = 0; j < field2.length; j++) {
//如果field1[i]属性名与field2[j]属性名内容相同
if (field1[i].getName().equals(field2[j].getName())) {
field1[i].setAccessible(true);
field2[j].setAccessible(true);
//如果field1[i]属性值与field2[j]属性值内容不相同
if (!compareTwo(field1[i].get(class1), field2[j].get(class2)) && field1[i].isAnnotationPresent(FieldMeta.class) && field2[j].isAnnotationPresent(FieldMeta.class)) {
FieldMeta metaAnnotation = field1[i].getAnnotation(FieldMeta.class);
Map map2 = new HashMap();
map2.put("name", metaAnnotation.name());
map2.put("old", field1[i].get(class1) == null ? "" : field1[i].get(class1) );
map2.put("new", field2[j].get(class2));
//解决时间格式化问题-bean上加了@DateTimeFormat(pattern="yyyy-MM-dd")
if(field1[i].isAnnotationPresent(DateTimeFormat.class) && field2[j].isAnnotationPresent(DateTimeFormat.class) ){
String old = DateUtils.formatDate((Date) field1[i].get(class1),field1[i].getAnnotation(DateTimeFormat.class).pattern());
map2.put("old",old == null ? "": old);
map2.put("new", DateUtils.formatDate((Date) field2[j].get(class2),field2[j].getAnnotation(DateTimeFormat.class).pattern()));
}
//解决数据字典text/value转换问题-bean上加了@Dict(dicCode = "groupField",isCommon = false)
if(field1[i].isAnnotationPresent(Dict.class) && field2[j].isAnnotationPresent(Dict.class) ){
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
boolean isCommon = field1[i].getAnnotation(Dict.class).isCommon();
if(!isCommon){
map2.put("old",compareObjectUtils.sysDictMapper.queryDictTextByKey(field1[i].getAnnotation(Dict.class).dicCode(), (String) field1[i].get(class1),null));
map2.put("new",compareObjectUtils.sysDictMapper.queryDictTextByKey(field2[j].getAnnotation(Dict.class).dicCode(), (String) field2[j].get(class2),null));
}else{
map2.put("old",compareObjectUtils.sysDictMapper.queryDictTextByKey(field1[i].getAnnotation(Dict.class).dicCode(), (String) field1[i].get(class1),sysUser.getTenantId()));
map2.put("new",compareObjectUtils.sysDictMapper.queryDictTextByKey(field2[j].getAnnotation(Dict.class).dicCode(), (String) field2[j].get(class2),sysUser.getTenantId()));
}
}
list.add(map2);
}
break;
}
}
}
return list;
}

//对比两个数据是否内容相同
public static boolean compareTwo(Object object1, Object object2) {

if (object1 == null && object2 == null) {
return true;
}
// 因源数据是没有进行赋值，是null值，改为""。
//if (object1 == "" && object2 == null) {
// return true;
//}
//if (object1 == null && object2 == "") {
// return true;
// }
if (object1 == null && object2 != null) {
return false;
}
if (object1.equals(object2)) {
return true;
}
return false;
}
}

3.调用方式：
在web项目的impl中的方法，controller调用即可。

比如：新建一个BasePowerOnRateServiceImpl.java 调用

// 随着开机率信息model变更而更新历史记录表

@Override
public boolean updateWithItem(BasePowerOnRate model) throws IllegalAccessException, ClassNotFoundException {

// 查旧数据
BasePowerOnRate oldModel = basePowerOnRateMapper.selectById(model.getId());
List> list = new ArrayList<>();
list = CompareObjectUtils.compareTwoClass(oldModel,model); //旧新数据对比

String content = ""; // 定义变更字符串
for(Map map : list){
if (map.get("old") == null) map.put("old","无");
content += map.get("name") + ":" + map.get("old") + " 变更为 " + map.get("new") + ";";
}
if(content.length()>0){
BasePowerOnRateHistory item = new BasePowerOnRateHistory(); // 数据变更实体对象
item.setBootUpId(model.getId());
item.setChangeContent(content); //变更内容
basePowerOnRateHistoryMapper.insert(item); //记录表新增历史
}
basePowerOnRateMapper.updateById(model); //更新原数据表
return true;
}

完成这些之后，可以启动项目，查看了。

效果如图：

简单容易实现，也不易出现问题，判断传入的对象中是否有 id，如果有 id 则说明是修改，如果没有 id 则说明是新建。

4.比对数据为空问题？
比如新旧数据对比，

list = CompareObjectUtils.compareTwoClass(oldModel,model);

你发现你的list为空？

原因：没有注解。

解决：需要在主实体类中添加一开始我们定义的那个注解！用于标识要对比的是哪个字段？

@FieldMeta(name = "开机时间")
比如我要比对开始时间，如图：

同一个实体中，可以添加多个该注解给不同的字段，达到比较多个字段的效果。

注意：

1.该方式并不完美，如果新添加的字段有对应的字典，那么需要添加字典对应的关联，这样就需要每次修改代码，但是上诉满足日常web项目开发需求。——本文更新已解决

2.这种方式在高并发的情况下不适用，可以通过kafka将数据收集到行式数据库，用更新flag来代替删除，就能很容易看到数据的变更记录了，即使过亿级别查询也非常快。

本文转载：https://blog.csdn.net/ITBigGod/article/details/106033696 亲测可用 感谢博主