AOP实现记录用户操作日志

最新推荐文章于 2024-08-09 00:36:50 发布
最新推荐文章于 2024-08-09 00:36:50 发布
阅读量3.4k 收藏 17
点赞数 5
分类专栏： springboot AOP 文章标签： aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fangchao2011/article/details/115319792
版权

1、依赖

        <!-- fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.11</version>
        </dependency>
		<!-- AOP切面 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

2、自定义切入点枚举类

OperaLog.java

import java.lang.annotation.*;

/**
 * 自定义操作日志注解
 */
@Target(ElementType.METHOD) //注解放置的目标位置,METHOD是可注解在方法级别上
@Retention(RetentionPolicy.RUNTIME) //注解在哪个阶段执行
@Documented
public @interface OperaLog {

    String operaModule() default ""; // 操作模块
    String operaType() default "";  // 操作类型
    String operaDesc() default "";  // 操作说明
}

3、日志记录表、错误日志表

OperationLog.java


import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import java.io.Serializable;
import java.util.Date;

import com.dj.core.bean.EnumModel;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

/**
 * <p>
 * 请求日志表
 * </p>
 *
 * @author jack
 * @since 2020-12-24
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("tb_operation_log")
public class OperationLog extends Model<OperationLog> {

    private static final long serialVersionUID = 1L;

    /**
     * 主键
     */
    @TableId(value = "oper_id", type = IdType.AUTO)
    private Long operId;

    /**
     * 功能模块
     */
    private String operModul;

    /**
     * 操作类型
     */
    private Integer operType;

    /**
     * 操作描述
     */
    private String operDesc;

    /**
     * 请求参数
     */
    private String operRequParam;

    /**
     * 返回参数
     */
    private String operRespParam;

    /**
     * 操作人ID
     */
    private Integer operUserId;

    /**
     * 操作人姓名
     */
    private String operUserName;

    /**
     * 操作方法
     */
    private String operMethod;

    /**
     * 请求URI
     */
    private String operUri;

    /**
     * 请求IP
     */
    private String operIp;

    /**
     * 版本
     */
    private String operVer;

    /**
     * 操作时间
     */
    private Date operCreateTime;


    @Override
    protected Serializable pkVal() {
        return this.operId;
    }

    /**
     * 操作类型（1-系统登录 2-内容管理）
     */
    public enum OperType implements EnumModel {
        login(1, "系统登录"), content(2, "内容管理");
        private Integer value; // 值
        private String text; // 文本

        private OperType(Integer value, String text) {
            this.value = value;
            this.text = text;
        }

        public Integer getValue() {
            return value;
        }

        public String getText() {
            return text;
        }
    }

}

ExceptionLog.java

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import java.io.Serializable;
import java.util.Date;

import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

/**
 * <p>
 * 请求错误日志表
 * </p>
 *
 * @author jack
 * @since 2020-12-24
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("tb_exception_log")
public class ExceptionLog extends Model<ExceptionLog> {

    private static final long serialVersionUID = 1L;

    /**
     * 主键
     */
    @TableId(value = "exc_id", type = IdType.AUTO)
    private Long excId;

    /**
     * 请求参数
     */
    private String excRequParam;

    /**
     * 异常名称
     */
    private String excName;

    /**
     * 异常信息
     */
    private String excMessage;

    /**
     * 操作人ID
     */
    private Integer operUserId;

    /**
     * 操作人姓名
     */
    private String operUserName;

    /**
     * 操作方法
     */
    private String operMethod;

    /**
     * 请求URI
     */
    private String operUri;

    /**
     * 请求IP
     */
    private String operIp;

    /**
     * 版本
     */
    private String operVer;

    /**
     * 操作时间
     */
    private Date operCreateTime;


    @Override
    protected Serializable pkVal() {
        return this.excId;
    }

}

枚举类：EnumModel .java

/**
 * @Description: 枚举模型
 * @author Dreamji
 * @date 2017年11月10日 下午8:13:16
 */
public interface EnumModel {

	// 获取值
	public Integer getValue();

	// 获取文本
	public String getText();
}

4、定义操作日志切面

备注：operationLogService、exceptionLogService 实现类在此省略。

OperaLogAspect.java

import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
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.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;


/**
 * @program: bike-lease
 * @description: AOP日志
 * @author: Jack.Fang
 * @date:2020-12-22 1104
 **/
@Aspect
@Component
@Slf4j
public class OperaLogAspect {

    /**
     * 操作版本号
     * <p>
     * 项目启动时从命令行传入，例如：java -jar xxx.war --version=201902
     * </p>
     */
    @Value("${version}")
    private String operVer;

    @Autowired
    private OperationLogService operationLogService;

    @Autowired
    private ExceptionLogService exceptionLogService;

    public UserContext getUserContext() {
        return UserContext.getCurrentContext();
    }

    /**
     * 设置操作日志切入点 记录操作日志 在注解的位置切入代码
     */
    @Pointcut("@annotation(com.dj.yier.aop.OperaLog) || execution(* com.dj.admin.controller.AdminLoginController.doLogin(..)))")
    public void operLogPoinCut() {
    }

    /**
     * 设置操作异常切入点记录异常日志 扫描所有controller包下操作
     */
    @Pointcut("execution(public * com.dj.*.controller.*.*(..))")
    public void operExceptionLogPoinCut() {
    }

    /**
     * 正常返回通知，拦截用户操作日志，连接点正常执行完成后执行， 如果连接点抛出异常，则不会执行
     *
     * @param joinPoint 切入点
     * @param keys      返回结果
     */
    @AfterReturning(value = "operLogPoinCut()", returning = "keys")
    public void saveOperLog(JoinPoint joinPoint, Object keys) {
        // 获取RequestAttributes
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        // 从获取RequestAttributes中获取HttpServletRequest的信息
        HttpServletRequest request = (HttpServletRequest) requestAttributes
                .resolveReference(RequestAttributes.REFERENCE_REQUEST);

        OperationLog operlog = new OperationLog();
        try {
            // 从切面织入点处通过反射机制获取织入点处的方法
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            // 获取切入点所在的方法
            Method method = signature.getMethod();
            // 获取操作
            OperaLog opLog = method.getAnnotation(OperaLog.class);
            if (opLog != null) {
                String operModul = opLog.operaModule();
                String operDesc = opLog.operaDesc();
                operlog.setOperModul(operModul); // 操作模块
                operlog.setOperType(OperationLog.OperType.content.getValue()); // 操作类型：2-内容管理
                operlog.setOperDesc(operDesc); // 操作描述
            }
            // 请求的参数
            Map<String, String> rtnMap = converMap(request.getParameterMap());
            // 将参数所在的数组转换成json
            String params = JSON.toJSONString(rtnMap);

            // 获取请求的类名
            String className = joinPoint.getTarget().getClass().getName();
            boolean isH5 = false;
            if("com.dj.yier.controller.h5.H5DealCardController".equals(className)){
                //核销页
                isH5 = true;
            }
            // 获取请求的方法名
            String methodName = method.getName();
            if(methodName.equals("doLogin")){
                //登录模块
                operlog.setOperModul("系统登录"); // 操作模块
                operlog.setOperType(OperationLog.OperType.login.getValue()); // 操作类型：1-系统登录
                operlog.setOperDesc("用户系统登录"); // 操作描述
            }else {
                operlog.setOperRequParam(params); // 请求参数
            }
            operlog.setOperMethod(className + "." + methodName); // 请求方法
            UserContext userContext = getUserContext();
            String respParam = JSON.toJSONString(keys);
            if(respParam.length()>1000){//防止过长
                respParam = respParam.substring(0,1000);
            }
            operlog.setOperRespParam(respParam); // 返回结果
            operlog.setOperUserId(isH5?999:userContext.getUserId()); // 请求用户ID
            operlog.setOperUserName(isH5?"核销用户":userContext.getUserName()); // 请求用户名称
            operlog.setOperIp(getIpAddress(request)); // 请求IP
            operlog.setOperUri(request.getRequestURI()); // 请求URI
            operlog.setOperCreateTime(new Date()); // 创建时间
            operlog.setOperVer(operVer); // 操作版本
            operationLogService.save(operlog);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 异常返回通知，用于拦截异常日志信息 连接点抛出异常后执行
     *
     * @param joinPoint 切入点
     * @param e         异常信息
     */
    @AfterThrowing(pointcut = "operExceptionLogPoinCut()", throwing = "e")
    public void saveExceptionLog(JoinPoint joinPoint, Throwable e) {
        // 获取RequestAttributes
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        // 从获取RequestAttributes中获取HttpServletRequest的信息
        HttpServletRequest request = (HttpServletRequest) requestAttributes
                .resolveReference(RequestAttributes.REFERENCE_REQUEST);

        ExceptionLog excepLog = new ExceptionLog();
        try {
            // 从切面织入点处通过反射机制获取织入点处的方法
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            // 获取切入点所在的方法
            Method method = signature.getMethod();
            // 获取请求的类名
            String className = joinPoint.getTarget().getClass().getName();
            // 获取请求的方法名
            String methodName = method.getName();
            methodName = className + "." + methodName;
            // 请求的参数
            Map<String, String> rtnMap = converMap(request.getParameterMap());
            // 将参数所在的数组转换成json
            String params = JSON.toJSONString(rtnMap);
            UserContext userContext = getUserContext();
            excepLog.setExcRequParam(params); // 请求参数
            excepLog.setOperMethod(methodName); // 请求方法名
            excepLog.setExcName(e.getClass().getName()); // 异常名称
            excepLog.setExcMessage(stackTraceToString(e.getClass().getName(), e.getMessage(), e.getStackTrace())); // 异常信息
            excepLog.setOperUserId(userContext.getUserId()); // 操作员ID
            excepLog.setOperUserName(userContext.getUserName()); // 操作员名称
            excepLog.setOperUri(request.getRequestURI()); // 操作URI
            excepLog.setOperIp(getIpAddress(request)); // 操作员IP
            excepLog.setOperVer(operVer); // 操作版本号
            excepLog.setOperCreateTime(new Date()); // 发生异常时间
            exceptionLogService.save(excepLog);

        } catch (Exception e2) {
            e2.printStackTrace();
        }

    }

    /**
     * 转换request 请求参数
     *
     * @param paramMap request获取的参数数组
     */
    public Map<String, String> converMap(Map<String, String[]> paramMap) {
        Map<String, String> rtnMap = new HashMap<String, String>();
        for (String key : paramMap.keySet()) {
            rtnMap.put(key, paramMap.get(key)[0]);
        }
        return rtnMap;
    }

    /**
     * 转换异常信息为字符串
     *
     * @param exceptionName    异常名称
     * @param exceptionMessage 异常信息
     * @param elements         堆栈信息
     */
    public String stackTraceToString(String exceptionName, String exceptionMessage, StackTraceElement[] elements) {
        StringBuffer strbuff = new StringBuffer();
        for (StackTraceElement stet : elements) {
            strbuff.append(stet + "\n");
        }
        String message = exceptionName + ":" + exceptionMessage + "\n\t" + strbuff.toString();
        return message;
    }

    public static String getIpAddress(HttpServletRequest request) {
        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_CLIENT_IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_X_FORWARDED_FOR");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        return ip;
    }
}

5、在需要记录日志的Controller方法上打上@OperaLog注解

@OperaLog(operaModule="审批管理",operaType="查询",operaDesc="查询审批列表")
    @RequestMapping("/index")
    public ModelAndView index(HttpServletRequest request, HttpServletResponse response, MakeOrder info) {
        Page<MakeOrder> page = new Page<>(request);
        page = makeOrderService.getMakeOrderPage(page, info);
        return mav("admin/approval/index").addObject(Page.PAGE_KEY, page).addObject("info", info);
    }

大功告成。

在这里插入图片描述

Jack方
关注
专栏目录
博客3 Aop使用、缓存优化 别的优化、总结
QAQ
08-24 459
1、AOP使用 (1)定义一个注解： //Type 代表可以放在类上面 Method 代表可以放在方法上 @Target({ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface LogAnnotation { String module() default ""; String operator() default ""; } 然后再Controller加注解就行 然后
java 用户操作日志_SpringBoot+AOP实现用户操作日志的记录
weixin_35207054的博客
02-15 1597
前言：任何一个项目都会有一个用户操作日志(也叫行为日志)的模块，它主要用来记录某个用户做了某个操作，当出现操作失败时，通过日志就可以快速的查找是哪个用户在哪个模块出现了错误，以便于开发人员快速定位问题所在。实现这一功能一般有两种方法：第一种就是很传统的做法，就是在每个模块进行插入日志的操作(不推荐)，这种做法虽然实现了记录用户的操作，但很繁琐而且基本上是重复的工作。第二种就是使用Spring的AO...
SpringBoot中使用AOP实现日志记录功能
customer08的博客
05-20 1385
日志记录在软件开发中是极其重要的，能够帮助开发人员快速定位问题、监控系统性能、提高系统安全性、跟踪业务流程等，是保障系统稳定运行和快速问题排查的重要手段
基于自定义注解与 Spring AOP 的通用日志记录实现
最新发布
天天的博客
08-09 954
在软件开发中，针对用户操作日志的记录是一个普遍且重要的需求，旨在跟踪用户行为、保障系统安全及进行后续的问题追踪与性能分析。传统上，若在每次方法调用时都手动构造日志实体并同步插入数据库，不仅会导致代码冗余且难以维护，还会因同步操作而拖慢系统性能。为了优化这一流程, 可以使用自定义注解和aop的方式进行对日志的记录, 能动态记录指定记录的参数, 如请求参数, 响应参数, 操作时间, 操作用户的用户名, 方法耗时等等, 可以灵活拓展，而无需在每个业务逻辑点中显式编写日志代码。
使用 SpringBoot AOP 记录操作日志、异常日志
ITMuch的专栏
10-05 424
点击上方IT牧场，选择置顶或者星标技术干货每日送达来源：cnblogs.com/wm-dv/p/11735828.html一、创建日志记录表、异常日志表，表结构如下：二、添加Ma...
使用Spring Boot AOP实现日志记录
一名想当程序员的人
07-30 3934
1.1 什么是AOPAOP（Aspect Oriented Programming），面向切面思想，是Spring的三大核心思想之一（两外两个：IOC-控制反转、DI-依赖注入）。那么AOP为何那么重要呢？在我们的程序中，经常存在一些系统性的需求，比如权限校验、日志记录、统计等，这些代码会散落穿插在各个业务逻辑中，例如下面这个示意图：有多少业务操作，就要写多少重复的校验和日志记录代码，这显然是无法接受的。
在SpringBoot中用SpringAOP实现日志记录功能
weixin_30485379的博客
07-28 325
背景： 我需要在一个SpringBoot的项目中的每个controller加入一个日志记录，记录关于请求的一些信息。 代码类似于: 　　logger.info(request.getRequestUrl()); 之类的。 代码不难，但由于Controller的数量不少，干起来也是体力活。所以想到了用Spring AOP来解决这个问题。 首先，在pom中加入SpringA...
自定义注解+Spring AOP实现记录用户操作日志-附件资源
03-02
自定义注解+Spring AOP实现记录用户操作日志-附件资源
利用spring AOP记录用户操作日志的方法示例
08-30
1. 使用 Spring AOP 记录用户操作日志： Spring AOP 可以帮助开发者实现记录用户操作日志的功能。通过使用 Aspect 来记录用户的操作日志，可以帮助开发者更好地了解用户的行为，提高系统的安全性和可靠性。 2. 使用...
SystemLog:Spring AOP实现记录系统操作日志
03-11
**Spring AOP 实现系统操作日志记录** 在软件开发中，系统操作日志记录是一项重要的功能，它有助于追踪和调试应用程序的运行过程，尤其是在大型系统中，日志记录能够提供关键信息，帮助开发者理解系统行为，定位...
AOP日志记录
Mr_25kjiang的博客
11-02 419
AOP日志 AOP日志就是简单记录一些用户执行的过程 导入依赖包 &lt;dependency&gt; &lt;groupId&gt;org.aspectj&lt;/groupId&gt; &lt;artifactId&gt;aspectjweaver&lt;/artifactId&gt; &lt;/dependency&gt;...
详解基于SpringBoot使用AOP技术实现操作日志管理
08-25
主要介绍了详解基于SpringBoot使用AOP技术实现操作日志管理，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
AOP的例子 记录日志
07-04
切面编程的例子，采用spring，可以在方法执行的前中后进行跟踪
spring aop 操作日志
06-04
本资源用来展示如何使用 spring aop 进行日志记录，例子里面通过aop的配置，把产生的日志存放到当前项目的根目录下，而且对方法执行过程中的参数进行了记录，对于aop如何记录日志不清楚的同学可以看看。
AOP记录操作日志
weixin_48878207的博客
04-22 3362
使用spring的aop结合自定义注解实现操作日志的记录 首先引入依赖 <!--aop--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> <!--json-
springboot使用aop记录接口操作日志
weixin_43241706的博客
12-23 542
国际管理，添加依赖 我们先自定义一个注解，有关自定义注解的说明可自行百度。 @Target({ ElementType.PARAMETER, ElementType.METHOD }) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Log { /** * 模块 */ String title() default ""; /** * 功能 */ .
Springboot使用aop技术（记录操作日志）
KeepStruggling的博客
05-16 1460
1. 前言         有一段时间没有使用面向切面编程（aop），有点生疏。恰好项目有在执行方法前后需要预处理和返回处理的需求，所以打算借机重拾起来。由于保密的原因，加上aop的原理大同小异，我还是从万年不变的日志记录开始aop的复习吧~ 2. 准备工作 2.1.表格创建 2.1.1操作日志表 CREATE TABLE `operation_log` ( `id` int(11) NOT NULL AUTO_INCREM
Java实战：Spring Boot实现AOP记录操作日志
oandy0的博客
02-22 2810
本文将详细介绍如何在Spring Boot应用程序中使用Aspect Oriented Programming（AOP）来实现记录操作日志的功能
【Springboot】基于AOP实现操作日志记录
ASL2915的博客
07-02 1596
基于AOP实现springboot项目中中的操作日志记录功能
SpringMVC自定义注解：AOP实现业务操作日志
本文将介绍如何在Spring MVC项目中创建一个自定义注解，利用AOP进行日志记录，以便满足客户对于业务操作日志的需求。 首先，我们需要理解需求背景。在项目接近尾声时，客户要求记录所有的业务操作日志，并包含关键...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值