使用SpringBoot/Aspect实现日志埋点

在开发过程中，可能会遇到需要记录用户操作记录的情况，这时候可以使用Spring的AOP实现日志埋点，记录用户的操作行为

实现步骤：

1.日志记录注解(使用时直接添加到需要记录的方法上)

package com.immo.jkzs.annotation;

import com.immo.jkzs.enums.OperationType;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface OperateLogAnnotation {
    String module() default "";    //模块

    String remark() default "";    //备注

    OperationType operationType() default OperationType.UNKNOWN;//操作类型
}
           

2.操作类型

package com.immo.jkzs.enums;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.Getter;

/**
 * 操作类型(enum):主要是select,insert,update,delete
 */
@AllArgsConstructor
@Getter
public enum OperationType {

    /**
     * 操作类型
     */
    UNKNOWN("unknown"),
    DELETE("delete"),
    SELECT("select"),
    UPDATE("update"),
    INSERT("insert");

    private String value;
}
           

3.定义切面类

package com.immo.jkzs.aspect;

import com.immo.jkzs.annotation.OperateLogAnnotation;
import com.immo.jkzs.common.UserInfo;
import com.immo.jkzs.entity.BaseUser;
import com.immo.jkzs.entity.OperateLog;
import com.immo.jkzs.service.IOperateLogService;
import com.immo.jkzs.service.IRedisService;
import com.immo.jkzs.util.DateUtils;
import com.immo.jkzs.util.IdUtils;
import com.immo.jkzs.util.IpAddressUtil;
import com.immo.jkzs.util.StringUtils;
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.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;

/**
 * 用户操作日志
 *
 * @author Jonathan.WQ
 */
@Aspect
@Component
public class OperationLogAspect {
    
    @Autowired
    private IOperateLogService operateLogService;

    @Pointcut("@annotation(com.immo.jkzs.annotation.OperateLogAnnotation)")
    public void pointcut() {
    }

    @Around("pointcut()")
    public Object around(ProceedingJoinPoint joinPoint) {
        Object result = null;
        //模块开始时间
        long start = System.currentTimeMillis();
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        OperateLog operateLog = new OperateLog();
        operateLog.setId(IdUtils.getInstanse().getUID());
        String className = joinPoint.getTarget().getClass().getName();
        String methodName = signature.getName();
        // 设置请求的方法名
        operateLog.setMethod(className + "." + methodName + "()");
        // 请求的方法参数值
        Object[] args = joinPoint.getArgs();
        LocalVariableTableParameterNameDiscoverer u = new LocalVariableTableParameterNameDiscoverer();
        String[] paramNames = u.getParameterNames(method);
        if (args != null && paramNames != null) {
            StringBuilder paramsBuilder = new StringBuilder();
            for (int i = 0; i < args.length; i++) {
                String paramName = paramNames[i];
                Object arg = args[i];
                //考虑到参数过长的情况，故而截取
                paramsBuilder.append(paramName).append(": ");
                String paramValue = String.valueOf(arg);
                if (paramValue.length() > 50) {
                    paramsBuilder.append(paramValue.substring(0, 50));
                } else {
                    paramsBuilder.append(paramValue);
                }
                paramsBuilder.append("...");
                if (i != args.length - 1) {
                    paramsBuilder.append("  ,");
                }
            }
            // 设置请求的方法参数名称
            operateLog.setParameter(paramsBuilder.toString());
        }
        // 获取request
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        // 设置IP地址
        operateLog.setIp(IpAddressUtil.getIpAddr(request));
        // 获取用户
        String authorization = request.getParameter("Authorization");
        if (StringUtils.isNotNull(authorization)) {
            BaseUser user = UserInfoThreadLocal.getUser();
            operateLog.setUserName(user.getName());
            operateLog.setUserId(user.getId());
        }
        //获取系统时间
        operateLog.setCreateTime(DateUtils.getCurrentDate());
        OperateLogAnnotation OperateLogAnnotation = method.getAnnotation(OperateLogAnnotation.class);
        if (OperateLogAnnotation != null) {
            // 注解上的描述
            try {
                operateLog.setModule(OperateLogAnnotation.module());
                operateLog.setRemark(OperateLogAnnotation.remark());
                operateLog.setOperationType(OperateLogAnnotation.operationType().name());
                result = joinPoint.proceed();
                long end = System.currentTimeMillis();
                //将计算好的时间保存在实体中
                operateLog.setResponseTime("" + (end - start));
                operateLog.setCommit("success");
                //保存进数据库
                operateLogService.save(operateLog);
            } catch (Throwable e) {
                operateLog.setModule(OperateLogAnnotation.module());
                long end = System.currentTimeMillis();
                operateLog.setResponseTime("" + (end - start));
                operateLog.setCommit("failed");
                operateLog.setExceptionType(e.getClass().getName());
                //保存进数据库
                operateLogService.save(operateLog);
            }
        }
        return result;
    }
}
           

4.用户操作日志

package com.immo.jkzs.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.experimental.Accessors;

import java.io.Serializable;
import java.util.Date;

/**
 * 用户操作记录表
 *
 * @author Jonathan.WQ
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
@TableName("operate_log")
public class OperateLog implements Serializable {

    private static final long serialVersionUID = 1L;


    /**
     * 主键
     */
    @TableId(value = "id", type = IdType.INPUT)
    private String id;//

    /**
     * 用户ID
     */
    @TableField("user_id")
    private String userId;


    /**
     * 用户昵称
     */
    @TableField("user_name")
    private String userName;


    /**
     * 用户类型
     */
    @TableField("user_type")
    private String userType;


    /**
     * 访问模块
     */
    @TableField("module")
    private String module;

    /**
     * 操作类型
     */
    @TableField("operation_type")
    private String operationType;


    /**
     * 备注
     */
    @TableField("remark")
    private String remark;


    /**
     * 访问方法
     */
    @TableField("method")
    private String method;


    /**
     * 访问参数
     */
    @TableField("parameter")
    private String parameter;


    /**
     * 响应时间ms
     */
    @TableField("response_time")
    private String responseTime;


    /**
     * 创建时间
     */
    @TableField("create_time")
    private Date createTime;


    /**
     * 执行结果
     */
    @TableField("commit")
    private String commit;


    /**
     * 异常类型
     */
    @TableField("exception_type")
    private String exceptionType;


    /**
     * IP地址
     */
    @TableField("ip")
    private String ip;
}
           

5.使用注解

@OperateLogAnnotation(remark = "新增意见反馈",operationType= OperationType.INSERT)
@PostMapping("/add")
public CommonResult addHandler(@RequestParam("feedBack") FeedBackDTO feedbackDTO, HttpServletRequest request) {
        return feedbackService.add(feedbackDTO, request);
}