高效審計！Spring AOP + 多線程 + 批量處理的智能解決方案
作者：編程疏影
本方案基于 Spring AOP 實現自動攔截日志操作，結合 異步任務執行 提升系統吞吐能力，并采用 批量存儲 降低數據庫壓力，從而構建了一套高效、低耦合的審計日志解決方案。
在現代企業應用中，審計日志（Audit Log）是必不可少的功能。它不僅可以用于安全合規審計，還能幫助開發者進行系統調試與問題排查。然而，傳統的日志記錄方式往往存在性能瓶頸，例如同步記錄日志可能會影響系統響應速度，而單條插入數據庫的方式則容易造成數據庫壓力過大。
為了解決這些問題，我們可以結合 Spring AOP、異步處理 和 批量存儲，實現一個高效、可靠的審計日志方案。本篇文章將詳細講解該方案的設計思路，并提供完整的代碼實現。
關鍵需求
- 記錄核心業務操作的完整軌跡
- 捕獲操作前后的數據狀態
- 包含操作者信息、時間戳及變更詳情
- 采用異步存儲，減少對主業務流程的影響
解決方案
自定義注解
package com.icoderoad.audit.annotation;
import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interfaceOperationAudit{
/** 操作類型標識 */
StringoperationCode();
/** 操作描述（支持 SpEL 表達式） */
Stringdescription() default"";
/** 操作者表達式 */
Stringoperator() default"@auditOperator.getName";
/** 操作前狀態 */
StringpreState() default"";
/** 操作后狀態 */
StringpostState() default"";
}審計實體及存儲
審計記錄實體
package com.icoderoad.audit.entity;
import jakarta.persistence.*;
import java.time.LocalDateTime;
@Entity
@Table(name = "sys_audit_log")
public class AuditRecord {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String operationCode;
@Column(length = 500)
private String description;
private String operator;
private LocalDateTime operationTime;
@Lob
private String preState;
@Lob
private String postState;
private boolean success;
private String errorMessage;
}數據訪問層
package com.icoderoad.audit.repository;
import com.icoderoad.audit.entity.AuditRecord;
import org.springframework.data.jpa.repository.JpaRepository;
public interface AuditRepository extends JpaRepository<AuditRecord, Long> {}異步審計記錄器
package com.icoderoad.audit.service;
import com.icoderoad.audit.entity.AuditRecord;
import com.icoderoad.audit.repository.AuditRepository;
import org.springframework.stereotype.Component;
import java.util.*;
import java.util.concurrent.*;
@Component
public class AuditRecorder {
private static final long MAX_FLUSH_INTERVAL = 3000;
private volatile long lastFlushTime = System.currentTimeMillis();
private final BlockingQueue<AuditRecord> auditQueue = new LinkedBlockingQueue<>(1000);
private final Executor executor = Executors.newSingleThreadExecutor();
private final AuditRepository auditRepository;
public AuditRecorder(AuditRepository auditRepository) {
this.auditRepository = auditRepository;
startConsumer();
}
public void record(AuditRecord record) {
if (!auditQueue.offer(record)) {
System.err.println("審計隊列已滿，記錄被丟棄: " + record);
}
}
private void startConsumer() {
executor.execute(() -> {
List<AuditRecord> buffer = new ArrayList<>(100);
while (!Thread.interrupted()) {
try {
AuditRecord record = auditQueue.poll(MAX_FLUSH_INTERVAL, TimeUnit.MILLISECONDS);
if (record != null) {
buffer.add(record);
}
if (buffer.size() >= 100 || System.currentTimeMillis() - lastFlushTime > MAX_FLUSH_INTERVAL) {
if (!buffer.isEmpty()) {
auditRepository.saveAll(buffer);
buffer.clear();
lastFlushTime = System.currentTimeMillis();
}
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
});
}
}審計切面
package com.icoderoad.audit.aspect;
import com.icoderoad.audit.annotation.OperationAudit;
import com.icoderoad.audit.entity.AuditRecord;
import com.icoderoad.audit.service.AuditRecorder;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.expression.*;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
import java.time.LocalDateTime;
@Aspect
@Component
public class AuditAspect implements BeanFactoryAware {
private final AuditRecorder auditRecorder;
private BeanFactory beanFactory;
private final ExpressionParser parser = new SpelExpressionParser();
private final ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
public AuditAspect(AuditRecorder auditRecorder) {
this.auditRecorder = auditRecorder;
}
@Around("@annotation(auditAnnotation)")
public Object auditOperation(ProceedingJoinPoint joinPoint, OperationAudit auditAnnotation) throws Throwable {
Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
Object[] args = joinPoint.getArgs();
EvaluationContext context = createEvaluationContext(method, args);
AuditRecord record = prepareAuditRecord(auditAnnotation, context);
record.setPreState(evaluateExpression(auditAnnotation.preState(), context));
try {
Object result = joinPoint.proceed();
context.setVariable("result", result);
record.setPostState(evaluateExpression(auditAnnotation.postState(), context));
record.setSuccess(true);
return result;
} catch (Exception ex) {
record.setSuccess(false);
record.setErrorMessage(ex.getMessage());
throw ex;
} finally {
auditRecorder.record(record);
}
}
private EvaluationContext createEvaluationContext(Method method, Object[] args) {
MethodBasedEvaluationContext context = new MethodBasedEvaluationContext(null, method, args, parameterNameDiscoverer);
context.setBeanResolver(new BeanFactoryResolver(this.beanFactory));
return context;
}
private AuditRecord prepareAuditRecord(OperationAudit annotation, EvaluationContext context) {
AuditRecord record = new AuditRecord();
record.setOperationCode(annotation.operationCode());
record.setDescription(evaluateExpression(annotation.description(), context));
record.setOperator(evaluateExpression(annotation.operator(), context));
record.setOperationTime(LocalDateTime.now());
return record;
}
private String evaluateExpression(String expr, EvaluationContext context) {
try {
return parser.parseExpression(expr).getValue(context, String.class);
} catch (Exception e) {
return "";
}
}
@Override
public void setBeanFactory(BeanFactory beanFactory) {
this.beanFactory = beanFactory;
}
}測試
package com.icoderoad.audit.service;
import com.icoderoad.audit.annotation.OperationAudit;
import org.springframework.stereotype.Service;
@Service
public class OrderService {
@OperationAudit(
operationCode = "ORDER_STATUS_UPDATE",
description = "'訂單狀態更新: ' + #orderNo",
preState = "#oldStatus",
postState = "#newStatus"
)
public void updateOrderStatus(String orderNo, Integer oldStatus, Integer newStatus) {
// 業務邏輯...
}
}結論
本方案基于 Spring AOP 實現自動攔截日志操作，結合 異步任務執行 提升系統吞吐能力，并采用 批量存儲 降低數據庫壓力，從而構建了一套高效、低耦合的審計日志解決方案。
在實際應用中，該方案能夠有效提升日志存儲的效率，同時減少對主業務流程的影響。如果你的系統需要高效的日志管理，推薦采用該方案，并可根據業務需求進一步擴展，例如支持多數據源存儲、日志清理策略等。
責任編輯：武曉燕
來源：
路條編程
