// 示例：成本评估模型
@Component
public class CostEvaluationModel {
    
    @Autowired
    private SupplierProfileService supplierProfileService;
    
    @Autowired
    private CostHistoryService costHistoryService;
    
    // 计算供应商综合成本
    public double calculateSupplierCost(String supplierId, String businessType, int messageCount) {
        SupplierProfile supplier = supplierProfileService.getSupplierProfile(supplierId);
        if (supplier == null) {
            return Double.MAX_VALUE; // 供应商不存在，成本无限大
        }
        
        CostConfiguration costConfig = supplier.getCostConfig();
        if (costConfig == null) {
            return Double.MAX_VALUE;
        }
        
        double totalCost = 0.0;
        
        // 基础费用
        if (costConfig.getBasePrice() != null) {
            totalCost += costConfig.getBasePrice().doubleValue();
        }
        
        // 按条计费
        if (costConfig.getPerMessagePrice() != null) {
            totalCost += costConfig.getPerMessagePrice().doubleValue() * messageCount;
        }
        
        // 分层定价
        if (costConfig.getTieredPricing() != null && !costConfig.getTieredPricing().isEmpty()) {
            totalCost += calculateTieredCost(costConfig.getTieredPricing(), messageCount);
        }
        
        // 免费额度扣除
        if (costConfig.getFreeQuota() != null) {
            int remainingQuota = Math.max(0, 
                costConfig.getFreeQuota().intValue() - getCurrentMonthUsage(supplierId));
            int billableCount = Math.max(0, messageCount - remainingQuota);
            totalCost = costConfig.getPerMessagePrice().doubleValue() * billableCount;
        }
        
        // 动态成本调整（基于历史数据）
        double dynamicFactor = calculateDynamicCostFactor(supplierId, businessType);
        totalCost *= dynamicFactor;
        
        return totalCost;
    }
    
    // 计算分层成本
    private double calculateTieredCost(Map<String, BigDecimal> tieredPricing, int messageCount) {
        double tieredCost = 0.0;
        int remainingCount = messageCount;
        
        // 按价格从低到高排序
        List<Map.Entry<String, BigDecimal>> sortedTiers = 
            tieredPricing.entrySet().stream()
                .sorted(Comparator.comparing(e -> e.getValue()))
                .collect(Collectors.toList());
        
        for (Map.Entry<String, BigDecimal> tier : sortedTiers) {
            if (remainingCount <= 0) {
                break;
            }
            
            String[] range = tier.getKey().split("-");
            int tierStart = Integer.parseInt(range[0]);
            int tierEnd = range.length > 1 ? Integer.parseInt(range[1]) : Integer.MAX_VALUE;
            int tierSize = tierEnd - tierStart + 1;
            
            int currentTierCount = Math.min(remainingCount, tierSize);
            tieredCost += tier.getValue().doubleValue() * currentTierCount;
            remainingCount -= currentTierCount;
        }
        
        return tieredCost;
    }
    
    // 计算动态成本因子
    private double calculateDynamicCostFactor(String supplierId, String businessType) {
        // 基于历史成本数据计算动态因子
        List<CostHistory> recentCosts = costHistoryService.getRecentCosts(
            supplierId, businessType, 30); // 最近30天
            
        if (recentCosts.isEmpty()) {
            return 1.0; // 没有历史数据，使用默认因子
        }
        
        // 计算平均成本变化趋势
        double averageCost = recentCosts.stream()
            .mapToDouble(CostHistory::getCost)
            .average()
            .orElse(0.0);
            
        double currentCost = recentCosts.get(recentCosts.size() - 1).getCost();
        
        // 如果当前成本高于平均成本，增加成本因子
        if (averageCost > 0 && currentCost > averageCost) {
            return 1.0 + (currentCost - averageCost) / averageCost;
        }
        
        return 1.0;
    }
    
    // 获取当月使用量
    private int getCurrentMonthUsage(String supplierId) {
        // 从统计服务获取当月使用量
        return statisticsService.getCurrentMonthUsage(supplierId);
    }
}

关键成本要点：

多维度计算：综合考虑基础费用、按条计费、分层定价等
免费额度：合理处理免费额度扣除
动态调整：基于历史数据动态调整成本评估
实时计算：支持实时成本计算

到达率维度

// 示例：到达率评估模型
@Component
public class DeliveryRateEvaluationModel {
    
    @Autowired
    private SupplierHealthService supplierHealthService;
    
    @Autowired
    private DeliveryReceiptService deliveryReceiptService;
    
    // 计算供应商到达率
    public double calculateDeliveryRate(String supplierId, String businessType, String countryCode) {
        SupplierHealth health = supplierHealthService.getSupplierHealth(supplierId);
        if (health == null) {
            return 0.0; // 无健康数据，到达率为0
        }
        
        // 基础到达率
        double baseDeliveryRate = health.getSuccessRate();
        
        // 地域到达率调整
        double regionalAdjustment = getRegionalDeliveryRateAdjustment(supplierId, countryCode);
        
        // 业务类型调整
        double businessTypeAdjustment = getBusinessTypeAdjustment(supplierId, businessType);
        
        // 时间衰减因子（近期表现权重更高）
        double timeDecayFactor = calculateTimeDecayFactor(health);
        
        // 综合到达率计算
        double综合到达率 = baseDeliveryRate * regionalAdjustment * businessTypeAdjustment * timeDecayFactor;
        
        // 确保到达率在合理范围内
        return Math.max(0.0, Math.min(1.0, 综合到达率));
    }
    
    // 获取地域到达率调整因子
    private double getRegionalDeliveryRateAdjustment(String supplierId, String countryCode) {
        if (StringUtils.isEmpty(countryCode)) {
            return 1.0; // 无地域信息，不调整
        }
        
        SupplierProfile supplier = supplierProfileService.getSupplierProfile(supplierId);
        if (supplier == null) {
            return 1.0;
        }
        
        // 检查供应商是否支持该地域
        if (!supplier.getCoverageAreas().contains(countryCode)) {
            return 0.0; // 不支持该地域，到达率为0
        }
        
        // 从历史数据获取地域到达率
        Double regionalRate = deliveryReceiptService.getRegionalDeliveryRate(supplierId, countryCode);
        if (regionalRate == null) {
            return 1.0; // 无历史数据，使用默认值
        }
        
        // 与全局到达率比较，计算调整因子
        SupplierHealth health = supplierHealthService.getSupplierHealth(supplierId);
        double globalRate = health != null ? health.getSuccessRate() : 0.8; // 默认全局到达率80%
        
        if (globalRate > 0) {
            return regionalRate / globalRate;
        }
        
        return 1.0;
    }
    
    // 获取业务类型调整因子
    private double getBusinessTypeAdjustment(String supplierId, String businessType) {
        // 从配置获取业务类型调整因子
        Double adjustment = configurationService.getBusinessTypeAdjustment(
            supplierId, businessType);
        return adjustment != null ? adjustment : 1.0;
    }
    
    // 计算时间衰减因子
    private double calculateTimeDecayFactor(SupplierHealth health) {
        if (health == null || health.getLastRequestTime() == null) {
            return 1.0;
        }
        
        long hoursSinceLastRequest = Duration.between(
            health.getLastRequestTime(), LocalDateTime.now()).toHours();
            
        // 使用指数衰减函数，最近的表现权重更高
        double decayRate = 0.1; // 衰减率
        return Math.exp(-decayRate * hoursSinceLastRequest);
    }
}

关键到达率要点：

多维度评估：综合考虑全局、地域、业务类型等因素
动态调整：基于实时数据动态调整到达率评估
时间权重：近期表现权重更高
地域适配：考虑供应商的地域覆盖能力

延迟维度

// 示例：延迟评估模型
@Component
public class LatencyEvaluationModel {
    
    @Autowired
    private SupplierHealthService supplierHealthService;
    
    @Autowired
    private NetworkQualityService networkQualityService;
    
    // 计算供应商延迟评分
    public double calculateLatencyScore(String supplierId, String receiverLocation) {
        SupplierHealth health = supplierHealthService.getSupplierHealth(supplierId);
        if (health == null) {
            return 0.0; // 无健康数据，延迟评分最低
        }
        
        // 基础响应时间
        long baseResponseTime = health.getAverageResponseTime();
        
        // 网络质量调整
        double networkQualityAdjustment = getNetworkQualityAdjustment(supplierId, receiverLocation);
        
        // 负载调整
        double loadAdjustment = getLoadAdjustment(supplierId);
        
        // 综合延迟计算
        double综合延迟 = baseResponseTime * networkQualityAdjustment * loadAdjustment;
        
        // 转换为评分（延迟越低，评分越高）
        return calculateLatencyScoreFromTime(综合延迟);
    }
    
    // 根据延迟时间计算评分
    private double calculateLatencyScoreFromTime(double latencyMs) {
        // 使用反比例函数，延迟越低评分越高
        if (latencyMs <= 0) {
            return 100.0; // 理想情况，满分
        }
        
        // 设定基准延迟为1000ms，对应评分为50分
        double baseLatency = 1000.0;
        double baseScore = 50.0;
        
        // 使用反比例函数计算评分
        double score = baseScore * baseLatency / latencyMs;
        
        // 限制评分范围
        return Math.max(0.0, Math.min(100.0, score));
    }
    
    // 获取网络质量调整因子
    private double getNetworkQualityAdjustment(String supplierId, String receiverLocation) {
        if (StringUtils.isEmpty(receiverLocation)) {
            return 1.0; // 无位置信息，不调整
        }
        
        // 获取供应商节点位置
        String supplierLocation = getSupplierLocation(supplierId);
        if (StringUtils.isEmpty(supplierLocation)) {
            return 1.0; // 无供应商位置信息，不调整
        }
        
        // 计算网络距离
        double distance = calculateDistance(supplierLocation, receiverLocation);
        
        // 获取网络质量指数
        double networkQualityIndex = networkQualityService.getNetworkQuality(
            supplierLocation, receiverLocation);
            
        // 综合调整因子（距离和网络质量的综合影响）
        double distanceFactor = 1.0 + (distance / 10000.0); // 每10000公里增加1倍延迟
        double qualityFactor = networkQualityIndex > 0 ? (2.0 - networkQualityIndex) : 1.0;
        
        return distanceFactor * qualityFactor;
    }
    
    // 获取负载调整因子
    private double getLoadAdjustment(String supplierId) {
        SupplierHealth health = supplierHealthService.getSupplierHealth(supplierId);
        if (health == null) {
            return 1.0;
        }
        
        // 计算当前负载比例
        double currentLoad = (double) health.getCurrentConnections() / health.getMaxConnections();
        
        // 负载越高，延迟越长
        if (currentLoad < 0.7) {
            return 1.0; // 负载较低，无影响
        } else if (currentLoad < 0.9) {
            return 1.0 + (currentLoad - 0.7) * 2.0; // 负载中等，适度增加延迟
        } else {
            return 1.0 + (currentLoad - 0.7) * 5.0; // 负载高，大幅增加延迟
        }
    }
    
    // 计算地理距离（简化实现）
    private double calculateDistance(String location1, String location2) {
        // 实际实现中应使用更精确的地理距离计算算法
        // 这里使用简化的计算方法
        return 1000.0; // 示例值
    }
    
    // 获取供应商位置
    private String getSupplierLocation(String supplierId) {
        SupplierProfile supplier = supplierProfileService.getSupplierProfile(supplierId);
        if (supplier != null) {
            return supplier.getProviderConfig().getCustomProperties().get("location");
        }
        return null;
    }
}

关键延迟要点：

多因素计算：综合响应时间、网络质量、负载等因素
地理位置：考虑发送方和接收方的地理位置
网络质量：基于实际网络质量调整延迟评估
负载影响：考虑供应商当前负载对延迟的影响

地域维度

// 示例：地域评估模型
@Component
public class RegionalEvaluationModel {
    
    @Autowired
    private SupplierProfileService supplierProfileService;
    
    @Autowired
    private RegulatoryComplianceService complianceService;
    
    // 计算地域适配评分
    public double calculateRegionalScore(String supplierId, String countryCode) {
        if (StringUtils.isEmpty(countryCode)) {
            return 1.0; // 无地域要求，完全适配
        }
        
        SupplierProfile supplier = supplierProfileService.getSupplierProfile(supplierId);
        if (supplier == null) {
            return 0.0; // 供应商不存在，不适配
        }
        
        // 检查地域覆盖
        if (!supplier.getCoverageAreas().contains(countryCode)) {
            return 0.0; // 不支持该地域
        }
        
        // 合规性检查
        double complianceScore = checkRegulatoryCompliance(supplierId, countryCode);
        
        // 本地化支持检查
        double localizationScore = checkLocalizationSupport(supplierId, countryCode);
        
        // 网络质量检查
        double networkQualityScore = checkNetworkQuality(supplierId, countryCode);
        
        // 综合地域评分
        return complianceScore * 0.4 + localizationScore * 0.3 + networkQualityScore * 0.3;
    }
    
    // 检查法规合规性
    private double checkRegulatoryCompliance(String supplierId, String countryCode) {
        // 检查供应商是否符合目标国家/地区的法规要求
        boolean isCompliant = complianceService.isSupplierCompliant(supplierId, countryCode);
        return isCompliant ? 1.0 : 0.0;
    }
    
    // 检查本地化支持
    private double checkLocalizationSupport(String supplierId, String countryCode) {
        SupplierProfile supplier = supplierProfileService.getSupplierProfile(supplierId);
        if (supplier == null) {
            return 0.0;
        }
        
        // 检查是否支持本地语言
        String localLanguage = getLocalLanguage(countryCode);
        boolean supportsLocalLanguage = supplier.getSupportedLanguages().contains(localLanguage);
        
        // 检查是否支持本地号码格式
        boolean supportsLocalNumberFormat = supplier.getSupportedNumberFormats().contains(countryCode);
        
        // 检查是否有本地客服支持
        boolean hasLocalSupport = supplier.getLocalSupportCountries().contains(countryCode);
        
        // 计算本地化支持评分
        int supportCount = 0;
        if (supportsLocalLanguage) supportCount++;
        if (supportsLocalNumberFormat) supportCount++;
        if (hasLocalSupport) supportCount++;
        
        return (double) supportCount / 3.0;
    }
    
    // 检查网络质量
    private double checkNetworkQuality(String supplierId, String countryCode) {
        // 获取该地域的网络质量评分
        Double networkQuality = networkQualityService.getRegionalNetworkQuality(
            supplierId, countryCode);
        return networkQuality != null ? networkQuality : 0.8; // 默认80分
    }
    
    // 获取国家/地区的本地语言
    private String getLocalLanguage(String countryCode) {
        // 根据国家代码返回主要语言代码
        switch (countryCode.toUpperCase()) {
            case "CN": return "zh-CN";
            case "US": return "en-US";
            case "JP": return "ja-JP";
            case "KR": return "ko-KR";
            case "GB": return "en-GB";
            default: return "en-US";
        }
    }
}

关键地域要点：

覆盖检查：检查供应商的地域覆盖范围
合规性：确保符合当地法规要求
本地化：支持本地语言和号码格式
网络质量：考虑地域网络质量因素

综合评分算法

// 示例：综合评分算法
@Component
public class ComprehensiveRoutingScoreCalculator {
    
    @Autowired
    private CostEvaluationModel costEvaluationModel;
    
    @Autowired
    private DeliveryRateEvaluationModel deliveryRateEvaluationModel;
    
    @Autowired
    private LatencyEvaluationModel latencyEvaluationModel;
    
    @Autowired
    private RegionalEvaluationModel regionalEvaluationModel;
    
    // 计算供应商综合评分
    public double calculateComprehensiveScore(String supplierId, 
                                           RoutingContext context) {
        // 计算各维度评分
        double costScore = calculateCostScore(supplierId, context);
        double deliveryRateScore = calculateDeliveryRateScore(supplierId, context);
        double latencyScore = calculateLatencyScore(supplierId, context);
        double regionalScore = calculateRegionalScore(supplierId, context);
        
        // 获取权重配置
        RoutingWeights weights = getRoutingWeights(context.getBusinessType());
        
        // 计算综合评分
        double comprehensiveScore = 
            costScore * weights.getCostWeight() +
            deliveryRateScore * weights.getDeliveryRateWeight() +
            latencyScore * weights.getLatencyWeight() +
            regionalScore * weights.getRegionalWeight();
            
        // 应用动态调整因子
        double dynamicAdjustment = calculateDynamicAdjustment(supplierId, context);
        
        return comprehensiveScore * dynamicAdjustment;
    }
    
    // 计算成本评分（成本越低，评分越高）
    private double calculateCostScore(String supplierId, RoutingContext context) {
        double cost = costEvaluationModel.calculateSupplierCost(
            supplierId, context.getBusinessType(), context.getMessageCount());
            
        // 成本评分使用反比例函数
        if (cost <= 0) {
            return 100.0; // 成本为0或负数，最高分
        }
        
        // 设定基准成本，对应基准评分
        double baseCost = 0.01; // 基准成本（每条消息1分钱）
        double baseScore = 80.0; // 基准评分
        
        double score = baseScore * baseCost / cost;
        return Math.max(0.0, Math.min(100.0, score));
    }
    
    // 计算到达率评分
    private double calculateDeliveryRateScore(String supplierId, RoutingContext context) {
        double deliveryRate = deliveryRateEvaluationModel.calculateDeliveryRate(
            supplierId, context.getBusinessType(), context.getReceiverCountryCode());
            
        // 到达率直接作为评分（百分比形式）
        return deliveryRate * 100.0;
    }
    
    // 计算延迟评分
    private double calculateLatencyScore(String supplierId, RoutingContext context) {
        return latencyEvaluationModel.calculateLatencyScore(
            supplierId, context.getReceiverLocation());
    }
    
    // 计算地域评分
    private double calculateRegionalScore(String supplierId, RoutingContext context) {
        return regionalEvaluationModel.calculateRegionalScore(
            supplierId, context.getReceiverCountryCode());
    }
    
    // 获取路由权重配置
    private RoutingWeights getRoutingWeights(String businessType) {
        // 根据业务类型获取不同的权重配置
        switch (businessType.toLowerCase()) {
            case "verification":
                // 验证码业务：到达率最重要，其次是延迟，成本相对不重要
                return new RoutingWeights(0.2, 0.5, 0.2, 0.1);
            case "marketing":
                // 营销业务：成本最重要，其次是到达率
                return new RoutingWeights(0.5, 0.3, 0.1, 0.1);
            case "notification":
                // 通知业务：平衡考虑各因素
                return new RoutingWeights(0.25, 0.25, 0.25, 0.25);
            case "alert":
                // 告警业务：延迟最重要，其次是到达率
                return new RoutingWeights(0.1, 0.3, 0.5, 0.1);
            default:
                // 默认权重
                return new RoutingWeights(0.25, 0.25, 0.25, 0.25);
        }
    }
    
    // 计算动态调整因子
    private double calculateDynamicAdjustment(String supplierId, RoutingContext context) {
        double adjustment = 1.0;
        
        // 考虑供应商当前状态
        SupplierHealth health = supplierHealthService.getSupplierHealth(supplierId);
        if (health != null) {
            // 如果供应商最近有故障，降低评分
            if (health.getSuccessiveFailureCount() > 0) {
                adjustment *= 0.8; // 降低20%
            }
            
            // 如果供应商负载过高，降低评分
            double loadRatio = (double) health.getCurrentConnections() / health.getMaxConnections();
            if (loadRatio > 0.9) {
                adjustment *= 0.7; // 负载过高，降低30%
            } else if (loadRatio > 0.8) {
                adjustment *= 0.9; // 负载较高，降低10%
            }
        }
        
        return adjustment;
    }
}

// 路由上下文
public class RoutingContext {
    private String businessType;
    private String receiverCountryCode;
    private String receiverLocation;
    private int messageCount;
    private Map<String, Object> extendedProperties;
    
    // 构造函数、getter和setter方法...
}

// 路由权重配置
public class RoutingWeights {
    private double costWeight;
    private double deliveryRateWeight;
    private double latencyWeight;
    private double regionalWeight;
    
    public RoutingWeights(double costWeight, double deliveryRateWeight, 
                         double latencyWeight, double regionalWeight) {
        this.costWeight = costWeight;
        this.deliveryRateWeight = deliveryRateWeight;
        this.latencyWeight = latencyWeight;
        this.regionalWeight = regionalWeight;
        
        // 验证权重总和为1
        double total = costWeight + deliveryRateWeight + latencyWeight + regionalWeight;
        if (Math.abs(total - 1.0) > 0.001) {
            throw new IllegalArgumentException("权重总和必须为1.0");
        }
    }
    
    // getter方法...
}

关键评分要点：

多维度综合：综合考虑成本、到达率、延迟、地域等因素
动态权重：根据不同业务类型设置不同权重
实时计算：基于实时数据计算评分
调整机制：支持动态调整因子

智能路由实现

基于评估模型实现智能路由决策：

路由决策引擎

// 示例：智能路由决策引擎
@Service
public class IntelligentRoutingEngine {
    
    @Autowired
    private ComprehensiveRoutingScoreCalculator scoreCalculator;
    
    @Autowired
    private SupplierGroupService supplierGroupService;
    
    @Autowired
    private SupplierHealthService supplierHealthService;
    
    // 选择最优供应商
    public SupplierSelectionResult selectOptimalSupplier(RoutingContext context) {
        // 获取可用供应商列表
        List<SupplierProfile> availableSuppliers = 
            supplierGroupService.getAvailableSuppliers(
                context.getBusinessType(), context.getChannelType());
                
        if (availableSuppliers.isEmpty()) {
            return SupplierSelectionResult.failure("无可用供应商");
        }
        
        // 过滤掉不健康的供应商
        List<SupplierProfile> healthySuppliers = filterHealthySuppliers(availableSuppliers);
        if (healthySuppliers.isEmpty()) {
            return SupplierSelectionResult.failure("无健康供应商");
        }
        
        // 计算各供应商的综合评分
        List<SupplierScore> supplierScores = calculateSupplierScores(healthySuppliers, context);
        
        // 选择评分最高的供应商
        SupplierScore bestSupplier = supplierScores.stream()
            .max(Comparator.comparing(SupplierScore::getScore))
            .orElse(null);
            
        if (bestSupplier == null) {
            return SupplierSelectionResult.failure("无法选择供应商");
        }
        
        // 记录选择日志
        logSupplierSelection(bestSupplier, supplierScores, context);
        
        return SupplierSelectionResult.success(bestSupplier.getSupplierId(), 
                                             bestSupplier.getScore(),
                                             supplierScores);
    }
    
    // 过滤健康供应商
    private List<SupplierProfile> filterHealthySuppliers(List<SupplierProfile> suppliers) {
        return suppliers.stream()
            .filter(supplier -> supplierHealthService.isSupplierHealthy(supplier.getSupplierId()))
            .collect(Collectors.toList());
    }
    
    // 计算供应商评分
    private List<SupplierScore> calculateSupplierScores(List<SupplierProfile> suppliers, 
                                                      RoutingContext context) {
        List<SupplierScore> scores = new ArrayList<>();
        
        for (SupplierProfile supplier : suppliers) {
            try {
                double score = scoreCalculator.calculateComprehensiveScore(
                    supplier.getSupplierId(), context);
                scores.add(new SupplierScore(supplier.getSupplierId(), score));
            } catch (Exception e) {
                log.error("计算供应商评分失败: supplierId={}", supplier.getSupplierId(), e);
                scores.add(new SupplierScore(supplier.getSupplierId(), 0.0));
            }
        }
        
        return scores;
    }
    
    // 记录供应商选择日志
    private void logSupplierSelection(SupplierScore selectedSupplier, 
                                    List<SupplierScore> allScores, 
                                    RoutingContext context) {
        log.info("供应商选择结果: selectedSupplier={}, score={}, context={}, allScores={}",
                selectedSupplier.getSupplierId(), selectedSupplier.getScore(), context, allScores);
                
        // 发送监控指标
        metricsService.recordSupplierSelection(selectedSupplier.getSupplierId(), 
                                             selectedSupplier.getScore());
    }
}

// 供应商评分
public class SupplierScore {
    private String supplierId;
    private double score;
    
    public SupplierScore(String supplierId, double score) {
        this.supplierId = supplierId;
        this.score = score;
    }
    
    // getter方法...
}

// 供应商选择结果
public class SupplierSelectionResult {
    private boolean success;
    private String supplierId;
    private double score;
    private String errorMessage;
    private List<SupplierScore> allScores;
    
    public static SupplierSelectionResult success(String supplierId, double score, 
                                                List<SupplierScore> allScores) {
        SupplierSelectionResult result = new SupplierSelectionResult();
        result.success = true;
        result.supplierId = supplierId;
        result.score = score;
        result.allScores = allScores;
        return result;
    }
    
    public static SupplierSelectionResult failure(String errorMessage) {
        SupplierSelectionResult result = new SupplierSelectionResult();
        result.success = false;
        result.errorMessage = errorMessage;
        return result;
    }
    
    // getter方法...
}

关键引擎要点：

智能选择：基于综合评分选择最优供应商
健康过滤：过滤掉不健康的供应商
日志记录：完整记录选择过程和结果
监控指标：发送选择结果监控指标

动态路由调整

// 示例：动态路由调整
@Component
public class DynamicRoutingAdjuster {
    
    @Autowired
    private RoutingMetricsService routingMetricsService;
    
    @Autowired
    private SupplierHealthService supplierHealthService;
    
    @Autowired
    private ConfigurationService configurationService;
    
    // 动态调整路由策略
    @Scheduled(fixedRate = 60000) // 每分钟执行一次
    public void adjustRoutingStrategy() {
        // 获取当前路由统计信息
        RoutingStatistics currentStats = routingMetricsService.getCurrentStatistics();
        
        // 分析路由效果
        RoutingAnalysisResult analysisResult = analyzeRoutingPerformance(currentStats);
        
        // 根据分析结果调整路由策略
        if (analysisResult.需要调整()) {
            adjustWeights(analysisResult);
            adjustThresholds(analysisResult);
        }
    }
    
    // 分析路由性能
    private RoutingAnalysisResult analyzeRoutingPerformance(RoutingStatistics stats) {
        RoutingAnalysisResult result = new RoutingAnalysisResult();
        
        // 分析各业务类型的路由效果
        for (String businessType : stats.getBusinessTypes()) {
            BusinessTypeRoutingStats businessStats = stats.getBusinessStats(businessType);
            
            // 计算成功率
            double successRate = businessStats.getSuccessfulRequests() / 
                               (double) businessStats.getTotalRequests();
                               
            // 计算平均成本
            double avgCost = businessStats.getTotalCost() / businessStats.getSuccessfulRequests();
            
            // 计算平均延迟
            double avgLatency = businessStats.getTotalLatency() / businessStats.getSuccessfulRequests();
            
            // 与目标值比较
            Double targetSuccessRate = configurationService.getTargetSuccessRate(businessType);
            Double targetCost = configurationService.getTargetCost(businessType);
            Double targetLatency = configurationService.getTargetLatency(businessType);
            
            BusinessTypeAnalysis analysis = new BusinessTypeAnalysis(
                businessType, successRate, avgCost, avgLatency,
                targetSuccessRate, targetCost, targetLatency);
                
            result.addBusinessTypeAnalysis(analysis);
        }
        
        return result;
    }
    
    // 调整权重
    private void adjustWeights(RoutingAnalysisResult analysisResult) {
        for (BusinessTypeAnalysis analysis : analysisResult.getBusinessTypeAnalyses()) {
            String businessType = analysis.getBusinessType();
            
            // 如果成功率低于目标值，增加到达率权重
            if (analysis.getSuccessRate() < analysis.getTargetSuccessRate()) {
                increaseDeliveryRateWeight(businessType);
            }
            
            // 如果成本高于目标值，增加成本权重
            if (analysis.getAvgCost() > analysis.getTargetCost()) {
                increaseCostWeight(businessType);
            }
            
            // 如果延迟高于目标值，增加延迟权重
            if (analysis.getAvgLatency() > analysis.getTargetLatency()) {
                increaseLatencyWeight(businessType);
            }
        }
    }
    
    // 调整阈值
    private void adjustThresholds(RoutingAnalysisResult analysisResult) {
        for (BusinessTypeAnalysis analysis : analysisResult.getBusinessTypeAnalyses()) {
            String businessType = analysis.getBusinessType();
            
            // 如果成功率持续偏低，降低供应商健康阈值
            if (analysis.getSuccessRate() < analysis.getTargetSuccessRate() * 0.9) {
                lowerHealthThreshold(businessType);
            }
            
            // 如果成本持续偏高，调整成本优化策略
            if (analysis.getAvgCost() > analysis.getTargetCost() * 1.1) {
                adjustCostOptimizationStrategy(businessType);
            }
        }
    }
    
    private void increaseDeliveryRateWeight(String businessType) {
        // 增加到达率权重
        configurationService.increaseDeliveryRateWeight(businessType, 0.05);
        log.info("调整业务类型 {} 的到达率权重", businessType);
    }
    
    private void increaseCostWeight(String businessType) {
        // 增加成本权重
        configurationService.increaseCostWeight(businessType, 0.05);
        log.info("调整业务类型 {} 的成本权重", businessType);
    }
    
    private void increaseLatencyWeight(String businessType) {
        // 增加延迟权重
        configurationService.increaseLatencyWeight(businessType, 0.05);
        log.info("调整业务类型 {} 的延迟权重", businessType);
    }
    
    private void lowerHealthThreshold(String businessType) {
        // 降低健康阈值
        configurationService.lowerHealthThreshold(businessType);
        log.info("调整业务类型 {} 的健康阈值", businessType);
    }
    
    private void adjustCostOptimizationStrategy(String businessType) {
        // 调整成本优化策略
        configurationService.adjustCostOptimizationStrategy(businessType);
        log.info("调整业务类型 {} 的成本优化策略", businessType);
    }
}

// 路由分析结果
public class RoutingAnalysisResult {
    private List<BusinessTypeAnalysis> businessTypeAnalyses = new ArrayList<>();
    private boolean needsAdjustment = false;
    
    public void addBusinessTypeAnalysis(BusinessTypeAnalysis analysis) {
        businessTypeAnalyses.add(analysis);
        // 如果有任何业务类型需要调整，则整体需要调整
        if (analysis.需要调整()) {
            needsAdjustment = true;
        }
    }
    
    // getter方法...
}

// 业务类型分析
public class BusinessTypeAnalysis {
    private String businessType;
    private double successRate;
    private double avgCost;
    private double avgLatency;
    private Double targetSuccessRate;
    private Double targetCost;
    private Double targetLatency;
    
    public BusinessTypeAnalysis(String businessType, double successRate, double avgCost, 
                              double avgLatency, Double targetSuccessRate, 
                              Double targetCost, Double targetLatency) {
        this.businessType = businessType;
        this.successRate = successRate;
        this.avgCost = avgCost;
        this.avgLatency = avgLatency;
        this.targetSuccessRate = targetSuccessRate;
        this.targetCost = targetCost;
        this.targetLatency = targetLatency;
    }
    
    public boolean 需要调整() {
        return successRate < targetSuccessRate * 0.95 ||
               avgCost > targetCost * 1.05 ||
               avgLatency > targetLatency * 1.05;
    }
    
    // getter方法...
}

关键调整要点：

动态优化：根据实际效果动态调整路由策略
权重调整：根据业务需求调整各维度权重
阈值优化：优化健康检查和选择阈值
持续改进：持续分析和改进路由效果

路由策略配置管理

灵活的配置管理支持路由策略的动态调整：

策略配置

// 示例：路由策略配置管理
@Entity
@Table(name = "routing_strategies")
public class RoutingStrategy {
    @Id
    private String strategyId;
    
    private String strategyName;
    private String description;
    private String businessType;
    private String channelType;
    private boolean enabled;
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
    
    // 权重配置
    @Embedded
    private RoutingWeights weights;
    
    // 阈值配置
    @Embedded
    private RoutingThresholds thresholds;
    
    // 业务规则
    @ElementCollection
    private List<RoutingRule> rules;
    
    // 构造函数、getter和setter方法...
}

// 路由阈值配置
@Embeddable
public class RoutingThresholds {
    private double minSuccessRate; // 最小成功率阈值
    private double maxCost; // 最大成本阈值
    private long maxLatency; // 最大延迟阈值（毫秒）
    private double minRegionalScore; // 最小地域评分阈值
    
    // getter和setter方法...
}

// 路由规则
@Embeddable
public class RoutingRule {
    private String condition; // 规则条件
    private String action; // 规则动作
    private int priority; // 优先级
    private boolean enabled; // 是否启用
    
    // getter和setter方法...
}

关键配置要点：

灵活配置：支持权重、阈值、规则的灵活配置
业务适配：根据不同业务类型配置不同策略
动态生效：支持配置的动态更新和生效
版本管理：配置的版本管理和回滚

策略管理服务

// 示例：路由策略管理服务
@Service
public class RoutingStrategyService {
    
    @Autowired
    private RoutingStrategyRepository routingStrategyRepository;
    
    @Autowired
    private ConfigurationService configurationService;
    
    // 创建路由策略
    public RoutingStrategy createRoutingStrategy(RoutingStrategy strategy) {
        validateRoutingStrategy(strategy);
        
        strategy.setStrategyId(UUID.randomUUID().toString());
        strategy.setCreatedAt(LocalDateTime.now());
        strategy.setUpdatedAt(LocalDateTime.now());
        
        RoutingStrategy savedStrategy = routingStrategyRepository.save(strategy);
        
        // 更新配置缓存
        configurationService.updateRoutingStrategy(savedStrategy);
        
        log.info("路由策略创建成功: strategyId={}", strategy.getStrategyId());
        return savedStrategy;
    }
    
    // 更新路由策略
    public RoutingStrategy updateRoutingStrategy(String strategyId, RoutingStrategy strategy) {
        RoutingStrategy existingStrategy = routingStrategyRepository.findById(strategyId)
            .orElseThrow(() -> new StrategyNotFoundException("路由策略未找到: " + strategyId));
            
        // 更新字段
        existingStrategy.setStrategyName(strategy.getStrategyName());
        existingStrategy.setDescription(strategy.getDescription());
        existingStrategy.setEnabled(strategy.isEnabled());
        existingStrategy.setWeights(strategy.getWeights());
        existingStrategy.setThresholds(strategy.getThresholds());
        existingStrategy.setRules(strategy.getRules());
        existingStrategy.setUpdatedAt(LocalDateTime.now());
        
        RoutingStrategy updatedStrategy = routingStrategyRepository.save(existingStrategy);
        
        // 更新配置缓存
        configurationService.updateRoutingStrategy(updatedStrategy);
        
        log.info("路由策略更新成功: strategyId={}", strategyId);
        return updatedStrategy;
    }
    
    // 获取路由策略
    public RoutingStrategy getRoutingStrategy(String businessType, String channelType) {
        return routingStrategyRepository.findByBusinessTypeAndChannelType(businessType, channelType);
    }
    
    // 验证路由策略
    private void validateRoutingStrategy(RoutingStrategy strategy) {
        if (StringUtils.isEmpty(strategy.getStrategyName())) {
            throw new ValidationException("策略名称不能为空");
        }
        
        if (StringUtils.isEmpty(strategy.getBusinessType())) {
            throw new ValidationException("业务类型不能为空");
        }
        
        if (strategy.getWeights() == null) {
            throw new ValidationException("权重配置不能为空");
        }
        
        // 验证权重总和
        RoutingWeights weights = strategy.getWeights();
        double totalWeight = weights.getCostWeight() + weights.getDeliveryRateWeight() +
                           weights.getLatencyWeight() + weights.getRegionalWeight();
                           
        if (Math.abs(totalWeight - 1.0) > 0.001) {
            throw new ValidationException("权重总和必须为1.0");
        }
    }
}