Spring Boot审计自定义：批量保存时如何生成单条审计日志？

默认的JPA审计机制会为每个实体的持久化操作生成独立的审计日志，所以批量保存列表时会产生多条日志。要实现单条汇总日志，可以通过以下几种方式处理：

方案一：手动控制审计逻辑（简单直接） #

绕过自动审计机制，统一设置实体的审计字段，然后手动插入一条汇总的审计日志：

1. 统一设置实体审计字段：在批量保存前，为所有实体设置相同的创建人、创建时间等审计字段，替代自动审计的赋值逻辑。
2. 批量插入实体：使用批量插入语句（避免逐个触发实体监听），提升性能同时防止自动审计触发。
3. 手动生成单条审计日志：插入一条记录本次批量操作的汇总日志，包含操作人、时间、涉及实体数量等信息。

示例代码：

@Service
public class BatchEntityService {

    @Autowired
    private EntityManager entityManager;
    @Autowired
    private AuditLogRepository auditLogRepository;
    @Autowired
    private Authentication authentication;

    @Transactional
    public void batchSave(List<Entity> entities) {
        // 统一设置审计字段
        String currentUser = authentication.getName();
        LocalDateTime now = LocalDateTime.now();
        entities.forEach(entity -> {
            entity.setCreatedBy(currentUser);
            entity.setCreatedDate(now);
        });

        // 批量插入实体（避免逐个触发监听）
        entityManager.createQuery(
                "INSERT INTO Entity (name, createdBy, createdDate) " +
                "SELECT e.name, e.createdBy, e.createdDate FROM :entities e")
                .setParameter("entities", entities)
                .executeUpdate();

        // 插入单条汇总审计日志
        AuditLog auditLog = new AuditLog();
        auditLog.setOperationType("BATCH_SAVE");
        auditLog.setOperator(currentUser);
        auditLog.setOperationTime(now);
        auditLog.setEntityCount(entities.size());
        auditLog.setDetails("批量保存了" + entities.size() + "条Entity记录");
        auditLogRepository.save(auditLog);
    }
}

方案二：自定义审计监听器（兼容批量/非批量操作） #

通过自定义监听器，结合ThreadLocal跟踪批量操作上下文，在批量操作时合并审计日志，非批量操作时保留原有逻辑：

1. 自定义监听器：继承AuditingEntityListener，用ThreadLocal存储批量操作的上下文信息。
2. 标记批量操作：在批量保存方法开始时初始化上下文，结束时生成汇总日志并清理上下文。
3. 修改实体监听配置：将实体的@EntityListeners指向自定义监听器。

示例代码：

public class BatchAwareAuditingListener extends AuditingEntityListener {

    private static final ThreadLocal<BatchAuditContext> BATCH_CONTEXT = new ThreadLocal<>();

    // 启动批量操作上下文
    public static void startBatch() {
        BATCH_CONTEXT.set(new BatchAuditContext());
    }

    // 结束批量操作并生成审计日志
    public static void endBatch(AuditLogRepository auditLogRepository) {
        BatchAuditContext context = BATCH_CONTEXT.get();
        if (context != null) {
            AuditLog auditLog = new AuditLog();
            auditLog.setOperationType("BATCH_SAVE");
            auditLog.setOperator(context.getOperator());
            auditLog.setOperationTime(context.getOperationTime());
            auditLog.setEntityCount(context.getEntityCount());
            auditLog.setDetails("批量保存了" + context.getEntityCount() + "条记录");
            auditLogRepository.save(auditLog);
            BATCH_CONTEXT.remove();
        }
    }

    @Override
    public void onPrePersist(Object entity) {
        BatchAuditContext context = BATCH_CONTEXT.get();
        if (context != null) {
            // 批量操作时统一设置审计字段，不生成单条日志
            Auditable<String, Long, LocalDateTime> auditable = (Auditable<String, Long, LocalDateTime>) entity;
            auditable.setCreatedBy(context.getOperator());
            auditable.setCreatedDate(context.getOperationTime());
            context.incrementEntityCount();
        } else {
            // 非批量操作走默认审计逻辑
            super.onPrePersist(entity);
        }
    }

    // 批量操作上下文类
    static class BatchAuditContext {
        private String operator;
        private LocalDateTime operationTime;
        private int entityCount;

        public BatchAuditContext() {
            Authentication auth = SecurityContextHolder.getContext().getAuthentication();
            this.operator = auth.getName();
            this.operationTime = LocalDateTime.now();
            this.entityCount = 0;
        }

        // getter和自增方法
        public String getOperator() { return operator; }
        public LocalDateTime getOperationTime() { return operationTime; }
        public int getEntityCount() { return entityCount; }
        public void incrementEntityCount() { this.entityCount++; }
    }
}

实体配置修改：

@Entity
@EntityListeners(BatchAwareAuditingListener.class)
public class Entity implements Auditable<String, Long, LocalDateTime> {
    // 实体字段及Auditable接口实现
}

批量保存服务方法：

@Service
public class BatchEntityService {

    @Autowired
    private EntityRepository entityRepository;
    @Autowired
    private AuditLogRepository auditLogRepository;

    @Transactional
    public void batchSave(List<Entity> entities) {
        try {
            BatchAwareAuditingListener.startBatch();
            entityRepository.saveAll(entities);
        } finally {
            BatchAwareAuditingListener.endBatch(auditLogRepository);
        }
    }
}

方案三：事件驱动生成审计日志（解耦性强） #

通过Spring事件机制，在批量保存完成后发布事件，由监听器生成单条汇总日志：

1. 定义批量操作事件：包含操作实体列表、操作人、时间等信息。
2. 发布事件：在批量保存完成后发布事件。
3. 监听事件生成日志：创建事件监听器，响应事件并插入汇总审计日志。

示例代码：

// 批量保存事件类
public class BatchSaveEvent<T> {
    private final List<T> entities;
    private final String operator;
    private final LocalDateTime operationTime;

    public BatchSaveEvent(List<T> entities) {
        this.entities = entities;
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        this.operator = auth.getName();
        this.operationTime = LocalDateTime.now();
    }

    // getter方法
    public List<T> getEntities() { return entities; }
    public String getOperator() { return operator; }
    public LocalDateTime getOperationTime() { return operationTime; }
}

批量保存服务：

@Service
public class BatchEntityService {

    @Autowired
    private ApplicationEventPublisher eventPublisher;
    @Autowired
    private EntityRepository entityRepository;

    @Transactional
    public void batchSave(List<Entity> entities) {
        // 统一设置审计字段
        String currentUser = SecurityContextHolder.getContext().getAuthentication().getName();
        LocalDateTime now = LocalDateTime.now();
        entities.forEach(e -> {
            e.setCreatedBy(currentUser);
            e.setCreatedDate(now);
        });

        entityRepository.saveAll(entities);
        // 发布批量保存事件
        eventPublisher.publishEvent(new BatchSaveEvent<>(entities));
    }
}

事件监听器：

@Component
public class BatchAuditEventListener {

    @Autowired
    private AuditLogRepository auditLogRepository;

    @EventListener
    public void handleBatchSaveEvent(BatchSaveEvent<?> event) {
        AuditLog auditLog = new AuditLog();
        auditLog.setOperationType("BATCH_SAVE");
        auditLog.setOperator(event.getOperator());
        auditLog.setOperationTime(event.getOperationTime());
        auditLog.setEntityCount(event.getEntities().size());
        auditLog.setDetails("批量保存了" + event.getEntities().size() + "条记录");
        auditLogRepository.save(auditLog);
    }
}

方案选择建议 #

• 若业务逻辑简单，优先选择方案一，代码直观易维护；
• 若需要兼容批量和非批量操作的审计逻辑，选择方案二，对业务代码侵入小；
• 若系统已有事件驱动架构，或需要解耦审计逻辑，选择方案三，扩展性更强。

内容的提问来源于stack exchange，提问作者Kumar Reddy