记录页面修改差异(java注解实现)

简介: 记录页面修改差异(java注解实现)

一、需求

系统中有用户、客户等信息时,需要记录修改前后的差异;

举例,用户信息修改了两次,第一次修改了微信、qq;第二次修改了qq:

{
    "code":0,
    "data":[
        {
            "systemUserId":1,
            "systemUserName":"超级管理员",
            "date":"2022-09-22 09:53:25",
            "detail":[
                {
                    "attribute":"weixinOne",
                    "name":"微信",
                    "valueOld":"5696",
                    "valueNew":"56898"
                },
                {
                    "attribute":"qq",
                    "name":"QQ",
                    "valueOld":"131312268",
                    "valueNew":"13131245"
                }
            ]
        },
        {
            "systemUserId":1,
            "systemUserName":"超级管理员",
            "date":"2022-09-22 09:53:02",
            "detail":[
                {
                    "attribute":"qq",
                    "name":"QQ",
                    "valueOld":"131312267",
                    "valueNew":"131312268"
                }
            ]
        }
    ],
    "msg":""
}

二、实现思路

1、对需要监控对象的字段使用注解,注解写明字段的名称;

2、使用反射比较两个对象,如果对象字段有注解,比较属性的值,如果值不一样,记录;

三、代码实现

1、定义注解

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
 
/**
 * 自定义注解
 * @author Administrator
 *
 */
@Retention(RetentionPolicy.RUNTIME)
public @interface LogCompar {
 
    String value();
 
}


2、编写工具类

import cn.hutool.core.date.DateUtil;
import xxxxx.LogCompar;
import lombok.extern.java.Log;
 
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Objects;
 
@Log
public class ObjectCopareUtils {
    public static <T> List<EditLog> compareObject(Object oldBean, Object newBean) {
        List<EditLog> res = new ArrayList<>(16);
        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) {
                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())) {
                    LogCompar logCompar = field.getAnnotation(LogCompar.class);
                    //判断是否有注解
                    if (logCompar != null) {
                        EditLog tem = new EditLog();
                        //获取注解名称
                        tem.setAttribute(field.getName());
                        tem.setName(logCompar.value());
                        String typeName = o1.getClass().getName();
                        if (o2 != null) {
                            if ("java.lang.String".equals(typeName) || "java.lang.Long".equals(typeName) || "java.lang.Integer".equals(typeName) || "java.lang.Float".equals(typeName) || "java.lang.Double".equals(typeName)) {
                                tem.setValueOld(String.valueOf(o1));
                                tem.setValueNew(String.valueOf(o2));
 
                            } else if ("java.lang.Boolean".equals(typeName)) {
                                tem.setValueOld((Boolean) o1 == true ? "true" : "false");
                                tem.setValueNew((Boolean) o2 == true ? "true" : "false");
                            } else if ("java.util.Date".equals(typeName) || "cn.hutool.core.date.DateTime".equals(typeName)) {
                                String oldDay = DateUtil.format(((Date) o1), "yyyy-MM-dd HH:mm:ss");
                                String newDay = DateUtil.format(((Date) o2), "yyyy-MM-dd HH:mm:ss");
                                if(Objects.equals(oldDay,newDay)){
                                   continue;
                                }
                                tem.setValueOld(oldDay);
                                tem.setValueNew(newDay);
                            } else {
                                tem.setValueOld("类型匹配有误");
                                tem.setValueNew("类型匹配有误");
                            }
                        }
 
                        res.add(tem);
                    }
 
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return res;
    }
}


3、其他代码

import lombok.Data;
 
@Data
public class EditLog {
    /*对象属性*/
    private String attribute;
    /*对象注解名称*/
    private String name;
    /*对象修改前值*/
    private String valueOld;
    /*对象修改后值*/
    private String valueNew;
}
import lombok.Data;
import lombok.NoArgsConstructor;
 
 
@Data
@NoArgsConstructor
public class StudentDO {
 
    /**
     * 学员ID
     */
    private Long id;
    /**
     * 姓名
     */
 
    @LogCompar("名字")
    private String name;
    /**
     * 性别
     */
 
    @LogCompar("性别")
    private Integer sex;
    /**
     * 民族
     */
 
    @LogCompar("民族")
    private Integer nation;
    /**
     * 上课手机
     */
 
    @LogCompar("手机号码")
    private String classPhone;
    /**
     * 电话1
     */
 
    @LogCompar("备用手机")
    private String phoneOne;
    /**
     * 电话2
     */
 
    private String phoneTwo;
    /**
     * 微信
     */
 
    @LogCompar("微信")
    private String weixinOne;
    /**
     *
     */
 
    private String weixinTwo;
    /**
     * QQ
     */
 
    @LogCompar("QQ")
    private String qq;
}

四、使用

        //比较两个对象
        List<EditLog> editLogs = ObjectCopareUtils.compareObject(dbStudent, updateObj);

业务细节,将本次日志追加到之前的修改中,查询的时候或者追加的时候对修改记录进行时间倒序排列(根据业务需要)。

//比较两个对象
        List<EditLog> editLogs = ObjectCopareUtils.compareObject(dbStudent, updateObj);
        if (!CollUtil.isEmpty(editLogs)) {
            Long loginUserId = SecurityFrameworkUtils.getLoginUserId();
            List<ObjectValueCopare> updateEditLog = new ArrayList<>();
            List<ObjectValueCopare> dbEditLog = dbStudent.getEditLog();
            if (!CollUtil.isEmpty(dbEditLog)) {
                updateEditLog.addAll(dbEditLog);
            }
            ObjectValueCopare addEditLog = new ObjectValueCopare();
            addEditLog.setSystemUserId(loginUserId);
            AdminUserDO adminUserDO = adminUserMapper.selectById(loginUserId);
 
            addEditLog.setSystemUserName(adminUserDO.getNickname());
            addEditLog.setDate(DateUtil.formatDateTime(new Date()));
            addEditLog.setDetail(editLogs);
            updateEditLog.add(addEditLog);
            StudentDO updateEditLogStu = new StudentDO();
            updateEditLogStu.setId(id);
            updateEditLogStu.setEditLog(updateEditLog);
            studentMapper.updateById(updateEditLogStu);
        }

记录数据样例

{
    "code":0,
    "data":[
        {
            "systemUserId":1,
            "systemUserName":"超级管理员",
            "date":"2022-09-22 09:53:25",
            "detail":[
                {
                    "attribute":"weixinOne",
                    "name":"微信",
                    "valueOld":"5696",
                    "valueNew":"56898"
                },
                {
                    "attribute":"qq",
                    "name":"QQ",
                    "valueOld":"131312268",
                    "valueNew":"13131245"
                }
            ]
        },
        {
            "systemUserId":1,
            "systemUserName":"超级管理员",
            "date":"2022-09-22 09:53:02",
            "detail":[
                {
                    "attribute":"qq",
                    "name":"QQ",
                    "valueOld":"131312267",
                    "valueNew":"131312268"
                }
            ]
        }
    ],
    "msg":""
}

相关文章
|
30天前
|
XML Java 编译器
Java学习十六—掌握注解:让编程更简单
Java 注解(Annotation)是一种特殊的语法结构,可以在代码中嵌入元数据。它们不直接影响代码的运行,但可以通过工具和框架提供额外的信息,帮助在编译、部署或运行时进行处理。
87 43
Java学习十六—掌握注解:让编程更简单
|
24天前
|
Java 开发者 Spring
[Java]自定义注解
本文介绍了Java中的四个元注解(@Target、@Retention、@Documented、@Inherited)及其使用方法,并详细讲解了自定义注解的定义和使用细节。文章还提到了Spring框架中的@AliasFor注解,通过示例帮助读者更好地理解和应用这些注解。文中强调了注解的生命周期、继承性和文档化特性,适合初学者和进阶开发者参考。
45 14
|
24天前
|
前端开发 Java
[Java]讲解@CallerSensitive注解
本文介绍了 `@CallerSensitive` 注解及其作用,通过 `Reflection.getCallerClass()` 方法返回调用方的 Class 对象。文章还详细解释了如何通过配置 VM Options 使自定义类被启动类加载器加载,以识别该注解。涉及的 VM Options 包括 `-Xbootclasspath`、`-Xbootclasspath/a` 和 `-Xbootclasspath/p`。最后,推荐了几篇关于 ClassLoader 的详细文章,供读者进一步学习。
30 12
|
18天前
|
Java 编译器
Java进阶之标准注解
Java进阶之标准注解
28 0
|
1月前
|
JSON Java 数据库
java 常用注解大全、注解笔记
关于Java常用注解的大全和笔记,涵盖了实体类、JSON处理、HTTP请求映射等多个方面的注解使用。
35 0
java 常用注解大全、注解笔记
|
2月前
|
Arthas Java 测试技术
Java字节码文件、组成,jclasslib插件、阿里arthas工具,Java注解
Java字节码文件、组成、详解、分析;常用工具,jclasslib插件、阿里arthas工具;如何定位线上问题;Java注解
Java字节码文件、组成,jclasslib插件、阿里arthas工具,Java注解
|
1月前
|
IDE Java 编译器
java的反射与注解
java的反射与注解
16 0
|
2月前
|
Java 编译器 程序员
Java注解,元注解,自定义注解的使用
本文讲解了Java中注解的概念和作用,包括基本注解的用法(@Override, @Deprecated, @SuppressWarnings, @SafeVarargs, @FunctionalInterface),Java提供的元注解(@Retention, @Target, @Documented, @Inherited),以及如何自定义注解并通过反射获取注解信息。
Java注解,元注解,自定义注解的使用
|
1月前
|
XML Java 数据格式
Java-spring注解的作用
Java-spring注解的作用
23 0
|
2月前
|
Java 数据库连接 数据格式
【Java笔记+踩坑】Spring基础2——IOC,DI注解开发、整合Mybatis,Junit
IOC/DI配置管理DruidDataSource和properties、核心容器的创建、获取bean的方式、spring注解开发、注解开发管理第三方bean、Spring整合Mybatis和Junit
【Java笔记+踩坑】Spring基础2——IOC,DI注解开发、整合Mybatis,Junit
下一篇
无影云桌面