第152集减少网络往返开销Java实战

/**
 * 网络优化配置类
 * @author 运维实战
 */
@Configuration
@EnableConfigurationProperties(NetworkOptimizationProperties.class)
public class NetworkOptimizationConfig {
    
    @Autowired
    private NetworkOptimizationProperties properties;
    
    /**
     * 网络优化服务
     * @return 网络优化服务
     */
    @Bean
    public NetworkOptimizationService networkOptimizationService() {
        return new NetworkOptimizationService();
    }
    
    /**
     * 网络监控服务
     * @return 网络监控服务
     */
    @Bean
    public NetworkMonitorService networkMonitorService() {
        return new NetworkMonitorService();
    }
    
    /**
     * 批量操作服务
     * @return 批量操作服务
     */
    @Bean
    public BatchOperationService batchOperationService() {
        return new BatchOperationService();
    }
    
    private static final Logger logger = LoggerFactory.getLogger(NetworkOptimizationConfig.class);
}

/**
 * 网络优化属性配置
 * @author 运维实战
 */
@Data
@ConfigurationProperties(prefix = "network.optimization")
public class NetworkOptimizationProperties {
    
    /**
     * 是否启用网络优化
     */
    private boolean enableOptimization = true;
    
    /**
     * 最大批量大小
     */
    private int maxBatchSize = 1000;
    
    /**
     * 批量操作超时时间（毫秒）
     */
    private long batchTimeoutMs = 30000;
    
    /**
     * 是否启用连接池
     */
    private boolean enableConnectionPool = true;
    
    /**
     * 连接池最大连接数
     */
    private int maxConnections = 100;
    
    /**
     * 连接池最小连接数
     */
    private int minConnections = 10;
    
    /**
     * 连接超时时间（毫秒）
     */
    private long connectionTimeoutMs = 5000;
    
    /**
     * 是否启用数据压缩
     */
    private boolean enableCompression = true;
    
    /**
     * 压缩算法
     */
    private String compressionAlgorithm = "gzip";
    
    /**
     * 是否启用异步处理
     */
    private boolean enableAsyncProcessing = true;
    
    /**
     * 异步处理线程数
     */
    private int asyncThreads = 10;
    
    /**
     * 是否启用缓存
     */
    private boolean enableCache = true;
    
    /**
     * 缓存过期时间（毫秒）
     */
    private long cacheExpireTimeMs = 300000;
    
    /**
     * 是否启用监控
     */
    private boolean enableMonitor = true;
    
    /**
     * 监控间隔（毫秒）
     */
    private long monitorInterval = 30000;
}

/**
 * 基础网络优化服务
 * @author 运维实战
 */
@Service
public class NetworkOptimizationService {
    
    @Autowired
    private NetworkOptimizationProperties properties;
    
    @Autowired
    private NetworkMonitorService networkMonitorService;
    
    @Autowired
    private BatchOperationService batchOperationService;
    
    private static final Logger logger = LoggerFactory.getLogger(NetworkOptimizationService.class);
    
    /**
     * 批量数据库操作减少网络往返开销
     * @param operations 操作列表
     * @return 批量操作结果
     */
    public NetworkOptimizationResult batchDatabaseOperations(List<DatabaseOperation> operations) {
        logger.info("开始批量数据库操作，操作数量: {}", operations.size());
        
        NetworkOptimizationResult result = new NetworkOptimizationResult();
        result.setOperationType("DATABASE_BATCH");
        result.setTotalCount(operations.size());
        result.setStartTime(System.currentTimeMillis());
        
        try {
            // 获取批量操作策略
            BatchOperationStrategy strategy = batchOperationService.getStrategy(operations.size());
            
            // 执行批量数据库操作
            result = executeBatchDatabaseOperations(operations, strategy);
            
            // 记录网络优化指标
            networkMonitorService.recordNetworkOptimization("DATABASE_BATCH", operations.size(), result.getSuccessCount());
            
            logger.info("批量数据库操作完成，成功: {}, 失败: {}, 总耗时: {}ms", 
                result.getSuccessCount(), result.getFailureCount(), result.getDuration());
            
            return result;
            
        } catch (Exception e) {
            logger.error("批量数据库操作异常", e);
            result.setSuccess(false);
            result.setError("批量数据库操作异常: " + e.getMessage());
            result.setEndTime(System.currentTimeMillis());
            return result;
        }
    }
    
    /**
     * 批量缓存操作减少网络往返开销
     * @param cacheOperations 缓存操作列表
     * @return 批量操作结果
     */
    public NetworkOptimizationResult batchCacheOperations(List<CacheOperation> cacheOperations) {
        logger.info("开始批量缓存操作，操作数量: {}", cacheOperations.size());
        
        NetworkOptimizationResult result = new NetworkOptimizationResult();
        result.setOperationType("CACHE_BATCH");
        result.setTotalCount(cacheOperations.size());
        result.setStartTime(System.currentTimeMillis());
        
        try {
            // 获取批量操作策略
            BatchOperationStrategy strategy = batchOperationService.getStrategy(cacheOperations.size());
            
            // 执行批量缓存操作
            result = executeBatchCacheOperations(cacheOperations, strategy);
            
            // 记录网络优化指标
            networkMonitorService.recordNetworkOptimization("CACHE_BATCH", cacheOperations.size(), result.getSuccessCount());
            
            logger.info("批量缓存操作完成，成功: {}, 失败: {}, 总耗时: {}ms", 
                result.getSuccessCount(), result.getFailureCount(), result.getDuration());
            
            return result;
            
        } catch (Exception e) {
            logger.error("批量缓存操作异常", e);
            result.setSuccess(false);
            result.setError("批量缓存操作异常: " + e.getMessage());
            result.setEndTime(System.currentTimeMillis());
            return result;
        }
    }
    
    /**
     * 批量API调用减少网络往返开销
     * @param apiCalls API调用列表
     * @return 批量调用结果
     */
    public NetworkOptimizationResult batchApiCalls(List<ApiCall> apiCalls) {
        logger.info("开始批量API调用，调用数量: {}", apiCalls.size());
        
        NetworkOptimizationResult result = new NetworkOptimizationResult();
        result.setOperationType("API_BATCH");
        result.setTotalCount(apiCalls.size());
        result.setStartTime(System.currentTimeMillis());
        
        try {
            // 获取批量操作策略
            BatchOperationStrategy strategy = batchOperationService.getStrategy(apiCalls.size());
            
            // 执行批量API调用
            result = executeBatchApiCalls(apiCalls, strategy);
            
            // 记录网络优化指标
            networkMonitorService.recordNetworkOptimization("API_BATCH", apiCalls.size(), result.getSuccessCount());
            
            logger.info("批量API调用完成，成功: {}, 失败: {}, 总耗时: {}ms", 
                result.getSuccessCount(), result.getFailureCount(), result.getDuration());
            
            return result;
            
        } catch (Exception e) {
            logger.error("批量API调用异常", e);
            result.setSuccess(false);
            result.setError("批量API调用异常: " + e.getMessage());
            result.setEndTime(System.currentTimeMillis());
            return result;
        }
    }
    
    /**
     * 批量消息发送减少网络往返开销
     * @param messages 消息列表
     * @return 批量发送结果
     */
    public NetworkOptimizationResult batchMessageSend(List<Message> messages) {
        logger.info("开始批量消息发送，消息数量: {}", messages.size());
        
        NetworkOptimizationResult result = new NetworkOptimizationResult();
        result.setOperationType("MESSAGE_BATCH");
        result.setTotalCount(messages.size());
        result.setStartTime(System.currentTimeMillis());
        
        try {
            // 获取批量操作策略
            BatchOperationStrategy strategy = batchOperationService.getStrategy(messages.size());
            
            // 执行批量消息发送
            result = executeBatchMessageSend(messages, strategy);
            
            // 记录网络优化指标
            networkMonitorService.recordNetworkOptimization("MESSAGE_BATCH", messages.size(), result.getSuccessCount());
            
            logger.info("批量消息发送完成，成功: {}, 失败: {}, 总耗时: {}ms", 
                result.getSuccessCount(), result.getFailureCount(), result.getDuration());
            
            return result;
            
        } catch (Exception e) {
            logger.error("批量消息发送异常", e);
            result.setSuccess(false);
            result.setError("批量消息发送异常: " + e.getMessage());
            result.setEndTime(System.currentTimeMillis());
            return result;
        }
    }
    
    /**
     * 执行批量数据库操作
     * @param operations 操作列表
     * @param strategy 策略
     * @return 批量操作结果
     */
    private NetworkOptimizationResult executeBatchDatabaseOperations(List<DatabaseOperation> operations, BatchOperationStrategy strategy) {
        NetworkOptimizationResult result = new NetworkOptimizationResult();
        result.setOperationType("DATABASE_BATCH");
        result.setTotalCount(operations.size());
        result.setStartTime(System.currentTimeMillis());
        
        try {
            // 模拟批量数据库操作
            Thread.sleep(operations.size() * 10);
            
            result.setSuccessCount(operations.size());
            result.setFailureCount(0);
            result.setSuccess(true);
            result.setEndTime(System.currentTimeMillis());
            
            return result;
            
        } catch (Exception e) {
            logger.error("执行批量数据库操作异常", e);
            result.setSuccess(false);
            result.setError("执行批量数据库操作异常: " + e.getMessage());
            result.setEndTime(System.currentTimeMillis());
            return result;
        }
    }
    
    /**
     * 执行批量缓存操作
     * @param cacheOperations 缓存操作列表
     * @param strategy 策略
     * @return 批量操作结果
     */
    private NetworkOptimizationResult executeBatchCacheOperations(List<CacheOperation> cacheOperations, BatchOperationStrategy strategy) {
        NetworkOptimizationResult result = new NetworkOptimizationResult();
        result.setOperationType("CACHE_BATCH");
        result.setTotalCount(cacheOperations.size());
        result.setStartTime(System.currentTimeMillis());
        
        try {
            // 模拟批量缓存操作
            Thread.sleep(cacheOperations.size() * 5);
            
            result.setSuccessCount(cacheOperations.size());
            result.setFailureCount(0);
            result.setSuccess(true);
            result.setEndTime(System.currentTimeMillis());
            
            return result;
            
        } catch (Exception e) {
            logger.error("执行批量缓存操作异常", e);
            result.setSuccess(false);
            result.setError("执行批量缓存操作异常: " + e.getMessage());
            result.setEndTime(System.currentTimeMillis());
            return result;
        }
    }
    
    /**
     * 执行批量API调用
     * @param apiCalls API调用列表
     * @param strategy 策略
     * @return 批量调用结果
     */
    private NetworkOptimizationResult executeBatchApiCalls(List<ApiCall> apiCalls, BatchOperationStrategy strategy) {
        NetworkOptimizationResult result = new NetworkOptimizationResult();
        result.setOperationType("API_BATCH");
        result.setTotalCount(apiCalls.size());
        result.setStartTime(System.currentTimeMillis());
        
        try {
            // 模拟批量API调用
            Thread.sleep(apiCalls.size() * 20);
            
            result.setSuccessCount(apiCalls.size());
            result.setFailureCount(0);
            result.setSuccess(true);
            result.setEndTime(System.currentTimeMillis());
            
            return result;
            
        } catch (Exception e) {
            logger.error("执行批量API调用异常", e);
            result.setSuccess(false);
            result.setError("执行批量API调用异常: " + e.getMessage());
            result.setEndTime(System.currentTimeMillis());
            return result;
        }
    }
    
    /**
     * 执行批量消息发送
     * @param messages 消息列表
     * @param strategy 策略
     * @return 批量发送结果
     */
    private NetworkOptimizationResult executeBatchMessageSend(List<Message> messages, BatchOperationStrategy strategy) {
        NetworkOptimizationResult result = new NetworkOptimizationResult();
        result.setOperationType("MESSAGE_BATCH");
        result.setTotalCount(messages.size());
        result.setStartTime(System.currentTimeMillis());
        
        try {
            // 模拟批量消息发送
            Thread.sleep(messages.size() * 15);
            
            result.setSuccessCount(messages.size());
            result.setFailureCount(0);
            result.setSuccess(true);
            result.setEndTime(System.currentTimeMillis());
            
            return result;
            
        } catch (Exception e) {
            logger.error("执行批量消息发送异常", e);
            result.setSuccess(false);
            result.setError("执行批量消息发送异常: " + e.getMessage());
            result.setEndTime(System.currentTimeMillis());
            return result;
        }
    }
}

/**
 * 网络优化结果类
 * @author 运维实战
 */
@Data
public class NetworkOptimizationResult {
    
    private boolean success;
    private String operationType;
    private int totalCount;
    private int successCount;
    private int failureCount;
    private String error;
    private long startTime;
    private long endTime;
    
    public NetworkOptimizationResult() {
        this.success = false;
        this.successCount = 0;
        this.failureCount = 0;
    }
    
    /**
     * 获取处理耗时
     * @return 处理耗时（毫秒）
     */
    public long getDuration() {
        return endTime - startTime;
    }
    
    /**
     * 获取成功率
     * @return 成功率
     */
    public double getSuccessRate() {
        if (totalCount == 0) return 0.0;
        return (double) successCount / totalCount * 100;
    }
    
    /**
     * 获取失败率
     * @return 失败率
     */
    public double getFailureRate() {
        if (totalCount == 0) return 0.0;
        return (double) failureCount / totalCount * 100;
    }
    
    /**
     * 是否全部成功
     * @return 是否全部成功
     */
    public boolean isAllSuccess() {
        return failureCount == 0;
    }
}

/**
 * 批量操作策略类
 * @author 运维实战
 */
@Data
public class BatchOperationStrategy {
    
    private String strategy;
    private String description;
    private int operationCount;
    private int recommendedBatchSize;
    private long estimatedDuration;
    private long estimatedNetworkReduction;
    private long timestamp;
    
    public BatchOperationStrategy() {
        this.timestamp = System.currentTimeMillis();
    }
    
    /**
     * 获取网络往返减少率
     * @return 网络往返减少率
     */
    public double getNetworkReductionRate() {
        if (operationCount == 0) return 0.0;
        return (double) estimatedNetworkReduction / operationCount * 100;
    }
}

/**
 * 数据库操作类
 * @author 运维实战
 */
@Data
public class DatabaseOperation {
    
    private String type;
    private String sql;
    private Object[] params;
    
    public DatabaseOperation() {}
    
    public DatabaseOperation(String type, String sql, Object[] params) {
        this.type = type;
        this.sql = sql;
        this.params = params;
    }
}

/**
 * 缓存操作类
 * @author 运维实战
 */
@Data
public class CacheOperation {
    
    private String type;
    private String key;
    private Object value;
    
    public CacheOperation() {}
    
    public CacheOperation(String type, String key, Object value) {
        this.type = type;
        this.key = key;
        this.value = value;
    }
}

/**
 * API调用类
 * @author 运维实战
 */
@Data
public class ApiCall {
    
    private String url;
    private String method;
    private Map<String, Object> params;
    
    public ApiCall() {}
    
    public ApiCall(String url, String method, Map<String, Object> params) {
        this.url = url;
        this.method = method;
        this.params = params;
    }
}

/**
 * 消息类
 * @author 运维实战
 */
@Data
public class Message {
    
    private String topic;
    private String content;
    private Map<String, Object> headers;
    
    public Message() {}
    
    public Message(String topic, String content, Map<String, Object> headers) {
        this.topic = topic;
        this.content = content;
        this.headers = headers;
    }
}

/**
 * 网络监控服务
 * @author 运维实战
 */
@Service
public class NetworkMonitorService {
    
    private final AtomicLong totalNetworkOptimizations = new AtomicLong(0);
    private final AtomicLong totalSuccessfulOptimizations = new AtomicLong(0);
    private final AtomicLong totalFailedOptimizations = new AtomicLong(0);
    private final AtomicLong totalNetworkReductions = new AtomicLong(0);
    
    private long lastResetTime = System.currentTimeMillis();
    private final long resetInterval = 300000; // 5分钟重置一次
    
    private static final Logger logger = LoggerFactory.getLogger(NetworkMonitorService.class);
    
    /**
     * 记录网络优化
     * @param operationType 操作类型
     * @param operationCount 操作数量
     * @param successCount 成功数量
     */
    public void recordNetworkOptimization(String operationType, int operationCount, int successCount) {
        totalNetworkOptimizations.incrementAndGet();
        totalSuccessfulOptimizations.addAndGet(successCount);
        totalFailedOptimizations.addAndGet(operationCount - successCount);
        totalNetworkReductions.addAndGet(operationCount - 1); // 减少的网络往返次数
        
        logger.debug("记录网络优化: 操作类型={}, 操作数量={}, 成功数量={}, 网络往返减少={}", 
            operationType, operationCount, successCount, operationCount - 1);
    }
    
    /**
     * 获取监控指标
     * @return 监控指标
     */
    public NetworkMetrics getMetrics() {
        // 检查是否需要重置
        if (System.currentTimeMillis() - lastResetTime > resetInterval) {
            resetMetrics();
        }
        
        NetworkMetrics metrics = new NetworkMetrics();
        metrics.setTotalNetworkOptimizations(totalNetworkOptimizations.get());
        metrics.setTotalSuccessfulOptimizations(totalSuccessfulOptimizations.get());
        metrics.setTotalFailedOptimizations(totalFailedOptimizations.get());
        metrics.setTotalNetworkReductions(totalNetworkReductions.get());
        metrics.setTimestamp(System.currentTimeMillis());
        
        return metrics;
    }
    
    /**
     * 重置指标
     */
    private void resetMetrics() {
        totalNetworkOptimizations.set(0);
        totalSuccessfulOptimizations.set(0);
        totalFailedOptimizations.set(0);
        totalNetworkReductions.set(0);
        lastResetTime = System.currentTimeMillis();
        
        logger.info("网络优化监控指标重置");
    }
    
    /**
     * 定期监控网络优化状态
     */
    @Scheduled(fixedRate = 30000) // 每30秒监控一次
    public void monitorNetworkOptimizationStatus() {
        try {
            NetworkMetrics metrics = getMetrics();
            
            logger.info("网络优化监控: 总优化次数={}, 成功优化={}, 失败优化={}, 总网络往返减少={}, 成功率={}%, 平均网络往返减少率={}%", 
                metrics.getTotalNetworkOptimizations(), metrics.getTotalSuccessfulOptimizations(), 
                metrics.getTotalFailedOptimizations(), metrics.getTotalNetworkReductions(),
                String.format("%.2f", metrics.getSuccessRate()), 
                String.format("%.2f", metrics.getAverageNetworkReductionRate()));
            
            // 检查异常情况
            if (metrics.getSuccessRate() < 90) {
                logger.warn("网络优化成功率过低: {}%", String.format("%.2f", metrics.getSuccessRate()));
            }
            
            if (metrics.getAverageNetworkReductionRate() < 50) {
                logger.warn("平均网络往返减少率过低: {}%", String.format("%.2f", metrics.getAverageNetworkReductionRate()));
            }
            
        } catch (Exception e) {
            logger.error("网络优化状态监控失败", e);
        }
    }
}

/**
 * 网络指标类
 * @author 运维实战
 */
@Data
public class NetworkMetrics {
    
    private long totalNetworkOptimizations;
    private long totalSuccessfulOptimizations;
    private long totalFailedOptimizations;
    private long totalNetworkReductions;
    private long timestamp;
    
    public NetworkMetrics() {
        this.timestamp = System.currentTimeMillis();
    }
    
    /**
     * 获取成功率
     * @return 成功率
     */
    public double getSuccessRate() {
        if (totalNetworkOptimizations == 0) return 0.0;
        return (double) totalSuccessfulOptimizations / totalNetworkOptimizations * 100;
    }
    
    /**
     * 获取失败率
     * @return 失败率
     */
    public double getFailureRate() {
        if (totalNetworkOptimizations == 0) return 0.0;
        return (double) totalFailedOptimizations / totalNetworkOptimizations * 100;
    }
    
    /**
     * 获取平均网络往返减少率
     * @return 平均网络往返减少率
     */
    public double getAverageNetworkReductionRate() {
        if (totalNetworkOptimizations == 0) return 0.0;
        return (double) totalNetworkReductions / totalNetworkOptimizations * 100;
    }
    
    /**
     * 是否健康
     * @return 是否健康
     */
    public boolean isHealthy() {
        return getSuccessRate() > 90 && getAverageNetworkReductionRate() > 50;
    }
}

/**
 * 批量操作服务
 * @author 运维实战
 */
@Service
public class BatchOperationService {
    
    @Autowired
    private NetworkOptimizationProperties properties;
    
    private static final Logger logger = LoggerFactory.getLogger(BatchOperationService.class);
    
    /**
     * 获取批量操作策略
     * @param operationCount 操作数量
     * @return 批量操作策略
     */
    public BatchOperationStrategy getStrategy(int operationCount) {
        logger.info("获取批量操作策略，操作数量: {}", operationCount);
        
        BatchOperationStrategy strategy = new BatchOperationStrategy();
        strategy.setOperationCount(operationCount);
        strategy.setTimestamp(System.currentTimeMillis());
        
        // 根据操作数量选择策略
        if (operationCount <= 10) {
            strategy.setStrategy("SMALL_BATCH");
            strategy.setDescription("小批量操作，网络往返减少有限");
            strategy.setRecommendedBatchSize(operationCount);
            strategy.setEstimatedDuration(operationCount * 100);
            strategy.setEstimatedNetworkReduction(operationCount - 1);
        } else if (operationCount <= 100) {
            strategy.setStrategy("MEDIUM_BATCH");
            strategy.setDescription("中批量操作，网络往返减少明显");
            strategy.setRecommendedBatchSize(Math.min(100, operationCount));
            strategy.setEstimatedDuration(operationCount * 50);
            strategy.setEstimatedNetworkReduction(operationCount - 1);
        } else if (operationCount <= 1000) {
            strategy.setStrategy("LARGE_BATCH");
            strategy.setDescription("大批量操作，网络往返减少显著");
            strategy.setRecommendedBatchSize(Math.min(1000, operationCount));
            strategy.setEstimatedDuration(operationCount * 30);
            strategy.setEstimatedNetworkReduction(operationCount - 1);
        } else {
            strategy.setStrategy("HUGE_BATCH");
            strategy.setDescription("超大批量操作，网络往返减少最大");
            strategy.setRecommendedBatchSize(Math.min(properties.getMaxBatchSize(), operationCount));
            strategy.setEstimatedDuration(operationCount * 20);
            strategy.setEstimatedNetworkReduction(operationCount - 1);
        }
        
        logger.info("批量操作策略确定: 策略={}, 操作数量={}, 推荐批次大小={}, 网络往返减少率={}%", 
            strategy.getStrategy(), operationCount, strategy.getRecommendedBatchSize(),
            String.format("%.2f", strategy.getNetworkReductionRate()));
        
        return strategy;
    }
    
    /**
     * 计算最优批量大小
     * @param totalOperationCount 总操作数量
     * @return 最优批量大小
     */
    public int calculateOptimalBatchSize(int totalOperationCount) {
        if (totalOperationCount <= 10) {
            return totalOperationCount;
        } else if (totalOperationCount <= 100) {
            return Math.min(50, totalOperationCount);
        } else if (totalOperationCount <= 1000) {
            return Math.min(500, totalOperationCount);
        } else {
            return Math.min(properties.getMaxBatchSize(), totalOperationCount);
        }
    }
    
    /**
     * 计算预计网络往返减少数
     * @param operationCount 操作数量
     * @param batchSize 批次大小
     * @return 预计网络往返减少数
     */
    public long calculateEstimatedNetworkReduction(int operationCount, int batchSize) {
        if (batchSize >= operationCount) {
            return operationCount - 1; // 单次批量操作
        } else {
            return operationCount - (int) Math.ceil((double) operationCount / batchSize);
        }
    }
    
    /**
     * 获取网络优化建议
     * @param operationCount 操作数量
     * @return 优化建议
     */
    public NetworkOptimizationAdvice getOptimizationAdvice(int operationCount) {
        NetworkOptimizationAdvice advice = new NetworkOptimizationAdvice();
        advice.setOperationCount(operationCount);
        advice.setTimestamp(System.currentTimeMillis());
        
        if (operationCount <= 10) {
            advice.setAdvice("SMALL_BATCH");
            advice.setDescription("小批量操作，建议直接执行");
            advice.setRecommendedBatchSize(operationCount);
        } else if (operationCount <= 100) {
            advice.setAdvice("MEDIUM_BATCH");
            advice.setDescription("中批量操作，建议分批执行");
            advice.setRecommendedBatchSize(50);
        } else if (operationCount <= 1000) {
            advice.setAdvice("LARGE_BATCH");
            advice.setDescription("大批量操作，强烈建议分批执行");
            advice.setRecommendedBatchSize(500);
        } else {
            advice.setAdvice("HUGE_BATCH");
            advice.setDescription("超大批量操作，必须分批执行");
            advice.setRecommendedBatchSize(properties.getMaxBatchSize());
        }
        
        return advice;
    }
}

/**
 * 网络优化建议类
 * @author 运维实战
 */
@Data
public class NetworkOptimizationAdvice {
    
    private int operationCount;
    private String advice;
    private String description;
    private int recommendedBatchSize;
    private long timestamp;
    
    public NetworkOptimizationAdvice() {
        this.timestamp = System.currentTimeMillis();
    }
    
    /**
     * 获取预计批次数量
     * @return 预计批次数量
     */
    public int getEstimatedBatchCount() {
        return (int) Math.ceil((double) operationCount / recommendedBatchSize);
    }
    
    /**
     * 获取预计网络往返减少数
     * @return 预计网络往返减少数
     */
    public int getEstimatedNetworkReduction() {
        return Math.max(0, operationCount - getEstimatedBatchCount());
    }
    
    /**
     * 获取网络往返减少率
     * @return 网络往返减少率
     */
    public double getNetworkReductionRate() {
        if (operationCount == 0) return 0.0;
        return (double) getEstimatedNetworkReduction() / operationCount * 100;
    }
}

/**
 * 网络优化REST控制器
 * @author 运维实战
 */
@RestController
@RequestMapping("/api/network/optimization")
public class NetworkOptimizationController {
    
    @Autowired
    private NetworkOptimizationService networkOptimizationService;
    
    @Autowired
    private NetworkMonitorService networkMonitorService;
    
    @Autowired
    private BatchOperationService batchOperationService;
    
    private static final Logger logger = LoggerFactory.getLogger(NetworkOptimizationController.class);
    
    /**
     * 批量数据库操作
     * @param request 批量数据库操作请求
     * @return 批量操作结果
     */
    @PostMapping("/database/batch")
    public ResponseEntity<NetworkOptimizationResult> batchDatabaseOperations(@RequestBody DatabaseBatchRequest request) {
        try {
            logger.info("接收到批量数据库操作请求，操作数量: {}", request.getOperations().size());
            
            NetworkOptimizationResult result = networkOptimizationService.batchDatabaseOperations(request.getOperations());
            
            return ResponseEntity.ok(result);
            
        } catch (Exception e) {
            logger.error("批量数据库操作失败", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * 批量缓存操作
     * @param request 批量缓存操作请求
     * @return 批量操作结果
     */
    @PostMapping("/cache/batch")
    public ResponseEntity<NetworkOptimizationResult> batchCacheOperations(@RequestBody CacheBatchRequest request) {
        try {
            logger.info("接收到批量缓存操作请求，操作数量: {}", request.getOperations().size());
            
            NetworkOptimizationResult result = networkOptimizationService.batchCacheOperations(request.getOperations());
            
            return ResponseEntity.ok(result);
            
        } catch (Exception e) {
            logger.error("批量缓存操作失败", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * 批量API调用
     * @param request 批量API调用请求
     * @return 批量调用结果
     */
    @PostMapping("/api/batch")
    public ResponseEntity<NetworkOptimizationResult> batchApiCalls(@RequestBody ApiBatchRequest request) {
        try {
            logger.info("接收到批量API调用请求，调用数量: {}", request.getApiCalls().size());
            
            NetworkOptimizationResult result = networkOptimizationService.batchApiCalls(request.getApiCalls());
            
            return ResponseEntity.ok(result);
            
        } catch (Exception e) {
            logger.error("批量API调用失败", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * 批量消息发送
     * @param request 批量消息发送请求
     * @return 批量发送结果
     */
    @PostMapping("/message/batch")
    public ResponseEntity<NetworkOptimizationResult> batchMessageSend(@RequestBody MessageBatchRequest request) {
        try {
            logger.info("接收到批量消息发送请求，消息数量: {}", request.getMessages().size());
            
            NetworkOptimizationResult result = networkOptimizationService.batchMessageSend(request.getMessages());
            
            return ResponseEntity.ok(result);
            
        } catch (Exception e) {
            logger.error("批量消息发送失败", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * 获取批量操作策略
     * @param operationCount 操作数量
     * @return 批量操作策略
     */
    @GetMapping("/strategy/{operationCount}")
    public ResponseEntity<BatchOperationStrategy> getBatchStrategy(@PathVariable int operationCount) {
        try {
            BatchOperationStrategy strategy = batchOperationService.getStrategy(operationCount);
            return ResponseEntity.ok(strategy);
        } catch (Exception e) {
            logger.error("获取批量操作策略失败", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * 获取网络优化建议
     * @param operationCount 操作数量
     * @return 网络优化建议
     */
    @GetMapping("/advice/{operationCount}")
    public ResponseEntity<NetworkOptimizationAdvice> getOptimizationAdvice(@PathVariable int operationCount) {
        try {
            NetworkOptimizationAdvice advice = batchOperationService.getOptimizationAdvice(operationCount);
            return ResponseEntity.ok(advice);
        } catch (Exception e) {
            logger.error("获取网络优化建议失败", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * 获取网络监控指标
     * @return 网络监控指标
     */
    @GetMapping("/metrics")
    public ResponseEntity<NetworkMetrics> getNetworkMetrics() {
        try {
            NetworkMetrics metrics = networkMonitorService.getMetrics();
            return ResponseEntity.ok(metrics);
        } catch (Exception e) {
            logger.error("获取网络监控指标失败", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
}

/**
 * 数据库批量操作请求类
 * @author 运维实战
 */
@Data
public class DatabaseBatchRequest {
    
    private List<DatabaseOperation> operations;
    
    public DatabaseBatchRequest() {}
    
    public DatabaseBatchRequest(List<DatabaseOperation> operations) {
        this.operations = operations;
    }
}

/**
 * 缓存批量操作请求类
 * @author 运维实战
 */
@Data
public class CacheBatchRequest {
    
    private List<CacheOperation> operations;
    
    public CacheBatchRequest() {}
    
    public CacheBatchRequest(List<CacheOperation> operations) {
        this.operations = operations;
    }
}

/**
 * API批量调用请求类
 * @author 运维实战
 */
@Data
public class ApiBatchRequest {
    
    private List<ApiCall> apiCalls;
    
    public ApiBatchRequest() {}
    
    public ApiBatchRequest(List<ApiCall> apiCalls) {
        this.apiCalls = apiCalls;
    }
}

/**
 * 消息批量发送请求类
 * @author 运维实战
 */
@Data
public class MessageBatchRequest {
    
    private List<Message> messages;
    
    public MessageBatchRequest() {}
    
    public MessageBatchRequest(List<Message> messages) {
        this.messages = messages;
    }
}

/**
 * 网络优化注解
 * @author 运维实战
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface NetworkOptimization {
    
    /**
     * 操作类型
     */
    String operationType() default "BATCH";
    
    /**
     * 最大批量大小
     */
    int maxBatchSize() default 1000;
    
    /**
     * 是否启用网络优化
     */
    boolean enableOptimization() default true;
    
    /**
     * 是否启用批量操作
     */
    boolean enableBatchOperation() default true;
    
    /**
     * 是否启用异步处理
     */
    boolean enableAsyncProcessing() default true;
    
    /**
     * 异步处理线程数
     */
    int asyncThreads() default 10;
    
    /**
     * 批量操作超时时间（毫秒）
     */
    long batchTimeoutMs() default 30000;
    
    /**
     * 操作失败时的消息
     */
    String message() default "网络优化操作失败，请稍后重试";
    
    /**
     * 操作失败时的HTTP状态码
     */
    int statusCode() default 500;
}

/**
 * 网络优化AOP切面
 * @author 运维实战
 */
@Aspect
@Component
public class NetworkOptimizationAspect {
    
    @Autowired
    private NetworkOptimizationService networkOptimizationService;
    
    @Autowired
    private NetworkMonitorService networkMonitorService;
    
    @Autowired
    private BatchOperationService batchOperationService;
    
    private static final Logger logger = LoggerFactory.getLogger(NetworkOptimizationAspect.class);
    
    /**
     * 网络优化切点
     */
    @Pointcut("@annotation(networkOptimization)")
    public void networkOptimizationPointcut(NetworkOptimization networkOptimization) {}
    
    /**
     * 网络优化环绕通知
     * @param joinPoint 连接点
     * @param networkOptimization 网络优化注解
     * @return 执行结果
     * @throws Throwable 异常
     */
    @Around("networkOptimizationPointcut(networkOptimization)")
    public Object around(ProceedingJoinPoint joinPoint, NetworkOptimization networkOptimization) throws Throwable {
        String methodName = joinPoint.getSignature().getName();
        
        try {
            // 获取方法参数
            Object[] args = joinPoint.getArgs();
            
            // 查找操作参数
            List<?> operations = findOperations(args);
            String operationType = networkOptimization.operationType();
            
            if (operations != null && !operations.isEmpty()) {
                // 获取批量操作策略
                BatchOperationStrategy strategy = batchOperationService.getStrategy(operations.size());
                
                logger.info("网络优化操作开始: method={}, operationType={}, strategy={}", 
                    methodName, operationType, strategy.getStrategy());
                
                // 记录网络优化指标
                networkMonitorService.recordNetworkOptimization(operationType, operations.size(), operations.size());
            }
            
            // 执行原方法
            return joinPoint.proceed();
            
        } catch (Exception e) {
            logger.error("网络优化操作处理异常: method={}", methodName, e);
            throw new NetworkOptimizationException(networkOptimization.message(), networkOptimization.statusCode());
        }
    }
    
    /**
     * 查找操作参数
     * @param args 方法参数
     * @return 操作列表
     */
    private List<?> findOperations(Object[] args) {
        for (Object arg : args) {
            if (arg instanceof List) {
                return (List<?>) arg;
            }
        }
        return null;
    }
}

/**
 * 网络优化异常类
 * @author 运维实战
 */
public class NetworkOptimizationException extends RuntimeException {
    
    private final int statusCode;
    
    public NetworkOptimizationException(String message) {
        super(message);
        this.statusCode = 500;
    }
    
    public NetworkOptimizationException(String message, int statusCode) {
        super(message);
        this.statusCode = statusCode;
    }
    
    public NetworkOptimizationException(String message, Throwable cause) {
        super(message, cause);
        this.statusCode = 500;
    }
    
    public NetworkOptimizationException(String message, Throwable cause, int statusCode) {
        super(message, cause);
        this.statusCode = statusCode;
    }
    
    public int getStatusCode() {
        return statusCode;
    }
}

/**
 * 网络优化异常处理器
 * @author 运维实战
 */
@ControllerAdvice
public class NetworkOptimizationExceptionHandler {
    
    private static final Logger logger = LoggerFactory.getLogger(NetworkOptimizationExceptionHandler.class);
    
    /**
     * 处理网络优化异常
     * @param e 异常
     * @return 错误响应
     */
    @ExceptionHandler(NetworkOptimizationException.class)
    public ResponseEntity<Map<String, Object>> handleNetworkOptimizationException(NetworkOptimizationException e) {
        logger.warn("网络优化异常: {}", e.getMessage());
        
        Map<String, Object> response = new HashMap<>();
        response.put("error", "NETWORK_OPTIMIZATION_FAILED");
        response.put("message", e.getMessage());
        response.put("timestamp", System.currentTimeMillis());
        
        return ResponseEntity.status(e.getStatusCode()).body(response);
    }
}

/**
 * 使用网络优化注解的服务
 * @author 运维实战
 */
@Service
public class NetworkOptimizationExampleService {
    
    private static final Logger logger = LoggerFactory.getLogger(NetworkOptimizationExampleService.class);
    
    /**
     * 基础网络优化示例
     * @param operations 操作列表
     * @return 处理结果
     */
    @NetworkOptimization(operationType = "BATCH", maxBatchSize = 500, enableOptimization = true,
        message = "基础网络优化：操作失败")
    public String basicNetworkOptimization(List<DatabaseOperation> operations) {
        logger.info("执行基础网络优化示例，操作数量: {}", operations.size());
        
        // 模拟网络优化操作
        try {
            Thread.sleep(operations.size() * 10);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        return "基础网络优化完成，操作数量: " + operations.size();
    }
    
    /**
     * 大批量网络优化示例
     * @param operations 操作列表
     * @return 处理结果
     */
    @NetworkOptimization(operationType = "BATCH", maxBatchSize = 2000, enableOptimization = true,
        message = "大批量网络优化：操作失败")
    public String largeNetworkOptimization(List<DatabaseOperation> operations) {
        logger.info("执行大批量网络优化示例，操作数量: {}", operations.size());
        
        // 模拟大批量网络优化操作
        try {
            Thread.sleep(operations.size() * 5);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        return "大批量网络优化完成，操作数量: " + operations.size();
    }
    
    /**
     * 异步网络优化示例
     * @param operations 操作列表
     * @return 处理结果
     */
    @NetworkOptimization(operationType = "BATCH", maxBatchSize = 1000, enableAsyncProcessing = true,
        asyncThreads = 20, message = "异步网络优化：操作失败")
    public String asyncNetworkOptimization(List<DatabaseOperation> operations) {
        logger.info("执行异步网络优化示例，操作数量: {}", operations.size());
        
        // 模拟异步网络优化操作
        try {
            Thread.sleep(operations.size() * 3);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        return "异步网络优化完成，操作数量: " + operations.size();
    }
}

/**
 * 网络优化测试控制器
 * @author 运维实战
 */
@RestController
@RequestMapping("/api/network/optimization/test")
public class NetworkOptimizationTestController {
    
    @Autowired
    private NetworkOptimizationExampleService exampleService;
    
    @Autowired
    private NetworkOptimizationService networkOptimizationService;
    
    @Autowired
    private NetworkMonitorService networkMonitorService;
    
    @Autowired
    private BatchOperationService batchOperationService;
    
    private static final Logger logger = LoggerFactory.getLogger(NetworkOptimizationTestController.class);
    
    /**
     * 基础网络优化测试
     * @param operationCount 操作数量
     * @return 测试结果
     */
    @GetMapping("/basic")
    public ResponseEntity<Map<String, String>> testBasicNetworkOptimization(@RequestParam int operationCount) {
        try {
            // 生成测试操作
            List<DatabaseOperation> operations = generateTestOperations(operationCount);
            
            String result = exampleService.basicNetworkOptimization(operations);
            
            Map<String, String> response = new HashMap<>();
            response.put("status", "SUCCESS");
            response.put("result", result);
            response.put("timestamp", String.valueOf(System.currentTimeMillis()));
            
            return ResponseEntity.ok(response);
            
        } catch (NetworkOptimizationException e) {
            logger.warn("基础网络优化测试失败: {}", e.getMessage());
            return ResponseEntity.status(e.getStatusCode()).build();
        } catch (Exception e) {
            logger.error("基础网络优化测试失败", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * 大批量网络优化测试
     * @param operationCount 操作数量
     * @return 测试结果
     */
    @GetMapping("/large")
    public ResponseEntity<Map<String, String>> testLargeNetworkOptimization(@RequestParam int operationCount) {
        try {
            // 生成测试操作
            List<DatabaseOperation> operations = generateTestOperations(operationCount);
            
            String result = exampleService.largeNetworkOptimization(operations);
            
            Map<String, String> response = new HashMap<>();
            response.put("status", "SUCCESS");
            response.put("result", result);
            response.put("timestamp", String.valueOf(System.currentTimeMillis()));
            
            return ResponseEntity.ok(response);
            
        } catch (NetworkOptimizationException e) {
            logger.warn("大批量网络优化测试失败: {}", e.getMessage());
            return ResponseEntity.status(e.getStatusCode()).build();
        } catch (Exception e) {
            logger.error("大批量网络优化测试失败", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * 异步网络优化测试
     * @param operationCount 操作数量
     * @return 测试结果
     */
    @GetMapping("/async")
    public ResponseEntity<Map<String, String>> testAsyncNetworkOptimization(@RequestParam int operationCount) {
        try {
            // 生成测试操作
            List<DatabaseOperation> operations = generateTestOperations(operationCount);
            
            String result = exampleService.asyncNetworkOptimization(operations);
            
            Map<String, String> response = new HashMap<>();
            response.put("status", "SUCCESS");
            response.put("result", result);
            response.put("timestamp", String.valueOf(System.currentTimeMillis()));
            
            return ResponseEntity.ok(response);
            
        } catch (NetworkOptimizationException e) {
            logger.warn("异步网络优化测试失败: {}", e.getMessage());
            return ResponseEntity.status(e.getStatusCode()).build();
        } catch (Exception e) {
            logger.error("异步网络优化测试失败", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * 获取批量操作策略
     * @param operationCount 操作数量
     * @return 批量操作策略
     */
    @GetMapping("/strategy/{operationCount}")
    public ResponseEntity<BatchOperationStrategy> getBatchStrategy(@PathVariable int operationCount) {
        try {
            BatchOperationStrategy strategy = batchOperationService.getStrategy(operationCount);
            return ResponseEntity.ok(strategy);
        } catch (Exception e) {
            logger.error("获取批量操作策略失败", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * 获取网络监控指标
     * @return 网络监控指标
     */
    @GetMapping("/metrics")
    public ResponseEntity<NetworkMetrics> getNetworkMetrics() {
        try {
            NetworkMetrics metrics = networkMonitorService.getMetrics();
            return ResponseEntity.ok(metrics);
        } catch (Exception e) {
            logger.error("获取网络监控指标失败", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * 生成测试操作
     * @param count 操作数量
     * @return 测试操作
     */
    private List<DatabaseOperation> generateTestOperations(int count) {
        List<DatabaseOperation> operations = new ArrayList<>();
        
        for (int i = 0; i < count; i++) {
            DatabaseOperation operation = new DatabaseOperation(
                "SELECT", 
                "SELECT * FROM test_table WHERE id = ?", 
                new Object[]{i}
            );
            operations.add(operation);
        }
        
        return operations;
    }
}