第269集分库分表：分表数量为什么建议是2的n次方架构实战：分表数量设计、2的n次方原理与企业级分表数量优化方案

/**
 * 位运算分片服务
 */
@Service
public class BitwiseShardingService {

    @Autowired
    private DatabaseConnectionManager connectionManager;

    private final int SHARD_COUNT = 8; // 2^3 = 8
    private final int SHARD_MASK = SHARD_COUNT - 1; // 7 = 0b111

    /**
     * 使用位运算进行分片
     */
    public int shardByBitwise(String shardKey) {
        try {
            // 计算哈希值
            int hashCode = shardKey.hashCode();

            // 使用位与运算替代取模运算
            // hashCode % SHARD_COUNT 等价于 hashCode & SHARD_MASK
            int shardIndex = hashCode & SHARD_MASK;

            // 确保结果为正数
            return Math.abs(shardIndex);

        } catch (Exception e) {
            log.error("位运算分片失败: {}", shardKey, e);
            throw new ShardingException("位运算分片失败", e);
        }
    }

    /**
     * 使用位运算获取表名
     */
    public String getTableNameByBitwise(String tablePrefix, String shardKey) {
        int shardIndex = shardByBitwise(shardKey);
        return String.format("%s_%d", tablePrefix, shardIndex);
    }

    /**
     * 使用位运算执行SQL
     */
    public Object executeByBitwise(String tablePrefix, String shardKey, String sql, Object... params) {
        try {
            // 获取分片表名
            String tableName = getTableNameByBitwise(tablePrefix, shardKey);

            // 替换SQL中的表名
            String shardedSQL = replaceTableName(sql, tableName);

            // 获取数据源
            int shardIndex = shardByBitwise(shardKey);
            DataSource dataSource = connectionManager.getDataSource(shardIndex);

            // 执行SQL
            return executeSQL(dataSource, shardedSQL, params);

        } catch (Exception e) {
            log.error("位运算执行SQL失败", e);
            throw new ShardingException("位运算执行SQL失败", e);
        }
    }

    /**
     * 批量位运算分片
     */
    public Map<String, Integer> batchShardByBitwise(Map<String, String> shardKeyMap) {
        Map<String, Integer> shardResults = new HashMap<>();

        // 使用并行流处理
        shardKeyMap.entrySet().parallelStream().forEach(entry -> {
            String key = entry.getKey();
            String shardKey = entry.getValue();

            try {
                int shardIndex = shardByBitwise(shardKey);
                shardResults.put(key, shardIndex);
            } catch (Exception e) {
                log.error("批量位运算分片失败: {}", key, e);
                shardResults.put(key, -1);
            }
        });

        return shardResults;
    }

    /**
     * 位运算性能测试
     */
    public BitwisePerformanceTestResult testBitwisePerformance(int testCount) {
        try {
            BitwisePerformanceTestResult result = new BitwisePerformanceTestResult();
            result.setTestCount(testCount);
            result.setShardCount(SHARD_COUNT);

            // 测试位运算性能
            long startTime = System.nanoTime();
            for (int i = 0; i < testCount; i++) {
                String testKey = "test_key_" + i;
                shardByBitwise(testKey);
            }
            long endTime = System.nanoTime();
            long bitwiseTime = endTime - startTime;

            // 测试取模运算性能
            startTime = System.nanoTime();
            for (int i = 0; i < testCount; i++) {
                String testKey = "test_key_" + i;
                int hashCode = testKey.hashCode();
                int shardIndex = Math.abs(hashCode) % SHARD_COUNT;
            }
            endTime = System.nanoTime();
            long moduloTime = endTime - startTime;

            result.setBitwiseTime(bitwiseTime);
            result.setModuloTime(moduloTime);
            result.setPerformanceImprovement((double) (moduloTime - bitwiseTime) / moduloTime * 100);

            return result;

        } catch (Exception e) {
            log.error("位运算性能测试失败", e);
            throw new ShardingException("位运算性能测试失败", e);
        }
    }

    /**
     * 替换SQL中的表名
     */
    private String replaceTableName(String sql, String tableName) {
        return sql.replaceAll("\\{table_name\\}", tableName);
    }

    /**
     * 执行SQL
     */
    private Object executeSQL(DataSource dataSource, String sql, Object... params) {
        try (Connection connection = dataSource.getConnection();
             PreparedStatement statement = connection.prepareStatement(sql)) {

            // 设置参数
            for (int i = 0; i < params.length; i++) {
                statement.setObject(i + 1, params[i]);
            }

            // 执行SQL
            if (sql.trim().toUpperCase().startsWith("SELECT")) {
                ResultSet resultSet = statement.executeQuery();
                return convertResultSetToList(resultSet);
            } else {
                return statement.executeUpdate();
            }

        } catch (SQLException e) {
            log.error("SQL执行失败", e);
            throw new DatabaseException("SQL执行失败", e);
        }
    }

    /**
     * 转换ResultSet为List
     */
    private List<Map<String, Object>> convertResultSetToList(ResultSet resultSet) throws SQLException {
        List<Map<String, Object>> results = new ArrayList<>();
        ResultSetMetaData metaData = resultSet.getMetaData();
        int columnCount = metaData.getColumnCount();

        while (resultSet.next()) {
            Map<String, Object> row = new HashMap<>();
            for (int i = 1; i <= columnCount; i++) {
                String columnName = metaData.getColumnName(i);
                Object value = resultSet.getObject(i);
                row.put(columnName, value);
            }
            results.add(row);
        }

        return results;
    }
}

/**
 * 哈希均匀性分析服务
 */
@Service
public class HashUniformityAnalysisService {

    @Autowired
    private DatabaseConnectionManager connectionManager;

    /**
     * 分析哈希均匀性
     */
    public HashUniformityAnalysisResult analyzeHashUniformity(int shardCount, int testCount) {
        try {
            HashUniformityAnalysisResult result = new HashUniformityAnalysisResult();
            result.setShardCount(shardCount);
            result.setTestCount(testCount);

            // 生成测试数据
            List<String> testKeys = generateTestKeys(testCount);

            // 分析不同分片数量的均匀性
            Map<Integer, UniformityMetrics> uniformityMetrics = new HashMap<>();

            for (int n = 1; n <= 6; n++) {
                int currentShardCount = (int) Math.pow(2, n);
                UniformityMetrics metrics = analyzeUniformityForShardCount(testKeys, currentShardCount);
                uniformityMetrics.put(currentShardCount, metrics);
            }

            result.setUniformityMetrics(uniformityMetrics);

            // 找出最优分片数量
            int optimalShardCount = findOptimalShardCount(uniformityMetrics);
            result.setOptimalShardCount(optimalShardCount);

            return result;

        } catch (Exception e) {
            log.error("哈希均匀性分析失败", e);
            throw new ShardingException("哈希均匀性分析失败", e);
        }
    }

    /**
     * 分析特定分片数量的均匀性
     */
    private UniformityMetrics analyzeUniformityForShardCount(List<String> testKeys, int shardCount) {
        try {
            UniformityMetrics metrics = new UniformityMetrics();
            metrics.setShardCount(shardCount);

            // 统计每个分片的数据量
            Map<Integer, Integer> shardCounts = new HashMap<>();
            for (String key : testKeys) {
                int shardIndex = calculateShardIndex(key, shardCount);
                shardCounts.put(shardIndex, shardCounts.getOrDefault(shardIndex, 0) + 1);
            }

            // 计算均匀性指标
            List<Integer> counts = new ArrayList<>(shardCounts.values());
            double mean = counts.stream().mapToInt(Integer::intValue).average().orElse(0.0);
            double variance = counts.stream()
                    .mapToDouble(count -> Math.pow(count - mean, 2))
                    .average()
                    .orElse(0.0);
            double standardDeviation = Math.sqrt(variance);

            // 计算变异系数
            double coefficientOfVariation = standardDeviation / mean;

            // 计算基尼系数
            double giniCoefficient = calculateGiniCoefficient(counts);

            metrics.setMean(mean);
            metrics.setVariance(variance);
            metrics.setStandardDeviation(standardDeviation);
            metrics.setCoefficientOfVariation(coefficientOfVariation);
            metrics.setGiniCoefficient(giniCoefficient);

            return metrics;

        } catch (Exception e) {
            log.error("均匀性分析失败", e);
            return new UniformityMetrics();
        }
    }

    /**
     * 计算分片索引
     */
    private int calculateShardIndex(String key, int shardCount) {
        int hashCode = key.hashCode();

        if (isPowerOfTwo(shardCount)) {
            // 使用位运算
            int mask = shardCount - 1;
            return Math.abs(hashCode & mask);
        } else {
            // 使用取模运算
            return Math.abs(hashCode % shardCount);
        }
    }

    /**
     * 判断是否为2的幂
     */
    private boolean isPowerOfTwo(int n) {
        return n > 0 && (n & (n - 1)) == 0;
    }

    /**
     * 计算基尼系数
     */
    private double calculateGiniCoefficient(List<Integer> counts) {
        if (counts.isEmpty()) {
            return 0.0;
        }

        // 排序
        List<Integer> sortedCounts = new ArrayList<>(counts);
        Collections.sort(sortedCounts);

        int n = sortedCounts.size();
        long sum = sortedCounts.stream().mapToLong(Integer::longValue).sum();

        if (sum == 0) {
            return 0.0;
        }

        double gini = 0.0;
        for (int i = 0; i < n; i++) {
            gini += (2 * (i + 1) - n - 1) * sortedCounts.get(i);
        }

        return gini / (n * sum);
    }

    /**
     * 找出最优分片数量
     */
    private int findOptimalShardCount(Map<Integer, UniformityMetrics> uniformityMetrics) {
        // 基于基尼系数选择最优分片数量
        return uniformityMetrics.entrySet().stream()
                .min(Comparator.comparing(entry -> entry.getValue().getGiniCoefficient()))
                .map(Map.Entry::getKey)
                .orElse(8);
    }

    /**
     * 生成测试数据
     */
    private List<String> generateTestKeys(int count) {
        List<String> keys = new ArrayList<>();
        Random random = new Random();

        for (int i = 0; i < count; i++) {
            // 生成不同类型的测试键
            String keyType = i % 4 == 0 ? "user" : 
                            i % 4 == 1 ? "order" : 
                            i % 4 == 2 ? "product" : "payment";

            String key = keyType + "_" + random.nextInt(1000000);
            keys.add(key);
        }

        return keys;
    }

    /**
     * 分析2的n次方的优势
     */
    public PowerOfTwoAnalysisResult analyzePowerOfTwoAdvantages() {
        try {
            PowerOfTwoAnalysisResult result = new PowerOfTwoAnalysisResult();

            // 分析计算性能
            PerformanceAnalysis performanceAnalysis = analyzePerformance();
            result.setPerformanceAnalysis(performanceAnalysis);

            // 分析内存使用
            MemoryAnalysis memoryAnalysis = analyzeMemoryUsage();
            result.setMemoryAnalysis(memoryAnalysis);

            // 分析扩展性
            ScalabilityAnalysis scalabilityAnalysis = analyzeScalability();
            result.setScalabilityAnalysis(scalabilityAnalysis);

            // 分析缓存友好性
            CacheFriendlinessAnalysis cacheAnalysis = analyzeCacheFriendliness();
            result.setCacheAnalysis(cacheAnalysis);

            return result;

        } catch (Exception e) {
            log.error("2的n次方优势分析失败", e);
            throw new ShardingException("2的n次方优势分析失败", e);
        }
    }

    /**
     * 分析计算性能
     */
    private PerformanceAnalysis analyzePerformance() {
        PerformanceAnalysis analysis = new PerformanceAnalysis();

        // 测试不同分片数量的计算性能
        Map<Integer, Long> performanceResults = new HashMap<>();

        for (int n = 1; n <= 6; n++) {
            int shardCount = (int) Math.pow(2, n);
            long time = testCalculationPerformance(shardCount, 1000000);
            performanceResults.put(shardCount, time);
        }

        analysis.setPerformanceResults(performanceResults);

        // 计算性能提升
        long baselineTime = performanceResults.get(2); // 2^1 = 2
        Map<Integer, Double> performanceImprovement = new HashMap<>();

        for (Map.Entry<Integer, Long> entry : performanceResults.entrySet()) {
            int shardCount = entry.getKey();
            long time = entry.getValue();
            double improvement = (double) (baselineTime - time) / baselineTime * 100;
            performanceImprovement.put(shardCount, improvement);
        }

        analysis.setPerformanceImprovement(performanceImprovement);

        return analysis;
    }

    /**
     * 测试计算性能
     */
    private long testCalculationPerformance(int shardCount, int testCount) {
        long startTime = System.nanoTime();

        if (isPowerOfTwo(shardCount)) {
            // 使用位运算
            int mask = shardCount - 1;
            for (int i = 0; i < testCount; i++) {
                String key = "test_key_" + i;
                int hashCode = key.hashCode();
                int shardIndex = Math.abs(hashCode & mask);
            }
        } else {
            // 使用取模运算
            for (int i = 0; i < testCount; i++) {
                String key = "test_key_" + i;
                int hashCode = key.hashCode();
                int shardIndex = Math.abs(hashCode % shardCount);
            }
        }

        long endTime = System.nanoTime();
        return endTime - startTime;
    }

    /**
     * 分析内存使用
     */
    private MemoryAnalysis analyzeMemoryUsage() {
        MemoryAnalysis analysis = new MemoryAnalysis();

        // 分析不同分片数量的内存使用
        Map<Integer, Long> memoryUsage = new HashMap<>();

        for (int n = 1; n <= 6; n++) {
            int shardCount = (int) Math.pow(2, n);
            long memory = estimateMemoryUsage(shardCount);
            memoryUsage.put(shardCount, memory);
        }

        analysis.setMemoryUsage(memoryUsage);

        return analysis;
    }

    /**
     * 估算内存使用
     */
    private long estimateMemoryUsage(int shardCount) {
        // 估算每个分片的内存使用
        long perShardMemory = 1024 * 1024; // 1MB per shard
        return shardCount * perShardMemory;
    }

    /**
     * 分析扩展性
     */
    private ScalabilityAnalysis analyzeScalability() {
        ScalabilityAnalysis analysis = new ScalabilityAnalysis();

        // 分析扩展的便利性
        List<Integer> powerOfTwoShards = Arrays.asList(2, 4, 8, 16, 32, 64);
        List<Integer> nonPowerOfTwoShards = Arrays.asList(3, 5, 7, 9, 11, 13);

        analysis.setPowerOfTwoShards(powerOfTwoShards);
        analysis.setNonPowerOfTwoShards(nonPowerOfTwoShards);

        // 分析扩展复杂度
        Map<Integer, Double> expansionComplexity = new HashMap<>();

        for (int shardCount : powerOfTwoShards) {
            double complexity = calculateExpansionComplexity(shardCount);
            expansionComplexity.put(shardCount, complexity);
        }

        analysis.setExpansionComplexity(expansionComplexity);

        return analysis;
    }

    /**
     * 计算扩展复杂度
     */
    private double calculateExpansionComplexity(int shardCount) {
        // 2的n次方扩展复杂度较低
        if (isPowerOfTwo(shardCount)) {
            return 1.0; // 低复杂度
        } else {
            return 2.0; // 高复杂度
        }
    }

    /**
     * 分析缓存友好性
     */
    private CacheFriendlinessAnalysis analyzeCacheFriendliness() {
        CacheFriendlinessAnalysis analysis = new CacheFriendlinessAnalysis();

        // 分析缓存行对齐
        Map<Integer, Boolean> cacheLineAlignment = new HashMap<>();

        for (int n = 1; n <= 6; n++) {
            int shardCount = (int) Math.pow(2, n);
            boolean aligned = isCacheLineAligned(shardCount);
            cacheLineAlignment.put(shardCount, aligned);
        }

        analysis.setCacheLineAlignment(cacheLineAlignment);

        return analysis;
    }

    /**
     * 判断是否缓存行对齐
     */
    private boolean isCacheLineAligned(int shardCount) {
        // 2的n次方通常更容易实现缓存行对齐
        return isPowerOfTwo(shardCount);
    }
}

/**
 * 取模运算优化服务
 */
@Service
public class ModuloOptimizationService {

    @Autowired
    private DatabaseConnectionManager connectionManager;

    /**
     * 优化的取模分片
     */
    public int optimizedModuloSharding(String shardKey, int shardCount) {
        try {
            int hashCode = shardKey.hashCode();

            if (isPowerOfTwo(shardCount)) {
                // 使用位运算优化
                return optimizedPowerOfTwoSharding(hashCode, shardCount);
            } else {
                // 使用优化的取模运算
                return optimizedModuloSharding(hashCode, shardCount);
            }

        } catch (Exception e) {
            log.error("优化取模分片失败: {}", shardKey, e);
            throw new ShardingException("优化取模分片失败", e);
        }
    }

    /**
     * 2的n次方优化分片
     */
    private int optimizedPowerOfTwoSharding(int hashCode, int shardCount) {
        // 使用位与运算替代取模运算
        int mask = shardCount - 1;
        int shardIndex = hashCode & mask;

        // 确保结果为正数
        return Math.abs(shardIndex);
    }

    /**
     * 优化的取模运算
     */
    private int optimizedModuloSharding(int hashCode, int shardCount) {
        // 使用更高效的取模运算
        int shardIndex = hashCode % shardCount;

        // 确保结果为正数
        return shardIndex < 0 ? shardIndex + shardCount : shardIndex;
    }

    /**
     * 判断是否为2的幂
     */
    private boolean isPowerOfTwo(int n) {
        return n > 0 && (n & (n - 1)) == 0;
    }

    /**
     * 批量优化分片
     */
    public Map<String, Integer> batchOptimizedSharding(Map<String, String> shardKeyMap, int shardCount) {
        Map<String, Integer> shardResults = new HashMap<>();

        // 使用并行流处理
        shardKeyMap.entrySet().parallelStream().forEach(entry -> {
            String key = entry.getKey();
            String shardKey = entry.getValue();

            try {
                int shardIndex = optimizedModuloSharding(shardKey, shardCount);
                shardResults.put(key, shardIndex);
            } catch (Exception e) {
                log.error("批量优化分片失败: {}", key, e);
                shardResults.put(key, -1);
            }
        });

        return shardResults;
    }

    /**
     * 分片性能对比测试
     */
    public ShardingPerformanceComparisonResult compareShardingPerformance(int testCount) {
        try {
            ShardingPerformanceComparisonResult result = new ShardingPerformanceComparisonResult();
            result.setTestCount(testCount);

            // 测试不同分片数量的性能
            Map<Integer, PerformanceMetrics> performanceMetrics = new HashMap<>();

            for (int n = 1; n <= 6; n++) {
                int shardCount = (int) Math.pow(2, n);
                PerformanceMetrics metrics = testShardingPerformance(shardCount, testCount);
                performanceMetrics.put(shardCount, metrics);
            }

            result.setPerformanceMetrics(performanceMetrics);

            // 找出最优分片数量
            int optimalShardCount = findOptimalShardCount(performanceMetrics);
            result.setOptimalShardCount(optimalShardCount);

            return result;

        } catch (Exception e) {
            log.error("分片性能对比测试失败", e);
            throw new ShardingException("分片性能对比测试失败", e);
        }
    }

    /**
     * 测试分片性能
     */
    private PerformanceMetrics testShardingPerformance(int shardCount, int testCount) {
        PerformanceMetrics metrics = new PerformanceMetrics();
        metrics.setShardCount(shardCount);

        // 生成测试数据
        List<String> testKeys = generateTestKeys(testCount);

        // 测试位运算性能
        long startTime = System.nanoTime();
        for (String key : testKeys) {
            if (isPowerOfTwo(shardCount)) {
                optimizedPowerOfTwoSharding(key.hashCode(), shardCount);
            } else {
                optimizedModuloSharding(key.hashCode(), shardCount);
            }
        }
        long endTime = System.nanoTime();
        long totalTime = endTime - startTime;

        metrics.setTotalTime(totalTime);
        metrics.setAverageTime((double) totalTime / testCount);
        metrics.setThroughput((double) testCount / totalTime * 1_000_000_000); // 每秒处理数

        return metrics;
    }

    /**
     * 找出最优分片数量
     */
    private int findOptimalShardCount(Map<Integer, PerformanceMetrics> performanceMetrics) {
        // 基于吞吐量选择最优分片数量
        return performanceMetrics.entrySet().stream()
                .max(Comparator.comparing(entry -> entry.getValue().getThroughput()))
                .map(Map.Entry::getKey)
                .orElse(8);
    }

    /**
     * 生成测试数据
     */
    private List<String> generateTestKeys(int count) {
        List<String> keys = new ArrayList<>();
        Random random = new Random();

        for (int i = 0; i < count; i++) {
            String key = "test_key_" + random.nextInt(1000000);
            keys.add(key);
        }

        return keys;
    }

    /**
     * 分片数量建议
     */
    public ShardingCountRecommendation recommendShardingCount(ShardingRequirement requirement) {
        try {
            ShardingCountRecommendation recommendation = new ShardingCountRecommendation();

            // 分析业务需求
            BusinessRequirementAnalysis businessAnalysis = analyzeBusinessRequirement(requirement);
            recommendation.setBusinessAnalysis(businessAnalysis);

            // 分析数据特征
            DataCharacteristicAnalysis dataAnalysis = analyzeDataCharacteristic(requirement);
            recommendation.setDataAnalysis(dataAnalysis);

            // 分析性能需求
            PerformanceRequirementAnalysis performanceAnalysis = analyzePerformanceRequirement(requirement);
            recommendation.setPerformanceAnalysis(performanceAnalysis);

            // 生成建议
            List<Integer> recommendedCounts = generateRecommendedCounts(businessAnalysis, dataAnalysis, performanceAnalysis);
            recommendation.setRecommendedCounts(recommendedCounts);

            // 选择最佳建议
            int bestRecommendation = selectBestRecommendation(recommendedCounts, requirement);
            recommendation.setBestRecommendation(bestRecommendation);

            return recommendation;

        } catch (Exception e) {
            log.error("分片数量建议失败", e);
            throw new ShardingException("分片数量建议失败", e);
        }
    }

    /**
     * 分析业务需求
     */
    private BusinessRequirementAnalysis analyzeBusinessRequirement(ShardingRequirement requirement) {
        BusinessRequirementAnalysis analysis = new BusinessRequirementAnalysis();

        // 分析业务类型
        analysis.setBusinessType(requirement.getBusinessType());

        // 分析并发需求
        analysis.setConcurrencyRequirement(requirement.getConcurrencyRequirement());

        // 分析扩展需求
        analysis.setScalabilityRequirement(requirement.getScalabilityRequirement());

        return analysis;
    }

    /**
     * 分析数据特征
     */
    private DataCharacteristicAnalysis analyzeDataCharacteristic(ShardingRequirement requirement) {
        DataCharacteristicAnalysis analysis = new DataCharacteristicAnalysis();

        // 分析数据量
        analysis.setDataVolume(requirement.getDataVolume());

        // 分析数据增长
        analysis.setDataGrowth(requirement.getDataGrowth());

        // 分析数据分布
        analysis.setDataDistribution(requirement.getDataDistribution());

        return analysis;
    }

    /**
     * 分析性能需求
     */
    private PerformanceRequirementAnalysis analyzePerformanceRequirement(ShardingRequirement requirement) {
        PerformanceRequirementAnalysis analysis = new PerformanceRequirementAnalysis();

        // 分析QPS需求
        analysis.setQpsRequirement(requirement.getQpsRequirement());

        // 分析响应时间需求
        analysis.setResponseTimeRequirement(requirement.getResponseTimeRequirement());

        // 分析可用性需求
        analysis.setAvailabilityRequirement(requirement.getAvailabilityRequirement());

        return analysis;
    }

    /**
     * 生成建议的分片数量
     */
    private List<Integer> generateRecommendedCounts(BusinessRequirementAnalysis businessAnalysis, 
            DataCharacteristicAnalysis dataAnalysis, PerformanceRequirementAnalysis performanceAnalysis) {

        List<Integer> recommendations = new ArrayList<>();

        // 基于数据量建议
        if (dataAnalysis.getDataVolume() > 10000000) { // 1000万
            recommendations.addAll(Arrays.asList(16, 32, 64));
        } else if (dataAnalysis.getDataVolume() > 1000000) { // 100万
            recommendations.addAll(Arrays.asList(8, 16, 32));
        } else {
            recommendations.addAll(Arrays.asList(2, 4, 8));
        }

        // 基于QPS建议
        if (performanceAnalysis.getQpsRequirement() > 50000) { // 5万QPS
            recommendations.addAll(Arrays.asList(32, 64, 128));
        } else if (performanceAnalysis.getQpsRequirement() > 10000) { // 1万QPS
            recommendations.addAll(Arrays.asList(8, 16, 32));
        } else {
            recommendations.addAll(Arrays.asList(2, 4, 8));
        }

        // 去重并排序
        return recommendations.stream()
                .distinct()
                .sorted()
                .collect(Collectors.toList());
    }

    /**
     * 选择最佳建议
     */
    private int selectBestRecommendation(List<Integer> recommendations, ShardingRequirement requirement) {
        // 基于业务需求选择最佳建议
        if (requirement.getScalabilityRequirement() == ScalabilityRequirement.HIGH) {
            return recommendations.stream().max(Integer::compareTo).orElse(8);
        } else if (requirement.getScalabilityRequirement() == ScalabilityRequirement.MEDIUM) {
            return recommendations.get(recommendations.size() / 2);
        } else {
            return recommendations.stream().min(Integer::compareTo).orElse(2);
        }
    }
}

/**
 * 一致性哈希优化服务
 */
@Service
public class ConsistentHashOptimizationService {

    @Autowired
    private DatabaseConnectionManager connectionManager;

    /**
     * 优化的一致性哈希分片
     */
    public int optimizedConsistentHashSharding(String shardKey, List<String> nodes) {
        try {
            // 使用2的n次方虚拟节点
            int virtualNodeCount = calculateOptimalVirtualNodeCount(nodes.size());

            // 创建一致性哈希环
            ConsistentHashRing hashRing = createOptimizedHashRing(nodes, virtualNodeCount);

            // 计算分片
            return hashRing.getShardIndex(shardKey);

        } catch (Exception e) {
            log.error("优化一致性哈希分片失败: {}", shardKey, e);
            throw new ShardingException("优化一致性哈希分片失败", e);
        }
    }

    /**
     * 计算最优虚拟节点数量
     */
    private int calculateOptimalVirtualNodeCount(int nodeCount) {
        // 使用2的n次方作为虚拟节点数量
        int virtualNodeCount = 1;
        while (virtualNodeCount < nodeCount * 100) {
            virtualNodeCount *= 2;
        }
        return virtualNodeCount;
    }

    /**
     * 创建优化的哈希环
     */
    private ConsistentHashRing createOptimizedHashRing(List<String> nodes, int virtualNodeCount) {
        ConsistentHashRing hashRing = new ConsistentHashRing();

        for (String node : nodes) {
            for (int i = 0; i < virtualNodeCount; i++) {
                String virtualNode = node + "_" + i;
                int hash = virtualNode.hashCode();
                hashRing.addNode(hash, node);
            }
        }

        return hashRing;
    }

    /**
     * 一致性哈希环
     */
    private static class ConsistentHashRing {
        private final TreeMap<Integer, String> hashRing = new TreeMap<>();

        public void addNode(int hash, String node) {
            hashRing.put(hash, node);
        }

        public int getShardIndex(String key) {
            int hash = key.hashCode();
            Map.Entry<Integer, String> entry = hashRing.ceilingEntry(hash);

            if (entry == null) {
                entry = hashRing.firstEntry();
            }

            return Math.abs(entry.getValue().hashCode()) % 8; // 假设8个分片
        }
    }

    /**
     * 批量一致性哈希分片
     */
    public Map<String, Integer> batchConsistentHashSharding(Map<String, String> shardKeyMap, List<String> nodes) {
        Map<String, Integer> shardResults = new HashMap<>();

        // 使用并行流处理
        shardKeyMap.entrySet().parallelStream().forEach(entry -> {
            String key = entry.getKey();
            String shardKey = entry.getValue();

            try {
                int shardIndex = optimizedConsistentHashSharding(shardKey, nodes);
                shardResults.put(key, shardIndex);
            } catch (Exception e) {
                log.error("批量一致性哈希分片失败: {}", key, e);
                shardResults.put(key, -1);
            }
        });

        return shardResults;
    }

    /**
     * 一致性哈希性能测试
     */
    public ConsistentHashPerformanceTestResult testConsistentHashPerformance(int testCount) {
        try {
            ConsistentHashPerformanceTestResult result = new ConsistentHashPerformanceTestResult();
            result.setTestCount(testCount);

            // 测试不同虚拟节点数量的性能
            Map<Integer, PerformanceMetrics> performanceMetrics = new HashMap<>();

            for (int n = 1; n <= 6; n++) {
                int virtualNodeCount = (int) Math.pow(2, n);
                PerformanceMetrics metrics = testVirtualNodePerformance(virtualNodeCount, testCount);
                performanceMetrics.put(virtualNodeCount, metrics);
            }

            result.setPerformanceMetrics(performanceMetrics);

            // 找出最优虚拟节点数量
            int optimalVirtualNodeCount = findOptimalVirtualNodeCount(performanceMetrics);
            result.setOptimalVirtualNodeCount(optimalVirtualNodeCount);

            return result;

        } catch (Exception e) {
            log.error("一致性哈希性能测试失败", e);
            throw new ShardingException("一致性哈希性能测试失败", e);
        }
    }

    /**
     * 测试虚拟节点性能
     */
    private PerformanceMetrics testVirtualNodePerformance(int virtualNodeCount, int testCount) {
        PerformanceMetrics metrics = new PerformanceMetrics();
        metrics.setShardCount(virtualNodeCount);

        // 生成测试数据
        List<String> testKeys = generateTestKeys(testCount);
        List<String> nodes = Arrays.asList("node1", "node2", "node3", "node4");

        // 测试一致性哈希性能
        long startTime = System.nanoTime();
        for (String key : testKeys) {
            optimizedConsistentHashSharding(key, nodes);
        }
        long endTime = System.nanoTime();
        long totalTime = endTime - startTime;

        metrics.setTotalTime(totalTime);
        metrics.setAverageTime((double) totalTime / testCount);
        metrics.setThroughput((double) testCount / totalTime * 1_000_000_000); // 每秒处理数

        return metrics;
    }

    /**
     * 找出最优虚拟节点数量
     */
    private int findOptimalVirtualNodeCount(Map<Integer, PerformanceMetrics> performanceMetrics) {
        // 基于吞吐量选择最优虚拟节点数量
        return performanceMetrics.entrySet().stream()
                .max(Comparator.comparing(entry -> entry.getValue().getThroughput()))
                .map(Map.Entry::getKey)
                .orElse(64);
    }

    /**
     * 生成测试数据
     */
    private List<String> generateTestKeys(int count) {
        List<String> keys = new ArrayList<>();
        Random random = new Random();

        for (int i = 0; i < count; i++) {
            String key = "test_key_" + random.nextInt(1000000);
            keys.add(key);
        }

        return keys;
    }
}

/**
 * 电商分表数量设计服务
 */
@Service
public class EcommerceShardingCountService {

    @Autowired
    private ModuloOptimizationService moduloOptimizationService;

    @Autowired
    private ConsistentHashOptimizationService consistentHashOptimizationService;

    /**
     * 用户表分表数量设计
     */
    public ShardingCountDesignResult designUserTableShardingCount() {
        try {
            ShardingCountDesignResult result = new ShardingCountDesignResult();
            result.setTableName("user");

            // 分析用户表特征
            UserTableAnalysis userAnalysis = analyzeUserTable();
            result.setTableAnalysis(userAnalysis);

            // 基于数据量建议分表数量
            List<Integer> dataBasedCounts = suggestShardingCountByData(userAnalysis.getDataVolume());
            result.setDataBasedCounts(dataBasedCounts);

            // 基于QPS建议分表数量
            List<Integer> qpsBasedCounts = suggestShardingCountByQPS(userAnalysis.getQpsRequirement());
            result.setQpsBasedCounts(qpsBasedCounts);

            // 基于业务特征建议分表数量
            List<Integer> businessBasedCounts = suggestShardingCountByBusiness(userAnalysis.getBusinessFeature());
            result.setBusinessBasedCounts(businessBasedCounts);

            // 综合建议
            int recommendedCount = calculateRecommendedCount(dataBasedCounts, qpsBasedCounts, businessBasedCounts);
            result.setRecommendedCount(recommendedCount);

            // 验证建议
            ShardingCountValidationResult validation = validateShardingCount(recommendedCount, userAnalysis);
            result.setValidation(validation);

            return result;

        } catch (Exception e) {
            log.error("用户表分表数量设计失败", e);
            throw new ShardingException("用户表分表数量设计失败", e);
        }
    }

    /**
     * 订单表分表数量设计
     */
    public ShardingCountDesignResult designOrderTableShardingCount() {
        try {
            ShardingCountDesignResult result = new ShardingCountDesignResult();
            result.setTableName("order");

            // 分析订单表特征
            OrderTableAnalysis orderAnalysis = analyzeOrderTable();
            result.setTableAnalysis(orderAnalysis);

            // 基于数据量建议分表数量
            List<Integer> dataBasedCounts = suggestShardingCountByData(orderAnalysis.getDataVolume());
            result.setDataBasedCounts(dataBasedCounts);

            // 基于QPS建议分表数量
            List<Integer> qpsBasedCounts = suggestShardingCountByQPS(orderAnalysis.getQpsRequirement());
            result.setQpsBasedCounts(qpsBasedCounts);

            // 基于业务特征建议分表数量
            List<Integer> businessBasedCounts = suggestShardingCountByBusiness(orderAnalysis.getBusinessFeature());
            result.setBusinessBasedCounts(businessBasedCounts);

            // 综合建议
            int recommendedCount = calculateRecommendedCount(dataBasedCounts, qpsBasedCounts, businessBasedCounts);
            result.setRecommendedCount(recommendedCount);

            // 验证建议
            ShardingCountValidationResult validation = validateShardingCount(recommendedCount, orderAnalysis);
            result.setValidation(validation);

            return result;

        } catch (Exception e) {
            log.error("订单表分表数量设计失败", e);
            throw new ShardingException("订单表分表数量设计失败", e);
        }
    }

    /**
     * 商品表分表数量设计
     */
    public ShardingCountDesignResult designProductTableShardingCount() {
        try {
            ShardingCountDesignResult result = new ShardingCountDesignResult();
            result.setTableName("product");

            // 分析商品表特征
            ProductTableAnalysis productAnalysis = analyzeProductTable();
            result.setTableAnalysis(productAnalysis);

            // 基于数据量建议分表数量
            List<Integer> dataBasedCounts = suggestShardingCountByData(productAnalysis.getDataVolume());
            result.setDataBasedCounts(dataBasedCounts);

            // 基于QPS建议分表数量
            List<Integer> qpsBasedCounts = suggestShardingCountByQPS(productAnalysis.getQpsRequirement());
            result.setQpsBasedCounts(qpsBasedCounts);

            // 基于业务特征建议分表数量
            List<Integer> businessBasedCounts = suggestShardingCountByBusiness(productAnalysis.getBusinessFeature());
            result.setBusinessBasedCounts(businessBasedCounts);

            // 综合建议
            int recommendedCount = calculateRecommendedCount(dataBasedCounts, qpsBasedCounts, businessBasedCounts);
            result.setRecommendedCount(recommendedCount);

            // 验证建议
            ShardingCountValidationResult validation = validateShardingCount(recommendedCount, productAnalysis);
            result.setValidation(validation);

            return result;

        } catch (Exception e) {
            log.error("商品表分表数量设计失败", e);
            throw new ShardingException("商品表分表数量设计失败", e);
        }
    }

    /**
     * 分析用户表
     */
    private UserTableAnalysis analyzeUserTable() {
        UserTableAnalysis analysis = new UserTableAnalysis();

        // 设置数据量
        analysis.setDataVolume(5000000); // 500万用户

        // 设置QPS需求
        analysis.setQpsRequirement(10000); // 1万QPS

        // 设置业务特征
        analysis.setBusinessFeature(BusinessFeature.HIGH_CONCURRENCY);

        return analysis;
    }

    /**
     * 分析订单表
     */
    private OrderTableAnalysis analyzeOrderTable() {
        OrderTableAnalysis analysis = new OrderTableAnalysis();

        // 设置数据量
        analysis.setDataVolume(50000000); // 5000万订单

        // 设置QPS需求
        analysis.setQpsRequirement(20000); // 2万QPS

        // 设置业务特征
        analysis.setBusinessFeature(BusinessFeature.HIGH_CONCURRENCY);

        return analysis;
    }

    /**
     * 分析商品表
     */
    private ProductTableAnalysis analyzeProductTable() {
        ProductTableAnalysis analysis = new ProductTableAnalysis();

        // 设置数据量
        analysis.setDataVolume(1000000); // 100万商品

        // 设置QPS需求
        analysis.setQpsRequirement(5000); // 5千QPS

        // 设置业务特征
        analysis.setBusinessFeature(BusinessFeature.MEDIUM_CONCURRENCY);

        return analysis;
    }

    /**
     * 基于数据量建议分表数量
     */
    private List<Integer> suggestShardingCountByData(long dataVolume) {
        List<Integer> suggestions = new ArrayList<>();

        if (dataVolume > 100000000) { // 1亿
            suggestions.addAll(Arrays.asList(64, 128, 256));
        } else if (dataVolume > 10000000) { // 1000万
            suggestions.addAll(Arrays.asList(16, 32, 64));
        } else if (dataVolume > 1000000) { // 100万
            suggestions.addAll(Arrays.asList(4, 8, 16));
        } else {
            suggestions.addAll(Arrays.asList(2, 4, 8));
        }

        return suggestions;
    }

    /**
     * 基于QPS建议分表数量
     */
    private List<Integer> suggestShardingCountByQPS(int qpsRequirement) {
        List<Integer> suggestions = new ArrayList<>();

        if (qpsRequirement > 100000) { // 10万QPS
            suggestions.addAll(Arrays.asList(128, 256, 512));
        } else if (qpsRequirement > 50000) { // 5万QPS
            suggestions.addAll(Arrays.asList(32, 64, 128));
        } else if (qpsRequirement > 10000) { // 1万QPS
            suggestions.addAll(Arrays.asList(8, 16, 32));
        } else {
            suggestions.addAll(Arrays.asList(2, 4, 8));
        }

        return suggestions;
    }

    /**
     * 基于业务特征建议分表数量
     */
    private List<Integer> suggestShardingCountByBusiness(BusinessFeature businessFeature) {
        List<Integer> suggestions = new ArrayList<>();

        switch (businessFeature) {
            case HIGH_CONCURRENCY:
                suggestions.addAll(Arrays.asList(16, 32, 64));
                break;
            case MEDIUM_CONCURRENCY:
                suggestions.addAll(Arrays.asList(4, 8, 16));
                break;
            case LOW_CONCURRENCY:
                suggestions.addAll(Arrays.asList(2, 4, 8));
                break;
            default:
                suggestions.addAll(Arrays.asList(2, 4, 8));
                break;
        }

        return suggestions;
    }

    /**
     * 计算推荐数量
     */
    private int calculateRecommendedCount(List<Integer> dataBasedCounts, List<Integer> qpsBasedCounts, 
            List<Integer> businessBasedCounts) {

        // 计算加权平均
        double dataWeight = 0.4;
        double qpsWeight = 0.4;
        double businessWeight = 0.2;

        double dataAvg = dataBasedCounts.stream().mapToInt(Integer::intValue).average().orElse(8.0);
        double qpsAvg = qpsBasedCounts.stream().mapToInt(Integer::intValue).average().orElse(8.0);
        double businessAvg = businessBasedCounts.stream().mapToInt(Integer::intValue).average().orElse(8.0);

        double weightedAvg = dataAvg * dataWeight + qpsAvg * qpsWeight + businessAvg * businessWeight;

        // 找到最接近的2的n次方
        return findNearestPowerOfTwo((int) Math.round(weightedAvg));
    }

    /**
     * 找到最接近的2的n次方
     */
    private int findNearestPowerOfTwo(int target) {
        if (target <= 0) {
            return 2;
        }

        int power = 1;
        while (power < target) {
            power *= 2;
        }

        int lower = power / 2;
        int upper = power;

        return (target - lower) < (upper - target) ? lower : upper;
    }

    /**
     * 验证分表数量
     */
    private ShardingCountValidationResult validateShardingCount(int shardCount, TableAnalysis tableAnalysis) {
        ShardingCountValidationResult validation = new ShardingCountValidationResult();
        validation.setShardCount(shardCount);

        // 验证是否为2的n次方
        boolean isPowerOfTwo = isPowerOfTwo(shardCount);
        validation.setPowerOfTwo(isPowerOfTwo);

        // 验证性能
        PerformanceValidation performanceValidation = validatePerformance(shardCount, tableAnalysis);
        validation.setPerformanceValidation(performanceValidation);

        // 验证扩展性
        ScalabilityValidation scalabilityValidation = validateScalability(shardCount, tableAnalysis);
        validation.setScalabilityValidation(scalabilityValidation);

        // 验证资源使用
        ResourceValidation resourceValidation = validateResourceUsage(shardCount, tableAnalysis);
        validation.setResourceValidation(resourceValidation);

        return validation;
    }

    /**
     * 判断是否为2的幂
     */
    private boolean isPowerOfTwo(int n) {
        return n > 0 && (n & (n - 1)) == 0;
    }

    /**
     * 验证性能
     */
    private PerformanceValidation validatePerformance(int shardCount, TableAnalysis tableAnalysis) {
        PerformanceValidation validation = new PerformanceValidation();

        // 计算单表数据量
        long dataPerShard = tableAnalysis.getDataVolume() / shardCount;
        validation.setDataPerShard(dataPerShard);

        // 计算单表QPS
        int qpsPerShard = tableAnalysis.getQpsRequirement() / shardCount;
        validation.setQpsPerShard(qpsPerShard);

        // 验证是否满足性能要求
        boolean performanceOk = dataPerShard < 1000000 && qpsPerShard < 1000;
        validation.setPerformanceOk(performanceOk);

        return validation;
    }

    /**
     * 验证扩展性
     */
    private ScalabilityValidation validateScalability(int shardCount, TableAnalysis tableAnalysis) {
        ScalabilityValidation validation = new ScalabilityValidation();

        // 计算扩展倍数
        int expansionMultiplier = calculateExpansionMultiplier(shardCount);
        validation.setExpansionMultiplier(expansionMultiplier);

        // 验证扩展便利性
        boolean scalabilityOk = isPowerOfTwo(shardCount);
        validation.setScalabilityOk(scalabilityOk);

        return validation;
    }

    /**
     * 计算扩展倍数
     */
    private int calculateExpansionMultiplier(int shardCount) {
        if (isPowerOfTwo(shardCount)) {
            return 2; // 2的n次方可以轻松扩展为2的n+1次方
        } else {
            return 1; // 非2的n次方扩展困难
        }
    }

    /**
     * 验证资源使用
     */
    private ResourceValidation validateResourceUsage(int shardCount, TableAnalysis tableAnalysis) {
        ResourceValidation validation = new ResourceValidation();

        // 计算资源使用
        long memoryUsage = shardCount * 1024 * 1024; // 1MB per shard
        validation.setMemoryUsage(memoryUsage);

        // 验证资源使用是否合理
        boolean resourceOk = memoryUsage < 1024 * 1024 * 1024; // 1GB
        validation.setResourceOk(resourceOk);

        return validation;
    }
}