个人笔记：注解实现动态拼接日志内容jeecg-boot框架

已于 2024-08-06 16:26:31 修改
阅读量341 收藏
点赞数 5
分类专栏： 个人笔记 文章标签： 笔记
于 2024-08-06 16:24:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JAVAwhwhsg/article/details/140958606
版权

个人在项目中的使用方法，有问题还请不吝指正，积极讨论
自定义注解类

package org.jeecg.common.aspect.annotation;

import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.enums.ModuleType;

import java.lang.annotation.*;

/**
 * 系统日志注解
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface AutoLog {

	/**
	 * 日志内容
	 * 
	 * @return
	 */
	String value() default "";

	/**
	 * 日志类型
	 * 
	 * @return 0:操作日志;1:登录日志;2:定时任务;
	 */
	int logType() default CommonConstant.LOG_TYPE_2;
	
	/**
	 * 操作日志类型
	 * 
	 * @return （1查询，2添加，3修改，4删除）
	 */
	int operateType() default 0;

	/**
	 * 模块类型 默认为common
	 * @return
	 */
	ModuleType module() default ModuleType.COMMON;
}

切面类

package org.jeecg.common.aspect;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.PropertyFilter;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.jeecg.common.api.dto.LogDTO;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.enums.ModuleType;
import org.jeecg.common.constant.enums.OperateTypeEnum;
import org.jeecg.modules.base.service.BaseCommonService;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.IpUtils;
import org.jeecg.common.util.SpringContextUtils;
import org.jeecg.common.util.oConvertUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
import org.springframework.stereotype.Component;
import org.springframework.validation.BindingResult;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;



/**
 * 系统日志，切面处理类
 */
@Aspect
@Component
public class AutoLogAspect {

    @Resource
    private BaseCommonService baseCommonService;

    @Pointcut("@annotation(org.jeecg.common.aspect.annotation.AutoLog)")
    public void logPointCut() {

    }

    @Around("logPointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        long beginTime = System.currentTimeMillis();
        //执行方法
        Object result = point.proceed();
        //执行时长(毫秒)
        long time = System.currentTimeMillis() - beginTime;

        //保存日志
        saveSysLog(point, time, result);

        return result;
    }
    /**
     * 处理注解中的动态参数，把变量占位符替换成实际的变量值
     */
    private static String dynamicParam(String logContent, Map<String,Object> paramsMap){
        AtomicReference<String> actual = new AtomicReference<>(logContent);
        if(StringUtils.isBlank(logContent)){
            return actual.get();
        }
        paramsMap.entrySet().stream().forEach(p->{
            if(actual.get().contains(p.getKey())){
                actual.set(actual.get().replaceAll(p.getKey(), p.getValue() + ""));
            }
        });
        return actual.get();
    }
    private static boolean isSimpleType(String name){
        AtomicBoolean result = new AtomicBoolean(false);
        String[] className = {"String","Integer","Long","int","float","double","char"};
        Arrays.asList(className).forEach(n->{
            if(name.contains(n)) {
                result.set(name.contains(n));
            }
        });
        return result.get();
    }


    private void saveSysLog(ProceedingJoinPoint joinPoint, long time, Object obj) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();

        // 解析切面的所有参数，放入一个Map
        Map<String, Object> paramsMap = produceParamsMap(joinPoint, signature);

        LogDTO dto = new LogDTO();
        AutoLog syslog = method.getAnnotation(AutoLog.class);
        if (syslog != null) {
            //update-begin-author:taoyan date:
            //解析注解传进来的日志内容
            String content = dynamicParam(syslog.value(), paramsMap);
//            String content = syslog.value();
            if (syslog.module() == ModuleType.ONLINE) {
                content = getOnlineLogContent(obj, content);
            }
            //注解上的描述,操作日志内容
            dto.setLogType(syslog.logType());
            dto.setLogContent(content);
        }

        //请求的方法名
        String className = joinPoint.getTarget().getClass().getName();
        String methodName = signature.getName();
        dto.setMethod(className + "." + methodName + "()");


        //设置操作类型
        if (CommonConstant.LOG_TYPE_2 == dto.getLogType()) {
            dto.setOperateType(getOperateType(methodName, syslog.operateType()));
        }

        //获取request
        HttpServletRequest request = SpringContextUtils.getHttpServletRequest();
        //请求的参数
        dto.setRequestParam(getRequestParams(request, joinPoint));
        //设置IP地址
        dto.setIp(IpUtils.getIpAddr(request));
        //获取登录用户信息
        LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        if (sysUser != null) {
            dto.setUserid(sysUser.getUsername());
            dto.setUsername(sysUser.getRealname());

        }
        //耗时
        dto.setCostTime(time);
        dto.setCreateTime(new Date());
        //saas
        dto.setTenantId(request.getHeader(CommonConstant.TENANT_ID));
        //保存系统日志
        baseCommonService.addLog(dto);
    }

    /**
     * 把切面中的各种不同类型的参数信息，统一放入一个Map，从而不需要再去别的变量里面寻找参数
     */
    private Map<String, Object> produceParamsMap(ProceedingJoinPoint joinPoint, MethodSignature signature) {
        Map<String,Object> paramsMap = new HashMap<>(); // 包含此切面的所有参数值的Map
        String[] argNames = signature.getParameterNames(); // 参数名
        Object[] argObjects = joinPoint.getArgs(); // 参数
        List<String> argNameList = Arrays.asList(argNames);
        for(int i = 0; i < argNameList.size(); i++){
            Class<?> clazz = argObjects[i].getClass();

            // 把简单数据类型的参数放入参数Map （包括了Request对象中的ParameterMap）
            Object currentParam = joinPoint.getArgs()[i];
            if(isSimpleType(clazz.getName())){
                paramsMap.put(argNameList.get(i), currentParam);
                continue;
            }

            // 把Request对象中的Attribute属性放入参数Map
            if (currentParam instanceof ServletRequest) {
                ServletRequest request = (ServletRequest) currentParam;
                Enumeration<String> attr = request.getAttributeNames();
                while(attr.hasMoreElements()){
                    String attrName = attr.nextElement();
                    String attrValue = "";
                    if (request.getAttribute(attrName) != null) {
                        attrValue = request.getAttribute(attrName).toString();
                    }
                    paramsMap.put(attrName, attrValue);
                }
                continue;
            }

            // 把不属于以上两种类型的参数（即Spring MVC/Spring Boot自动接收的Bean类型）放入参数Map
            JSONObject object = (JSONObject) JSONObject.toJSON(currentParam);

            object.keySet().stream().forEach(p->{
                paramsMap.put(p,object.get(p));
            });
        }
        return paramsMap;
    }


    /**
     * 获取操作类型
     */
    private int getOperateType(String methodName, int operateType) {
        if (operateType > 0) {
            return operateType;
        }
        return OperateTypeEnum.getTypeByMethodName(methodName);
    }
    /**
     * 获取请求参数
     *
     */
    private String getRequestParams(HttpServletRequest request, JoinPoint joinPoint) {
        String httpMethod = request.getMethod();
        String params = "";
        if ("POST".equals(httpMethod) || "PUT".equals(httpMethod) || "PATCH".equals(httpMethod)) {
            Object[] paramArray = paramArray(joinPoint);
            params = JSONObject.toJSONString(paramArray);
        } else {
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method method = signature.getMethod();
            // 请求的方法参数值
            Object[] args = joinPoint.getArgs();
            // 请求的方法参数名称
            LocalVariableTableParameterNameDiscoverer u = new LocalVariableTableParameterNameDiscoverer();
            String[] paramNames = u.getParameterNames(method);
            if (args != null && paramNames != null) {
                for (int i = 0; i < args.length; i++) {
                    params += "  " + paramNames[i] + ": " + args[i];
                }
            }
        }
        return params;
    }
    private Object[] paramArray(JoinPoint joinPoint) {
        // 存放方法参数的数组
        Object[] paramArray  = new Object[joinPoint.getArgs().length];

        if (joinPoint.getArgs() != null && joinPoint.getArgs().length > 0) {

            for (int i = 0; i < joinPoint.getArgs().length; i++) {

                if (joinPoint.getArgs()[i] instanceof ServletRequest || joinPoint.getArgs()[i] instanceof ServletResponse || joinPoint.getArgs()[i] instanceof MultipartFile) {

                    // 跳过Servlet类型的参数

                    continue;

                }

                paramArray[i] = joinPoint.getArgs()[i];

            }

        }
        return paramArray;
    }

    /**
     * @param request:   request
     * @param joinPoint: joinPoint
     * @Description: 获取请求参数
     * @Return: java.lang.String
     */
    private String getReqestParams(HttpServletRequest request, JoinPoint joinPoint) {
        String httpMethod = request.getMethod();
        String params = "";
        if (CommonConstant.HTTP_POST.equals(httpMethod) || CommonConstant.HTTP_PUT.equals(httpMethod) || CommonConstant.HTTP_PATCH.equals(httpMethod)) {
            Object[] paramsArray = joinPoint.getArgs();
            // java.lang.IllegalStateException: It is illegal to call this method if the current request is not in asynchronous mode (i.e. isAsyncStarted() returns false)
            //  https://my.oschina.net/mengzhang6/blog/2395893
            Object[] arguments = new Object[paramsArray.length];
            for (int i = 0; i < paramsArray.length; i++) {
                if (paramsArray[i] instanceof BindingResult || paramsArray[i] instanceof ServletRequest || paramsArray[i] instanceof ServletResponse || paramsArray[i] instanceof MultipartFile) {
                    //ServletRequest不能序列化，从入参里排除，否则报异常：java.lang.IllegalStateException: It is illegal to call this method if the current request is not in asynchronous mode (i.e. isAsyncStarted() returns false)
                    //ServletResponse不能序列化 从入参里排除，否则报异常：java.lang.IllegalStateException: getOutputStream() has already been called for this response
                    continue;
                }
                arguments[i] = paramsArray[i];
            }
            //update-begin-author:taoyan date:20200724 for:日志数据太长的直接过滤掉
            PropertyFilter profilter = new PropertyFilter() {
                @Override
                public boolean apply(Object o, String name, Object value) {
                    int length = 500;
                    if (value != null && value.toString().length() > length) {
                        return false;
                    }
                    return true;
                }
            };
            params = JSONObject.toJSONString(arguments, profilter);
            //update-end-author:taoyan date:20200724 for:日志数据太长的直接过滤掉
        } else {
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method method = signature.getMethod();
            // 请求的方法参数值
            Object[] args = joinPoint.getArgs();
            // 请求的方法参数名称
            LocalVariableTableParameterNameDiscoverer u = new LocalVariableTableParameterNameDiscoverer();
            String[] paramNames = u.getParameterNames(method);
            if (args != null && paramNames != null) {
                for (int i = 0; i < args.length; i++) {
                    params += "  " + paramNames[i] + ": " + args[i];
                }
            }
        }
        return params;
    }

    /**
     * online日志内容拼接
     *
     * @param obj
     * @param content
     * @return
     */
    private String getOnlineLogContent(Object obj, String content) {
        if (Result.class.isInstance(obj)) {
            Result res = (Result) obj;
            String msg = res.getMessage();
            String tableName = res.getOnlTable();
            if (oConvertUtils.isNotEmpty(tableName)) {
                content += ",表名:" + tableName;
            }
            if (res.isSuccess()) {
                content += "," + (oConvertUtils.isEmpty(msg) ? "操作成功" : msg);
            } else {
                content += "," + (oConvertUtils.isEmpty(msg) ? "操作失败" : msg);
            }
        }
        return content;
    }
}

使用方式

// 这里的name在参数实体中要有，或者在方法执行完成之前给这个属性赋值 使用在方法上
@AutoLog(value = "测试日志内容-文章名称：name")

request实体

package org.jeecg.modules;

import lombok.Data;

@Data
public class Request {

    private String id;
    
    private  String name;

}

service中

//方法执行完之前都可以设置
request.setName("母猪产后护理讲解");

最后日志输出

测试日志内容-文章名称：母猪产后护理讲解

表结构


SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for sys_log
-- ----------------------------
DROP TABLE IF EXISTS `sys_log`;
CREATE TABLE `sys_log`  (
  `id` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `log_type` int NULL DEFAULT NULL COMMENT '日志类型（1登录日志，2操作日志）',
  `log_content` varchar(4000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '日志内容',
  `operate_type` int NULL DEFAULT NULL COMMENT '操作类型',
  `userid` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '操作用户账号',
  `username` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '操作用户名称',
  `ip` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT 'IP',
  `method` varchar(500) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '请求java方法',
  `request_url` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '请求路径',
  `request_param` longtext CHARACTER SET utf8 COLLATE utf8_general_ci NULL COMMENT '请求参数',
  `request_type` varchar(10) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '请求类型',
  `cost_time` bigint NULL DEFAULT NULL COMMENT '耗时',
  `create_by` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '创建人',
  `create_time` datetime(0) NULL DEFAULT NULL COMMENT '创建时间',
  `update_by` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '更新人',
  `update_time` datetime(0) NULL DEFAULT NULL COMMENT '更新时间',
  `tenant_id` int NULL DEFAULT 0,
  `integrity` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '完整性',
  PRIMARY KEY (`id`) USING BTREE,
  INDEX `idx_sl_userid`(`userid`) USING BTREE,
  INDEX `idx_sl_log_type`(`log_type`) USING BTREE,
  INDEX `idx_sl_operate_type`(`operate_type`) USING BTREE,
  INDEX `idx_sl_create_time`(`create_time`) USING BTREE
) ENGINE = MyISAM AUTO_INCREMENT = 1 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '系统日志表' ROW_FORMAT = DYNAMIC;

SET FOREIGN_KEY_CHECKS = 1;
随它吧�
关注
专栏目录
企业级信息系统开发讲课笔记4.1 Spring Boot入门程序
howard2005的专栏
05-03 945
1. 了解Spring Boot框架的优点； 2. 掌握使用Maven方式构建Spring Boot项目； 3. 掌握使用Spring Initializr方式构建Spring Boot项目
jeecgboot日志存入mysql_jeecg系统日志管理
weixin_30166691的博客
02-05 1518
Jeecg中通过Spring_AOP+注解方式实现日志的管理一、设计思路通过spring的aop切面功能，拦截到请求的所有的符合切面表达式的方法，判断是否含有注解标志，生成日志对象，然后通过aop的后置通知进行日志的持久化。二、代码实现1、工程结构：2、pom.xml增加aop依赖：org.springframeworkspring-aop4.1.7.RELEASEaspectjaspectjrt...
Spring Boot 通过AOP+自定义注解实现日志管理
lixuanhong的博客
10-22 941
Spring Boot 通过AOP+自定义注解实现日志管理
jeecgboot logback-spring.xml配置不生成新日志文件
JEECG官方博客
04-22 4543
日志文件不随时间生成新得日志文件，一直累积在启动时的生成的日志文件里。 查找资料发现，是TimeBasedRollingPolicy和SizeBasedTriggeringPolicy冲突。 将两个去掉，使用 ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy 。 PS : RollingFileNamePattern中 %d %i ...
学习笔记（五）：自定义日志注解
qq_49111986的博客
05-16 402
自定义注解
SpringBoot学习笔记-S2
Dijkstra's Monk-ey的博客
04-05 831
SpringBoot中的常见注解 `@RequestBody` `@RestController` @Controller `@Validated`： JWT(JSON Web Token)的使用 ThreadLocal的使用 功能 意义 拦截器工具类 MyBatis中#{ }和${ }的区别 `#{ }`和`${ }`均是MyBatis的占位符。配置MyBatis时的常见问题及解决方案 Failed to configure a DataSource Caused by: org.springframe
乐优商城个人笔记上-主要框架、基础知识、管理系统代码
weixin_48713918的博客
10-29 2041
SpringBoot 内置tomcat 提供了自动配置，搭建spring应用的脚手架 复杂的配置，混乱的依赖关系
【Mybatis-Plus 学习笔记】2、日志配置及常用 CRUD
村雨遥
08-08 494
前言 上一篇文章中我们讲了 Mybatis-Plus 的定义以及相关特点，并从零开始编写了一个 SpringBoot + Mybatis-Plus 的实例。今天我们就来看看，如何利用 MP 来实现对数据库的增删改查。 日志配置 使用 MP 时，默认是不打印任何 SQL 语句的。而为了方便日常开发工作的调试，我们需要联合控制台和各种数据可视化工具进行语句的拼接检查，因此我们利用 MP 自带的日志功能，在控制台输出我们的 SQL 语句，从而方便我们调试。 在配置文件 application.yml （IDEA
课程设计基于Spring Boot+Semantic ui的个人博客系统的设计与实现
weixin_51787261的博客
06-02 1955
本项目是基于互联网软件开发技术搭建的一款个人博客系统，因为自己十分喜欢创作，比如写一些开源项目，写一些博客笔记，虽然网络上有许多大型博客系统，但是一直想写一个属于自己专有的博客系统，比如可以上传一些自己的知识笔记，上传一些自己的生活照片等，于是便花了三周的时间设计了这款个人博客，该博客的前端部分用的是一款比较轻量级的框架Semantic ui，后端用的SpringBoot，数据库用的是mysql。 关键词：个人博客系统；Spring Boot；Semantic ui； 本系统后端采用的是一款主流的
mybatis-plus学习项目笔记
07-07
MyBatis-Plus继承了MyBatis的动态SQL功能，可以通过`if`、`choose`、`when`、`otherwise`等标签实现灵活的SQL拼接。 7. **插件机制** MyBatis-Plus提供了插件机制，可以自定义全局拦截器，实现如日志记录、性能...
一个小小的注解，帮你搞定 SpringBoot 操作日志
2401_84415615的博客
04-20 1145
至此，文章终于到了尾声。技术能力：先写岗位所需能力，再写加分能力，不要写无关能力；项目经历：只写明星项目，描述遵循 STAR 法则；简历印象：简历遵循三大原则：清晰，简短，必要，要有的放矢，不要海投；以及最后为大家准备的福利时间：简历模板+Java面试题+热门技术系列教程视频《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！” />至此，文章终于到了尾声。技术能力：先写岗位所需能力，再写加分能力，不要写无关能力；
Spring Boot笔记总结（第二天）
m0_63255968的博客
07-22 151
Spring Boot使用slf4j日志
（笔记）第三期书生·浦语大模型实战营（十一卷王场）--书生入门岛通关第2关Python 基础知识
haidizym的博客
10-02 409
学员闯关手册：https://aicarrier.feishu.cn/wiki/ZcgkwqteZi9s4ZkYr0Gcayg1n1g?课程视频：https://www.bilibili.com/video/BV1mS421X7h4/课程文档：https://github.com/InternLM/Tutorial/tree/camp3/docs/L0/Python。
江科大笔记—LED闪烁& LED流水灯& 蜂鸣器
m0_62005595的博客
09-28 480
LED闪烁& LED流水灯& 蜂鸣器
【韩顺平Java笔记】第6章：数组、排序和查找
最新发布
随手写写
10-02 710
排序是将多个数据，依指定的顺序进行排列的过程。
Spring（学习笔记）
m0_74728220的博客
10-02 960
context:annotation-config/>是 Spring 配置文件中的一个标签，用于开启注解配置功能。这个标签可以让 Spring 容器识别并处理使用注解定义的 bean。例如，可以使用 @Autowired 注解自动装配 bean，或者使用 @Component 注解将类标记为 bean 等。为什么加载上下文的时候，被包含的Bean它的构造函数的代码会执行呀？好像是很多代码都执行了！！！没有无参构造，有有参构造会报错！也就是说必须要有无参构造！这是为什么呀！
Coursera_ Algorithms I 学习笔记：Module_3_Analysis_of_Algorithm_Introduction
approximately_的博客
09-29 1178
Coursera_ Algorithms I 学习笔记：Module_3_Analysis_of_Algorithm_Introduction
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值