日志操作记录工具类

最新推荐文章于 2024-07-27 17:56:15 发布
最新推荐文章于 2024-07-27 17:56:15 发布
阅读量296 收藏
点赞数 1
分类专栏： 工具类 日志记录 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50493320/article/details/128050655
版权

1.创建一个日志记录表，这里就不细说了

2.需要封装一个注解

package com.kte.common.annotation;
import com.kte.common.enums.DictTypeEnum;
import java.lang.annotation.*;

/**
 * @className: FieldRecord
 **/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface FieldRecord {
	/**
	 * 字段名称
	 */
	String fieldName() default "";

	/**
	 * 时间格式
	 */
	String dateFormat() default "";

	/**
	 * 自定义字典
	 */
	String[] whether() default {};

	/**
	 * 字典枚举
	 */
	DictTypeEnum model() default DictTypeEnum.NULLDICT;

	/**
	 * 字典是否需要分隔记录
	 */
	boolean isDictSplit() default false;
}

3.引入日志记录工具类`

package com.kte.common.utils;

import com.google.common.collect.Maps;
import com.kte.common.annotation.FieldRecord;
import com.kte.core.tool.utils.DateUtil;
import com.kte.core.tool.utils.Func;
import com.kte.core.tool.utils.ObjectUtil;
import org.apache.commons.lang3.StringUtils;

import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * @description: 日志记录工具类
 * @className: LogBeanUtils
 **/
public class LogBeanUtils {

	private static final String BIG_DECIMAL_NAME = "java.math.BigDecimal";

	/**
	 * 获取变更内容
	 *
	 * @param newBean
	 * @param oldBean
	 */
	public static <T> String getChangedFields(T newBean, T oldBean) {
		Field[] fields = newBean.getClass().getDeclaredFields();
		StringBuilder builder = new StringBuilder();
		for (Field field : fields) {
			field.setAccessible(true);
			if (field.isAnnotationPresent(FieldRecord.class)) {
				try {
					Object newValue = field.get(newBean);
					Object oldValue = field.get(oldBean);
					if (checkFields(builder, field, newValue, oldValue)) {
						continue;
					}
				} catch (Exception e) {
					e.printStackTrace();
					System.out.println(e);
				}
			}
		}
		String context = StringUtils.replace(builder.toString(), "null", "");
		return context;
	}

	/**
	 * 获取变更内容不记录空值
	 *
	 * @param newBean
	 * @param oldBean
	 * @param isRecordNull
	 * @return java.lang.String
	 */
	public static <T> String getChangedFields(T newBean, T oldBean, String isRecordNull) {
		Field[] fields = newBean.getClass().getDeclaredFields();
		StringBuilder builder = new StringBuilder();
		boolean equals = "yes".equals(isRecordNull);
		for (Field field : fields) {
			field.setAccessible(true);
			if (field.isAnnotationPresent(FieldRecord.class)) {
				try {
					Object newValue = field.get(newBean);
					Object oldValue = field.get(oldBean);
					if (checkFields(builder, field, newValue, oldValue, equals)) {
						continue;
					}
				} catch (Exception e) {
					e.printStackTrace();
					System.out.println(e);
				}
			}
		}
		String context = StringUtils.replace(builder.toString(), "null", "");
		return context;
	}

	public static <T> String getChangedFields(T newBean, T oldBean, Boolean isExcelChange) {
		Field[] fields = newBean.getClass().getDeclaredFields();
		StringBuilder builder = new StringBuilder();
		for (Field field : fields) {
			field.setAccessible(true);
			if (field.isAnnotationPresent(FieldRecord.class)) {
				try {
					Object newValue = field.get(newBean);
					Object oldValue = field.get(oldBean);
					if (isExcelChange) {
						if (ObjectUtil.isEmpty(newValue)) {
							continue;
						}
					}
					if (checkFields(builder, field, newValue, oldValue)) {
						continue;
					}
				} catch (Exception e) {
					e.printStackTrace();
					System.out.println(e);
				}
			}
		}
		String context = StringUtils.replace(builder.toString(), "null", "");
		return context;
	}

	private static boolean checkFields(StringBuilder builder, Field field, Object newValue, Object oldValue) {
		if (ObjectUtil.isEmpty(newValue) && ObjectUtil.isEmpty(oldValue)) {
			return true;
		}
		if (ObjectUtil.isEmpty(newValue)) {
			newValue = null;
		}
		if (ObjectUtil.isEmpty(oldValue)) {
			oldValue = null;
		}
		//处理BigDecimal类型的数据
		String name = field.getType().getName();
		if (name.equals(BIG_DECIMAL_NAME)) {
			BigDecimal decimal = ObjectUtil.isEmpty(newValue) ? BigDecimal.ZERO : (BigDecimal) newValue;
			BigDecimal decimal1 = ObjectUtil.isEmpty(oldValue) ? BigDecimal.ZERO : (BigDecimal) oldValue;
			if (decimal.compareTo(decimal1) == 0) {
				return true;
			}
		}
		if (!Objects.equals(newValue, oldValue)) {
			FieldRecord fieldRecord = field.getAnnotation(FieldRecord.class);
			String[] whethers = fieldRecord.whether();
			if (ObjectUtil.isNotEmpty(whethers) && whethers.length > 0) {
				HashMap<String, String> dictMap = Maps.newHashMap();
				//解析字典
				if (ObjectUtil.isNotEmpty(fieldRecord.whether())) {
					for (String whether : whethers) {
						String[] s = whether.split("_");
						dictMap.put(s[0], s[1]);
					}
					//获取字段名称
					if (fieldRecord.isDictSplit()) {
						String[] oldSplit = oldValue.toString().split(",");
						String[] newSplit = newValue.toString().split(",");
						String oldCollect = Arrays.stream(oldSplit).map(dictMap::get).collect(Collectors.joining(","));
						String newCollect = Arrays.stream(newSplit).map(dictMap::get).collect(Collectors.joining(","));
						setValue(builder, fieldRecord, oldCollect, newCollect);
						dictMap.clear();
					} else {
						setValue(builder, fieldRecord, dictMap.get(oldValue.toString()), dictMap.get(newValue.toString()));
						dictMap.clear();
					}
					return true;
				}
			}
			Boolean x = getDate(builder, newValue, oldValue, fieldRecord);
			if (x != null) {
				return x;
			}
			//获取字段名称
			builder.append(fieldRecord.fieldName());
			builder.append(": 【更改前：");
			builder.append(oldValue);
			builder.append(", 更改后：");
			builder.append(newValue);
			builder.append("】;\n");
		}
		return false;
	}

	private static boolean checkFields(StringBuilder builder, Field field, Object newValue, Object oldValue, boolean isRecordNull) {
		if (ObjectUtil.isEmpty(newValue) && ObjectUtil.isEmpty(oldValue)) {
			return true;
		}
		if (ObjectUtil.isEmpty(newValue)) {
			if (isRecordNull) {
				return true;
			}
		}
		if (ObjectUtil.isEmpty(oldValue)) {
			oldValue = "";
		}
		//处理BigDecimal类型的数据
		String name = field.getType().getName();
		if (name.equals(BIG_DECIMAL_NAME)) {
			BigDecimal decimal = (BigDecimal) newValue;
			BigDecimal decimal1 = (BigDecimal) oldValue;
			if (decimal.compareTo(decimal1) == 0) {
				return true;
			}
		}
		if (!Objects.equals(newValue, oldValue)) {
			FieldRecord fieldRecord = field.getAnnotation(FieldRecord.class);
			String[] whethers = fieldRecord.whether();
			if (ObjectUtil.isNotEmpty(whethers) && whethers.length > 0) {
				HashMap<String, String> dictMap = Maps.newHashMap();
				//解析字典
				if (ObjectUtil.isNotEmpty(fieldRecord.whether())) {
					for (String whether : whethers) {
						String[] s = whether.split("_");
						dictMap.put(s[0], s[1]);
					}
					//获取字段名称
					if (fieldRecord.isDictSplit()) {
						String[] oldSplit = oldValue.toString().split(",");
						String[] newSplit = newValue.toString().split(",");
						String oldCollect = Arrays.stream(oldSplit).map(dictMap::get).collect(Collectors.joining(","));
						String newCollect = Arrays.stream(newSplit).map(dictMap::get).collect(Collectors.joining(","));
						setValue(builder, fieldRecord, oldCollect, newCollect);
						dictMap.clear();
					} else {
						setValue(builder, fieldRecord, dictMap.get(oldValue.toString()), dictMap.get(newValue.toString()));
						dictMap.clear();
					}
					return true;
				}
			}
			Boolean x = getDate(builder, newValue, oldValue, fieldRecord);
			if (x != null) {
				return x;
			}
			//获取字段名称
			builder.append(fieldRecord.fieldName());
			builder.append(": 【更改前：");
			builder.append(oldValue);
			builder.append(", 更改后：");
			builder.append(newValue);
			builder.append("】;\n");
		}
		return false;
	}

	private static Boolean getDate(StringBuilder builder, Object newValue, Object oldValue, FieldRecord fieldRecord) {
		String dateFormat = fieldRecord.dateFormat();
		if (Func.isNotBlank(dateFormat)) {
			if (oldValue instanceof Date) {
				Date oldValue1 = (Date) oldValue;
				Date newValue1 = (Date) newValue;
				switch (dateFormat) {
					case DateUtil.PATTERN_DATE:
						setValue(builder, fieldRecord, DateUtil.format(oldValue1, DateUtil.PATTERN_DATE), DateUtil.format(newValue1, DateUtil.PATTERN_DATE));
						break;
					case DateUtil.PATTERN_DATETIME:
						setValue(builder, fieldRecord, DateUtil.format(oldValue1, DateUtil.PATTERN_DATETIME), DateUtil.format(newValue1, DateUtil.PATTERN_DATETIME));
						break;
					default:
						break;
				}
			} else if (ObjectUtil.isEmpty(oldValue) && ObjectUtil.isNotEmpty(newValue)) {
				//处理老对象没有时间和新对象有时间问题
				Date newValue1 = (Date) newValue;
				switch (dateFormat) {
					case DateUtil.PATTERN_DATE:
						setValue(builder, fieldRecord, "", DateUtil.format(newValue1, DateUtil.PATTERN_DATE));
						break;
					case DateUtil.PATTERN_DATETIME:
						setValue(builder, fieldRecord, "", DateUtil.format(newValue1, DateUtil.PATTERN_DATETIME));
						break;
					default:
						break;
				}
			}
			if (oldValue instanceof LocalDateTime) {
				LocalDateTime oldValue1 = (LocalDateTime) oldValue;
				LocalDateTime newValue1 = (LocalDateTime) newValue;
				switch (dateFormat) {
					case DateUtil.PATTERN_DATE:
						setValue(builder, fieldRecord, DateUtil.format(oldValue1, DateUtil.PATTERN_DATE), DateUtil.format(newValue1, DateUtil.PATTERN_DATE));
						break;
					case DateUtil.PATTERN_DATETIME:
						setValue(builder, fieldRecord, DateUtil.format(oldValue1, DateUtil.PATTERN_DATETIME), DateUtil.format(newValue1, DateUtil.PATTERN_DATETIME));
						break;
					default:
						break;
				}
			} else if (ObjectUtil.isEmpty(oldValue) && ObjectUtil.isNotEmpty(newValue)) {
				//处理老对象没有时间和新对象有时间问题
				LocalDateTime newValue1 = (LocalDateTime) newValue;
				switch (dateFormat) {
					case DateUtil.PATTERN_DATE:
						setValue(builder, fieldRecord, "", DateUtil.format(newValue1, DateUtil.PATTERN_DATE));
						break;
					case DateUtil.PATTERN_DATETIME:
						setValue(builder, fieldRecord, "", DateUtil.format(newValue1, DateUtil.PATTERN_DATETIME));
						break;
					default:
						break;
				}
			}
			return true;
		}
		return null;
	}

	private static void setValue(StringBuilder builder, FieldRecord fieldRecord, String oldValue, String newValue) {
		builder.append(fieldRecord.fieldName());
		builder.append(": 【更改前：");
		builder.append(oldValue);
		builder.append(", 更改后：");
		builder.append(newValue);
		builder.append("】;\n");
	}
}

测试

package com.kte.system.user.vo;

import com.kte.common.annotation.FieldRecord;
import com.kte.product.annotation.FieldMeta;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

/**
 * 对象实体类
 */
@Data
public class UserLogVo {
	/**
	 * 用户姓名
	 */
	@ApiModelProperty(value = "用户姓名")
	@FieldRecord(fieldName = "用户姓名")
	private String realName;
	/**
	 * 电子邮箱
	 */
	@ApiModelProperty(value = "电子邮箱")
	@FieldRecord(fieldName = "电子邮箱")
	private String email;
	/**
	 * 手机号码
	 */
	@ApiModelProperty(value = "手机号码 ")
	@FieldRecord(fieldName = "手机号码")
	private String phone;
	/**
	 * 用户性别
	 */
	@ApiModelProperty(value = "用户性别")
	@FieldRecord(fieldName = "用户性别", whether = {"1_男", "2_女"})
	private String sex;
}

//调用工具类，获取变更的内容
String change=LogBeanUtils.getChangedFields(T newBean, T oldBean, String isRecordNull);

把变更的内容记录入库，此位置省略入库操作，自行编写

//注意细节：
1. @FieldRecord：需要记录变更得字段必须加上此注解
2. whether：枚举转换，如性别，我们入库记录的是“1和2”，记录日志时可自动装换为“男和女”
生活要像疯子一样过
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
开源｜操作日志工具
Elltor
11-18 699
摘要：业务系统中难免要记录敏感操作，可以通过硬编码或者简单注解实现，但是都不够优雅，今天分享一个自己写的日志工具。
MFC日志记录工具类/c++/vs2015
01-19
MFC使用的日志记录工具类 在指定目录下使用当前日期进行记录，程序运行时可自动将每日的日志记录在一个文件中。适用于长期运行的程序。写日志时会进行加锁操作。 项目是使用VS2015建立的支持MFC的控制台程序进行测试...
java获取日志记录通用工具类
Rodge的博客
10-07 3668
日志注解类： /** * 日志注解类 * * @author： Rodge * @time： 2018年10月07日 下午11:29:10 * @version： V1.0.0 */ @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) public @interface LogField ...
操作日志工具类
weixin_33806914的博客
05-29 415
package com.util; import java.util.Date; import java.util.UUID; import javax.servlet.http.HttpServletRequest; import org.springframework.context.ApplicationContext; import org.springframe...
Python日志记录工具logging
微小冷的学习笔记
02-09 1106
Python标准库提供了一个灵活的事件日志系统`logging`，可以对软件执行时发生的事件进行追踪，是开发过程中必不可少的调试工具。
私人工具集2——C#日志操作类(LogHelper)
redAnt的博客
02-27 2604
github地址： 此分享内容，仅仅为本人个人理解，仅供参考 浅谈程序日志 日志，记录系统运行情况的一个文本。没错，就是一个文本，可以以txt为后缀结尾，通常情况下以.log为后缀。通常一个公司不只有一个业务系统，因此，日志文件又通常以系统名称+日期的格式命名。甚至有些日志系统以xml的文档形式存储（如windows的内部日志）。 日志可以帮助开发人员和运维人员快速定位问题，同时观察系统运行的情况，耗时。 如下是一个示例： 通常系统的根目录都有一个log名的文件夹（目录），用于存放产生的日志，便于..
java工程中封装静态的log4j日志工具类
PiaoMiaoXiaodao的博客
08-25 2646
一般在web工程或者普通java工程中都会用到日志记录工具,java一般使用的是log4j,用法大都是在每个需要记录日志的类上添加一个私有的日志记录器,记录本类中的异常:如下 private final Logger logger = LoggerFactory.getLogger(Test.class); logger.error(&amp;amp;quot;报错！&amp;amp;quot;, e); logger...
Android--日志工具类
fenghuochengshan的博客
05-31 964
其中，logPath为日志文件目录的路径，logFileName为日志文件名。初始化完成后，即可使用v()、d()、i()、w()、e()方法分别输出不同级别的日志。在该类中会自动将日志信息加入缓存，并在缓存数量达到一定阈值时才会将整个缓存一次性写入文件，从而减少IO操作的次数。
Unity 工具类 之 日志本地化保存和简单界面显示日志
仙魁XAN
04-30 1805
参考：https://blog.csdn.net/nicepainkiller/article/details/84958804 SRDebugger 工具可以参考使用，功能更加完善 ManagerLoger.cs using System.Collections; using System.Collections.Generic; u...
C#底层库--程序日志记录类
花北城的博客
04-15 2099
本文将介绍，如何在项目中跟踪记录程序运行状态的日志，日志：包含程序运行状态、报错异常信息、用户点击事件等。 说的神乎其神，其实很简单，就是说创建一个含日期的文本文件（.txt），文件里存放一些日志信息。
QT日志类SimpleQtLogger的简单记录
吻等离子的博客
05-14 1369
SimpleQtLogger是一个轻量级、易于使用的Qt日志库，旨在提供简单而灵活的日志记录功能。它利用Qt的核心模块（如QString和QFile），确保与Qt应用程序的无缝集成。SimpleQtLogger支持多种日志级别（如Debug、Info、Warning、Error），可以将日志输出到控制台、文件或其他自定义目标。SimpleQtLogger是一个功能强大、易于使用的Qt日志库，适用于各种Qt应用程序的日志记录需求。
在MVC中记录操作日志类
03-12
在MVC（Model-View-Controller）架构中，记录操作日志是一项重要的功能，它能够帮助开发者追踪系统的行为，诊断问题，以及满足审计和合规需求。以下是对这一主题的详细阐述： 1. **MVC架构简介** MVC是一种设计...
日志工具类-java实现
12-16
我们可以创建一个名为`LoggerUtil`的工具类，其中包含静态方法来处理各种日志操作。以下是一个基本的`LoggerUtil`类的实现： ```java import java.util.logging.Level; import java.util.logging.Logger; public ...
java日志记录工具类
09-25
调用方法:IndexDataLog.print(入参)，可以设置文件大小，文件写满以后自动创建新的日志文件。一般用来记录用户的搜索词，或操作记录。目前以json格式保存日志，入参稍作修改，可以传入对象,linux和windows都支持。
Android日志文件的读写工具类
08-19
总结来说，Android日志文件的读写工具类简化了开发过程中与文件操作相关的任务，提供了一种便捷的方式来记录和管理应用程序的日志信息。通过合理使用此类，开发者可以更好地追踪程序运行状态，进行问题排查，同时也...
golang 接口
m0_70982551的博客
07-24 815
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 367
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
【Java算法专场】二分查找(下）
最新发布
zhyhgx的博客
07-27 432
本道题是要在一个从0~n-1的数组中找缺失的数，我们可以采用哈希表来解决，但此时时空复杂度达到了O(n),这是一个有序的数组，我们可以采用二分查找来解决，使时间复杂度达到O(logn).我们可以发现，每个数组的下标和其元素是相同的，那么我们可以通过判断下标和元素的大小，来确定缺失值的位置。3.mid=4+(5-4)/2=4,nums[mid]=5
springboot之自动装配
weixin_50153914的博客
07-23 508
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java文件操作工具类实例与详细功能解析
- 类中定义了`Level`和`Logger`，表明该工具类采用了日志记录机制，可以捕获和记录在执行文件操作过程中可能出现的`FileNotFoundException`、`IOException`等异常，增强了程序的健壮性和调试便利性。 6. **列表和...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值