若依管理系统——自定义注解使用切面记录操作日志

最新推荐文章于 2024-05-20 11:22:17 发布
最新推荐文章于 2024-05-20 11:22:17 发布
阅读量4.4k 收藏 20
点赞数 5
分类专栏： 项目总结 文章标签： aop annotations
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DreamsArchitects/article/details/116707529
版权

目录

一、介绍

系统访问记录表：
在这里插入图片描述
操作日志记录表：
在这里插入图片描述

二、登录日志记录分析

在这里插入图片描述

2.1 异步定时任务管理器（线程池）

无论登录成功还是失败，都会用一个异步的任务AsyncManager.me().execute()来保存登录结果：
在这里插入图片描述

通过SpringUtils工具类的getBean方法获得定时任务线程池对象，(也可以通过@Autowired注解注入)。
在这里插入图片描述
在这里插入图片描述

通过executor.schedule(Runnable command, long delay, TimeUnit unit);方法执行任务：

  1. TimerTask是实现了Runnable接口。
  2. OPERATE_DELAY_TIME 操作延迟10毫秒 。
  3. TimeUnit.MILLISECONDS 时间单位。

在这里插入图片描述

2.2 异步工厂（产生任务用）

pom依赖：

 <!-- 解析客户端操作系统、浏览器等 -->
   <dependency>
       <groupId>eu.bitwalker</groupId>
       <artifactId>UserAgentUtils</artifactId>
       <version>1.21</version>
   </dependency>

在这里插入图片描述
在这里插入图片描述

三、用户操作行为记录分析

3.1 定义注解

import com.lsh.common.enums.BusinessType;
import com.lsh.common.enums.OperatorType;

import java.lang.annotation.*;

/**
 * 自定义操作日志记录注解
 * 
 * @author ruoyi
 *
 */
@Target({ ElementType.PARAMETER, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Log {
    /**
     * 模块 
     */
    public String title() default "";

    /**
     * 功能
     */
    public BusinessType businessType() default BusinessType.OTHER;

    /**
     * 操作人类别
     */
    public OperatorType operatorType() default OperatorType.MANAGE;

    /**
     * 是否保存请求的参数
     */
    public boolean isSaveRequestData() default true;
}

业务操作类型：
在这里插入图片描述
操作人类别：
在这里插入图片描述

3.2 定义切面

定义切面，

package com.lsh.oauth2.aspectj;

import com.alibaba.fastjson.JSON;
import com.lsh.common.annotation.Log;
import com.lsh.common.enums.BusinessStatus;
import com.lsh.common.enums.HttpMethod;
import com.lsh.common.util.ServletUtils;
import com.lsh.common.util.StringUtils;
import com.lsh.common.util.ip.IpUtils;
import com.lsh.oauth2.entity.SysOperLog;
import com.lsh.oauth2.manager.AsyncManager;
import com.lsh.oauth2.manager.factory.AsyncFactory;
import com.lsh.oauth2.service.TokenService;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.validation.BindingResult;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.HandlerMapping;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;

/**
 * @desc 操作日志记录处理
 * @author LiuShihao
 * @date 2021年09月24日09:16:35
 */
@Aspect
@Component
public class LogAspect {
    private static final Logger log = LoggerFactory.getLogger(LogAspect.class);

    @Autowired
    TokenService tokenService;

    // 配置织入点
    @Pointcut("@annotation(com.lsh.common.annotation.Log)")
    public void logPointCut() {
    }

    /**
     * 处理完请求后执行
     *
     * @param joinPoint 切点
     */
    @AfterReturning(pointcut = "logPointCut()", returning = "jsonResult")
    public void doAfterReturning(JoinPoint joinPoint, Object jsonResult) {
        handleLog(joinPoint, null, jsonResult);
    }

    /**
     * 拦截异常操作
     *
     * @param joinPoint 切点
     * @param e 异常
     */
    @AfterThrowing(value = "logPointCut()", throwing = "e")
    public void doAfterThrowing(JoinPoint joinPoint, Exception e) {
        handleLog(joinPoint, e, null);
    }

    protected void handleLog(final JoinPoint joinPoint, final Exception e, Object jsonResult) {
        try {
            // 获得注解
            Log controllerLog = getAnnotationLog(joinPoint);
            if (controllerLog == null) {
                return;
            }

            // 获取当前的用户  获取请求头中的Authorization信息（JWT令牌） 解析令牌 获得tokenkey，通过key获取Redis中的用户信息
            String loginUser = tokenService.getLoginUser(ServletUtils.getRequest());
            log.info("LogAspect：获取当前的用户:"+loginUser);

            // *========数据库日志=========*//
            SysOperLog operLog = new SysOperLog();
            operLog.setStatus(BusinessStatus.SUCCESS.ordinal());
            // 请求的地址
            String ip = IpUtils.getIpAddr(ServletUtils.getRequest());
            operLog.setOperIp(ip);
            // 返回参数
            operLog.setJsonResult(JSON.toJSONString(jsonResult));

            operLog.setOperUrl(ServletUtils.getRequest().getRequestURI());
            if (loginUser != null) {
//                operLog.setOperName(loginUser.getUsername());
                operLog.setOperName(loginUser);
            }

            if (e != null) {
                operLog.setStatus(BusinessStatus.FAIL.ordinal());
                operLog.setErrorMsg(StringUtils.substring(e.getMessage(), 0, 2000));
            }
            // 设置方法名称
            String className = joinPoint.getTarget().getClass().getName();
            String methodName = joinPoint.getSignature().getName();
            operLog.setMethod(className + "." + methodName + "()");
            // 设置请求方式
            operLog.setRequestMethod(ServletUtils.getRequest().getMethod());
            // 处理设置注解上的参数
            getControllerMethodDescription(joinPoint, controllerLog, operLog);
            // 保存数据库
            AsyncManager.me().execute(AsyncFactory.recordOper(operLog));
        } catch (Exception exp) {
            // 记录本地异常日志
            log.error("==前置通知异常==");
            log.error("异常信息:{}", exp.getMessage());
            exp.printStackTrace();
        }
    }

    /**
     * 获取注解中对方法的描述信息 用于Controller层注解
     *
     * @param log 日志
     * @param operLog 操作日志
     * @throws Exception
     */
    public void getControllerMethodDescription(JoinPoint joinPoint, Log log, SysOperLog operLog) throws Exception {
        // 设置action动作
        operLog.setBusinessType(log.businessType().ordinal());
        // 设置标题
        operLog.setTitle(log.title());
        // 设置操作人类别
        operLog.setOperatorType(log.operatorType().ordinal());
        // 是否需要保存request，参数和值
        if (log.isSaveRequestData()) {
            // 获取参数的信息，传入到数据库中。
            setRequestValue(joinPoint, operLog);
        }
    }

    /**
     * 获取请求的参数，放到log中
     *
     * @param operLog 操作日志
     * @throws Exception 异常
     */
    private void setRequestValue(JoinPoint joinPoint, SysOperLog operLog) throws Exception {
        String requestMethod = operLog.getRequestMethod();
        if (HttpMethod.PUT.name().equals(requestMethod) || HttpMethod.POST.name().equals(requestMethod)) {
            String params = argsArrayToString(joinPoint.getArgs());
            operLog.setOperParam(StringUtils.substring(params, 0, 2000));
        } else {
            Map<?, ?> paramsMap = (Map<?, ?>) ServletUtils.getRequest().getAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE);
            operLog.setOperParam(StringUtils.substring(paramsMap.toString(), 0, 2000));
        }
    }

    /**
     * 是否存在注解，如果存在就获取
     */
    private Log getAnnotationLog(JoinPoint joinPoint) throws Exception {
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method method = methodSignature.getMethod();

        if (method != null) {
            return method.getAnnotation(Log.class);
        }
        return null;
    }

    /**
     * 参数拼装
     */
    private String argsArrayToString(Object[] paramsArray) {
        String params = "";
        if (paramsArray != null && paramsArray.length > 0) {
            for (int i = 0; i < paramsArray.length; i++) {
                if (!isFilterObject(paramsArray[i])) {
                    Object jsonObj = JSON.toJSON(paramsArray[i]);
                    params += jsonObj.toString() + " ";
                }
            }
        }
        return params.trim();
    }

    /**
     * 判断是否需要过滤的对象。
     *
     * @param o 对象信息。
     * @return 如果是需要过滤的对象，则返回true；否则返回false。
     */
    @SuppressWarnings("rawtypes")
    public boolean isFilterObject(final Object o) {
        Class<?> clazz = o.getClass();
        if (clazz.isArray()) {
            return clazz.getComponentType().isAssignableFrom(MultipartFile.class);
        } else if (Collection.class.isAssignableFrom(clazz)) {
            Collection collection = (Collection) o;
            for (Iterator iter = collection.iterator(); iter.hasNext();) {
                return iter.next() instanceof MultipartFile;
            }
        } else if (Map.class.isAssignableFrom(clazz)) {
            Map map = (Map) o;
            for (Iterator iter = map.entrySet().iterator(); iter.hasNext();) {
                Map.Entry entry = (Map.Entry) iter.next();
                return entry.getValue() instanceof MultipartFile;
            }
        }
        return o instanceof MultipartFile || o instanceof HttpServletRequest || o instanceof HttpServletResponse
                || o instanceof BindingResult;
    }
}

3.3 使用注解

在这里插入图片描述

四、源码

代码中涉及的工具类不在贴出，代码已经上传Git：https://gitee.com/L1692312138/spring-cloud-alibaba
在这里插入图片描述

SQL

CREATE TABLE `sys_logininfor` (
  `info_id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '访问ID',
  `user_name` varchar(50) DEFAULT '' COMMENT '用户账号',
  `ipaddr` varchar(128) DEFAULT '' COMMENT '登录IP地址',
  `login_location` varchar(255) DEFAULT '' COMMENT '登录地点',
  `browser` varchar(50) DEFAULT '' COMMENT '浏览器类型',
  `os` varchar(50) DEFAULT '' COMMENT '操作系统',
  `status` char(1) DEFAULT '0' COMMENT '登录状态（0成功 1失败）',
  `msg` varchar(255) DEFAULT '' COMMENT '提示消息',
  `login_time` datetime DEFAULT NULL COMMENT '访问时间',
  PRIMARY KEY (`info_id`)
) ENGINE=InnoDB AUTO_INCREMENT=42 DEFAULT CHARSET=utf8 COMMENT='系统访问记录';


CREATE TABLE `sys_oper_log` (
  `oper_id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '日志主键',
  `title` varchar(50) DEFAULT '' COMMENT '模块标题',
  `business_type` int(2) DEFAULT '0' COMMENT '业务类型（0其它 1新增 2修改 3删除）',
  `method` varchar(100) DEFAULT '' COMMENT '方法名称',
  `request_method` varchar(10) DEFAULT '' COMMENT '请求方式',
  `operator_type` int(1) DEFAULT '0' COMMENT '操作类别（0其它 1后台用户 2手机端用户）',
  `oper_name` varchar(50) DEFAULT '' COMMENT '操作人员',
  `dept_name` varchar(50) DEFAULT '' COMMENT '部门名称',
  `oper_url` varchar(255) DEFAULT '' COMMENT '请求URL',
  `oper_ip` varchar(128) DEFAULT '' COMMENT '主机地址',
  `oper_location` varchar(255) DEFAULT '' COMMENT '操作地点',
  `oper_param` varchar(2000) DEFAULT '' COMMENT '请求参数',
  `json_result` varchar(2000) DEFAULT '' COMMENT '返回参数',
  `status` int(1) DEFAULT '0' COMMENT '操作状态（0正常 1异常）',
  `error_msg` varchar(2000) DEFAULT '' COMMENT '错误消息',
  `oper_time` datetime DEFAULT NULL COMMENT '操作时间',
  PRIMARY KEY (`oper_id`)
) ENGINE=InnoDB AUTO_INCREMENT=139 DEFAULT CHARSET=utf8 COMMENT='操作日志记录';
Liu_Shihao
关注
  • 5
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java自定义日志模块实现
06-18
自定义日志模块（接口及代理实现），而不直接使用第三方日志框架接口，避免在日志框架升级或者切换时，代码过多耦合。 这个举例说明一下： 比如，在某一项目开始时使用的是“log4j”框架，后面经过研究发现“sf4j”框架功能更强大，想切换到“sf4j”。常规的做法是，修改项目中每一处调用到“log4j”相关模块的代码。如果是项目比较大，所要花费的工作量也真不少，但如果使用了上面的方式，则只需要实现“LoggerAdapter”接口，使之与具体的日志（logger）进行适配，并且（如果必要）重写或者调整LoggerAdapterFacory类即可。 注意：代码使用的是utf-8编码
学习若依框架----之----根据aop切面记录操作日志
XuDream的博客
09-07 2810
*** 自定义操作日志记录注解*/*** 模块/*** 功能/*** 操作人类别/*** 是否保存请求的参数/*** 是否保存响应的参数}
若依学习（前后端分离版）——自定义注解@Log（如何自定义注解，实现aop）
hwp_ing的博客
03-04 3407
定义了注解的相关信息。这里定义的属性可以在使用时加以定义注解@Target和@Retention的作用。
Java利用Aop切面记录操作日志（注解方式）
最新发布
m0_73774439的博客
05-20 1239
⾯向切⾯编程，它是⼀种思想，它是对某⼀类事情的 集中处理。⽽ AOP 是⼀种思想，⽽ Spring AOP 是⼀个框架，提供了⼀种对 AOP 思想的实现，它们的关系和 IoC 与 DI 类似。@Mapping/*** 操作具体某个功能的描述* @return*//*** 操作类型* @return*/@Aspect@Component@Autowired@Autowired@Autowired@Autowired// 获取request对象。
若依框架实体类增加自定义注解，自动插入创建人、时间等信息
lianyunpeng的博客
02-01 1978
该文章优化了若依框架，在新增和修改方法时，之前每次都需要手动注入基础信息。增加aop注解之后，只需要在新增和修改方法上增加注解就行。3.代码生成增加注解。
若依框架----源码分析（@Log）
03-23 3910
若依框架----源码分析（@Log）
若依logback日志配置采坑
字节叔叔
02-23 1787
推荐改成ThresholdFilter，ThresholdFilter也是基于日志事件的日志级别进行过滤的，但它只允许你指定一个阈值级别。只有达到或超过这个阈值级别的日志事件才会被允许通过过滤器。例如，如果你将阈值级别设置为WARN，那么只有WARN、ERROR和FATAL级别的日志事件才会被允许通过。若依使用的appender过滤器是level，如下述代码，这种过滤器只能导出级别为INFO的日志，warn和error都导出不出来。
若依学习——异步日志（若依的两个线程池）（LoggerFactory.getLogger(“sys-user“)）
hwp_ing的博客
03-06 4365
若依在登录的时候会使用到线程池来进行日志记录如下所示。在若依项目中配置了两个线程池，当项目启动时，线程池会初始化被spring管理。不过若依项目中只是用到了第二个线程池，后面我会讲怎么使用第一个线程池。
spring boot - 引入 logback 日志
pursue.dreams的博客
12-11 550
logback xml文件如下： <?xml version="1.0" encoding="UTF-8"?> <configuration> <!-- 日志存放路径 --> <property name="log.path" value="D:/logs" /> <!-- 日志输出格式 --> <propert...
ruoyi 框架自定义 日志输出
OOObject的博客
04-17 1523
ruoyi 框架自定义 日志输出
SSM_CRM管理系统——java
05-21
**Spring框架**是Java企业级应用开发中的基石，它提供了依赖注入（DI）和面向切面编程（AOP）等核心特性。依赖注入使得组件间的耦合度降低，提高了代码的可测试性和可维护性。SpringMVC是Spring框架的一部分，专注于...
Spring Boot Aspect 切面 AOP 拦截器 Interceptor 监控control请求耗时
03-13
在Spring Boot应用中，面向切面编程（AOP）是一种强大的设计模式，它允许我们以声明式的方式插入代码，比如日志记录、事务管理或权限检查。Aspect是AOP的核心概念，它封装了关注点，使得我们可以将这些关注点与业务...
新闻管理系统-Struts 2+Spring 3+Hibernate框架技术精讲与整合案例
12-07
Spring框架则是一个全面的企业级应用框架，它提供依赖注入（DI）和面向切面编程（AOP）等特性。在本案例中，Spring 3可能被用来管理Bean的生命周期，包括新闻实体类、DAO接口及其实现、Service接口及其实现等。...
Java实现AOP面向切面编程的实例教程
09-02
AOP的核心思想是将系统中的横切关注点，如日志记录、事务管理、权限检查等，从业务逻辑中分离出来，以提高代码的可读性和可维护性。在Spring框架中，AOP的实现主要依赖于JDK动态代理和CGLIB字节码增强。 在Java中，...
基于ssm+jsp的龙腾公司员工信息管理系统源码数据库.zip
03-12
本系统——基于SSM+JSP的龙腾公司员工信息管理系统，正是这样一款高效、实用的工具，它集成了Spring、SpringMVC、MyBatis三大框架，结合了Java后端技术和JSP前端展示，旨在为企业提供全面、精准的员工信息管理解决...
java web实训项目：基于SSM的学生成绩管理系统.zip
09-10
《基于SSM的学生成绩管理系统——Java Web实训详解》 在Java Web开发领域，SSM框架（Spring、Spring MVC和MyBatis）是广泛应用于构建企业级Web应用的组合。本实训项目“基于SSM的学生成绩管理系统”正是以此为基础...
SpringUtils.getBean（）获取bean
qq_39822451的博客
07-22 1万+
private final static BeanService service = SpringUtils.getBean(BeanService.class);
ruoyi-vue版本（二十五）SpringUtils 工具类详解
一天不写代码难受的博客
06-23 427
【代码】ruoyi-vue版本（二十五）SpringUtils 工具类详解。
若依框架-遇到的相关问题-（持续更新中 建议收藏）
热门推荐
一茗道人 ~~ ~ 阿亮-的博客
05-24 2万+
一、项目启动相关问题 二、新建子模块相关问题 三、权限相关问题 四、任务调度相关问题（定时任务） 五、前后端访问问题（api/Controller访问） 六、工具类相关问题
java自定义注解 aop切面
06-03
好的，您的问题是关于Java自定义注解和AOP切面的。那么我来分别解释一下。 Java自定义注解是一种元数据，它可以被应用于类、方法、字段等Java程序元素上。它们可以提供额外的信息或标记，以便其他程序可以读取和使用它们。自定义注解可以用于许多场合，如配置、文档生成、日志跟踪等等。 而AOP（面向切面编程）是一种编程范式，它可以在程序运行时动态地将代码切入到类的方法中。AOP可以帮助我们解决诸如日志记录、事务管理、性能统计等通用的问题，从而提高代码的可维护性和可重用性。 在Java中，我们可以使用自定义注解和AOP结合起来，以便实现更加灵活和可控的代码切入。我们可以在自定义注解中定义一些切入点，然后将AOP切面与这些切入点关联起来，从而实现对代码的切入和拦截。 总之，Java自定义注解和AOP切面都是非常有用的工具，它们可以帮助我们更好地组织和管理代码，提高代码的可维护性和可重用性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Liu_Shihao

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值