┌─────────────────────────────────────┐
│         Controller/Service層         │
└───────────────┬─────────────────────┘
                │
                ▼
┌─────────────────────────────────────┐
│         Mapper接口（帶注解）          │
│    @DataChangeLog(businessType)     │
└───────────────┬─────────────────────┘
                │
                ▼
┌─────────────────────────────────────┐
│      MyBatis Executor.update()       │
│          攔截器攔截點(diǎn)                 │
└───────────────┬─────────────────────┘
                │
                ▼
┌─────────────────────────────────────┐
│     ImprovedDataChangeInterceptor    │
│  ┌─────────────────────────────┐   │
│  │ 1. 獲取注解/判斷是否需要記錄 │   │
│  │ 2. 查詢?cè)紨?shù)據(jù)              │   │
│  │ 3. 執(zhí)行SQL操作               │   │
│  │ 4. 事務(wù)提交后查詢新數(shù)據(jù)       │   │
│  │ 5. 對(duì)比差異并保存記錄         │   │
│  └─────────────────────────────┘   │
└───────────────┬─────────────────────┘
                │
                ▼
┌─────────────────────────────────────┐
│         sys_data_change_log          │
│          數(shù)據(jù)變更記錄表               │
└─────────────────────────────────────┘

CREATE TABLE sys_data_change_log (
    id bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主鍵ID',
    business_type varchar(50) NOT NULL COMMENT '業(yè)務(wù)類型',
    business_id varchar(50) NOT NULL COMMENT '業(yè)務(wù)數(shù)據(jù)ID',
    field_name varchar(50) NOT NULL COMMENT '字段名稱',
    field_comment varchar(100) DEFAULT NULL COMMENT '字段注釋',
    old_value text COMMENT '變更前值',
    new_value text COMMENT '變更后值',
    change_type varchar(20) DEFAULT 'UPDATE' COMMENT '變更類型',
    change_by varchar(50) NOT NULL COMMENT '變更人',
    change_time datetime NOT NULL COMMENT '變更時(shí)間',
    PRIMARY KEY (id),
    KEY idx_business (business_type, business_id),
    KEY idx_change_time (change_time)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='數(shù)據(jù)變更記錄表';

package com.demo.framework.aspectj.lang.annotation;
import java.lang.annotation.*;
/**
 * 數(shù)據(jù)變更記錄注解
 * 標(biāo)記在Mapper方法上，表示該方法需要記錄數(shù)據(jù)變更
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataChangeLog {
    /**
     * 業(yè)務(wù)類型
     */
    String businessType() default "";
    /**
     * 是否記錄詳情（字段級(jí)別）
     */
    boolean detail() default true;
    /**
     * 忽略的字段
     */
    String[] ignoreFields() default {"createTime", "updateTime", "createBy", "updateBy"};
}

package com.demo.system.domain;

import com.demo.common.annotation.Excel;
import java.util.Date;

/**
 * 數(shù)據(jù)變更記錄對(duì)象 sys_data_change_log
 */
public class SysDataChangeLog {
    private static final long serialVersionUID = 1L;
    
    /** 主鍵ID */
    private Long id;
    
    /** 業(yè)務(wù)類型 */
    @Excel(name = "業(yè)務(wù)類型")
    private String businessType;
    
    /** 業(yè)務(wù)數(shù)據(jù)ID */
    @Excel(name = "業(yè)務(wù)數(shù)據(jù)ID")
    private String businessId;
    
    /** 字段名稱 */
    @Excel(name = "字段名稱")
    private String fieldName;
    
    /** 字段注釋 */
    @Excel(name = "字段注釋")
    private String fieldComment;
    
    /** 變更前值 */
    @Excel(name = "變更前值")
    private String oldValue;
    
    /** 變更后值 */
    @Excel(name = "變更后值")
    private String newValue;
    
    /** 變更類型 */
    @Excel(name = "變更類型")
    private String changeType;
    
    /** 變更人 */
    @Excel(name = "變更人")
    private String changeBy;
    
    /** 變更時(shí)間 */
    @Excel(name = "變更時(shí)間", dateFormat = "yyyy-MM-dd HH:mm:ss")
    private Date changeTime;
    
    // getters and setters...
}

/**
 * 注冊(cè)事務(wù)提交后的任務(wù)
 * 核心：確保數(shù)據(jù)真正寫入數(shù)據(jù)庫后才記錄變更日志
 */
private void registerAfterCommitTask(Runnable task) {
    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        // 事務(wù)中：注冊(cè)事務(wù)同步器，事務(wù)提交后執(zhí)行
        TransactionSynchronizationManager.registerSynchronization(
            new TransactionSynchronization() {
                @Override
                public void afterCommit() {
                    task.run();
                }
                
                @Override
                public void afterCompletion(int status) {
                    if (status == STATUS_ROLLED_BACK) {
                        log.debug("事務(wù)回滾，不記錄變更");
                    }
                }
            }
        );
    } else {
        // 無事務(wù)：直接執(zhí)行
        log.debug("無事務(wù)環(huán)境，直接執(zhí)行");
        task.run();
    }
}

/**
 * 處理更新操作
 * 三步走策略：
 * 1. 更新前查詢?cè)紨?shù)據(jù)
 * 2. 執(zhí)行更新操作
 * 3. 事務(wù)提交后查詢新數(shù)據(jù)并對(duì)比記錄
 */
private Object handleUpdate(Invocation invocation, MappedStatement ms, 
                            Object parameter, DataChangeLog dataChangeLog) throws Throwable {
    log.debug("處理更新操作，業(yè)務(wù)類型：{}", dataChangeLog.businessType());
    
    // 1. 更新前查詢?cè)紨?shù)據(jù)
    Object beforeData = queryDataById(parameter, ms);
    log.debug("更新前數(shù)據(jù)：{}", JSON.toJSONString(beforeData));
    
    // 2. 緩存操作信息
    OperationInfo opInfo = new OperationInfo();
    opInfo.setBusinessType(dataChangeLog.businessType());
    opInfo.setIgnoreFields(dataChangeLog.ignoreFields());
    opInfo.setParameter(parameter);
    opInfo.setSqlCommandType(SqlCommandType.UPDATE);
    opInfo.setMapperId(ms.getId());
    opInfo.setBeforeData(beforeData);
    OPERATION_INFO_THREAD_LOCAL.set(opInfo);
    
    // 3. 執(zhí)行更新操作
    Object result = invocation.proceed();
    
    // 4. 如果更新成功，在事務(wù)提交后處理變更記錄
    if (Integer.parseInt(result.toString()) > 0) {
        registerAfterCommitTask(() -> processUpdateAfterCommit(opInfo));
    }
    
    return result;
}

/**
 * 事務(wù)提交后處理更新操作
 */
private void processUpdateAfterCommit(OperationInfo opInfo) {
    try {
        // 1. 更新后查詢最新數(shù)據(jù)
        Object afterData = queryDataById(opInfo.getParameter(), opInfo.getMapperId());
        log.debug("更新后數(shù)據(jù)：{}", JSON.toJSONString(afterData));
        
        if (opInfo.getBeforeData() != null && afterData != null) {
            // 2. 對(duì)比數(shù)據(jù)差異
            List<SysDataChangeLog> changeLogs = compareData(
                opInfo.getBeforeData(), 
                afterData, 
                opInfo.getBusinessType(),
                opInfo.getIgnoreFields()
            );
            
            // 3. 批量保存變更記錄
            if (!changeLogs.isEmpty()) {
                dataChangeLogService.insertBatch(changeLogs);
                log.info("保存{}條更新變更記錄", changeLogs.size());
            }
        }
    } catch (Exception e) {
        log.error("處理更新后變更記錄失敗", e);
    }
}

/**
 * 對(duì)比數(shù)據(jù)差異
 * 支持日期、數(shù)字類型的精確比較
 */
private List<SysDataChangeLog> compareData(Object beforeData, Object afterData, 
                                           String businessType, String[] ignoreFields) {
    List<SysDataChangeLog> changeLogs = new ArrayList<>();
    
    try {
        Map<String, Object> beforeMap = convertToMap(beforeData);
        Map<String, Object> afterMap = convertToMap(afterData);
        
        String businessId = extractBusinessId(afterMap);
        
        // 遍歷更新后的數(shù)據(jù)
        for (Map.Entry<String, Object> entry : afterMap.entrySet()) {
            String fieldName = entry.getKey();
            
            // 忽略指定字段
            if (shouldIgnore(fieldName, ignoreFields)) {
                continue;
            }
            
            Object beforeValue = beforeMap.get(fieldName);
            Object afterValue = entry.getValue();
            
            // 比較值是否變化
            if (!isValueEquals(beforeValue, afterValue)) {
                SysDataChangeLog changeLog = createChangeLog(
                    businessType, businessId, fieldName,
                    getFieldComment(afterData, fieldName),
                    beforeValue, afterValue, "UPDATE"
                );
                changeLogs.add(changeLog);
            }
        }
        
    } catch (Exception e) {
        log.error("對(duì)比數(shù)據(jù)差異失敗", e);
    }
    
    return changeLogs;
}

/**
 * 判斷兩個(gè)值是否相等（處理各種數(shù)據(jù)類型）
 */
private boolean isValueEquals(Object v1, Object v2) {
    if (v1 == null && v2 == null) return true;
    if (v1 == null || v2 == null) return false;
    
    // 處理日期類型
    if (v1 instanceof Date && v2 instanceof Date) {
        return ((Date) v1).getTime() == ((Date) v2).getTime();
    }
    
    // 處理數(shù)字類型（避免精度問題）
    if (v1 instanceof Number && v2 instanceof Number) {
        return new BigDecimal(v1.toString())
            .compareTo(new BigDecimal(v2.toString())) == 0;
    }
    
    return v1.equals(v2);
}

package com.demo.framework.config;

import com.demo.framework.interceptor.ImprovedDataChangeInterceptor;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.session.SqlSessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;
import javax.annotation.PostConstruct;
import java.util.List;

/**
 * 攔截器手動(dòng)注冊(cè)配置
 * 解決攔截器未自動(dòng)注冊(cè)到MyBatis的問題
 */
@Configuration
public class InterceptorManualConfig {
    
    private static final org.slf4j.Logger log = 
        org.slf4j.LoggerFactory.getLogger(InterceptorManualConfig.class);
    
    @Autowired
    private List<SqlSessionFactory> sqlSessionFactories;
    
    @Autowired
    @Lazy // 避免循環(huán)依賴
    private ImprovedDataChangeInterceptor dataChangeInterceptor;
    
    @PostConstruct
    public void manualRegisterInterceptor() {
        log.info("========== 開始手動(dòng)注冊(cè)數(shù)據(jù)變更攔截器 ==========");
        log.info("發(fā)現(xiàn) {} 個(gè)SqlSessionFactory", sqlSessionFactories.size());
        
        for (int i = 0; i < sqlSessionFactories.size(); i++) {
            SqlSessionFactory sqlSessionFactory = sqlSessionFactories.get(i);
            org.apache.ibatis.session.Configuration configuration = 
                sqlSessionFactory.getConfiguration();
            
            // 檢查是否已經(jīng)注冊(cè)
            boolean alreadyRegistered = false;
            for (Interceptor interceptor : configuration.getInterceptors()) {
                if (interceptor instanceof ImprovedDataChangeInterceptor) {
                    alreadyRegistered = true;
                    log.info("SqlSessionFactory[{}] 攔截器已存在，跳過注冊(cè)", i);
                    break;
                }
            }
            
            if (!alreadyRegistered) {
                log.info("注冊(cè)攔截器到 SqlSessionFactory[{}]: {}", 
                    i, sqlSessionFactory);
                configuration.addInterceptor(dataChangeInterceptor);
            }
        }
        
        // 驗(yàn)證注冊(cè)結(jié)果
        verifyInterceptorRegistration();
        log.info("========== 攔截器手動(dòng)注冊(cè)完成 ==========");
    }
    
    /**
     * 驗(yàn)證攔截器注冊(cè)結(jié)果
     */
    private void verifyInterceptorRegistration() {
        for (int i = 0; i < sqlSessionFactories.size(); i++) {
            SqlSessionFactory sqlSessionFactory = sqlSessionFactories.get(i);
            List<Interceptor> interceptors = 
                sqlSessionFactory.getConfiguration().getInterceptors();
            
            log.info("SqlSessionFactory[{}] 已注冊(cè)攔截器數(shù)量: {}", i, interceptors.size());
            for (Interceptor interceptor : interceptors) {
                log.info("  - {}", interceptor.getClass().getSimpleName());
            }
        }
    }
}

package com.demo.framework.config;

import com.demo.framework.interceptor.ImprovedDataChangeInterceptor;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;

/**
 * 通過MyBatis配置類注冊(cè)攔截器
 */
@Configuration
@AutoConfigureAfter(MybatisAutoConfiguration.class)
public class MyBatisInterceptorConfig {
    
    @Autowired
    private ApplicationContext applicationContext;
    
    @Autowired
    private ImprovedDataChangeInterceptor dataChangeInterceptor;
    
    @PostConstruct
    public void init() {
        // 獲取所有SqlSessionFactory
        String[] sqlSessionFactoryNames = 
            applicationContext.getBeanNamesForType(SqlSessionFactory.class);
        
        for (String name : sqlSessionFactoryNames) {
            SqlSessionFactory sqlSessionFactory = 
                applicationContext.getBean(name, SqlSessionFactory.class);
            
            // 獲取當(dāng)前的攔截器列表
            org.apache.ibatis.session.Configuration configuration = 
                sqlSessionFactory.getConfiguration();
            
            // 添加攔截器（如果不存在）
            boolean exists = false;
            for (Interceptor interceptor : configuration.getInterceptors()) {
                if (interceptor instanceof ImprovedDataChangeInterceptor) {
                    exists = true;
                    break;
                }
            }
            
            if (!exists) {
                configuration.addInterceptor(dataChangeInterceptor);
            }
        }
    }
}

package com.demo.framework.config;

import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.session.SqlSessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import java.util.List;

/**
 * 啟動(dòng)后驗(yàn)證攔截器注冊(cè)情況
 */
@Component
public class InterceptorVerifyRunner implements CommandLineRunner {
    
    private static final org.slf4j.Logger log = 
        org.slf4j.LoggerFactory.getLogger(InterceptorVerifyRunner.class);
    
    @Autowired
    private List<SqlSessionFactory> sqlSessionFactories;
    
    @Override
    public void run(String... args) throws Exception {
        log.info("========== 數(shù)據(jù)變更攔截器注冊(cè)驗(yàn)證 ==========");
        
        for (int i = 0; i < sqlSessionFactories.size(); i++) {
            SqlSessionFactory factory = sqlSessionFactories.get(i);
            List<Interceptor> interceptors = factory.getConfiguration().getInterceptors();
            
            boolean hasInterceptor = false;
            for (Interceptor interceptor : interceptors) {
                String className = interceptor.getClass().getName();
                if (className.contains("DataChangeInterceptor")) {
                    hasInterceptor = true;
                    log.info("? SqlSessionFactory[{}] 已注冊(cè)攔截器: {}", 
                        i, className);
                }
            }
            
            if (!hasInterceptor) {
                log.error("? SqlSessionFactory[{}] 未找到數(shù)據(jù)變更攔截器!", i);
            }
        }
        
        log.info("==========================================");
    }
}

package com.demo.web.controller.monitor;

import com.demo.common.core.controller.BaseController;
import com.demo.common.core.domain.AjaxResult;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.session.SqlSessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 攔截器調(diào)試控制器
 */
@RestController
@RequestMapping("/monitor/interceptor")
public class InterceptorDebugController extends BaseController {
    
    @Autowired
    private List<SqlSessionFactory> sqlSessionFactories;
    
    /**
     * 查看攔截器注冊(cè)狀態(tài)
     */
    @GetMapping("/status")
    public AjaxResult status() {
        List<Map<String, Object>> result = new ArrayList<>();
        
        for (int i = 0; i < sqlSessionFactories.size(); i++) {
            SqlSessionFactory factory = sqlSessionFactories.get(i);
            Map<String, Object> factoryInfo = new HashMap<>();
            factoryInfo.put("factoryIndex", i);
            factoryInfo.put("factoryName", factory.getClass().getSimpleName());
            
            List<Interceptor> interceptors = factory.getConfiguration().getInterceptors();
            List<String> interceptorNames = new ArrayList<>();
            for (Interceptor interceptor : interceptors) {
                interceptorNames.add(interceptor.getClass().getSimpleName());
            }
            
            factoryInfo.put("interceptorCount", interceptors.size());
            factoryInfo.put("interceptors", interceptorNames);
            factoryInfo.put("hasDataChangeInterceptor", 
                interceptorNames.stream().anyMatch(name -> name.contains("DataChange")));
            
            result.add(factoryInfo);
        }
        
        return success(result);
    }
    
    /**
     * 測(cè)試攔截器是否工作
     */
    @GetMapping("/test")
    public AjaxResult test() {
        // 返回提示信息，實(shí)際測(cè)試需要調(diào)用Mapper方法
        return success("請(qǐng)調(diào)用實(shí)際的Mapper方法測(cè)試攔截器，如：/system/user/update");
    }
}

package com.demo.system.mapper;

import com.demo.framework.aspectj.lang.annotation.DataChangeLog;
import com.demo.system.domain.SysUser;
import org.apache.ibatis.annotations.Param;
import java.util.List;

public interface SysUserMapper {
    
    /**
     * 修改用戶信息
     */
    @DataChangeLog(
        businessType = "user.update",
        ignoreFields = {"createTime", "updateTime", "password"}
    )
    public int updateUser(SysUser user);
    
    /**
     * 新增用戶
     */
    @DataChangeLog(businessType = "user.insert")
    public int insertUser(SysUser user);
    
    /**
     * 刪除用戶
     */
    @DataChangeLog(businessType = "user.delete")
    public int deleteUserById(Long userId);
    
    /**
     * 批量刪除用戶
     */
    @DataChangeLog(businessType = "user.batchDelete")
    public int deleteUserByIds(@Param("userIds") List<Long> userIds);
    
    /**
     * 查詢用戶（用于獲取變更前后的數(shù)據(jù)）
     */
    public SysUser selectUserById(Long userId);
}

@Service
public class SysUserServiceImpl implements ISysUserService {
    
    @Autowired
    private SysUserMapper userMapper;
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int updateUser(SysUser user) {
        // 直接調(diào)用Mapper，攔截器會(huì)自動(dòng)處理數(shù)據(jù)變更記錄
        // 記錄會(huì)在事務(wù)提交后自動(dòng)寫入
        return userMapper.updateUser(user);
    }
}

/**
 * 批量操作優(yōu)化
 */
private static final int BATCH_THRESHOLD = 100; // 批量閾值

// 分批保存變更記錄
if (allChangeLogs.size() > BATCH_THRESHOLD) {
    List<List<SysDataChangeLog>> partitions = partitionList(allChangeLogs, BATCH_THRESHOLD);
    for (List<SysDataChangeLog> partition : partitions) {
        dataChangeLogService.insertBatch(partition);
    }
} else {
    dataChangeLogService.insertBatch(allChangeLogs);
}

# application.yml
logging:
  level:
    com.demo.framework.interceptor: DEBUG
    org.apache.ibatis: INFO