基于SpringBoot + MyBatis-Plus高效实现数据变更记录

public void updateOrder(Order order) {
    Order oldOrder = orderMapper.selectById(order.getId()); // 第一次查询
    // ... 一堆业务逻辑 ...
    orderMapper.updateById(order); // 业务更新
    logService.saveChangeLog(oldOrder, order); 
}

@Intercepts({
    @Signature(type = Executor.class, method = "update", 
               args = {MappedStatement.class, Object.class})
})
@Component
@Slf4j
public class DataChangeInterceptor implements Interceptor {
    
    @Autowired
    private ApplicationEventPublisher eventPublisher; // 事件发布器
    
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        MappedStatement ms = (MappedStatement) invocation.getArgs()[0];
        Object parameter = invocation.getArgs()[1];
        
        // 1. 仅拦截增删改操作
        SqlCommandType commandType = ms.getSqlCommandType();
        if (commandType == SqlCommandType.INSERT || 
            commandType == SqlCommandType.UPDATE || 
            commandType == SqlCommandType.DELETE) {
            
            // 2. 获取实体信息（MyBatis-Plus增强）
            if (parameter instanceof Map) {
                // 处理Wrapper等复杂参数，提取实体
            } else if (parameter != null) {
                // 3. 关键：在操作执行前，根据ID查询旧数据（仅UPDATE需要）
                Object oldData = null;
                if (commandType == SqlCommandType.UPDATE) {
                    oldData = fetchOldData(parameter, ms); // 根据主键查旧数据
                }
                
                // 4. 执行原始SQL操作
                Object result = invocation.proceed();
                
                // 5. 异步发布变更事件（不阻塞主流程）
                if ((int)result > 0) {
                    DataChangeEvent event = new DataChangeEvent(
                            this, 
                            commandType, 
                            oldData, 
                            parameter, // 新数据
                            ThreadLocalUtil.getCurrentOperator() // 操作人从线程上下文获取
                    );
                    eventPublisher.publishEvent(event); // 异步处理
                }
                return result;
            }
        }
        return invocation.proceed();
    }
    
    private Object fetchOldData(Object entity, MappedStatement ms) {
        // 利用MyBatis-Plus的TableInfo工具类，反射获取主键值和实体类型
        TableInfo tableInfo = TableInfoHelper.getTableInfo(entity.getClass());
        if (tableInfo != null) {
            Object idValue = tableInfo.getPropertyValue(entity, tableInfo.getKeyProperty());
            return sqlSessionTemplate.selectOne(ms.getId() + "_selectById", idValue); // 复用Mapper查询
        }
        return null;
    }
}

@Data
public class DataChangeEvent {
    private final SqlCommandType changeType; // 操作类型
    private final Object oldData;            // 变更前数据（JSON字符串或实体）
    private final Object newData;            // 变更后数据
    private final String operator;           // 操作人（从ThreadLocal或安全上下文获取）
    private final LocalDateTime changeTime = LocalDateTime.now();
    private final String entityClassName;    // 实体类名
    
    // 关键：将数据转换为JSON，避免后续序列化问题
    public String getOldDataJson() {
        return JSON.toJSONString(oldData);
    }
    
    public String getNewDataJson() {
        return JSON.toJSONString(newData);
    }
}

@Component
@Slf4j
public class DataChangeEventListener {
    
    @Async("dataChangeExecutor") // 指定独立线程池，不占用业务资源
    @EventListener
    @Transactional(propagation = Propagation.REQUIRES_NEW) // 新事务，与业务事务分离
    public void handleDataChangeEvent(DataChangeEvent event) {
        try {
            // 1. 构建变更记录实体
            ChangeLog changeLog = new ChangeLog();
            changeLog.setEntityClass(event.getEntityClassName());
            changeLog.setChangeType(event.getChangeType().name());
            changeLog.setOldData(event.getOldDataJson());
            changeLog.setNewData(event.getNewDataJson());
            changeLog.setOperator(event.getOperator());
            
            // 2. 计算具体变更的字段（精细化记录）
            if (event.getChangeType() == SqlCommandType.UPDATE) {
                Map<String, Object> fieldChanges = DiffUtil.diff(
                    event.getOldDataJson(), 
                    event.getNewDataJson()
                );
                changeLog.setChangedFields(JSON.toJSONString(fieldChanges));
            }
            
            // 3. 持久化到数据库（或发送到消息队列）
            changeLogMapper.insert(changeLog);
            
        } catch (Exception e) {
            // 4. 降级策略：记录失败时，至少打印日志或存入死信队列
            log.error("数据变更记录失败，事件内容：{}", JSON.toJSONString(event), e);
            // 可在此处将事件发送至Redis或Kafka进行重试
        }
    }
}

spring:
  task:
    execution:
      pool:
        data-change-executor:
          core-size: 2
          max-size: 5
          queue-capacity: 1000 # 缓冲区，抗瞬时峰值

CREATE TABLE `change_log` (
  `id` bigint NOT NULL COMMENT '主键',
  `entity_class` varchar(255) NOT NULL COMMENT '实体类名',
  `entity_id` varchar(64) NOT NULL COMMENT '实体ID', -- 从数据中提取
  `change_type` varchar(10) NOT NULL COMMENT '操作类型',
  `changed_fields` json DEFAULT NULL COMMENT '变更的字段（JSON）', -- 快速定位
  `old_data` json DEFAULT NULL COMMENT '完整旧数据',
  `new_data` json DEFAULT NULL COMMENT '完整新数据',
  `operator` varchar(64) DEFAULT NULL COMMENT '操作人',
  `create_time` datetime NOT NULL COMMENT '创建时间',
  PRIMARY KEY (`id`),
  KEY `idx_entity` (`entity_class`,`entity_id`), -- 按实体查询
  KEY `idx_time` (`create_time`) -- 按时间范围查询
) COMMENT='数据变更记录表';

public class OperatorContext {
    private static final ThreadLocal<String> CURRENT_OPERATOR = new ThreadLocal<>();
    
    public static void setOperator(String operatorId) {
        CURRENT_OPERATOR.set(operatorId);
    }
    // 在拦截器或Spring Security过滤器中设置
}