高效審計！Spring AOP + 多線程 + 批量處理的智能解決方案

作者：編程疏影 2025-03-03 01:25:00

本方案基于 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 實現自動攔截日志操作，結合 異步任務執行 提升系統吞吐能力，并采用 批量存儲 降低數據庫壓力，從而構建了一套高效、低耦合的審計日志解決方案。

在實際應用中，該方案能夠有效提升日志存儲的效率，同時減少對主業務流程的影響。如果你的系統需要高效的日志管理，推薦采用該方案，并可根據業務需求進一步擴展，例如支持多數據源存儲、日志清理策略等。

責任編輯：武曉燕來源：路條編程