SpringBoot使用AOP方式记录日志入库-世界杯8强-世界杯新闻_中国队进世界杯

SpringBoot使用AOP方式记录日志入库

admin 1753 2025-10-08 02:14:09

大概流程

先设计系统操作日志表结构，代码中实现日志实体类和mapper层,

然后自定义日志注解，提取主要属性作为注解属性，例如，操作行为：注册用户操作类型：新增；

定义日志注解的切面类，是处理日志入库的逻辑实现；最后使用注解测试效果。

以最近项目作为简单示例实现这个功能为保持代码原汁原味，将繁琐的工具类也贴上，

自己作取舍，多余就删掉，少了自己想法填，各自的系统数据结构不同，需要根据现有逻辑修改如果代码不全可以留言我来补全

项目背景

Springboot 2.5.8 tkMybatis mysql 8.X

0.导入使用到的依赖

org.springframework.boot

spring-boot-starter-aop

1.设计日志表日志实体类代码

import java.util.Date;

import javax.persistence.*;

import lombok.Getter;

import lombok.Setter;

import lombok.ToString;

@Getter

@Setter

@ToString

@Table(name = "log_user_operate")

public class LogUserOperate {

@Id

@Column(name = "id")

@GeneratedValue(generator = "JDBC")

private Integer id;

/**

* 模块标题

@Column(name = "title")

private String title;

/**

* 业务类型（0其它 1新增 2修改 3删除）

@Column(name = "business_type")

private Integer businessType;

/**

* 方法名称

@Column(name = "`method`")

private String method;

/**

* 操作人

@Column(name = "operate_user")

private String operateUser;

/**

* 操作人姓名

@Column(name = "operate_name")

private String operateName;

/**

* 部门名称

@Column(name = "dept_name")

private String deptName;

/**

* 操作时间

@Column(name = "operate_time")

private Date operateTime;

/**

* 请求URL

@Column(name = "oper_url")

private String operUrl;

/**

* 主机地址

@Column(name = "oper_ip")

private String operIp;

/**

* 请求方式

@Column(name = "request_method")

private String requestMethod;

/**

* 请求参数

@Column(name = "oper_param")

private String operParam;

/**

* 返回结果

@Column(name = "return_value")

private String returnValue;

/**

* 文字描述

@Column(name = "`operation`")

private String operation;

/**

* 操作状态（0正常 1异常）

@Column(name = "`status`")

private Integer status = 0;

/**

* 失败原因

@Column(name = "error_msg")

private String errorMsg;

/**

* 系统名称

@Column(name = "sys_name")

private String sysName = "Device_Manage";

/**

* 响应用时ms

@Column(name = "cost_time")

private Long costTime;

}

2.Mapper持久层

Mapper持久层插入日志需要调用持久层中的insert方法，将日志记录插入到数据库中。

import com.fri.device_management.model.LogUserOperate;

import tk.mybatis.mapper.common.Mapper;

public interface LogUserOperateMapper extends Mapper {

}

3.自定义日志注解 Log注解的作用仅用于标识

注解的类型是@interface，就是在interface之前加了个@。

添加@Retention(RetentionPolicy.RUNTIME)指定注解运行时生效。

添加@Target(ElementType.METHOD)指定注解作用在方法上。

【其中businessType 使用了枚举类也可以直接使用123这样的数值】

import com.fri.device_management.common.log.enums.BusinessType;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

/**

* 自定义操作日志记录注解

* 注解的属性值就是在使用注解时可以传的参数

@Target({ ElementType.PARAMETER, ElementType.METHOD })

@Retention(RetentionPolicy.RUNTIME)

public @interface UserLog {

/**

* 模块

public String title() default "";

/**

* 功能

public BusinessType businessType() default BusinessType.OTHER;

/**

* 是否保存请求的参数

public boolean isSaveRequestData() default true;

}

3.1我这边使用到的枚举类业务操作类型

/**

* 业务操作类型

public enum BusinessType

{

/**

* 其它

OTHER,

/**

* 新增

INSERT,

/**

* 修改

UPDATE,

/**

* 查询

QUERY,

/**

* 删除

DELETE,

/**

* 授权

GRANT,

/**

* 导出

EXPORT,

/**

* 导入

IMPORT,

/**

* 强退

FORCE,

/**

* 生成代码

GENCODE,

/**

* 清空数据

CLEAN,

}

3.2我这边使用到的枚举类操作状态类型

/**

* 操作状态

public enum BusinessStatus

{

/**

* 成功

SUCCESS,

/**

* 失败

FAIL,

}

4.切入面处理逻辑这里是重点通读这块代码自己想怎么实现都成

如果不需要记录那么多信息就用不到这些工具类其中获取当前登录用户信息，返回数据结果需要根据自己的项目中适配

import com.alibaba.fastjson.JSON;

import com.alibaba.fastjson.JSONObject;

import com.fri.device_management.common.log.annotation.UserLog;

import com.fri.device_management.common.log.enums.BusinessStatus;

import com.fri.device_management.common.utils.IpUtils;

import com.fri.device_management.common.utils.ServletUtils;

import com.fri.device_management.common.utils.StringUtils;

import com.fri.device_management.mapper.LogUserOperateMapper;

import com.fri.device_management.mapper.UserMapper;

import com.fri.device_management.model.LogUserOperate;

import com.fri.device_management.model.User;

import lombok.extern.slf4j.Slf4j;

import org.aspectj.lang.JoinPoint;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.Signature;

import org.aspectj.lang.annotation.AfterReturning;

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.http.HttpMethod;

import org.springframework.stereotype.Component;

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.Arrays;

import java.util.Map;

/**

* 切面类

* 操作日志记录处理详细罗杰

* 一个切面对应一个注解标记切入点

* 连接点：JoinPoint，可以被AOP控制的方法（暗含方法执行时的相关信息）

* 通知：Advice，指哪些重复的逻辑，也就是共性功能（最终体现为一个方法）

* 切入点：PointCut，匹配连接点的条件，通知仅会在切入点方法执行时被应用

* 切面：Aspect，描述通知与切入点的对应关系（通知+切入点）

* 目标对象：Target，通知所应用的对象

@Aspect

@Component

@Slf4j

public class UserLogAspect {

@Autowired

private HttpServletRequest request;

// 日志入库的mapper

@Autowired

private LogUserOperateMapper logUserOperateMapper;

// 通过请求内的信息，获取当前登录用户的个人信息补充日志的内容

@Autowired

private UserMapper userMapper;

/**

* 配置切入点自定义注解的包路径

@Pointcut("@annotation(com.fri.device_management.common.log.annotation.UserLog)")

public void logPointCut()

{

}

/**

* 处理完请求后执行

* @param proceedingJoinPoint 切点

@AfterReturning(pointcut = "logPointCut()", returning = "jsonResult")

public void doAfterReturning(JoinPoint proceedingJoinPoint, Object jsonResult)

{

handleLog(proceedingJoinPoint, null, jsonResult);

}

protected void handleLog(final JoinPoint joinPoint, final Exception e, Object jsonResult)

{

try

{

// 获得注解

UserLog controllerLog = getAnnotationLog(joinPoint);

if (controllerLog == null)

{

return;

}

// 获取当前的登录用户

String token = request.getHeader("Authorization");

User loginUser = userMapper.selectByToken(token);

// *========数据库日志=========*//

// SysOperLog operLog = new SysOperLog();

LogUserOperate operateLog = new LogUserOperate();

operateLog.setSysName("Device-Manage");

operateLog.setStatus(BusinessStatus.SUCCESS.ordinal());

operateLog.setDeptName(loginUser.getDepartmentName());

operateLog.setOperateName(loginUser.getRealName());

// 请求的地址

String ip = IpUtils.getIpAddr(ServletUtils.getRequest());

operateLog.setOperIp(ip);

// 返回参数

operateLog.setReturnValue(JSON.toJSONString(jsonResult));

operateLog.setOperUrl(ServletUtils.getRequest().getRequestURI());

if (e != null)

{

operateLog.setStatus(BusinessStatus.FAIL.ordinal());

operateLog.setErrorMsg(StringUtils.substring(e.getMessage(), 0, 2000));

}

// 设置方法名称

String className = joinPoint.getTarget().getClass().getName();

String methodName = joinPoint.getSignature().getName();

operateLog.setMethod(className + "." + methodName + "()");

// 设置请求方式

operateLog.setRequestMethod(ServletUtils.getRequest().getMethod());

// 处理设置注解上的参数

getControllerMethodDescription(joinPoint, controllerLog, operateLog);

// 保存数据库

logUserOperateMapper.insertSelective(operateLog);

}

catch (Exception exp)

{

// 记录本地异常日志

log.error("==前置通知异常==");

log.error("异常信息:{}", exp.getMessage());

exp.printStackTrace();

}

/**

* 获取注解中对方法的描述信息用于Controller层注解

* @param log 日志

* @param operLog 操作日志

* @throws Exception

public void getControllerMethodDescription(JoinPoint joinPoint, UserLog log, LogUserOperate operLog) throws Exception

{

// 设置action动作

operLog.setBusinessType(log.businessType().ordinal());

// 设置标题

operLog.setTitle(log.title());

// 是否需要保存request，参数和值

if (log.isSaveRequestData())

{

// 获取参数的信息，传入到数据库中。

setRequestValue(joinPoint, operLog);

}

/**

* 获取请求的参数，放到log中

* @param operLog 操作日志

* @throws Exception 异常

private void setRequestValue(JoinPoint joinPoint, LogUserOperate 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 UserLog getAnnotationLog(JoinPoint joinPoint) throws Exception

{

Signature signature = joinPoint.getSignature();

MethodSignature methodSignature = (MethodSignature) signature;

Method method = methodSignature.getMethod();

if (method != null)

{

return method.getAnnotation(UserLog.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。

public boolean isFilterObject(final Object o)

{

return o instanceof MultipartFile || o instanceof HttpServletRequest || o instanceof HttpServletResponse;

}

4.1用到的工具类IpUtils

import org.springframework.util.StringUtils;

import java.net.InetAddress;

import java.net.UnknownHostException;

import javax.servlet.http.HttpServletRequest;

/**

* 获取IP方法

public class IpUtils

{

public static String getIpAddr(HttpServletRequest request)

{

if (request == null)

{

return "unknown";

}

String ip = request.getHeader("x-forwarded-for");