第207集接口性能监控与优化实战：耗时分析、调用统计、性能调优的架构级解决方案

// 智能接口耗时监控器
@Component
@Slf4j
public class IntelligentInterfaceLatencyMonitor {
    
    private final LatencyDataCollector latencyCollector;
    private final LatencyAnalyzer latencyAnalyzer;
    private final LatencyAlertManager alertManager;
    private final MeterRegistry meterRegistry;
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(10);
    
    public IntelligentInterfaceLatencyMonitor(LatencyDataCollector latencyCollector,
                                            LatencyAnalyzer latencyAnalyzer,
                                            LatencyAlertManager alertManager,
                                            MeterRegistry meterRegistry) {
        this.latencyCollector = latencyCollector;
        this.latencyAnalyzer = latencyAnalyzer;
        this.alertManager = alertManager;
        this.meterRegistry = meterRegistry;
        
        // 启动耗时监控
        startLatencyMonitoring();
    }
    
    // 启动耗时监控
    private void startLatencyMonitoring() {
        // 定期收集耗时数据
        scheduler.scheduleAtFixedRate(() -> {
            try {
                collectLatencyData();
            } catch (Exception e) {
                log.error("Error collecting latency data", e);
            }
        }, 0, 1, TimeUnit.SECONDS);
        
        // 定期分析耗时趋势
        scheduler.scheduleAtFixedRate(() -> {
            try {
                analyzeLatencyTrends();
            } catch (Exception e) {
                log.error("Error analyzing latency trends", e);
            }
        }, 0, 30, TimeUnit.SECONDS);
        
        // 定期检查告警条件
        scheduler.scheduleAtFixedRate(() -> {
            try {
                checkLatencyAlerts();
            } catch (Exception e) {
                log.error("Error checking latency alerts", e);
            }
        }, 0, 10, TimeUnit.SECONDS);
    }
    
    // 收集耗时数据
    public void collectLatencyData() {
        try {
            // 获取所有接口的耗时数据
            List<InterfaceLatencyData> latencyDataList = latencyCollector.collectAllLatencyData();
            
            for (InterfaceLatencyData data : latencyDataList) {
                // 处理每个接口的耗时数据
                processLatencyData(data);
                
                // 更新指标
                updateLatencyMetrics(data);
            }
            
        } catch (Exception e) {
            log.error("Error collecting latency data", e);
            meterRegistry.counter("latency.collection.error").increment();
        }
    }
    
    // 处理耗时数据
    private void processLatencyData(InterfaceLatencyData data) {
        try {
            // 计算统计指标
            LatencyStatistics stats = calculateLatencyStatistics(data);
            
            // 检测异常耗时
            detectAnomalousLatency(data, stats);
            
            // 记录耗时历史
            recordLatencyHistory(data, stats);
            
        } catch (Exception e) {
            log.error("Error processing latency data for interface: {}", data.getInterfaceName(), e);
        }
    }
    
    // 计算耗时统计指标
    private LatencyStatistics calculateLatencyStatistics(InterfaceLatencyData data) {
        LatencyStatistics stats = new LatencyStatistics();
        
        List<Long> latencies = data.getLatencies();
        
        if (latencies.isEmpty()) {
            return stats;
        }
        
        // 计算平均值
        double average = latencies.stream().mapToLong(Long::longValue).average().orElse(0.0);
        stats.setAverage(average);
        
        // 计算中位数
        List<Long> sortedLatencies = new ArrayList<>(latencies);
        Collections.sort(sortedLatencies);
        long median = sortedLatencies.get(sortedLatencies.size() / 2);
        stats.setMedian(median);
        
        // 计算P95
        int p95Index = (int) (sortedLatencies.size() * 0.95);
        long p95 = sortedLatencies.get(Math.min(p95Index, sortedLatencies.size() - 1));
        stats.setP95(p95);
        
        // 计算P99
        int p99Index = (int) (sortedLatencies.size() * 0.99);
        long p99 = sortedLatencies.get(Math.min(p99Index, sortedLatencies.size() - 1));
        stats.setP99(p99);
        
        // 计算最大值
        long max = sortedLatencies.get(sortedLatencies.size() - 1);
        stats.setMax(max);
        
        // 计算最小值
        long min = sortedLatencies.get(0);
        stats.setMin(min);
        
        // 计算标准差
        double variance = latencies.stream()
                .mapToDouble(latency -> Math.pow(latency - average, 2))
                .average()
                .orElse(0.0);
        double standardDeviation = Math.sqrt(variance);
        stats.setStandardDeviation(standardDeviation);
        
        return stats;
    }
    
    // 检测异常耗时
    private void detectAnomalousLatency(InterfaceLatencyData data, LatencyStatistics stats) {
        String interfaceName = data.getInterfaceName();
        
        // 检测平均耗时异常
        if (stats.getAverage() > 1000) { // 1秒
            log.warn("High average latency detected for interface {}: {} ms", 
                    interfaceName, stats.getAverage());
            triggerLatencyAlert(interfaceName, "High average latency", 
                    stats.getAverage(), AlertSeverity.WARNING);
        }
        
        // 检测P95耗时异常
        if (stats.getP95() > 2000) { // 2秒
            log.warn("High P95 latency detected for interface {}: {} ms", 
                    interfaceName, stats.getP95());
            triggerLatencyAlert(interfaceName, "High P95 latency", 
                    stats.getP95(), AlertSeverity.WARNING);
        }
        
        // 检测P99耗时异常
        if (stats.getP99() > 5000) { // 5秒
            log.warn("High P99 latency detected for interface {}: {} ms", 
                    interfaceName, stats.getP99());
            triggerLatencyAlert(interfaceName, "High P99 latency", 
                    stats.getP99(), AlertSeverity.CRITICAL);
        }
        
        // 检测最大耗时异常
        if (stats.getMax() > 10000) { // 10秒
            log.warn("Extremely high max latency detected for interface {}: {} ms", 
                    interfaceName, stats.getMax());
            triggerLatencyAlert(interfaceName, "Extremely high max latency", 
                    stats.getMax(), AlertSeverity.CRITICAL);
        }
        
        // 检测耗时波动异常
        if (stats.getStandardDeviation() > stats.getAverage() * 0.5) {
            log.warn("High latency variance detected for interface {}: {} ms", 
                    interfaceName, stats.getStandardDeviation());
            triggerLatencyAlert(interfaceName, "High latency variance", 
                    stats.getStandardDeviation(), AlertSeverity.WARNING);
        }
    }
    
    // 触发耗时告警
    private void triggerLatencyAlert(String interfaceName, String alertType, 
                                   double latency, AlertSeverity severity) {
        try {
            LatencyAlert alert = LatencyAlert.builder()
                    .interfaceName(interfaceName)
                    .alertType(alertType)
                    .latency(latency)
                    .severity(severity)
                    .timestamp(System.currentTimeMillis())
                    .build();
            
            alertManager.sendLatencyAlert(alert);
            
            meterRegistry.counter("latency.alert.triggered")
                    .tag("interface", interfaceName)
                    .tag("type", alertType)
                    .tag("severity", severity.name())
                    .increment();
            
        } catch (Exception e) {
            log.error("Error triggering latency alert", e);
        }
    }
    
    // 记录耗时历史
    private void recordLatencyHistory(InterfaceLatencyData data, LatencyStatistics stats) {
        try {
            LatencyHistoryRecord record = LatencyHistoryRecord.builder()
                    .interfaceName(data.getInterfaceName())
                    .timestamp(System.currentTimeMillis())
                    .averageLatency(stats.getAverage())
                    .medianLatency(stats.getMedian())
                    .p95Latency(stats.getP95())
                    .p99Latency(stats.getP99())
                    .maxLatency(stats.getMax())
                    .minLatency(stats.getMin())
                    .standardDeviation(stats.getStandardDeviation())
                    .sampleCount(data.getLatencies().size())
                    .build();
            
            // 这里可以将记录保存到数据库
            latencyCollector.saveLatencyHistory(record);
            
        } catch (Exception e) {
            log.error("Error recording latency history", e);
        }
    }
    
    // 分析耗时趋势
    public void analyzeLatencyTrends() {
        try {
            // 获取所有接口的耗时历史数据
            List<String> interfaceNames = latencyCollector.getAllInterfaceNames();
            
            for (String interfaceName : interfaceNames) {
                // 分析单个接口的耗时趋势
                analyzeInterfaceLatencyTrend(interfaceName);
            }
            
        } catch (Exception e) {
            log.error("Error analyzing latency trends", e);
            meterRegistry.counter("latency.trend.analysis.error").increment();
        }
    }
    
    // 分析单个接口的耗时趋势
    private void analyzeInterfaceLatencyTrend(String interfaceName) {
        try {
            // 获取接口的耗时历史数据
            List<LatencyHistoryRecord> historyRecords = latencyCollector.getLatencyHistory(
                    interfaceName, Duration.ofHours(1)); // 最近1小时
            
            if (historyRecords.size() < 10) {
                return; // 数据不足，无法分析趋势
            }
            
            // 分析趋势方向
            TrendDirection direction = analyzeTrendDirection(historyRecords);
            
            // 分析趋势强度
            double trendStrength = analyzeTrendStrength(historyRecords);
            
            // 预测未来耗时
            double predictedLatency = predictFutureLatency(historyRecords);
            
            // 检测趋势异常
            detectTrendAnomalies(interfaceName, direction, trendStrength, predictedLatency);
            
        } catch (Exception e) {
            log.error("Error analyzing latency trend for interface: {}", interfaceName, e);
        }
    }
    
    // 分析趋势方向
    private TrendDirection analyzeTrendDirection(List<LatencyHistoryRecord> records) {
        if (records.size() < 2) {
            return TrendDirection.STABLE;
        }
        
        // 使用线性回归分析趋势
        double slope = calculateLinearRegressionSlope(records);
        
        if (slope > 10) { // 每秒增加10ms
            return TrendDirection.INCREASING;
        } else if (slope < -10) { // 每秒减少10ms
            return TrendDirection.DECREASING;
        } else {
            return TrendDirection.STABLE;
        }
    }
    
    // 计算线性回归斜率
    private double calculateLinearRegressionSlope(List<LatencyHistoryRecord> records) {
        int n = records.size();
        double sumX = 0, sumY = 0, sumXY = 0, sumXX = 0;
        
        for (int i = 0; i < n; i++) {
            double x = i;
            double y = records.get(i).getAverageLatency();
            
            sumX += x;
            sumY += y;
            sumXY += x * y;
            sumXX += x * x;
        }
        
        return (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
    }
    
    // 分析趋势强度
    private double analyzeTrendStrength(List<LatencyHistoryRecord> records) {
        if (records.size() < 2) {
            return 0.0;
        }
        
        // 计算R²值来衡量趋势强度
        double slope = calculateLinearRegressionSlope(records);
        double meanY = records.stream().mapToDouble(LatencyHistoryRecord::getAverageLatency).average().orElse(0.0);
        
        double ssRes = 0.0; // 残差平方和
        double ssTot = 0.0; // 总平方和
        
        for (int i = 0; i < records.size(); i++) {
            double x = i;
            double y = records.get(i).getAverageLatency();
            double predictedY = slope * x + meanY;
            
            ssRes += Math.pow(y - predictedY, 2);
            ssTot += Math.pow(y - meanY, 2);
        }
        
        return 1 - (ssRes / ssTot);
    }
    
    // 预测未来耗时
    private double predictFutureLatency(List<LatencyHistoryRecord> records) {
        if (records.size() < 2) {
            return records.get(records.size() - 1).getAverageLatency();
        }
        
        // 使用线性回归预测未来值
        double slope = calculateLinearRegressionSlope(records);
        double meanY = records.stream().mapToDouble(LatencyHistoryRecord::getAverageLatency).average().orElse(0.0);
        
        // 预测下一个时间点的耗时
        double nextX = records.size();
        return slope * nextX + meanY;
    }
    
    // 检测趋势异常
    private void detectTrendAnomalies(String interfaceName, TrendDirection direction, 
                                    double trendStrength, double predictedLatency) {
        // 检测上升趋势异常
        if (direction == TrendDirection.INCREASING && trendStrength > 0.7) {
            log.warn("Strong increasing latency trend detected for interface {}: strength={}, predicted={} ms", 
                    interfaceName, trendStrength, predictedLatency);
            triggerLatencyAlert(interfaceName, "Increasing latency trend", 
                    predictedLatency, AlertSeverity.WARNING);
        }
        
        // 检测预测耗时异常
        if (predictedLatency > 2000) { // 2秒
            log.warn("High predicted latency for interface {}: {} ms", 
                    interfaceName, predictedLatency);
            triggerLatencyAlert(interfaceName, "High predicted latency", 
                    predictedLatency, AlertSeverity.WARNING);
        }
    }
    
    // 检查耗时告警
    public void checkLatencyAlerts() {
        try {
            // 获取所有告警规则
            List<LatencyAlertRule> alertRules = alertManager.getLatencyAlertRules();
            
            for (LatencyAlertRule rule : alertRules) {
                // 检查每个告警规则
                checkLatencyAlertRule(rule);
            }
            
        } catch (Exception e) {
            log.error("Error checking latency alerts", e);
            meterRegistry.counter("latency.alert.check.error").increment();
        }
    }
    
    // 检查单个告警规则
    private void checkLatencyAlertRule(LatencyAlertRule rule) {
        try {
            // 获取规则对应的接口数据
            InterfaceLatencyData data = latencyCollector.getInterfaceLatencyData(rule.getInterfaceName());
            
            if (data == null || data.getLatencies().isEmpty()) {
                return;
            }
            
            LatencyStatistics stats = calculateLatencyStatistics(data);
            
            // 检查告警条件
            boolean alertTriggered = false;
            String alertMessage = "";
            
            switch (rule.getMetricType()) {
                case AVERAGE:
                    if (stats.getAverage() > rule.getThreshold()) {
                        alertTriggered = true;
                        alertMessage = String.format("Average latency %.2f ms exceeds threshold %.2f ms", 
                                stats.getAverage(), rule.getThreshold());
                    }
                    break;
                case P95:
                    if (stats.getP95() > rule.getThreshold()) {
                        alertTriggered = true;
                        alertMessage = String.format("P95 latency %d ms exceeds threshold %.2f ms", 
                                stats.getP95(), rule.getThreshold());
                    }
                    break;
                case P99:
                    if (stats.getP99() > rule.getThreshold()) {
                        alertTriggered = true;
                        alertMessage = String.format("P99 latency %d ms exceeds threshold %.2f ms", 
                                stats.getP99(), rule.getThreshold());
                    }
                    break;
                case MAX:
                    if (stats.getMax() > rule.getThreshold()) {
                        alertTriggered = true;
                        alertMessage = String.format("Max latency %d ms exceeds threshold %.2f ms", 
                                stats.getMax(), rule.getThreshold());
                    }
                    break;
            }
            
            if (alertTriggered) {
                triggerLatencyAlert(rule.getInterfaceName(), alertMessage, 
                        rule.getThreshold(), rule.getSeverity());
            }
            
        } catch (Exception e) {
            log.error("Error checking latency alert rule: {}", rule, e);
        }
    }
    
    // 更新耗时指标
    private void updateLatencyMetrics(InterfaceLatencyData data) {
        String interfaceName = data.getInterfaceName();
        LatencyStatistics stats = calculateLatencyStatistics(data);
        
        // 更新平均耗时指标
        meterRegistry.gauge("interface.latency.average", stats.getAverage())
                .tag("interface", interfaceName)
                .register();
        
        // 更新P95耗时指标
        meterRegistry.gauge("interface.latency.p95", stats.getP95())
                .tag("interface", interfaceName)
                .register();
        
        // 更新P99耗时指标
        meterRegistry.gauge("interface.latency.p99", stats.getP99())
                .tag("interface", interfaceName)
                .register();
        
        // 更新最大耗时指标
        meterRegistry.gauge("interface.latency.max", stats.getMax())
                .tag("interface", interfaceName)
                .register();
        
        // 更新标准差指标
        meterRegistry.gauge("interface.latency.std_dev", stats.getStandardDeviation())
                .tag("interface", interfaceName)
                .register();
        
        // 更新样本数量指标
        meterRegistry.gauge("interface.latency.sample_count", data.getLatencies().size())
                .tag("interface", interfaceName)
                .register();
    }
}

// 耗时数据收集器
@Component
@Slf4j
public class LatencyDataCollector {
    
    private final Map<String, List<Long>> latencyDataMap = new ConcurrentHashMap<>();
    private final MeterRegistry meterRegistry;
    
    public LatencyDataCollector(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
    }
    
    // 记录接口耗时
    public void recordLatency(String interfaceName, long latency) {
        try {
            latencyDataMap.computeIfAbsent(interfaceName, k -> new ArrayList<>())
                    .add(latency);
            
            // 更新指标
            meterRegistry.counter("interface.latency.recorded")
                    .tag("interface", interfaceName)
                    .increment();
            
        } catch (Exception e) {
            log.error("Error recording latency for interface: {}", interfaceName, e);
        }
    }
    
    // 收集所有接口的耗时数据
    public List<InterfaceLatencyData> collectAllLatencyData() {
        List<InterfaceLatencyData> dataList = new ArrayList<>();
        
        try {
            for (Map.Entry<String, List<Long>> entry : latencyDataMap.entrySet()) {
                String interfaceName = entry.getKey();
                List<Long> latencies = new ArrayList<>(entry.getValue());
                
                InterfaceLatencyData data = InterfaceLatencyData.builder()
                        .interfaceName(interfaceName)
                        .latencies(latencies)
                        .timestamp(System.currentTimeMillis())
                        .build();
                
                dataList.add(data);
                
                // 清空已处理的数据
                entry.setValue(new ArrayList<>());
            }
            
        } catch (Exception e) {
            log.error("Error collecting latency data", e);
        }
        
        return dataList;
    }
    
    // 获取接口耗时数据
    public InterfaceLatencyData getInterfaceLatencyData(String interfaceName) {
        List<Long> latencies = latencyDataMap.get(interfaceName);
        
        if (latencies == null) {
            return null;
        }
        
        return InterfaceLatencyData.builder()
                .interfaceName(interfaceName)
                .latencies(new ArrayList<>(latencies))
                .timestamp(System.currentTimeMillis())
                .build();
    }
    
    // 获取所有接口名称
    public List<String> getAllInterfaceNames() {
        return new ArrayList<>(latencyDataMap.keySet());
    }
    
    // 获取接口耗时历史
    public List<LatencyHistoryRecord> getLatencyHistory(String interfaceName, Duration duration) {
        // 这里可以从数据库获取历史数据
        return new ArrayList<>();
    }
    
    // 保存耗时历史
    public void saveLatencyHistory(LatencyHistoryRecord record) {
        // 这里可以将记录保存到数据库
        log.debug("Saving latency history: {}", record);
    }
}

// 智能调用次数监控器
@Component
@Slf4j
public class IntelligentCallCountMonitor {
    
    private final CallCountCollector callCountCollector;
    private final CallCountAnalyzer callCountAnalyzer;
    private final CallCountAlertManager alertManager;
    private final MeterRegistry meterRegistry;
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(10);
    
    public IntelligentCallCountMonitor(CallCountCollector callCountCollector,
                                     CallCountAnalyzer callCountAnalyzer,
                                     CallCountAlertManager alertManager,
                                     MeterRegistry meterRegistry) {
        this.callCountCollector = callCountCollector;
        this.callCountAnalyzer = callCountAnalyzer;
        this.alertManager = alertManager;
        this.meterRegistry = meterRegistry;
        
        // 启动调用次数监控
        startCallCountMonitoring();
    }
    
    // 启动调用次数监控
    private void startCallCountMonitoring() {
        // 定期收集调用次数数据
        scheduler.scheduleAtFixedRate(() -> {
            try {
                collectCallCountData();
            } catch (Exception e) {
                log.error("Error collecting call count data", e);
            }
        }, 0, 1, TimeUnit.SECONDS);
        
        // 定期分析调用次数趋势
        scheduler.scheduleAtFixedRate(() -> {
            try {
                analyzeCallCountTrends();
            } catch (Exception e) {
                log.error("Error analyzing call count trends", e);
            }
        }, 0, 30, TimeUnit.SECONDS);
        
        // 定期检查调用次数告警
        scheduler.scheduleAtFixedRate(() -> {
            try {
                checkCallCountAlerts();
            } catch (Exception e) {
                log.error("Error checking call count alerts", e);
            }
        }, 0, 10, TimeUnit.SECONDS);
    }
    
    // 收集调用次数数据
    public void collectCallCountData() {
        try {
            // 获取所有接口的调用次数数据
            List<InterfaceCallCountData> callCountDataList = callCountCollector.collectAllCallCountData();
            
            for (InterfaceCallCountData data : callCountDataList) {
                // 处理每个接口的调用次数数据
                processCallCountData(data);
                
                // 更新指标
                updateCallCountMetrics(data);
            }
            
        } catch (Exception e) {
            log.error("Error collecting call count data", e);
            meterRegistry.counter("call_count.collection.error").increment();
        }
    }
    
    // 处理调用次数数据
    private void processCallCountData(InterfaceCallCountData data) {
        try {
            // 计算统计指标
            CallCountStatistics stats = calculateCallCountStatistics(data);
            
            // 检测异常调用次数
            detectAnomalousCallCount(data, stats);
            
            // 记录调用次数历史
            recordCallCountHistory(data, stats);
            
        } catch (Exception e) {
            log.error("Error processing call count data for interface: {}", data.getInterfaceName(), e);
        }
    }
    
    // 计算调用次数统计指标
    private CallCountStatistics calculateCallCountStatistics(InterfaceCallCountData data) {
        CallCountStatistics stats = new CallCountStatistics();
        
        List<CallCountRecord> records = data.getCallCountRecords();
        
        if (records.isEmpty()) {
            return stats;
        }
        
        // 计算总调用次数
        long totalCalls = records.stream().mapToLong(CallCountRecord::getCallCount).sum();
        stats.setTotalCalls(totalCalls);
        
        // 计算平均QPS
        double averageQPS = records.stream().mapToDouble(CallCountRecord::getQPS).average().orElse(0.0);
        stats.setAverageQPS(averageQPS);
        
        // 计算最大QPS
        double maxQPS = records.stream().mapToDouble(CallCountRecord::getQPS).max().orElse(0.0);
        stats.setMaxQPS(maxQPS);
        
        // 计算最小QPS
        double minQPS = records.stream().mapToDouble(CallCountRecord::getQPS).min().orElse(0.0);
        stats.setMinQPS(minQPS);
        
        // 计算QPS标准差
        double variance = records.stream()
                .mapToDouble(record -> Math.pow(record.getQPS() - averageQPS, 2))
                .average()
                .orElse(0.0);
        double standardDeviation = Math.sqrt(variance);
        stats.setQPSStandardDeviation(standardDeviation);
        
        // 计算成功率
        long totalSuccessCalls = records.stream().mapToLong(CallCountRecord::getSuccessCount).sum();
        double successRate = totalCalls > 0 ? (double) totalSuccessCalls / totalCalls : 0.0;
        stats.setSuccessRate(successRate);
        
        // 计算错误率
        long totalErrorCalls = records.stream().mapToLong(CallCountRecord::getErrorCount).sum();
        double errorRate = totalCalls > 0 ? (double) totalErrorCalls / totalCalls : 0.0;
        stats.setErrorRate(errorRate);
        
        return stats;
    }
    
    // 检测异常调用次数
    private void detectAnomalousCallCount(InterfaceCallCountData data, CallCountStatistics stats) {
        String interfaceName = data.getInterfaceName();
        
        // 检测QPS异常
        if (stats.getMaxQPS() > 1000) { // 1000 QPS
            log.warn("High QPS detected for interface {}: {} QPS", 
                    interfaceName, stats.getMaxQPS());
            triggerCallCountAlert(interfaceName, "High QPS", 
                    stats.getMaxQPS(), AlertSeverity.WARNING);
        }
        
        // 检测QPS波动异常
        if (stats.getQPSStandardDeviation() > stats.getAverageQPS() * 0.5) {
            log.warn("High QPS variance detected for interface {}: {} QPS", 
                    interfaceName, stats.getQPSStandardDeviation());
            triggerCallCountAlert(interfaceName, "High QPS variance", 
                    stats.getQPSStandardDeviation(), AlertSeverity.WARNING);
        }
        
        // 检测错误率异常
        if (stats.getErrorRate() > 0.05) { // 5%
            log.warn("High error rate detected for interface {}: {}%", 
                    interfaceName, stats.getErrorRate() * 100);
            triggerCallCountAlert(interfaceName, "High error rate", 
                    stats.getErrorRate() * 100, AlertSeverity.CRITICAL);
        }
        
        // 检测成功率异常
        if (stats.getSuccessRate() < 0.95) { // 95%
            log.warn("Low success rate detected for interface {}: {}%", 
                    interfaceName, stats.getSuccessRate() * 100);
            triggerCallCountAlert(interfaceName, "Low success rate", 
                    stats.getSuccessRate() * 100, AlertSeverity.WARNING);
        }
    }
    
    // 触发调用次数告警
    private void triggerCallCountAlert(String interfaceName, String alertType, 
                                      double value, AlertSeverity severity) {
        try {
            CallCountAlert alert = CallCountAlert.builder()
                    .interfaceName(interfaceName)
                    .alertType(alertType)
                    .value(value)
                    .severity(severity)
                    .timestamp(System.currentTimeMillis())
                    .build();
            
            alertManager.sendCallCountAlert(alert);
            
            meterRegistry.counter("call_count.alert.triggered")
                    .tag("interface", interfaceName)
                    .tag("type", alertType)
                    .tag("severity", severity.name())
                    .increment();
            
        } catch (Exception e) {
            log.error("Error triggering call count alert", e);
        }
    }
    
    // 记录调用次数历史
    private void recordCallCountHistory(InterfaceCallCountData data, CallCountStatistics stats) {
        try {
            CallCountHistoryRecord record = CallCountHistoryRecord.builder()
                    .interfaceName(data.getInterfaceName())
                    .timestamp(System.currentTimeMillis())
                    .totalCalls(stats.getTotalCalls())
                    .averageQPS(stats.getAverageQPS())
                    .maxQPS(stats.getMaxQPS())
                    .minQPS(stats.getMinQPS())
                    .qpsStandardDeviation(stats.getQPSStandardDeviation())
                    .successRate(stats.getSuccessRate())
                    .errorRate(stats.getErrorRate())
                    .build();
            
            // 这里可以将记录保存到数据库
            callCountCollector.saveCallCountHistory(record);
            
        } catch (Exception e) {
            log.error("Error recording call count history", e);
        }
    }
    
    // 分析调用次数趋势
    public void analyzeCallCountTrends() {
        try {
            // 获取所有接口的调用次数历史数据
            List<String> interfaceNames = callCountCollector.getAllInterfaceNames();
            
            for (String interfaceName : interfaceNames) {
                // 分析单个接口的调用次数趋势
                analyzeInterfaceCallCountTrend(interfaceName);
            }
            
        } catch (Exception e) {
            log.error("Error analyzing call count trends", e);
            meterRegistry.counter("call_count.trend.analysis.error").increment();
        }
    }
    
    // 分析单个接口的调用次数趋势
    private void analyzeInterfaceCallCountTrend(String interfaceName) {
        try {
            // 获取接口的调用次数历史数据
            List<CallCountHistoryRecord> historyRecords = callCountCollector.getCallCountHistory(
                    interfaceName, Duration.ofHours(1)); // 最近1小时
            
            if (historyRecords.size() < 10) {
                return; // 数据不足，无法分析趋势
            }
            
            // 分析QPS趋势
            TrendDirection qpsTrend = analyzeQPSTrend(historyRecords);
            
            // 分析成功率趋势
            TrendDirection successRateTrend = analyzeSuccessRateTrend(historyRecords);
            
            // 预测未来QPS
            double predictedQPS = predictFutureQPS(historyRecords);
            
            // 检测趋势异常
            detectCallCountTrendAnomalies(interfaceName, qpsTrend, successRateTrend, predictedQPS);
            
        } catch (Exception e) {
            log.error("Error analyzing call count trend for interface: {}", interfaceName, e);
        }
    }
    
    // 分析QPS趋势
    private TrendDirection analyzeQPSTrend(List<CallCountHistoryRecord> records) {
        if (records.size() < 2) {
            return TrendDirection.STABLE;
        }
        
        // 使用线性回归分析QPS趋势
        double slope = calculateQPSTrendSlope(records);
        
        if (slope > 10) { // 每秒增加10 QPS
            return TrendDirection.INCREASING;
        } else if (slope < -10) { // 每秒减少10 QPS
            return TrendDirection.DECREASING;
        } else {
            return TrendDirection.STABLE;
        }
    }
    
    // 计算QPS趋势斜率
    private double calculateQPSTrendSlope(List<CallCountHistoryRecord> records) {
        int n = records.size();
        double sumX = 0, sumY = 0, sumXY = 0, sumXX = 0;
        
        for (int i = 0; i < n; i++) {
            double x = i;
            double y = records.get(i).getAverageQPS();
            
            sumX += x;
            sumY += y;
            sumXY += x * y;
            sumXX += x * x;
        }
        
        return (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
    }
    
    // 分析成功率趋势
    private TrendDirection analyzeSuccessRateTrend(List<CallCountHistoryRecord> records) {
        if (records.size() < 2) {
            return TrendDirection.STABLE;
        }
        
        // 使用线性回归分析成功率趋势
        double slope = calculateSuccessRateTrendSlope(records);
        
        if (slope > 0.01) { // 每秒增加1%
            return TrendDirection.INCREASING;
        } else if (slope < -0.01) { // 每秒减少1%
            return TrendDirection.DECREASING;
        } else {
            return TrendDirection.STABLE;
        }
    }
    
    // 计算成功率趋势斜率
    private double calculateSuccessRateTrendSlope(List<CallCountHistoryRecord> records) {
        int n = records.size();
        double sumX = 0, sumY = 0, sumXY = 0, sumXX = 0;
        
        for (int i = 0; i < n; i++) {
            double x = i;
            double y = records.get(i).getSuccessRate();
            
            sumX += x;
            sumY += y;
            sumXY += x * y;
            sumXX += x * x;
        }
        
        return (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
    }
    
    // 预测未来QPS
    private double predictFutureQPS(List<CallCountHistoryRecord> records) {
        if (records.size() < 2) {
            return records.get(records.size() - 1).getAverageQPS();
        }
        
        // 使用线性回归预测未来QPS
        double slope = calculateQPSTrendSlope(records);
        double meanY = records.stream().mapToDouble(CallCountHistoryRecord::getAverageQPS).average().orElse(0.0);
        
        // 预测下一个时间点的QPS
        double nextX = records.size();
        return slope * nextX + meanY;
    }
    
    // 检测调用次数趋势异常
    private void detectCallCountTrendAnomalies(String interfaceName, TrendDirection qpsTrend, 
                                             TrendDirection successRateTrend, double predictedQPS) {
        // 检测QPS上升趋势异常
        if (qpsTrend == TrendDirection.INCREASING && predictedQPS > 1000) {
            log.warn("High predicted QPS for interface {}: {} QPS", 
                    interfaceName, predictedQPS);
            triggerCallCountAlert(interfaceName, "High predicted QPS", 
                    predictedQPS, AlertSeverity.WARNING);
        }
        
        // 检测成功率下降趋势异常
        if (successRateTrend == TrendDirection.DECREASING) {
            log.warn("Decreasing success rate trend detected for interface {}", interfaceName);
            triggerCallCountAlert(interfaceName, "Decreasing success rate trend", 
                    0, AlertSeverity.WARNING);
        }
    }
    
    // 检查调用次数告警
    public void checkCallCountAlerts() {
        try {
            // 获取所有告警规则
            List<CallCountAlertRule> alertRules = alertManager.getCallCountAlertRules();
            
            for (CallCountAlertRule rule : alertRules) {
                // 检查每个告警规则
                checkCallCountAlertRule(rule);
            }
            
        } catch (Exception e) {
            log.error("Error checking call count alerts", e);
            meterRegistry.counter("call_count.alert.check.error").increment();
        }
    }
    
    // 检查单个告警规则
    private void checkCallCountAlertRule(CallCountAlertRule rule) {
        try {
            // 获取规则对应的接口数据
            InterfaceCallCountData data = callCountCollector.getInterfaceCallCountData(rule.getInterfaceName());
            
            if (data == null || data.getCallCountRecords().isEmpty()) {
                return;
            }
            
            CallCountStatistics stats = calculateCallCountStatistics(data);
            
            // 检查告警条件
            boolean alertTriggered = false;
            String alertMessage = "";
            
            switch (rule.getMetricType()) {
                case QPS:
                    if (stats.getAverageQPS() > rule.getThreshold()) {
                        alertTriggered = true;
                        alertMessage = String.format("Average QPS %.2f exceeds threshold %.2f", 
                                stats.getAverageQPS(), rule.getThreshold());
                    }
                    break;
                case MAX_QPS:
                    if (stats.getMaxQPS() > rule.getThreshold()) {
                        alertTriggered = true;
                        alertMessage = String.format("Max QPS %.2f exceeds threshold %.2f", 
                                stats.getMaxQPS(), rule.getThreshold());
                    }
                    break;
                case ERROR_RATE:
                    if (stats.getErrorRate() > rule.getThreshold()) {
                        alertTriggered = true;
                        alertMessage = String.format("Error rate %.2f%% exceeds threshold %.2f%%", 
                                stats.getErrorRate() * 100, rule.getThreshold() * 100);
                    }
                    break;
                case SUCCESS_RATE:
                    if (stats.getSuccessRate() < rule.getThreshold()) {
                        alertTriggered = true;
                        alertMessage = String.format("Success rate %.2f%% below threshold %.2f%%", 
                                stats.getSuccessRate() * 100, rule.getThreshold() * 100);
                    }
                    break;
            }
            
            if (alertTriggered) {
                triggerCallCountAlert(rule.getInterfaceName(), alertMessage, 
                        rule.getThreshold(), rule.getSeverity());
            }
            
        } catch (Exception e) {
            log.error("Error checking call count alert rule: {}", rule, e);
        }
    }
    
    // 更新调用次数指标
    private void updateCallCountMetrics(InterfaceCallCountData data) {
        String interfaceName = data.getInterfaceName();
        CallCountStatistics stats = calculateCallCountStatistics(data);
        
        // 更新总调用次数指标
        meterRegistry.gauge("interface.call_count.total", stats.getTotalCalls())
                .tag("interface", interfaceName)
                .register();
        
        // 更新平均QPS指标
        meterRegistry.gauge("interface.call_count.average_qps", stats.getAverageQPS())
                .tag("interface", interfaceName)
                .register();
        
        // 更新最大QPS指标
        meterRegistry.gauge("interface.call_count.max_qps", stats.getMaxQPS())
                .tag("interface", interfaceName)
                .register();
        
        // 更新成功率指标
        meterRegistry.gauge("interface.call_count.success_rate", stats.getSuccessRate())
                .tag("interface", interfaceName)
                .register();
        
        // 更新错误率指标
        meterRegistry.gauge("interface.call_count.error_rate", stats.getErrorRate())
                .tag("interface", interfaceName)
                .register();
        
        // 更新QPS标准差指标
        meterRegistry.gauge("interface.call_count.qps_std_dev", stats.getQPSStandardDeviation())
                .tag("interface", interfaceName)
                .register();
    }
}

// 智能性能优化器
@Component
@Slf4j
public class IntelligentPerformanceOptimizer {
    
    private final PerformanceAnalyzer performanceAnalyzer;
    private final OptimizationStrategyManager strategyManager;
    private final MeterRegistry meterRegistry;
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(5);
    
    public IntelligentPerformanceOptimizer(PerformanceAnalyzer performanceAnalyzer,
                                          OptimizationStrategyManager strategyManager,
                                          MeterRegistry meterRegistry) {
        this.performanceAnalyzer = performanceAnalyzer;
        this.strategyManager = strategyManager;
        this.meterRegistry = meterRegistry;
        
        // 启动性能优化
        startPerformanceOptimization();
    }
    
    // 启动性能优化
    private void startPerformanceOptimization() {
        // 定期分析性能
        scheduler.scheduleAtFixedRate(() -> {
            try {
                analyzePerformance();
            } catch (Exception e) {
                log.error("Error analyzing performance", e);
            }
        }, 0, 60, TimeUnit.SECONDS);
        
        // 定期执行优化
        scheduler.scheduleAtFixedRate(() -> {
            try {
                executeOptimization();
            } catch (Exception e) {
                log.error("Error executing optimization", e);
            }
        }, 0, 300, TimeUnit.SECONDS);
    }
    
    // 分析性能
    public void analyzePerformance() {
        try {
            // 获取所有接口的性能数据
            List<InterfacePerformanceData> performanceDataList = performanceAnalyzer.getAllPerformanceData();
            
            for (InterfacePerformanceData data : performanceDataList) {
                // 分析单个接口的性能
                analyzeInterfacePerformance(data);
            }
            
        } catch (Exception e) {
            log.error("Error analyzing performance", e);
            meterRegistry.counter("performance.analysis.error").increment();
        }
    }
    
    // 分析单个接口的性能
    private void analyzeInterfacePerformance(InterfacePerformanceData data) {
        try {
            String interfaceName = data.getInterfaceName();
            
            // 分析性能瓶颈
            List<PerformanceBottleneck> bottlenecks = identifyPerformanceBottlenecks(data);
            
            // 分析优化机会
            List<OptimizationOpportunity> opportunities = identifyOptimizationOpportunities(data);
            
            // 生成优化建议
            List<OptimizationSuggestion> suggestions = generateOptimizationSuggestions(
                    interfaceName, bottlenecks, opportunities);
            
            // 执行优化建议
            executeOptimizationSuggestions(suggestions);
            
        } catch (Exception e) {
            log.error("Error analyzing interface performance: {}", data.getInterfaceName(), e);
        }
    }
    
    // 识别性能瓶颈
    private List<PerformanceBottleneck> identifyPerformanceBottlenecks(InterfacePerformanceData data) {
        List<PerformanceBottleneck> bottlenecks = new ArrayList<>();
        
        // 检查响应时间瓶颈
        if (data.getAverageLatency() > 1000) { // 1秒
            bottlenecks.add(PerformanceBottleneck.builder()
                    .type(BottleneckType.HIGH_LATENCY)
                    .description("High average latency: " + data.getAverageLatency() + " ms")
                    .severity(Severity.HIGH)
                    .build());
        }
        
        // 检查P95响应时间瓶颈
        if (data.getP95Latency() > 2000) { // 2秒
            bottlenecks.add(PerformanceBottleneck.builder()
                    .type(BottleneckType.HIGH_P95_LATENCY)
                    .description("High P95 latency: " + data.getP95Latency() + " ms")
                    .severity(Severity.HIGH)
                    .build());
        }
        
        // 检查QPS瓶颈
        if (data.getAverageQPS() > 1000) { // 1000 QPS
            bottlenecks.add(PerformanceBottleneck.builder()
                    .type(BottleneckType.HIGH_QPS)
                    .description("High QPS: " + data.getAverageQPS() + " QPS")
                    .severity(Severity.MEDIUM)
                    .build());
        }
        
        // 检查错误率瓶颈
        if (data.getErrorRate() > 0.05) { // 5%
            bottlenecks.add(PerformanceBottleneck.builder()
                    .type(BottleneckType.HIGH_ERROR_RATE)
                    .description("High error rate: " + (data.getErrorRate() * 100) + "%")
                    .severity(Severity.HIGH)
                    .build());
        }
        
        // 检查资源使用瓶颈
        if (data.getCpuUsage() > 0.8) { // 80%
            bottlenecks.add(PerformanceBottleneck.builder()
                    .type(BottleneckType.HIGH_CPU_USAGE)
                    .description("High CPU usage: " + (data.getCpuUsage() * 100) + "%")
                    .severity(Severity.MEDIUM)
                    .build());
        }
        
        if (data.getMemoryUsage() > 0.8) { // 80%
            bottlenecks.add(PerformanceBottleneck.builder()
                    .type(BottleneckType.HIGH_MEMORY_USAGE)
                    .description("High memory usage: " + (data.getMemoryUsage() * 100) + "%")
                    .severity(Severity.MEDIUM)
                    .build());
        }
        
        return bottlenecks;
    }
    
    // 识别优化机会
    private List<OptimizationOpportunity> identifyOptimizationOpportunities(InterfacePerformanceData data) {
        List<OptimizationOpportunity> opportunities = new ArrayList<>();
        
        // 缓存优化机会
        if (data.getCacheHitRate() < 0.8) { // 80%
            opportunities.add(OptimizationOpportunity.builder()
                    .type(OptimizationType.CACHE_OPTIMIZATION)
                    .description("Low cache hit rate: " + (data.getCacheHitRate() * 100) + "%")
                    .potentialImprovement(0.2) // 20% improvement
                    .effort(EffortLevel.MEDIUM)
                    .build());
        }
        
        // 数据库优化机会
        if (data.getDatabaseQueryTime() > data.getAverageLatency() * 0.5) {
            opportunities.add(OptimizationOpportunity.builder()
                    .type(OptimizationType.DATABASE_OPTIMIZATION)
                    .description("High database query time: " + data.getDatabaseQueryTime() + " ms")
                    .potentialImprovement(0.3) // 30% improvement
                    .effort(EffortLevel.HIGH)
                    .build());
        }
        
        // 网络优化机会
        if (data.getNetworkLatency() > data.getAverageLatency() * 0.3) {
            opportunities.add(OptimizationOpportunity.builder()
                    .type(OptimizationType.NETWORK_OPTIMIZATION)
                    .description("High network latency: " + data.getNetworkLatency() + " ms")
                    .potentialImprovement(0.15) // 15% improvement
                    .effort(EffortLevel.MEDIUM)
                    .build());
        }
        
        // 并发优化机会
        if (data.getConcurrencyLevel() < 0.5) {
            opportunities.add(OptimizationOpportunity.builder()
                    .type(OptimizationType.CONCURRENCY_OPTIMIZATION)
                    .description("Low concurrency level: " + (data.getConcurrencyLevel() * 100) + "%")
                    .potentialImprovement(0.25) // 25% improvement
                    .effort(EffortLevel.HIGH)
                    .build());
        }
        
        return opportunities;
    }
    
    // 生成优化建议
    private List<OptimizationSuggestion> generateOptimizationSuggestions(String interfaceName,
                                                                       List<PerformanceBottleneck> bottlenecks,
                                                                       List<OptimizationOpportunity> opportunities) {
        List<OptimizationSuggestion> suggestions = new ArrayList<>();
        
        // 基于瓶颈生成建议
        for (PerformanceBottleneck bottleneck : bottlenecks) {
            List<OptimizationSuggestion> bottleneckSuggestions = generateBottleneckSuggestions(
                    interfaceName, bottleneck);
            suggestions.addAll(bottleneckSuggestions);
        }
        
        // 基于优化机会生成建议
        for (OptimizationOpportunity opportunity : opportunities) {
            List<OptimizationSuggestion> opportunitySuggestions = generateOpportunitySuggestions(
                    interfaceName, opportunity);
            suggestions.addAll(opportunitySuggestions);
        }
        
        // 按优先级排序
        suggestions.sort((s1, s2) -> Integer.compare(s2.getPriority().getValue(), s1.getPriority().getValue()));
        
        return suggestions;
    }
    
    // 基于瓶颈生成建议
    private List<OptimizationSuggestion> generateBottleneckSuggestions(String interfaceName,
                                                                    PerformanceBottleneck bottleneck) {
        List<OptimizationSuggestion> suggestions = new ArrayList<>();
        
        switch (bottleneck.getType()) {
            case HIGH_LATENCY:
                suggestions.add(OptimizationSuggestion.builder()
                        .interfaceName(interfaceName)
                        .type(OptimizationType.CACHE_OPTIMIZATION)
                        .description("Add caching to reduce latency")
                        .priority(Priority.HIGH)
                        .effort(EffortLevel.MEDIUM)
                        .expectedImprovement(0.3)
                        .build());
                
                suggestions.add(OptimizationSuggestion.builder()
                        .interfaceName(interfaceName)
                        .type(OptimizationType.DATABASE_OPTIMIZATION)
                        .description("Optimize database queries")
                        .priority(Priority.HIGH)
                        .effort(EffortLevel.HIGH)
                        .expectedImprovement(0.4)
                        .build());
                break;
                
            case HIGH_QPS:
                suggestions.add(OptimizationSuggestion.builder()
                        .interfaceName(interfaceName)
                        .type(OptimizationType.LOAD_BALANCING)
                        .description("Implement load balancing")
                        .priority(Priority.MEDIUM)
                        .effort(EffortLevel.MEDIUM)
                        .expectedImprovement(0.5)
                        .build());
                
                suggestions.add(OptimizationSuggestion.builder()
                        .interfaceName(interfaceName)
                        .type(OptimizationType.CONCURRENCY_OPTIMIZATION)
                        .description("Increase concurrency")
                        .priority(Priority.MEDIUM)
                        .effort(EffortLevel.HIGH)
                        .expectedImprovement(0.3)
                        .build());
                break;
                
            case HIGH_ERROR_RATE:
                suggestions.add(OptimizationSuggestion.builder()
                        .interfaceName(interfaceName)
                        .type(OptimizationType.ERROR_HANDLING)
                        .description("Improve error handling")
                        .priority(Priority.HIGH)
                        .effort(EffortLevel.MEDIUM)
                        .expectedImprovement(0.2)
                        .build());
                
                suggestions.add(OptimizationSuggestion.builder()
                        .interfaceName(interfaceName)
                        .type(OptimizationType.CIRCUIT_BREAKER)
                        .description("Implement circuit breaker")
                        .priority(Priority.HIGH)
                        .effort(EffortLevel.MEDIUM)
                        .expectedImprovement(0.15)
                        .build());
                break;
        }
        
        return suggestions;
    }
    
    // 基于优化机会生成建议
    private List<OptimizationSuggestion> generateOpportunitySuggestions(String interfaceName,
                                                                      OptimizationOpportunity opportunity) {
        List<OptimizationSuggestion> suggestions = new ArrayList<>();
        
        switch (opportunity.getType()) {
            case CACHE_OPTIMIZATION:
                suggestions.add(OptimizationSuggestion.builder()
                        .interfaceName(interfaceName)
                        .type(OptimizationType.CACHE_OPTIMIZATION)
                        .description("Implement Redis caching")
                        .priority(Priority.MEDIUM)
                        .effort(EffortLevel.MEDIUM)
                        .expectedImprovement(opportunity.getPotentialImprovement())
                        .build());
                break;
                
            case DATABASE_OPTIMIZATION:
                suggestions.add(OptimizationSuggestion.builder()
                        .interfaceName(interfaceName)
                        .type(OptimizationType.DATABASE_OPTIMIZATION)
                        .description("Add database indexes")
                        .priority(Priority.HIGH)
                        .effort(EffortLevel.HIGH)
                        .expectedImprovement(opportunity.getPotentialImprovement())
                        .build());
                break;
                
            case NETWORK_OPTIMIZATION:
                suggestions.add(OptimizationSuggestion.builder()
                        .interfaceName(interfaceName)
                        .type(OptimizationType.NETWORK_OPTIMIZATION)
                        .description("Optimize network calls")
                        .priority(Priority.MEDIUM)
                        .effort(EffortLevel.MEDIUM)
                        .expectedImprovement(opportunity.getPotentialImprovement())
                        .build());
                break;
                
            case CONCURRENCY_OPTIMIZATION:
                suggestions.add(OptimizationSuggestion.builder()
                        .interfaceName(interfaceName)
                        .type(OptimizationType.CONCURRENCY_OPTIMIZATION)
                        .description("Implement async processing")
                        .priority(Priority.MEDIUM)
                        .effort(EffortLevel.HIGH)
                        .expectedImprovement(opportunity.getPotentialImprovement())
                        .build());
                break;
        }
        
        return suggestions;
    }
    
    // 执行优化建议
    private void executeOptimizationSuggestions(List<OptimizationSuggestion> suggestions) {
        for (OptimizationSuggestion suggestion : suggestions) {
            try {
                // 检查是否应该执行这个建议
                if (shouldExecuteSuggestion(suggestion)) {
                    // 执行优化建议
                    executeSuggestion(suggestion);
                    
                    // 记录执行结果
                    recordOptimizationExecution(suggestion);
                }
                
            } catch (Exception e) {
                log.error("Error executing optimization suggestion: {}", suggestion, e);
            }
        }
    }
    
    // 检查是否应该执行建议
    private boolean shouldExecuteSuggestion(OptimizationSuggestion suggestion) {
        // 只执行高优先级的建议
        if (suggestion.getPriority() != Priority.HIGH) {
            return false;
        }
        
        // 检查是否已经执行过
        if (hasBeenExecuted(suggestion)) {
            return false;
        }
        
        // 检查资源是否足够
        if (!hasEnoughResources(suggestion)) {
            return false;
        }
        
        return true;
    }
    
    // 执行建议
    private void executeSuggestion(OptimizationSuggestion suggestion) {
        log.info("Executing optimization suggestion: {}", suggestion);
        
        switch (suggestion.getType()) {
            case CACHE_OPTIMIZATION:
                executeCacheOptimization(suggestion);
                break;
            case DATABASE_OPTIMIZATION:
                executeDatabaseOptimization(suggestion);
                break;
            case NETWORK_OPTIMIZATION:
                executeNetworkOptimization(suggestion);
                break;
            case CONCURRENCY_OPTIMIZATION:
                executeConcurrencyOptimization(suggestion);
                break;
            case LOAD_BALANCING:
                executeLoadBalancingOptimization(suggestion);
                break;
            case ERROR_HANDLING:
                executeErrorHandlingOptimization(suggestion);
                break;
            case CIRCUIT_BREAKER:
                executeCircuitBreakerOptimization(suggestion);
                break;
        }
    }
    
    // 执行缓存优化
    private void executeCacheOptimization(OptimizationSuggestion suggestion) {
        log.info("Executing cache optimization for interface: {}", suggestion.getInterfaceName());
        // 这里可以实现缓存优化逻辑
    }
    
    // 执行数据库优化
    private void executeDatabaseOptimization(OptimizationSuggestion suggestion) {
        log.info("Executing database optimization for interface: {}", suggestion.getInterfaceName());
        // 这里可以实现数据库优化逻辑
    }
    
    // 执行网络优化
    private void executeNetworkOptimization(OptimizationSuggestion suggestion) {
        log.info("Executing network optimization for interface: {}", suggestion.getInterfaceName());
        // 这里可以实现网络优化逻辑
    }
    
    // 执行并发优化
    private void executeConcurrencyOptimization(OptimizationSuggestion suggestion) {
        log.info("Executing concurrency optimization for interface: {}", suggestion.getInterfaceName());
        // 这里可以实现并发优化逻辑
    }
    
    // 执行负载均衡优化
    private void executeLoadBalancingOptimization(OptimizationSuggestion suggestion) {
        log.info("Executing load balancing optimization for interface: {}", suggestion.getInterfaceName());
        // 这里可以实现负载均衡优化逻辑
    }
    
    // 执行错误处理优化
    private void executeErrorHandlingOptimization(OptimizationSuggestion suggestion) {
        log.info("Executing error handling optimization for interface: {}", suggestion.getInterfaceName());
        // 这里可以实现错误处理优化逻辑
    }
    
    // 执行熔断器优化
    private void executeCircuitBreakerOptimization(OptimizationSuggestion suggestion) {
        log.info("Executing circuit breaker optimization for interface: {}", suggestion.getInterfaceName());
        // 这里可以实现熔断器优化逻辑
    }
    
    // 检查是否已经执行过
    private boolean hasBeenExecuted(OptimizationSuggestion suggestion) {
        // 这里可以检查建议是否已经执行过
        return false;
    }
    
    // 检查是否有足够资源
    private boolean hasEnoughResources(OptimizationSuggestion suggestion) {
        // 这里可以检查是否有足够的资源执行建议
        return true;
    }
    
    // 记录优化执行
    private void recordOptimizationExecution(OptimizationSuggestion suggestion) {
        try {
            OptimizationExecutionRecord record = OptimizationExecutionRecord.builder()
                    .interfaceName(suggestion.getInterfaceName())
                    .suggestionType(suggestion.getType())
                    .description(suggestion.getDescription())
                    .executionTime(System.currentTimeMillis())
                    .expectedImprovement(suggestion.getExpectedImprovement())
                    .build();
            
            // 这里可以将记录保存到数据库
            log.info("Optimization execution recorded: {}", record);
            
            meterRegistry.counter("optimization.execution.success")
                    .tag("interface", suggestion.getInterfaceName())
                    .tag("type", suggestion.getType().name())
                    .increment();
            
        } catch (Exception e) {
            log.error("Error recording optimization execution", e);
        }
    }
    
    // 执行优化
    public void executeOptimization() {
        log.info("Executing performance optimization");
        
        try {
            // 获取所有优化建议
            List<OptimizationSuggestion> suggestions = strategyManager.getAllOptimizationSuggestions();
            
            // 执行优化建议
            executeOptimizationSuggestions(suggestions);
            
            meterRegistry.counter("optimization.execution.success").increment();
            
        } catch (Exception e) {
            log.error("Error executing optimization", e);
            meterRegistry.counter("optimization.execution.error").increment();
        }
    }
}

// 接口性能告警配置
@Configuration
public class InterfacePerformanceAlertConfig {
    
    @Bean
    public AlertRule highLatencyAlertRule() {
        return AlertRule.builder()
                .name("High Interface Latency")
                .description("Interface latency is too high")
                .condition("interface.latency.average > 1000")
                .severity(AlertSeverity.WARNING)
                .enabled(true)
                .build();
    }
    
    @Bean
    public AlertRule highP95LatencyAlertRule() {
        return AlertRule.builder()
                .name("High P95 Latency")
                .description("P95 latency is too high")
                .condition("interface.latency.p95 > 2000")
                .severity(AlertSeverity.WARNING)
                .enabled(true)
                .build();
    }
    
    @Bean
    public AlertRule highP99LatencyAlertRule() {
        return AlertRule.builder()
                .name("High P99 Latency")
                .description("P99 latency is too high")
                .condition("interface.latency.p99 > 5000")
                .severity(AlertSeverity.CRITICAL)
                .enabled(true)
                .build();
    }
    
    @Bean
    public AlertRule highQPSAlertRule() {
        return AlertRule.builder()
                .name("High QPS")
                .description("QPS is too high")
                .condition("interface.call_count.average_qps > 1000")
                .severity(AlertSeverity.WARNING)
                .enabled(true)
                .build();
    }
    
    @Bean
    public AlertRule highErrorRateAlertRule() {
        return AlertRule.builder()
                .name("High Error Rate")
                .description("Error rate is too high")
                .condition("interface.call_count.error_rate > 0.05")
                .severity(AlertSeverity.CRITICAL)
                .enabled(true)
                .build();
    }
    
    @Bean
    public AlertRule lowSuccessRateAlertRule() {
        return AlertRule.builder()
                .name("Low Success Rate")
                .description("Success rate is too low")
                .condition("interface.call_count.success_rate < 0.95")
                .severity(AlertSeverity.WARNING)
                .enabled(true)
                .build();
    }
}