接口操作日志切面

已于 2024-03-29 09:18:06 修改
阅读量287 收藏 4
点赞数 5
文章标签： java
于 2024-03-29 09:16:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014525726/article/details/137131674
版权

1、AOP切面

/**
 * @Author wyq
 * @Description 操作的日志记录切面
 * @Date 2024/2/21 11:46
 **/
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
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.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpMethod;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

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

@Component
@Aspect
@Slf4j
public class MyOperateLogAspect {



    @Autowired
    HttpServletRequest httpServletRequest;

    /**
     * 操作日志记录
     */
    @Autowired
    private MyOperatorLogBiz operatorLogBiz;

    /**
     * 声明切面
     * 只要Controller的方法中有@log注解就切入 重要
     */
    @Pointcut("@annotation(annotation.MyOpreatorLog)")
    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 {
            // 获得注解
            MyOpreatorLog opreatorLog = getAnnotationLog(joinPoint);
            if (opreatorLog == null) {
                return;
            }
            // 获取当前的用户
            MyOperatorLogEntity logEntity = MyOperatorLogEntity.builder()
                    .requestType(httpServletRequest.getMethod())
                    .requestUrl(httpServletRequest.getRequestURI())
                    .build();
            //设置异常信息
            if(e == null){
                //当不需要记录返回结果时，设值为空串  add-2023/09/12
                logEntity.setRequestResult(opreatorLog.isSaveResultData()? JSON.toJSONString(jsonResult) : "-");
                logEntity.setLogLevel(LogLevelConstants.LOG_LEVEL_INFO);
            }else{
                //记录错误原因，根据日志记录的时间戳，通过ELK查看报错详情
                logEntity.setRequestResult(e.getMessage());
                logEntity.setLogLevel(LogLevelConstants.LOG_LEVEL_ERROR);
            }
            //设置当前登录人信息
            logEntity.setCrtTime(new Date());
            logEntity.setCrtName("登录人名称");
            logEntity.setCrtUser("登录人id");
            logEntity.setCrtJobNo("登录人工号");
            //处理设置注解上的参数
            getControllerMethodDescription(joinPoint, opreatorLog, logEntity);
            //保存您的日志数据到数据库(1.0使用openFeign，2.0使用restTemplate调用日志服务爆粗你接口)
            operatorLogBiz.addRecord(logEntity);
        } catch (Exception exp) {
            // 记录本地异常日志
            log.error("==前置通知异常==");
            log.error("异常信息:{}", exp.getMessage());
            exp.printStackTrace();
        }
    }

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

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

    /**
     * 获取注解中对方法的描述信息 用于Controller层注解
     *
     * @param opreatorLog     日志
     * @param logEntity 操作日志
     * @throws Exception
     */
    public void getControllerMethodDescription(JoinPoint joinPoint, MyOpreatorLog opreatorLog, MyOperatorLogEntity logEntity) throws Exception {
        // 设置action动作
        logEntity.setOperatorType(String.valueOf(opreatorLog.operatorType()));
        // 设置菜单名称
        logEntity.setMenuName(opreatorLog.menuName());
        // 是否需要保存request，参数和值
        if (opreatorLog.isSaveRequestData()) {
            // 获取参数的信息，传入到数据库中。
            setRequestValue(joinPoint, logEntity);
        }
    }

    /**
     * 获取请求的参数，放到log中
     *
     * @param logEntity 操作日志
     * @throws Exception 异常
     */
    private void setRequestValue(JoinPoint joinPoint, MyOperatorLogEntity logEntity) throws Exception {
        String requestMethod = logEntity.getRequestType();
        if (HttpMethod.PUT.name().equals(requestMethod) || HttpMethod.POST.name().equals(requestMethod)) {
            String params = argsArrayToString(joinPoint.getArgs());
            logEntity.setRequestParam(StringUtils.substring(params, 0, 2000));
        } else {
            Map<String, String[]> parameterMap = httpServletRequest.getParameterMap();
            logEntity.setRequestParam(StringUtils.substring(JSON.toJSONString(parameterMap), 0, 2000));
        }
    }


    /**
     * 参数拼装
     */
    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。
     */
    public boolean isFilterObject(final Object o) {
        return o instanceof MultipartFile || o instanceof HttpServletRequest
                || o instanceof HttpServletResponse;
    }

}

2、切入点

/**
 * @Author wyq
 * @Description
 * @Date 2024/2/21 11:43
 **/
import java.lang.annotation.*;

/**
 * 日志管理 -- 操作日志注解
 */
@Documented
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyOpreatorLog {

    /**
     * 菜单路径
     */
    String menuName() default  "";


    /**
     * 操作类型
     */
    OperatorTypeConstant operatorType();

    /**
     * 是否保存请求数据
     */
    boolean isSaveRequestData() default true;

    /**
     * 是否保存返回结果,默认true add-2023/09/12
     */
    boolean isSaveResultData() default true;
}

3、日志级别及操作类型

/**
 * @Author wyq
 * @Description 操作日志等级分类
 * @Date 2024/2/21 12:00
 **/
public interface LogLevelConstants {

    String LOG_LEVEL_INFO = "INFO";

    String LOG_LEVEL_WARN = "WARN";
    String LOG_LEVEL_ERROR = "ERROR";
}


/**
 * @Author wyq
 * @Description 操作类型定制类
 * @Date 2024/2/21 11:44
 **/
public enum OperatorTypeConstant {

    SELECT("SELECT","查询"),
    ADD("ADD","新增"),
    EDIT("EDIT","修改"),
    DELETE("DELETE","删除"),
    IMPORT("IMPORT","导入"),
    EXPORT("EXPORT","导出"),
    COUNT("COUNT","统计");

    //操作标识
    private String mark;

    //操作名称
    private String name;

    OperatorTypeConstant(String mark,String name){
        this.mark = mark;
        this.name = name;
    }

    public String getName(){
        return name;
    }

    public String getMark(){
        return mark;
    }
}

4、存储实体

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="MyOperatorLogMapper">

	<!-- 可根据自己的需求，是否要使用 -->
    <resultMap type="MyOperatorLogEntity" id="myTransportCostOperatorLogMap">
        <result property="id" column="id"/>
        <result property="operatorType" column="operator_type"/>
        <result property="logLevel" column="log_level"/>
        <result property="menuName" column="menu_name"/>
        <result property="requestUrl" column="request_url"/>
        <result property="requestType" column="request_type"/>
        <result property="requestParam" column="request_param"/>
        <result property="requestResult" column="request_result"/>
        <result property="crtTime" column="crt_time"/>
        <result property="crtUser" column="crt_user"/>
        <result property="crtName" column="crt_name"/>
        <result property="crtJobNo" column="crt_job_no"/>
        <result property="crtHost" column="crt_host"/>
        <result property="status" column="status"/>
    </resultMap>
    <sql id="Base_Column_List">
        id, operator_type, log_level, menu_name, request_url, request_type, request_param, request_result, crt_time, crt_user, crt_name, crt_job_no, crt_host, status
    </sql>
</mapper>



import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.Table;
import java.io.Serializable;
import java.util.Date;


/**
 * 日志管理--操作日志
 *
 * @author wyq
 * @email 473664742@qq.com
 * @date 2022-09-16 18:42:12
 */
@Table(name = "my_operator_log")
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class MyOperatorLogEntity implements Serializable {
    private static final long serialVersionUID = 1L;

    /**
     * 主键
     */
    @Id
    private String id;

    /**
     * 菜单名称
     */
    @Column(name = "menu_name")
    private String menuName;

    /**
     * 操作类型
     */
    @Column(name = "operator_type")
    private String operatorType;

    /**
     * 日志类型（INFO、WARN、ERROR）
     */
    @Column(name = "log_level")
    private String logLevel;

    /**
     * 请求url
     */
    @Column(name = "request_url")
    private String requestUrl;

    /**
     * 请求类型(GET、POST、PUT、DELETE)
     */
    @Column(name = "request_type")
    private String requestType;

    /**
     * 请求参数
     */
    @Column(name = "request_param")
    private String requestParam;

    /**
     * 请求结果（SUCCESS、FAIL）
     */
    @Column(name = "request_result")
    private String requestResult;

    /**
     * 创建时间
     */
    @Column(name = "crt_time")
    private Date crtTime;

    /**
     * 创建人
     */
    @Column(name = "crt_user")
    private String crtUser;

    /**
     * 创建人
     */
    @Column(name = "crt_name")
    private String crtName;

    /**
     * 创建工号
     */
    @Column(name = "crt_job_no")
    private String crtJobNo;

    /**
     * Mac/IP
     */
    @Column(name = "crt_host")
    private String crtHost;

    /**
     * 1：有效  -1：删除
     */
    @Column(name = "status")
    private Integer status;



}

5、引用方式
@MyOpreatorLog(menuName = “日志管理-操作日志-列表查询”,operatorType = OperatorTypeConstant.SELECT)

说明：

  • 支持附件类型的请求，但不存储附件内容，仅存储参数
  • menuName 可以接入到自己的权限系统通过url比较获取，没有权限的话，自己手写
会飞的鱼1993
关注
日志记录（使用切面方式记录）
12-22
spring日志记录（使用切面方式记录） 1. 创建pojo类 @Data @Table(name = "tb_operate_record") public class OperateRecord { @Id private String id; //记录请求时间 @Column(name = "record_time") private Date recordTime; //操作者 private String username; //请求IP @Column(name = "request_ip") priv
写个日志请求切面，前后端甩锅更方便
Java笔记虾
03-13 468
译者：何甜甜在吗juejin.im/post/5e69d5b5e51d45183840b351最近项目进入联调阶段，服务层的接口需要和协议层进行交互，协...
Spring Boot中的日志切面实现
最新发布
Time的博客
10-06 1611
Spring AOP 是一个面向切面的编程（AOP）框架，它允许开发者将横切关注点（如日志记录、事务管理等）与业务逻辑分离。通过使用 Spring AOP，我们可以在不修改业务代码的情况下，为应用程序添加日志记录功能。
使用AOP切面实现日志记录功能
心态的博客
10-26 4958
说到AOP大家都可以想到他是面向切面的编程，它通过将横切关注点（例如日志记录、事务管理、权限控制等）从主要业务逻辑中分离出来，以模块化的方式进行管理。在AOP中，通过定义切面（Aspect）来捕获和处理横切关注点，然后将其应用于特定的目标对象或方法。官方的解释有点抽象，我们举个例子说明：假设我们需要在多个方法中添加日志记录功能。传统的方式是在每个方法中都添加日志代码，但这样会导致代码重复，并且当我们需要修改日志记录逻辑时，需要逐个修改所有方法。
利用注解式切面单独打印接口调用日志
chenzeyuczy的专栏
03-22 1191
背景：我们可能希望对项目中的接口性能进行监控，例如：接口调用时间，开始时间，结束时间，传入的参数等等，通常的做法是在接口代码开始处记录startTime，结尾处记录endTime，然后计算startTime和endTime之差，这种做法无法把这部分日志单独拆分成文件，而且冗余代码会比较多。可以考虑使用spring切面和环绕通知来打印这部分日志，并使用log4j2将这部分日志单独拆分出来。ps:拆分...
切面打日志
dainandainan1的博客
10-26 170
@Slf4j @Aspect @Component public class LogAspect { @Pointcut("execution(* com.sankuai.credit.caselibrary.server.service.impl.*.*(..))") private void service() { } @Around("service()||@annotation(com.sankuai.credit.caselibrary.server.aop..
【Java日志系列实践2】AOP切面实现业务日志
我的技术日常
04-05 5087
1 业务日志的标准 业务日志，也叫操作日志。主要功能： 记录用户行为，方便业务数据回溯与统计。 1.1 操作日志记录内容 操作日志记录主要内容：用户是谁，在什么时间，对什么数据，做了什么样的更改。 逻辑中必须增加业务日志的位置： （1）业务数据的变更处（新增、修改、删除） （2）特别分支条件、边界条件处。 1.2 业务常见的日志记录形式 ● 动态的文本记录，比如：2022-03-12 10:00 订单创建，创建用户“小新”，订单号：NO.123456 ”。 ● 修改类型的文本，包含修改前和修改后的
springBoot+aop+自定义注解+本地线程实现统一接口日志及接口响应时长
02-01
核心原理：通过自定义注解实现每个接口的描述及所在模块还有接口的操作类型，通过拦截器及访问方法后的切面aop记录接口的总耗时，在接口请求前在本地线程记录请求的参数，接口请求后记录返回参数及记录请求日志 ...
Java项目 日志框架+切面，完美记录
cat_book_milk的博客
07-22 1284
Java Spring Boot项目搭建日志框架，创建日志切面，方便追溯
springboot切面添加日志功能实例详解
08-25
最后，当用户访问任何一个接口时，我们的切面会自动捕获这个事件并记录日志。如果使用`@Before`注解，可以在方法执行前记录访问信息；如果使用`@AfterReturning`和`@AfterThrowing`，则分别在方法正常返回和抛出异常...
若依管理系统——自定义注解使用切面记录操作日志
DreamsArchitects的博客
09-28 4986
目录一、介绍二、登录日志记录分析2.1 异步定时任务管理器（线程池）2.2 异步工厂（产生任务用）三、用户操作行为记录分析3.1 定义注解3.2 定义切面3.3 使用注解四、源码SQL 一、介绍 系统访问记录表： 操作日志记录表： 二、登录日志记录分析 2.1 异步定时任务管理器（线程池） 无论登录成功还是失败，都会用一个异步的任务AsyncManager.me().execute()来保存登录结果： 通过SpringUtils工具类的getBean方法获得定时任务线程池对象，(也可以通过@Auto
Spring AOP日志切面
06-28
结合logback和切面对参数名和参数值，方法运行时间，方法返回值记录日志，pom中需要添加ogback和切面依赖。
springboot使用切面记录接口访问日志
擎云科技的博客
09-07 661
springboot使用切面记录接口访问日志
Spring Aop - 切面日志
空明的博客
05-09 531
SpringAop 切面日志
用切面来做日志记录器
炫的博客
07-18 408
@Aspect @Component @Slf4j public class UserLoginLogAspect { @Autowired UserLoginLogMapper userLoginLogMapper; @Resource(name = &quot;basicRedisTemplate&quot;) RedisTemplate redisTemplate; ...
AOP切面日志
java_highly的博客
12-11 186
package com.vivo.finance.vivopay.core.aop; /** 该切面主要是打印日志，需要注意一下几点 1.打印的方法为com.vivo.finance.member.core.facade 目录下添加@com.vivo.finance.member.core.common.NeedLogInAndOut 的 方法才能进入打印 2.提供过滤加密打印，需要在加密的字...
AOP记录接口交易记录
lhxinbobo的博客
01-11 3317
做了一个新项目，与周边系统交互比较多，随之而来的一个问题，就是当交互异常的时候不是很好分析具体原因。每次都需要去服务器拉去日志，然后分析。影响工作效率，因此考虑把部分关键接口的交易报文存储到一张表中，这样每次都可以直接去数据库查询。实现思路如下： 1.最简单的做法可能是在接口入口处获取下请求报文，请求时间等等，在出口处获取下响应报文，响应时间等等，然后保存下数据库。这样带来的一个弊端就是，记录日
Spring使用AOP的方式配合注解完成接口操作日志记录
Johnson_7的博客
12-14 459
Spring使用AOP的方式配合注解完成接口操作日志记录
Aop切面记录日志
mws666的博客
01-07 259
运用Aop的特性对访问接口的进行记录打印输出，分别记录用户的名称，访问功能，请求参数，请求Url,请求IP，请求结果，返回参数 package com.vimochina.vimo.config; import cn.hutool.json.JSONUtil; import eu.bitwalker.useragentutils.UserAgent; import io.jsonwebtok...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值