前言

一套完善的操作日志程序几乎是标配。

但日志记录最怕两件事：

• 一是侵入业务代码——每个接口里手动塞一堆日志代码，维护成本高、遗漏风险大；
• 二是拖慢主流程——日志写库是 I/O 操作。同步执行会拉高接口 RT，影响使用者体验。

使用者痛点解析

• 侵入式开发难维护业务方法里硬编码日志导致代码臃肿，后期功能变更需同步修改多处日志逻辑。
• 性能瓶颈诱因同步写库导致请求响应时间波动大，尤其在高并发场景下容易触发超时。按理说，
• 缺乏可 性单体实现难以满足多节点分布式部署的可靠购买需求。
• 错误不可追溯传统手工写日志容易遗漏异常信息或关键字段，使后期审计困难。

整体架构设计

在看代码之前，先理解整条数据流：

业务方法被调用
↓@AuditLog 注解标记 → AOP 切面拦截
↓主线程的观点是，收集请求上下文、使用者信息、入参 → 建立日志 VO
从↓主线程来看，执行目标方法
再看↓主线程，记录耗时、执行结果、异常信息
↓异步线程池的观点是。序列化 JSON → 推入 Redis List
再看↓定时任务，批量从 Redis 取出 → 反序列化 → 批量写入 MySQL

主要设计思想是 三层解耦

• 采集层: 零侵入地收集日志信息，不污染业务代码；

• 缓冲层: 削峰填谷。日志写入 Redis 是微秒级操作，几乎不影响主流程；

• 持久层: 批量入库。降低数据库写入压力，支持重试和降级。

第一步先这方面，定义自定义注解 @AuditLog

import java.lang.annotation.*;其实，@Target
@Retention
@Documented
public @interface AuditLog {
/** 操作模块名称 */
String firstModule default "";怎么说呢，/** 操作模块名称 */
String secondModule default "";/** 操作类型 */
String operationType;/** 操作描述 */
String operationDesc default "";}

设计解读

This annotation's sole responsibility is to declaratively describe "what this operation is". It decouples logging logic from business code and makes it runtime-accessible for AOP.

使用方式

Add one line on controller method。zero intrusion:

@AuditLog(
firstModule = SysAuditLogEnum.FIRST_LEVEL_BASIC_SET,secondModule = SysAuditLogEnum.SECOND_LEVEL_BASE_MANAGE,operationType = SysAuditLogEnum.ADD,operationDesc = "新增基地")
@PostMapping
public ServerResponse create BaseVO baseVO) {
return owmsBaseService.add;}

从接下来来看，AOP 切面——日志采集的主要

@Aspect
@Component
@Slf4j
public class AuditLogAspect {
private static final String AUDIT_LOG_QUEUE = "audit_log_queue";private static final String SUCCESS_STATUS = "success";其实，private static final String FAIL_STATUS = "fail";@Resource
private ThreadPoolTaskExecutor auditLogExecutor;怎么说呢，@Resource
private RedisUtil redisUtil;@Around")
public Object around throws Throwable {
log.info;其实，// 获取请求上下文
ServletRequestAttributes attributes =
RequestContextHolder.getRequestAttributes;if ) {
log.warn;return joinPoint.proceed;// 必须放行目标方法
}
HttpServletRequest request = attributes.getRequest;ThreadSession threadSession = ThreadSession.getThreadSession;// 建立基础信息
AuditLogRecordVO auditLogRecordVO =
buildAuditLog;StopWatch stopWatch = new StopWatch;话说回来，stopWatch.start;Object result = null;String status = SUCCESS_STATUS;String errorMsg = null;try {
result = joinPoint.proceed;话说回来，} catch {
status = FAIL_STATUS;errorMsg = e.getMessage;throw e，// 抛出异常保持业务原有行为
} finally {
stopWatch.stop;auditLogRecordVO.setExecutionTime);auditLogRecordVO.setStatus;auditLogRecordVO.setErrorMessage;// 异步写 Redis
auditLogExecutor.execute -> {
try {
String auditJson = JSONUtil.toJsonStr;log.info，redisUtil.lRightPush;老实说，} catch {
log.error;}
})，}
return result;}
private AuditLogRecordVO buildAuditLog(HttpServletRequest request,ThreadSession threadSession。AuditLog auditlog,ProceedingJoinPoint joinPoint) {
// 注解属性
String firstModule = auditlog.firstModule;String secondModule = auditlog.secondModule;String operationDesc= auditlog.operationDesc;String operationType= auditlog.operationType;// 方法参数
Object args = joinPoint.getArgs;String operationContext= JSONUtil.toJsonStr;
说起来，// 使用者信息从自定义 Session 中获取
String operatorAccount= threadSession.getLoginName;String operatorName = threadSession.getFiled;...
return AuditLogRecordVO.builder
.operatorAccount
.operatorName
.operationType
.operationDesc
.operationContext
... /* 省略其余字段赋值 */
.build;}
}

切面执行流程拆解

Around advice captures before/after/exception in one place: get request context & annotations before proceeding;record time & status after execution;finally push serialized log into Redis asynchronously.

① 为什么用 @Around 而不是 @Before + @After？

@Around 能同时拿到参数、返回值与异常。并控制 proceed 的时机，是测算耗时所必需的唯一选择。

② finally 块保证日志不丢

No matter success or exception,finally executes. Exception sets status='fail'。records message n rethrows – business behavior untouched but log remains complete.

③ buildAuditLog 在 proceed 前调用

User info & parameters are available early;time & result are only known post-execution – keeps logic tidy.

：线程池配置——为什么要异步？怎么异步，

为什么必须用多线程？

审计日志属于典型 fire-and-forget ——可降级/重试，但绝不能拖慢业务主流程。于是异步必要，其实，

ThreadPool 配置 java @Configuration @EnableAsync @Slf4j public class ThreadPoolConfig { public static final int MULTIPLE = 5;public static final int ALIVE_TIMEOUT=30;public static final int corePoolSize =Runtime.getRuntime.availableProcessors;public static final int maxPoolSize =;public static final int queueCapacity=;public static final int keepAliveSeconds=ALIVE_TIMEOUT;private String threadNamePrefix ="warehouse-";@Bean @Primary public ThreadPoolTaskExecutor getAuditTaskExecutor{ return generateThreadPoolTaskExecutor(corePoolSize。maxPoolSize,queueCapacity,keepAliveSeconds,threadNamePrefix,new ThreadPoolExecutor.CallerRunsPolicy);} } **参数解释**

场景	同步写 Redis	异步线程池
Redis 正常	接口 RT +1ms	主线程 +0ms
Redis 抖动	接口 RT +50ms	主线程 +0ms
Redis 宕机	接口阻塞至超时	主线程立即返回

参数	取值逻辑	说明
corePoolSize	CPU 核数	I/O 主导，可按核数设定
maxPoolSize	CPU × MULTIPLE	突发流量临时扩容
queueCapacity	max × MULTIPLE	缓冲队列避免过载
keepAliveSeconds	30s	非主要空闲后回收
RejectedExecutionHandler	CallerRunsPolicy	队列满时退化为同步执行保证不丢

CallerRunsPolicy 是关键选择。相较 Abort/Discard。它会让调用者直接跑任务，实现限流降速，而不是丢失。

提交方式

java auditExecutor.execute -> { try { redisUtil.lRightPush(AUDIT_LOG_QUEUE,JSONUtil.toJsonStr);说起来，}catch{ log.error;} })，

使用 execute 而非 submit，因为无需 Future 返回。

---

说到第四步，使用者——从 Redis 到数据库的批量落库

基础版 java @Component @Slf4j public class SysAuditConsumer{ private static final String AUDIT_LOG_QUEUE ="audit_log_queue";@Resource private RedisUtil redisUtil;@Resource private SysAuditService service;@Scheduled//20s一次批量消费 public void consume{ List logs=new ArrayList<>;try{ List strings= redisUtil.lRange;//LIMIT 可配置大小

 if){
redisUtil.lTrim,-1);//原子裁剪
for{
try{logs.add);其实，}catch{log.error;}
}
if){
service.saveBatch;//一次 DB 写多个 INSERT 合并成一次交互。}
}
}catch{log.error;}

} **关键点** * lRange+ lTrim 一次性读 & 裁剪减少网络往返。其实，* 每条 JSON 单独捕获错误；局部失败不致全局，说起来，* saveBatch 批量 DB 极大减少压力。

---

分布式锁版

java @Scheduled public void consume{ boolean lock=redisLock.tryLock,2500L);if{log.warn，return;} try{ /* 同上 */}finally{ redisLock.unlock;} } 确保同一时间只有一个实例消费。说起来，

---

使用者设计要点概览

1. lRange+lTrim 替代循环 lPop — 降低通信次数。
2. 独立错误捕获 — 单条失败不影响整批。按理说，
3. saveBatch 批量写库 — 明显提高吞吐。
4. fixedDelay 调整间隔 — 根据业务规模动态调节。

---

完整数据流回顾与图示

│ 业务方法 │
│ @Audit Log+PostMapping │
└───────▲──────────────────┘
│
▼
┌───────▼─────────────────────┐
│ AOP 切面拦截 │
│①采集注解属性 │
│②采集请求上下文 │
│③采集使用者信息 │
│④执行目标方法 │
│⑤记录耗时 & 状态 │
└───────▲─────────────────────┘
│
▼
┌───────▼─────────────────────┐
│ 异步线程池 |
│ 序列化JSON→Redis List │
│ “auditlogqueue” │
└───────▲──────────────────────┘
│
▼
┌───────▼─────────────────────┐
│ 定时使用者 │
│ 每 X 量拉取 N 条 │
│ 反序列化→saveBatch→MySQL │
└──────────────────────────────┘ 

三个层面各司其职： • AOP 切面负责“采集”——零侵入声明式；• Redis 队列负责“缓冲”——削峰填谷；其实，• 定时使用者负责“持久化”——批量存储。怎么说呢，

结束语

一套好的操作日志方案应该像空气一样存在——开发者只需要在方法上加一个注解。其余全部自动完成，怎么说呢，这篇文章介绍的 @AuditLog + AOP + 异步 + Redis + 定时批量存储方案正是这一理念落地的典范。按理说，在实际项目中，你可以根据自己的技术栈与规模细节进行微调。但主要思路保持不变即可轻松解决侵入性与性能瓶颈这两大痛点。

---