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<T> {
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<entity> 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<String,Object>里，
- 返回List<Map<String,Object>对象
大致原理：
我们会自定义一个注解，用注解来标识，需要关注的字段，当字段变化时，就将其变化历史记录到对应的表中。
具体实现过程，源码如下。
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<Map<String, Object>> compareTwoClass(Object class1, Object class2) throws ClassNotFoundException, IllegalAccessException {
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
//获取对象的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<String, Object> map2 = new HashMap<String, Object>();
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<Map<String, Object>> list = new ArrayList<>();
list = CompareObjectUtils.compareTwoClass(oldModel,model); //旧新数据对比
String content = ""; // 定义变更字符串
for(Map<String, Object> 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来代替删除，就能很容易看到数据的变更记录了，即使过亿级别查询也非常快。
本文到此结束了，其他更好文章，可以搜索哟！下次见
5028
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
