// 簡化版的插件執(zhí)行流程
public class Plugin implements InvocationHandler {
    
    private final Object target;  // 被代理的對(duì)象
    private final Interceptor interceptor;  // 攔截器
    private final Map<Class<?>, Set<Method>> signatureMap;  // 方法簽名映射
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 1. 檢查是否是需要攔截的方法
        Set<Method> methods = signatureMap.get(method.getDeclaringClass());
        if (methods != null && methods.contains(method)) {
            // 2. 執(zhí)行攔截器邏輯
            return interceptor.intercept(new Invocation(target, method, args));
        }
        // 3. 否則直接執(zhí)行原方法
        return method.invoke(target, args);
    }
}

@Intercepts({
    @Signature(
        type = StatementHandler.class,
        method = "query",
        args = {Statement.class, ResultHandler.class}
    ),
    @Signature(
        type = StatementHandler.class,
        method = "update",
        args = {Statement.class}
    )
})
@Slf4j
public class SimpleSqlMonitorPlugin implements Interceptor {
    
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        long startTime = System.currentTimeMillis();
        
        try {
            // 執(zhí)行原方法
            return invocation.proceed();
        } finally {
            long costTime = System.currentTimeMillis() - startTime;
            
            // 獲取StatementHandler
            StatementHandler handler = (StatementHandler) invocation.getTarget();
            BoundSql boundSql = handler.getBoundSql();
            
            // 打印日志
            log.info("SQL執(zhí)行耗時(shí): {}ms, SQL: {}", costTime, boundSql.getSql());
        }
    }
    
    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }
    
    @Override
    public void setProperties(Properties properties) {
        // 可以讀取配置
    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
public class SqlExecutionInfo {
    // 基本信息
    private String sqlId;                // Mapper方法全限定名
    private String sql;                  // 原始SQL
    private String realSql;              // 實(shí)際SQL（帶參數(shù)）
    private SqlCommandType commandType;  // 操作類型：SELECT/INSERT等
    
    // 執(zhí)行信息
    private long startTime;              // 開始時(shí)間
    private long endTime;                // 結(jié)束時(shí)間
    private long costTime;               // 耗時(shí)(ms)
    
    // 參數(shù)信息
    private Object parameters;           // 參數(shù)對(duì)象
    private Map<String, Object> paramMap; // 參數(shù)Map
    
    // 結(jié)果信息
    private Object result;               // 執(zhí)行結(jié)果
    private int resultSize;              // 結(jié)果集大小
    private boolean success;             // 是否成功
    private Throwable exception;         // 異常信息
    
    // 上下文信息
    private String mapperInterface;      // Mapper接口
    private String mapperMethod;         // Mapper方法
    private String stackTrace;           // 調(diào)用堆棧
    private String dataSource;           // 數(shù)據(jù)源
    private String transactionId;        // 事務(wù)ID
    
    // 性能指標(biāo)
    private long fetchSize;              // 獲取行數(shù)
    private long updateCount;            // 更新行數(shù)
    private long connectionAcquireTime;  // 獲取連接耗時(shí)
    
    public enum SqlCommandType {
        SELECT, INSERT, UPDATE, DELETE, UNKNOWN
    }
}

@Intercepts({
    @Signature(
        type = Executor.class,
        method = "update",
        args = {MappedStatement.class, Object.class}
    ),
    @Signature(
        type = Executor.class,
        method = "query",
        args = {MappedStatement.class, Object.class, 
                RowBounds.class, ResultHandler.class}
    ),
    @Signature(
        type = Executor.class,
        method = "query",
        args = {MappedStatement.class, Object.class, 
                RowBounds.class, ResultHandler.class,
                CacheKey.class, BoundSql.class}
    )
})
@Component
@Slf4j
public class SqlMonitorPlugin implements Interceptor {
    
    // 配置
    private long slowSqlThreshold = 1000;  // 慢SQL閾值(ms)，默認(rèn)1秒
    private boolean enableStackTrace = true;  // 是否收集堆棧
    private boolean enableAlert = true;  // 是否開啟告警
    private int maxStackTraceDepth = 5;  // 最大堆棧深度
    
    // 統(tǒng)計(jì)收集器
    private final SqlStatsCollector statsCollector = new SqlStatsCollector();
    // 告警器
    private final SlowSqlAlarmer alarmer = new SlowSqlAlarmer();
    
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        // 1. 創(chuàng)建執(zhí)行信息
        SqlExecutionInfo executionInfo = createExecutionInfo(invocation);
        
        Object result = null;
        Throwable exception = null;
        
        try {
            // 2. 執(zhí)行原方法
            result = invocation.proceed();
            
            // 3. 記錄結(jié)果信息
            recordResultInfo(executionInfo, result);
            executionInfo.setSuccess(true);
            
            return result;
            
        } catch (Throwable t) {
            // 4. 記錄異常
            exception = t;
            executionInfo.setException(t);
            executionInfo.setSuccess(false);
            throw t;
            
        } finally {
            // 5. 計(jì)算耗時(shí)
            executionInfo.setEndTime(System.currentTimeMillis());
            executionInfo.setCostTime(
                executionInfo.getEndTime() - executionInfo.getStartTime()
            );
            
            // 6. 收集統(tǒng)計(jì)信息
            statsCollector.collect(executionInfo);
            
            // 7. 記錄日志
            logExecution(executionInfo);
            
            // 8. 慢SQL告警
            if (executionInfo.getCostTime() > slowSqlThreshold) {
                triggerSlowSqlAlert(executionInfo);
            }
        }
    }
    
    private SqlExecutionInfo createExecutionInfo(Invocation invocation) {
        SqlExecutionInfo info = new SqlExecutionInfo();
        info.setStartTime(System.currentTimeMillis());
        
        // 獲取MappedStatement
        MappedStatement ms = (MappedStatement) invocation.getArgs()[0];
        Object parameter = invocation.getArgs()[1];
        
        // 設(shè)置基本信息
        info.setSqlId(ms.getId());
        info.setCommandType(ms.getSqlCommandType());
        
        // 獲取BoundSql
        BoundSql boundSql = ms.getBoundSql(parameter);
        info.setSql(boundSql.getSql());
        info.setParameters(parameter);
        
        // 解析參數(shù)
        parseParameters(info, boundSql, parameter);
        
        // 獲取調(diào)用堆棧
        if (enableStackTrace) {
            info.setStackTrace(getStackTrace());
        }
        
        // 解析Mapper信息
        parseMapperInfo(info, ms);
        
        return info;
    }
    
    private void parseParameters(SqlExecutionInfo info, BoundSql boundSql, Object parameter) {
        try {
            // 如果是Map類型
            if (parameter instanceof Map) {
                info.setParamMap((Map<String, Object>) parameter);
            } 
            // 如果是單個(gè)參數(shù)
            else if (parameter != null) {
                Map<String, Object> paramMap = new HashMap<>();
                
                // 獲取參數(shù)名稱
                Object paramObj = boundSql.getParameterObject();
                if (paramObj != null) {
                    // 如果是@Param注解的參數(shù)
                    if (paramObj instanceof Map) {
                        paramMap.putAll((Map<String, Object>) paramObj);
                    } 
                    // 如果是實(shí)體對(duì)象
                    else {
                        // 通過反射獲取屬性值
                        BeanInfo beanInfo = Introspector.getBeanInfo(paramObj.getClass());
                        PropertyDescriptor[] props = beanInfo.getPropertyDescriptors();
                        
                        for (PropertyDescriptor prop : props) {
                            if (!"class".equals(prop.getName())) {
                                Method getter = prop.getReadMethod();
                                if (getter != null) {
                                    Object value = getter.invoke(paramObj);
                                    paramMap.put(prop.getName(), value);
                                }
                            }
                        }
                    }
                }
                
                info.setParamMap(paramMap);
            }
            
            // 生成實(shí)際SQL（用于調(diào)試）
            info.setRealSql(generateRealSql(boundSql));
            
        } catch (Exception e) {
            log.warn("解析SQL參數(shù)失敗", e);
        }
    }
    
    private String generateRealSql(BoundSql boundSql) {
        String sql = boundSql.getSql();
        Object parameterObject = boundSql.getParameterObject();
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        
        if (parameterMappings == null || parameterMappings.isEmpty() || parameterObject == null) {
            return sql;
        }
        
        // 這里簡化處理，實(shí)際應(yīng)該用TypeHandler處理類型轉(zhuǎn)換
        try {
            for (ParameterMapping mapping : parameterMappings) {
                String property = mapping.getProperty();
                Object value = getParameterValue(property, parameterObject);
                
                // 簡單的字符串替換（僅用于日志，不要用于實(shí)際執(zhí)行）
                if (value instanceof String) {
                    value = "'" + value + "'";
                }
                
                sql = sql.replaceFirst("\\?", value.toString());
            }
        } catch (Exception e) {
            // 生成失敗返回原始SQL
        }
        
        return sql;
    }
    
    private Object getParameterValue(String property, Object parameterObject) {
        if (parameterObject instanceof Map) {
            return ((Map<?, ?>) parameterObject).get(property);
        } else {
            // 反射獲取屬性值
            try {
                BeanInfo beanInfo = Introspector.getBeanInfo(parameterObject.getClass());
                PropertyDescriptor[] props = beanInfo.getPropertyDescriptors();
                
                for (PropertyDescriptor prop : props) {
                    if (prop.getName().equals(property)) {
                        Method getter = prop.getReadMethod();
                        if (getter != null) {
                            return getter.invoke(parameterObject);
                        }
                    }
                }
            } catch (Exception e) {
                // ignore
            }
        }
        return "?";
    }
    
    private void parseMapperInfo(SqlExecutionInfo info, MappedStatement ms) {
        String sqlId = ms.getId();
        int lastDotIndex = sqlId.lastIndexOf(".");
        
        if (lastDotIndex > 0) {
            info.setMapperInterface(sqlId.substring(0, lastDotIndex));
            info.setMapperMethod(sqlId.substring(lastDotIndex + 1));
        }
    }
    
    private void recordResultInfo(SqlExecutionInfo info, Object result) {
        if (result instanceof List) {
            info.setResultSize(((List<?>) result).size());
        } else if (result instanceof Collection) {
            info.setResultSize(((Collection<?>) result).size());
        } else if (result != null) {
            info.setResultSize(1);
        }
        info.setResult(result);
    }
    
    private String getStackTrace() {
        StringBuilder stackTrace = new StringBuilder();
        StackTraceElement[] elements = Thread.currentThread().getStackTrace();
        
        int depth = 0;
        for (StackTraceElement element : elements) {
            // 過濾框架調(diào)用
            if (element.getClassName().startsWith("org.apache.ibatis") ||
                element.getClassName().startsWith("com.sun.proxy") ||
                element.getClassName().startsWith("java.lang.Thread")) {
                continue;
            }
            
            stackTrace.append(element.getClassName())
                     .append(".")
                     .append(element.getMethodName())
                     .append("(")
                     .append(element.getFileName())
                     .append(":")
                     .append(element.getLineNumber())
                     .append(")\n");
            
            if (++depth >= maxStackTraceDepth) {
                break;
            }
        }
        
        return stackTrace.toString();
    }
    
    private void logExecution(SqlExecutionInfo info) {
        if (log.isInfoEnabled()) {
            String logMsg = String.format(
                "SQL執(zhí)行統(tǒng)計(jì) - 方法: %s, 耗時(shí): %dms, 類型: %s, 結(jié)果: %d條, SQL: %s",
                info.getSqlId(),
                info.getCostTime(),
                info.getCommandType(),
                info.getResultSize(),
                info.getSql()
            );
            
            if (info.getCostTime() > slowSqlThreshold) {
                log.warn("?? " + logMsg);
            } else {
                log.info("? " + logMsg);
            }
        }
    }
    
    private void triggerSlowSqlAlert(SqlExecutionInfo info) {
        if (!enableAlert) {
            return;
        }
        
        SlowSqlAlert alert = new SlowSqlAlert();
        alert.setSqlId(info.getSqlId());
        alert.setSql(info.getSql());
        alert.setCostTime(info.getCostTime());
        alert.setThreshold(slowSqlThreshold);
        alert.setParameters(info.getParamMap());
        alert.setStackTrace(info.getStackTrace());
        alert.setAlertTime(new Date());
        
        alarmer.sendAlert(alert);
    }
    
    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }
    
    @Override
    public void setProperties(Properties properties) {
        // 讀取配置
        String threshold = properties.getProperty("slowSqlThreshold");
        if (threshold != null) {
            this.slowSqlThreshold = Long.parseLong(threshold);
        }
        
        String enableStack = properties.getProperty("enableStackTrace");
        if (enableStack != null) {
            this.enableStackTrace = Boolean.parseBoolean(enableStack);
        }
        
        String enableAlertProp = properties.getProperty("enableAlert");
        if (enableAlertProp != null) {
            this.enableAlert = Boolean.parseBoolean(enableAlertProp);
        }
        
        String maxDepth = properties.getProperty("maxStackTraceDepth");
        if (maxDepth != null) {
            this.maxStackTraceDepth = Integer.parseInt(maxDepth);
        }
    }
}

@Component
@Slf4j
public class SqlStatsCollector {
    
    // 使用ConcurrentHashMap保證線程安全
    private final ConcurrentHashMap<String, SqlStats> statsMap = new ConcurrentHashMap<>();
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
    
    // 統(tǒng)計(jì)信息
    @Data
    public static class SqlStats {
        private String sqlId;
        private long totalCount;           // 總執(zhí)行次數(shù)
        private long successCount;         // 成功次數(shù)
        private long errorCount;           // 失敗次數(shù)
        private long totalCostTime;        // 總耗時(shí)
        private long maxCostTime;          // 最大耗時(shí)
        private long minCostTime = Long.MAX_VALUE;  // 最小耗時(shí)
        private double avgCostTime;        // 平均耗時(shí)
        
        // 耗時(shí)分布
        private long[] costTimeDistribution = new long[6];  // 0-100, 100-500, 500-1000, 1000-3000, 3000-10000, >10000 ms
        
        // 最近100次耗時(shí)（用于計(jì)算P99等）
        private final LinkedList<Long> recentCosts = new LinkedList<>();
        private static final int RECENT_SIZE = 100;
        
        public synchronized void record(SqlExecutionInfo info) {
            totalCount++;
            if (info.isSuccess()) {
                successCount++;
            } else {
                errorCount++;
            }
            
            long cost = info.getCostTime();
            totalCostTime += cost;
            
            if (cost > maxCostTime) {
                maxCostTime = cost;
            }
            if (cost < minCostTime) {
                minCostTime = cost;
            }
            
            avgCostTime = (double) totalCostTime / totalCount;
            
            // 記錄耗時(shí)分布
            if (cost < 100) {
                costTimeDistribution[0]++;
            } else if (cost < 500) {
                costTimeDistribution[1]++;
            } else if (cost < 1000) {
                costTimeDistribution[2]++;
            } else if (cost < 3000) {
                costTimeDistribution[3]++;
            } else if (cost < 10000) {
                costTimeDistribution[4]++;
            } else {
                costTimeDistribution[5]++;
            }
            
            // 記錄最近耗時(shí)
            recentCosts.add(cost);
            if (recentCosts.size() > RECENT_SIZE) {
                recentCosts.removeFirst();
            }
        }
        
        public double getP99CostTime() {
            if (recentCosts.isEmpty()) {
                return 0;
            }
            
            List<Long> sorted = new ArrayList<>(recentCosts);
            Collections.sort(sorted);
            
            int index = (int) Math.ceil(0.99 * sorted.size()) - 1;
            return index >= 0 ? sorted.get(index) : sorted.get(0);
        }
        
        public double getSuccessRate() {
            return totalCount > 0 ? (double) successCount / totalCount * 100 : 100;
        }
    }
    
    public SqlStatsCollector() {
        // 每分鐘輸出一次統(tǒng)計(jì)報(bào)告
        scheduler.scheduleAtFixedRate(this::printStatsReport, 1, 1, TimeUnit.MINUTES);
        
        // 每小時(shí)清理一次舊數(shù)據(jù)
        scheduler.scheduleAtFixedRate(this::cleanupOldStats, 1, 1, TimeUnit.HOURS);
    }
    
    public void collect(SqlExecutionInfo info) {
        String sqlId = info.getSqlId();
        
        statsMap.compute(sqlId, (key, stats) -> {
            if (stats == null) {
                stats = new SqlStats();
                stats.setSqlId(sqlId);
            }
            stats.record(info);
            return stats;
        });
    }
    
    public SqlStats getStats(String sqlId) {
        return statsMap.get(sqlId);
    }
    
    public Map<String, SqlStats> getAllStats() {
        return new HashMap<>(statsMap);
    }
    
    private void printStatsReport() {
        if (statsMap.isEmpty()) {
            return;
        }
        
        log.info("======= SQL執(zhí)行統(tǒng)計(jì)報(bào)告 =======");
        log.info("統(tǒng)計(jì)時(shí)間: {}", new Date());
        log.info("總SQL數(shù)量: {}", statsMap.size());
        
        // 找出最慢的10個(gè)SQL
        List<SqlStats> topSlow = statsMap.values().stream()
            .sorted((s1, s2) -> Long.compare(s2.getMaxCostTime(), s1.getMaxCostTime()))
            .limit(10)
            .collect(Collectors.toList());
        
        log.info("最慢的10個(gè)SQL:");
        for (int i = 0; i < topSlow.size(); i++) {
            SqlStats stats = topSlow.get(i);
            log.info("{}. {} - 最大: {}ms, 平均: {:.2f}ms, 成功: {:.2f}%, 調(diào)用: {}次", 
                i + 1, stats.getSqlId(), stats.getMaxCostTime(), 
                stats.getAvgCostTime(), stats.getSuccessRate(), stats.getTotalCount());
        }
        
        // 統(tǒng)計(jì)總體情況
        long totalExecutions = statsMap.values().stream()
            .mapToLong(SqlStats::getTotalCount)
            .sum();
        
        double avgSuccessRate = statsMap.values().stream()
            .mapToDouble(SqlStats::getSuccessRate)
            .average()
            .orElse(0);
        
        log.info("總體統(tǒng)計(jì) - 總執(zhí)行: {}次, 平均成功率: {:.2f}%", 
            totalExecutions, avgSuccessRate);
    }
    
    private void cleanupOldStats() {
        // 清理24小時(shí)無調(diào)用的統(tǒng)計(jì)
        // 實(shí)際實(shí)現(xiàn)中可以添加最后調(diào)用時(shí)間字段
    }
}

@Component
@Slf4j
public class SlowSqlAlarmer {
    
    // 告警規(guī)則
    @Data
    public static class AlertRule {
        private String sqlPattern;        // SQL模式匹配
        private long threshold;           // 閾值(ms)
        private int interval;             // 告警間隔(分鐘)
        private String[] receivers;       // 接收人
        private AlertLevel level;         // 告警級(jí)別
        
        public enum AlertLevel {
            INFO, WARNING, ERROR, CRITICAL
        }
    }
    
    // 告警記錄
    @Data
    public static class AlertRecord {
        private String sqlId;
        private long costTime;
        private long threshold;
        private Date alertTime;
        private int count;  // 本次告警周期內(nèi)的次數(shù)
    }
    
    private final List<AlertRule> rules = new ArrayList<>();
    private final Map<String, AlertRecord> lastAlertMap = new ConcurrentHashMap<>();
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
    
    public SlowSqlAlarmer() {
        // 加載默認(rèn)規(guī)則
        loadDefaultRules();
        
        // 每小時(shí)清理一次舊告警記錄
        scheduler.scheduleAtFixedRate(this::cleanupAlertRecords, 1, 1, TimeUnit.HOURS);
    }
    
    private void loadDefaultRules() {
        // 規(guī)則1：所有SQL超過5秒
        AlertRule rule1 = new AlertRule();
        rule1.setSqlPattern(".*");
        rule1.setThreshold(5000);
        rule1.setInterval(5);
        rule1.setLevel(AlertRule.AlertLevel.ERROR);
        rule1.setReceivers(new String[]{"dba@company.com"});
        
        // 規(guī)則2：重要業(yè)務(wù)SQL超過1秒
        AlertRule rule2 = new AlertRule();
        rule2.setSqlPattern(".*(User|Order|Payment).*");
        rule2.setThreshold(1000);
        rule2.setInterval(1);
        rule2.setLevel(AlertRule.AlertLevel.WARNING);
        rule2.setReceivers(new String[]{"dev@company.com"});
        
        rules.add(rule1);
        rules.add(rule2);
    }
    
    public void sendAlert(SlowSqlAlert alert) {
        // 1. 匹配規(guī)則
        List<AlertRule> matchedRules = matchRules(alert);
        
        if (matchedRules.isEmpty()) {
            return;
        }
        
        for (AlertRule rule : matchedRules) {
            // 2. 檢查是否需要告警（防騷擾）
            if (shouldAlert(alert, rule)) {
                // 3. 發(fā)送告警
                doSendAlert(alert, rule);
                
                // 4. 記錄告警
                recordAlert(alert, rule);
            }
        }
    }
    
    private List<AlertRule> matchRules(SlowSqlAlert alert) {
        return rules.stream()
            .filter(rule -> alert.getCostTime() >= rule.getThreshold())
            .filter(rule -> alert.getSql().matches(rule.getSqlPattern()))
            .collect(Collectors.toList());
    }
    
    private boolean shouldAlert(SlowSqlAlert alert, AlertRule rule) {
        String key = alert.getSqlId() + ":" + rule.getThreshold();
        AlertRecord lastRecord = lastAlertMap.get(key);
        
        if (lastRecord == null) {
            return true;
        }
        
        // 檢查是否在告警間隔內(nèi)
        long timeDiff = System.currentTimeMillis() - lastRecord.getAlertTime().getTime();
        return timeDiff > rule.getInterval() * 60 * 1000;
    }
    
    private void doSendAlert(SlowSqlAlert alert, AlertRule rule) {
        String title = String.format("[%s] 慢SQL告警: %s", 
            rule.getLevel(), alert.getSqlId());
        
        StringBuilder content = new StringBuilder();
        content.append("SQL ID: ").append(alert.getSqlId()).append("\n");
        content.append("執(zhí)行耗時(shí): ").append(alert.getCostTime()).append("ms\n");
        content.append("閾值: ").append(rule.getThreshold()).append("ms\n");
        content.append("實(shí)際SQL: ").append(alert.getSql()).append("\n");
        content.append("參數(shù): ").append(alert.getParameters()).append("\n");
        content.append("告警時(shí)間: ").append(new Date()).append("\n");
        
        if (alert.getStackTrace() != null) {
            content.append("調(diào)用堆棧:\n").append(alert.getStackTrace());
        }
        
        // 發(fā)送郵件
        sendEmail(rule.getReceivers(), title, content.toString());
        
        // 發(fā)送企業(yè)微信/釘釘
        sendChatMessage(rule.getLevel(), title, content.toString());
        
        log.warn("發(fā)送慢SQL告警: {}, 耗時(shí): {}ms", alert.getSqlId(), alert.getCostTime());
    }
    
    private void recordAlert(SlowSqlAlert alert, AlertRule rule) {
        String key = alert.getSqlId() + ":" + rule.getThreshold();
        
        AlertRecord record = new AlertRecord();
        record.setSqlId(alert.getSqlId());
        record.setCostTime(alert.getCostTime());
        record.setThreshold(rule.getThreshold());
        record.setAlertTime(new Date());
        record.setCount(1);
        
        lastAlertMap.put(key, record);
    }
    
    private void sendEmail(String[] receivers, String title, String content) {
        // 實(shí)現(xiàn)郵件發(fā)送邏輯
        // 可以使用JavaMail或Spring Mail
    }
    
    private void sendChatMessage(AlertRule.AlertLevel level, String title, String content) {
        // 實(shí)現(xiàn)企業(yè)微信/釘釘消息發(fā)送
    }
    
    private void cleanupAlertRecords() {
        long now = System.currentTimeMillis();
        long hourMillis = 60 * 60 * 1000;
        
        lastAlertMap.entrySet().removeIf(entry -> 
            now - entry.getValue().getAlertTime().getTime() > 24 * hourMillis
        );
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    
    <settings>
        <!-- 開啟駝峰命名轉(zhuǎn)換 -->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
    
    <!-- 插件配置 -->
    <plugins>
        <plugin interceptor="com.yourcompany.mybatis.plugin.SqlMonitorPlugin">
            <!-- 慢SQL閾值，單位毫秒 -->
            <property name="slowSqlThreshold" value="1000"/>
            
            <!-- 是否開啟堆棧信息收集 -->
            <property name="enableStackTrace" value="true"/>
            
            <!-- 是否開啟告警 -->
            <property name="enableAlert" value="true"/>
            
            <!-- 最大堆棧深度 -->
            <property name="maxStackTraceDepth" value="5"/>
            
            <!-- 慢SQL告警規(guī)則（JSON格式） -->
            <property name="alertRules" value='
                [
                    {
                        "sqlPattern": ".*",
                        "threshold": 5000,
                        "interval": 5,
                        "level": "ERROR",
                        "receivers": ["dba@company.com"]
                    },
                    {
                        "sqlPattern": ".*(User|Order|Payment).*",
                        "threshold": 1000,
                        "interval": 1,
                        "level": "WARNING",
                        "receivers": ["dev@company.com"]
                    }
                ]
            '/>
        </plugin>
    </plugins>
    
    <!-- 其他配置... -->
    
</configuration>

# application.yml
mybatis:
  configuration:
    # MyBatis配置
    map-underscore-to-camel-case: true
    default-statement-timeout: 30
  # 插件配置
  configuration-properties:
    slowSqlThreshold: 1000
    enableStackTrace: true
    enableAlert: true
    maxStackTraceDepth: 5

@Configuration
public class MyBatisConfig {
    
    @Bean
    public SqlMonitorPlugin sqlMonitorPlugin() {
        SqlMonitorPlugin plugin = new SqlMonitorPlugin();
        
        Properties properties = new Properties();
        properties.setProperty("slowSqlThreshold", "1000");
        properties.setProperty("enableStackTrace", "true");
        properties.setProperty("enableAlert", "true");
        properties.setProperty("maxStackTraceDepth", "5");
        
        plugin.setProperties(properties);
        return plugin;
    }
}

// 異步發(fā)送告警
private void triggerSlowSqlAlert(SqlExecutionInfo info) {
    if (!enableAlert) {
        return;
    }
    
    CompletableFuture.runAsync(() -> {
        SlowSqlAlert alert = new SlowSqlAlert();
        // 構(gòu)建告警信息...
        alarmer.sendAlert(alert);
    });
}

// 控制采樣率，避免全量監(jiān)控
private boolean shouldSample() {
    // 10%的采樣率
    return ThreadLocalRandom.current().nextInt(100) < 10;
}

// 在intercept方法中使用
if (!shouldSample() && info.getCostTime() < slowSqlThreshold) {
    return invocation.proceed();
}

// 重用SqlExecutionInfo對(duì)象
private final ObjectPool<SqlExecutionInfo> infoPool = new GenericObjectPool<>(
    new BasePooledObjectFactory<SqlExecutionInfo>() {
        @Override
        public SqlExecutionInfo create() {
            return new SqlExecutionInfo();
        }
        
        @Override
        public void passivateObject(PooledObject<SqlExecutionInfo> p) {
            // 重置對(duì)象狀態(tài)
            p.getObject().reset();
        }
    }
);

private SqlExecutionInfo createExecutionInfo(Invocation invocation) {
    SqlExecutionInfo info = null;
    try {
        info = infoPool.borrowObject();
        // 填充數(shù)據(jù)...
        return info;
    } catch (Exception e) {
        return new SqlExecutionInfo();
    } finally {
        if (info != null) {
            infoPool.returnObject(info);
        }
    }
}

// 調(diào)試方法：在插件中加日志
@Override
public Object plugin(Object target) {
    log.info("插件包裝對(duì)象: {}", target.getClass().getName());
    return Plugin.wrap(target, this);
}

// 使用JMH進(jìn)行性能測(cè)試
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void testPluginPerformance() {
    // 測(cè)試代碼
}

// 定期清理緩存
scheduler.scheduleAtFixedRate(() -> {
    statsMap.entrySet().removeIf(entry -> 
        System.currentTimeMillis() - entry.getValue().getLastAccessTime() > 3600000
    );
}, 1, 1, TimeUnit.HOURS);

@Component
public class PluginMetrics {
    
    private final MeterRegistry meterRegistry;
    
    // 監(jiān)控指標(biāo)
    private final Counter totalSqlCounter;
    private final Counter slowSqlCounter;
    private final Timer sqlTimer;
    
    public PluginMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        
        this.totalSqlCounter = Counter.builder("mybatis.sql.total")
            .description("SQL執(zhí)行總次數(shù)")
            .register(meterRegistry);
        
        this.slowSqlCounter = Counter.builder("mybatis.sql.slow")
            .description("慢SQL次數(shù)")
            .register(meterRegistry);
        
        this.sqlTimer = Timer.builder("mybatis.sql.duration")
            .description("SQL執(zhí)行耗時(shí)")
            .publishPercentiles(0.5, 0.95, 0.99)
            .register(meterRegistry);
    }
    
    public void recordSqlExecution(long costTime, boolean isSlow) {
        totalSqlCounter.increment();
        sqlTimer.record(costTime, TimeUnit.MILLISECONDS);
        
        if (isSlow) {
            slowSqlCounter.increment();
        }
    }
}

public class SqlInjectionDetector {
    
    private static final Pattern SQL_INJECTION_PATTERN = Pattern.compile(
        "('|--|;|\\|/\\*|\\*/|@@|char|nchar|varchar|nvarchar|alter|begin|cast|create|cursor|declare|delete|drop|end|exec|execute|fetch|insert|kill|open|select|sys|sysobjects|syscolumns|table|update|union)"
    );
    
    public static boolean detectInjection(String sql) {
        if (sql == null) {
            return false;
        }
        
        // 檢查是否使用${}（容易導(dǎo)致注入）
        if (sql.contains("${")) {
            return true;
        }
        
        // 檢查危險(xiǎn)關(guān)鍵字
        return SQL_INJECTION_PATTERN.matcher(sql.toLowerCase()).find();
    }
    
    public static String sanitizeSql(String sql) {
        if (sql == null) {
            return null;
        }
        
        // 簡單的SQL清理
        return sql.replace("'", "''")
                 .replace("--", "")
                 .replace(";", "");
    }
}

// 在插件中使用
private void checkSqlInjection(SqlExecutionInfo info) {
    if (SqlInjectionDetector.detectInjection(info.getSql())) {
        log.error("檢測(cè)到可能的SQL注入: {}", info.getSql());
        
        // 發(fā)送安全告警
        sendSecurityAlert(info);
    }
}

public class ExplainAnalyzer {
    
    public ExecutionPlan analyzeExplain(String sql, Object params) {
        // 生成EXPLAIN SQL
        String explainSql = "EXPLAIN " + sql;
        
        // 執(zhí)行EXPLAIN
        // 解析結(jié)果
        // 返回執(zhí)行計(jì)劃
        
        return executionPlan;
    }
    
    @Data
    public static class ExecutionPlan {
        private String id;
        private String selectType;
        private String table;
        private String type;  // ALL, index, range, ref, eq_ref, const, system, NULL
        private String possibleKeys;
        private String key;
        private int keyLen;
        private String ref;
        private int rows;
        private String extra;  // Using filesort, Using temporary
    }
    
    public boolean isSlowPlan(ExecutionPlan plan) {
        // 判斷是否為慢查詢計(jì)劃
        return "ALL".equals(plan.getType()) ||  // 全表掃描
               plan.getExtra().contains("filesort") ||  // 文件排序
               plan.getExtra().contains("temporary");  // 臨時(shí)表
    }
}