怎么使用SpringBoot+Aop記錄用戶操作日志

這篇“怎么使用SpringBoot+Aop記錄用戶操作日志”文章的知識點大部分人都不太理解，所以小編給大家總結了以下內容，內容詳細，步驟清晰，具有一定的借鑒價值，希望大家閱讀完這篇文章能有所收獲，下面我們一起來看看這篇“怎么使用SpringBoot+Aop記錄用戶操作日志”文章吧。

1、設計用戶操作日志表: sys_oper_log

對應實體類為SysOperLog.java

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.util.Date;

/**
 * <p>
 * 操作日志記錄
 * </p>
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class SysOperLog implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(value = "id", type = IdType.AUTO)
    @ApiModelProperty("主鍵Id")
    private Integer id;

    @ApiModelProperty("模塊標題")
    private String title;

    @ApiModelProperty("參數")
    private String optParam;

    @ApiModelProperty("業務類型（0其它 1新增 2修改 3刪除）")
    private Integer businessType;

    @ApiModelProperty("路徑名稱")
    private String uri;

    @ApiModelProperty("操作狀態（0正常 1異常）")
    private Integer status;

    @ApiModelProperty("錯誤消息")
    private String errorMsg;

    @ApiModelProperty("操作時間")
    private Date operTime;
}

2、引入依賴

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>2.0.9</version>
</dependency>
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

3、自定義用戶操作日志注解

MyLog.java

import java.lang.annotation.*;

@Target({ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyLog {
    // 自定義模塊名，eg:登錄
    String title() default "";
    // 方法傳入的參數
    String optParam() default "";
    // 操作類型，eg:INSERT, UPDATE...
    BusinessType businessType() default BusinessType.OTHER;  
}

BusinessType.java — 操作類型枚舉類

public enum BusinessType {
    // 其它
    OTHER,
    // 查找
    SELECT,
    // 新增
    INSERT,
    // 修改
    UPDATE,
    // 刪除
    DELETE,
}

4、自定義用戶操作日志切面

LogAspect.java

import com.alibaba.fastjson.JSONObject;
import iot.sixiang.license.entity.SysOperLog;
import iot.sixiang.license.handler.IotLicenseException;
import iot.sixiang.license.jwt.UserUtils;
import iot.sixiang.license.service.SysOperLogService;
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.stereotype.Component;

import java.lang.reflect.Method;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

@Aspect
@Component
@Slf4j
public class LogAspect {
    /**
     * 該Service及其實現類相關代碼請自行實現，只是一個簡單的插入數據庫操作
     */
    @Autowired
    private SysOperLogService sysOperLogService;
    
	/**
     * @annotation(MyLog類的路徑) 在idea中，右鍵自定義的MyLog類-> 點擊Copy Reference
     */
    @Pointcut("@annotation(xxx.xxx.xxx.MyLog)")
    public void logPointCut() {
        log.info("------>配置織入點");
    }

    /**
     * 處理完請求后執行
     *
     * @param joinPoint 切點
     */
    @AfterReturning(pointcut = "logPointCut()")
    public void doAfterReturning(JoinPoint joinPoint) {
        handleLog(joinPoint, null);
    }

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

    private void handleLog(final JoinPoint joinPoint, final Exception e) {

        // 獲得MyLog注解
        MyLog controllerLog = getAnnotationLog(joinPoint);
        if (controllerLog == null) {
            return;
        }
        SysOperLog operLog = new SysOperLog();
        // 操作狀態（0正常 1異常）
        operLog.setStatus(0);
        // 操作時間
        operLog.setOperTime(new Date());
        if (e != null) {
            operLog.setStatus(1);
            // IotLicenseException為本系統自定義的異常類，讀者若要獲取異常信息，請根據自身情況變通
            operLog.setErrorMsg(StringUtils.substring(((IotLicenseException) e).getMsg(), 0, 2000));
        }

        // UserUtils.getUri();獲取方法上的路徑 如：/login，本文實現方法如下：
        // 1、在攔截器中 String uri = request.getRequestURI();
        // 2、用ThreadLocal存放uri，UserUtils.setUri(uri);
        // 3、UserUtils.getUri();
        String uri = UserUtils.getUri();
        operLog.setUri(uri);
        // 處理注解上的參數
        getControllerMethodDescription(joinPoint, controllerLog, operLog);
        // 保存數據庫
        sysOperLogService.addOperlog(operLog.getTitle(), operLog.getBusinessType(), operLog.getUri(), operLog.getStatus(), operLog.getOptParam(), operLog.getErrorMsg(), operLog.getOperTime());
    }

    /**
     * 是否存在注解，如果存在就獲取，不存在則返回null
     * @param joinPoint
     * @return
     */
    private MyLog getAnnotationLog(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method method = methodSignature.getMethod();
        if (method != null) {
            return method.getAnnotation(MyLog.class);
        }
        return null;
    }

    /**
     * 獲取Controller層上MyLog注解中對方法的描述信息
     * @param joinPoint 切點
     * @param myLog 自定義的注解
     * @param operLog 操作日志實體類
     */
    private void getControllerMethodDescription(JoinPoint joinPoint, MyLog myLog, SysOperLog operLog) {
        // 設置業務類型（0其它 1新增 2修改 3刪除）
        operLog.setBusinessType(myLog.businessType().ordinal());
        // 設置模塊標題，eg:登錄
        operLog.setTitle(myLog.title());
        // 對方法上的參數進行處理，處理完：userName=xxx,password=xxx
        String optParam = getAnnotationValue(joinPoint, myLog.optParam());
        operLog.setOptParam(optParam);

    }

    /**
     * 對方法上的參數進行處理
     * @param joinPoint
     * @param name
     * @return
     */
    private String getAnnotationValue(JoinPoint joinPoint, String name) {
        String paramName = name;
        // 獲取方法中所有的參數
        Map<String, Object> params = getParams(joinPoint);
        // 參數是否是動態的:#{paramName}
        if (paramName.matches("^#\\{\\D*\\}")) {
            // 獲取參數名,去掉#{ }
            paramName = paramName.replace("#{", "").replace("}", "");
            // 是否是復雜的參數類型:對象.參數名
            if (paramName.contains(".")) {
                String[] split = paramName.split("\\.");
                // 獲取方法中對象的內容
                Object object = getValue(params, split[0]);
                // 轉換為JsonObject
                JSONObject jsonObject = (JSONObject) JSONObject.toJSON(object);
                // 獲取值
                Object o = jsonObject.get(split[1]);
                return String.valueOf(o);
            } else {// 簡單的動態參數直接返回
                StringBuilder str = new StringBuilder();
                String[] paraNames = paramName.split(",");
                for (String paraName : paraNames) {
                    
                    String val = String.valueOf(getValue(params, paraName));
                    // 組裝成 userName=xxx,password=xxx,
                    str.append(paraName).append("=").append(val).append(",");
                }
                // 去掉末尾的,
                if (str.toString().endsWith(",")) {
                    String substring = str.substring(0, str.length() - 1);
                    return substring;
                } else {
                    return str.toString();
                }
            }
        }
        // 非動態參數直接返回
        return name;
    }

    /**
     * 獲取方法上的所有參數，返回Map類型, eg: 鍵："userName",值:xxx  鍵："password",值:xxx
    * @param joinPoint
     * @return
     */
    public Map<String, Object> getParams(JoinPoint joinPoint) {
        Map<String, Object> params = new HashMap<>(8);
        // 通過切點獲取方法所有參數值["zhangsan", "123456"]
        Object[] args = joinPoint.getArgs();
        // 通過切點獲取方法所有參數名 eg:["userName", "password"]
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        String[] names = signature.getParameterNames();
        for (int i = 0; i < args.length; i++) {
            params.put(names[i], args[i]);
        }
        return params;
    }

    /**
     * 從map中獲取鍵為paramName的值，不存在放回null
     * @param map
     * @param paramName
     * @return
     */
    private Object getValue(Map<String, Object> map, String paramName) {
        for (Map.Entry<String, Object> entry : map.entrySet()) {
            if (entry.getKey().equals(paramName)) {
                return entry.getValue();
            }
        }
        return null;
    }
}

5、MyLog注解的使用

@GetMapping("login")
@MyLog(title = "登錄", optParam = "#{userName},#{password}", businessType = BusinessType.OTHER)
public DataResult login(@RequestParam("userName") String userName, @RequestParam("password") String password) {
 ...
}

6、最終效果

以上就是關于“怎么使用SpringBoot+Aop記錄用戶操作日志”這篇文章的內容，相信大家都有了一定的了解，希望小編分享的內容對大家有幫助，若想了解更多相關的知識內容，請關注億速云行業資訊頻道。