第279集Redis微服务跨库查询，如何解决架构实战：Redis跨库查询策略、数据聚合方案与企业级Redis微服务数据查询解决方案

/**
 * Redis多实例查询服务
 */
@Service
public class RedisMultiInstanceQueryService {

    @Autowired
    private RedisTemplate<String, Object> userRedisTemplate;

    @Autowired
    private RedisTemplate<String, Object> orderRedisTemplate;

    @Autowired
    private RedisTemplate<String, Object> productRedisTemplate;

    @Autowired
    private RedisTemplate<String, Object> paymentRedisTemplate;

    @Autowired
    private RedisTemplate<String, Object> cacheRedisTemplate;

    private final String REDIS_QUERY_CACHE_PREFIX = "redis_query_cache:";
    private final long REDIS_QUERY_CACHE_EXPIRE = 1800; // 30分钟

    /**
     * 跨实例查询用户订单信息
     */
    public UserOrderQueryResult queryUserOrderInfo(Long userId) {
        try {
            // 从缓存获取
            String cacheKey = REDIS_QUERY_CACHE_PREFIX + "user_order:" + userId;
            UserOrderQueryResult cachedResult = (UserOrderQueryResult) cacheRedisTemplate.opsForValue().get(cacheKey);

            if (cachedResult != null) {
                return cachedResult;
            }

            // 1. 查询用户信息
            UserInfo userInfo = queryUserInfo(userId);

            // 2. 查询用户订单信息
            List<OrderInfo> orders = queryUserOrders(userId);

            // 3. 查询订单商品信息
            List<ProductInfo> products = queryOrderProducts(orders);

            // 4. 查询支付信息
            List<PaymentInfo> payments = queryOrderPayments(orders);

            // 5. 聚合数据
            UserOrderQueryResult result = aggregateUserOrderData(userInfo, orders, products, payments);

            // 缓存结果
            cacheRedisTemplate.opsForValue().set(cacheKey, result, Duration.ofSeconds(REDIS_QUERY_CACHE_EXPIRE));

            return result;

        } catch (Exception e) {
            log.error("跨实例查询用户订单信息失败", e);
            throw new RedisCrossDatabaseQueryException("跨实例查询用户订单信息失败", e);
        }
    }

    /**
     * 查询用户信息
     */
    private UserInfo queryUserInfo(Long userId) {
        try {
            String userKey = "user:" + userId;
            UserInfo userInfo = (UserInfo) userRedisTemplate.opsForValue().get(userKey);
            return userInfo;
        } catch (Exception e) {
            log.error("查询用户信息失败", e);
            throw new RedisCrossDatabaseQueryException("查询用户信息失败", e);
        }
    }

    /**
     * 查询用户订单信息
     */
    private List<OrderInfo> queryUserOrders(Long userId) {
        try {
            String orderKey = "user_orders:" + userId;
            Set<Object> orderIds = userRedisTemplate.opsForSet().members(orderKey);

            if (orderIds == null || orderIds.isEmpty()) {
                return new ArrayList<>();
            }

            List<OrderInfo> orders = new ArrayList<>();
            for (Object orderId : orderIds) {
                String orderDetailKey = "order:" + orderId;
                OrderInfo orderInfo = (OrderInfo) orderRedisTemplate.opsForValue().get(orderDetailKey);
                if (orderInfo != null) {
                    orders.add(orderInfo);
                }
            }

            return orders;

        } catch (Exception e) {
            log.error("查询用户订单信息失败", e);
            throw new RedisCrossDatabaseQueryException("查询用户订单信息失败", e);
        }
    }

    /**
     * 查询订单商品信息
     */
    private List<ProductInfo> queryOrderProducts(List<OrderInfo> orders) {
        try {
            if (orders.isEmpty()) {
                return new ArrayList<>();
            }

            List<ProductInfo> products = new ArrayList<>();
            for (OrderInfo order : orders) {
                String productKey = "product:" + order.getProductId();
                ProductInfo productInfo = (ProductInfo) productRedisTemplate.opsForValue().get(productKey);
                if (productInfo != null) {
                    products.add(productInfo);
                }
            }

            return products;

        } catch (Exception e) {
            log.error("查询订单商品信息失败", e);
            throw new RedisCrossDatabaseQueryException("查询订单商品信息失败", e);
        }
    }

    /**
     * 查询订单支付信息
     */
    private List<PaymentInfo> queryOrderPayments(List<OrderInfo> orders) {
        try {
            if (orders.isEmpty()) {
                return new ArrayList<>();
            }

            List<PaymentInfo> payments = new ArrayList<>();
            for (OrderInfo order : orders) {
                String paymentKey = "payment:" + order.getOrderId();
                PaymentInfo paymentInfo = (PaymentInfo) paymentRedisTemplate.opsForValue().get(paymentKey);
                if (paymentInfo != null) {
                    payments.add(paymentInfo);
                }
            }

            return payments;

        } catch (Exception e) {
            log.error("查询订单支付信息失败", e);
            throw new RedisCrossDatabaseQueryException("查询订单支付信息失败", e);
        }
    }

    /**
     * 聚合用户订单数据
     */
    private UserOrderQueryResult aggregateUserOrderData(UserInfo userInfo, List<OrderInfo> orders, 
            List<ProductInfo> products, List<PaymentInfo> payments) {
        try {
            UserOrderQueryResult result = new UserOrderQueryResult();
            result.setUserId(userInfo.getUserId());
            result.setUserName(userInfo.getUserName());
            result.setUserEmail(userInfo.getUserEmail());

            // 聚合订单信息
            result.setTotalOrders(orders.size());
            result.setTotalOrderAmount(orders.stream()
                    .mapToDouble(OrderInfo::getAmount)
                    .sum());

            // 聚合商品信息
            result.setTotalProducts(products.size());
            result.setTotalProductAmount(products.stream()
                    .mapToDouble(ProductInfo::getPrice)
                    .sum());

            // 聚合支付信息
            result.setTotalPayments(payments.size());
            result.setTotalPaymentAmount(payments.stream()
                    .mapToDouble(PaymentInfo::getAmount)
                    .sum());

            // 计算统计信息
            calculateUserOrderStatistics(result, orders, products, payments);

            return result;

        } catch (Exception e) {
            log.error("聚合用户订单数据失败", e);
            throw new RedisCrossDatabaseQueryException("聚合用户订单数据失败", e);
        }
    }

    /**
     * 计算用户订单统计信息
     */
    private void calculateUserOrderStatistics(UserOrderQueryResult result, List<OrderInfo> orders, 
            List<ProductInfo> products, List<PaymentInfo> payments) {
        try {
            UserOrderStatistics statistics = new UserOrderStatistics();

            // 计算订单统计
            statistics.setOrderCount(orders.size());
            statistics.setOrderAmount(result.getTotalOrderAmount());
            statistics.setAvgOrderAmount(orders.size() > 0 ? 
                    result.getTotalOrderAmount() / orders.size() : 0.0);

            // 计算商品统计
            statistics.setProductCount(products.size());
            statistics.setProductAmount(result.getTotalProductAmount());

            // 计算支付统计
            statistics.setPaymentCount(payments.size());
            statistics.setPaymentAmount(result.getTotalPaymentAmount());

            // 计算综合统计
            statistics.setTotalAmount(result.getTotalOrderAmount() + result.getTotalProductAmount());

            result.setStatistics(statistics);

        } catch (Exception e) {
            log.error("计算用户订单统计信息失败", e);
        }
    }

    /**
     * 并行查询多个Redis实例
     */
    public CompletableFuture<MultiInstanceQueryResult> queryMultipleInstancesAsync(
            MultiInstanceQueryRequest request) {
        try {
            CompletableFuture<UserInfo> userFuture = CompletableFuture.supplyAsync(() -> {
                return queryUserInfo(request.getUserId());
            });

            CompletableFuture<List<OrderInfo>> ordersFuture = CompletableFuture.supplyAsync(() -> {
                return queryUserOrders(request.getUserId());
            });

            CompletableFuture<List<ProductInfo>> productsFuture = CompletableFuture.supplyAsync(() -> {
                return queryUserProducts(request.getUserId());
            });

            CompletableFuture<List<PaymentInfo>> paymentsFuture = CompletableFuture.supplyAsync(() -> {
                return queryUserPayments(request.getUserId());
            });

            // 等待所有查询完成
            CompletableFuture<Void> allFutures = CompletableFuture.allOf(
                    userFuture, ordersFuture, productsFuture, paymentsFuture);

            return allFutures.thenApply(v -> {
                MultiInstanceQueryResult result = new MultiInstanceQueryResult();
                try {
                    result.setUserInfo(userFuture.get());
                    result.setOrders(ordersFuture.get());
                    result.setProducts(productsFuture.get());
                    result.setPayments(paymentsFuture.get());
                    result.setStatus(QueryStatus.SUCCESS);
                } catch (Exception e) {
                    result.setStatus(QueryStatus.FAILED);
                    result.setErrorMessage(e.getMessage());
                }
                return result;
            });

        } catch (Exception e) {
            log.error("并行查询多个Redis实例失败", e);
            CompletableFuture<MultiInstanceQueryResult> failedFuture = new CompletableFuture<>();
            failedFuture.completeExceptionally(e);
            return failedFuture;
        }
    }

    /**
     * 查询用户商品信息
     */
    private List<ProductInfo> queryUserProducts(Long userId) {
        try {
            String productKey = "user_products:" + userId;
            Set<Object> productIds = userRedisTemplate.opsForSet().members(productKey);

            if (productIds == null || productIds.isEmpty()) {
                return new ArrayList<>();
            }

            List<ProductInfo> products = new ArrayList<>();
            for (Object productId : productIds) {
                String productDetailKey = "product:" + productId;
                ProductInfo productInfo = (ProductInfo) productRedisTemplate.opsForValue().get(productDetailKey);
                if (productInfo != null) {
                    products.add(productInfo);
                }
            }

            return products;

        } catch (Exception e) {
            log.error("查询用户商品信息失败", e);
            throw new RedisCrossDatabaseQueryException("查询用户商品信息失败", e);
        }
    }

    /**
     * 查询用户支付信息
     */
    private List<PaymentInfo> queryUserPayments(Long userId) {
        try {
            String paymentKey = "user_payments:" + userId;
            Set<Object> paymentIds = userRedisTemplate.opsForSet().members(paymentKey);

            if (paymentIds == null || paymentIds.isEmpty()) {
                return new ArrayList<>();
            }

            List<PaymentInfo> payments = new ArrayList<>();
            for (Object paymentId : paymentIds) {
                String paymentDetailKey = "payment:" + paymentId;
                PaymentInfo paymentInfo = (PaymentInfo) paymentRedisTemplate.opsForValue().get(paymentDetailKey);
                if (paymentInfo != null) {
                    payments.add(paymentInfo);
                }
            }

            return payments;

        } catch (Exception e) {
            log.error("查询用户支付信息失败", e);
            throw new RedisCrossDatabaseQueryException("查询用户支付信息失败", e);
        }
    }
}

/**
 * Redis聚合查询服务
 */
@Service
public class RedisAggregationQueryService {

    @Autowired
    private RedisTemplate<String, Object> userRedisTemplate;

    @Autowired
    private RedisTemplate<String, Object> orderRedisTemplate;

    @Autowired
    private RedisTemplate<String, Object> productRedisTemplate;

    @Autowired
    private RedisTemplate<String, Object> paymentRedisTemplate;

    @Autowired
    private RedisTemplate<String, Object> cacheRedisTemplate;

    private final String REDIS_AGGREGATION_CACHE_PREFIX = "redis_aggregation_cache:";
    private final long REDIS_AGGREGATION_CACHE_EXPIRE = 1800; // 30分钟

    /**
     * 聚合查询用户订单统计
     */
    public UserOrderAggregationResult aggregateUserOrderStatistics(Long userId) {
        try {
            // 从缓存获取
            String cacheKey = REDIS_AGGREGATION_CACHE_PREFIX + "user_order_stats:" + userId;
            UserOrderAggregationResult cachedResult = (UserOrderAggregationResult) cacheRedisTemplate.opsForValue().get(cacheKey);

            if (cachedResult != null) {
                return cachedResult;
            }

            // 1. 查询订单统计
            OrderStatistics orderStats = queryOrderStatistics(userId);

            // 2. 查询商品统计
            ProductStatistics productStats = queryProductStatistics(userId);

            // 3. 查询支付统计
            PaymentStatistics paymentStats = queryPaymentStatistics(userId);

            // 4. 聚合数据
            UserOrderAggregationResult result = aggregateStatistics(userId, orderStats, productStats, paymentStats);

            // 缓存结果
            cacheRedisTemplate.opsForValue().set(cacheKey, result, Duration.ofSeconds(REDIS_AGGREGATION_CACHE_EXPIRE));

            return result;

        } catch (Exception e) {
            log.error("聚合查询用户订单统计失败", e);
            throw new RedisCrossDatabaseQueryException("聚合查询用户订单统计失败", e);
        }
    }

    /**
     * 查询订单统计
     */
    private OrderStatistics queryOrderStatistics(Long userId) {
        try {
            // 查询订单总数
            String orderKey = "user_orders:" + userId;
            Long totalOrders = userRedisTemplate.opsForSet().size(orderKey);

            // 查询订单金额统计
            String orderDetailKey = "user_orders:" + userId;
            Set<Object> orderIds = userRedisTemplate.opsForSet().members(orderDetailKey);

            double totalAmount = 0.0;
            double minAmount = Double.MAX_VALUE;
            double maxAmount = Double.MIN_VALUE;
            Map<String, Long> statusCount = new HashMap<>();

            if (orderIds != null && !orderIds.isEmpty()) {
                for (Object orderId : orderIds) {
                    String orderKeyDetail = "order:" + orderId;
                    OrderInfo orderInfo = (OrderInfo) orderRedisTemplate.opsForValue().get(orderKeyDetail);
                    if (orderInfo != null) {
                        double amount = orderInfo.getAmount();
                        totalAmount += amount;
                        minAmount = Math.min(minAmount, amount);
                        maxAmount = Math.max(maxAmount, amount);

                        // 统计状态
                        String status = orderInfo.getStatus();
                        statusCount.put(status, statusCount.getOrDefault(status, 0L) + 1);
                    }
                }
            }

            double avgAmount = totalOrders > 0 ? totalAmount / totalOrders : 0.0;

            // 构建订单统计
            OrderStatistics orderStats = new OrderStatistics();
            orderStats.setUserId(userId);
            orderStats.setTotalOrders(totalOrders);
            orderStats.setTotalAmount(totalAmount);
            orderStats.setAvgAmount(avgAmount);
            orderStats.setMinAmount(minAmount == Double.MAX_VALUE ? 0.0 : minAmount);
            orderStats.setMaxAmount(maxAmount == Double.MIN_VALUE ? 0.0 : maxAmount);
            orderStats.setStatusCount(statusCount);

            return orderStats;

        } catch (Exception e) {
            log.error("查询订单统计失败", e);
            throw new RedisCrossDatabaseQueryException("查询订单统计失败", e);
        }
    }

    /**
     * 查询商品统计
     */
    private ProductStatistics queryProductStatistics(Long userId) {
        try {
            // 查询商品总数
            String productKey = "user_products:" + userId;
            Long totalProducts = userRedisTemplate.opsForSet().size(productKey);

            // 查询商品价格统计
            String productDetailKey = "user_products:" + userId;
            Set<Object> productIds = userRedisTemplate.opsForSet().members(productDetailKey);

            double totalPrice = 0.0;
            double minPrice = Double.MAX_VALUE;
            double maxPrice = Double.MIN_VALUE;
            Map<String, Long> categoryCount = new HashMap<>();

            if (productIds != null && !productIds.isEmpty()) {
                for (Object productId : productIds) {
                    String productKeyDetail = "product:" + productId;
                    ProductInfo productInfo = (ProductInfo) productRedisTemplate.opsForValue().get(productKeyDetail);
                    if (productInfo != null) {
                        double price = productInfo.getPrice();
                        totalPrice += price;
                        minPrice = Math.min(minPrice, price);
                        maxPrice = Math.max(maxPrice, price);

                        // 统计分类
                        String category = productInfo.getCategory();
                        categoryCount.put(category, categoryCount.getOrDefault(category, 0L) + 1);
                    }
                }
            }

            double avgPrice = totalProducts > 0 ? totalPrice / totalProducts : 0.0;

            // 构建商品统计
            ProductStatistics productStats = new ProductStatistics();
            productStats.setUserId(userId);
            productStats.setTotalProducts(totalProducts);
            productStats.setTotalPrice(totalPrice);
            productStats.setAvgPrice(avgPrice);
            productStats.setMinPrice(minPrice == Double.MAX_VALUE ? 0.0 : minPrice);
            productStats.setMaxPrice(maxPrice == Double.MIN_VALUE ? 0.0 : maxPrice);
            productStats.setCategoryCount(categoryCount);

            return productStats;

        } catch (Exception e) {
            log.error("查询商品统计失败", e);
            throw new RedisCrossDatabaseQueryException("查询商品统计失败", e);
        }
    }

    /**
     * 查询支付统计
     */
    private PaymentStatistics queryPaymentStatistics(Long userId) {
        try {
            // 查询支付总数
            String paymentKey = "user_payments:" + userId;
            Long totalPayments = userRedisTemplate.opsForSet().size(paymentKey);

            // 查询支付金额统计
            String paymentDetailKey = "user_payments:" + userId;
            Set<Object> paymentIds = userRedisTemplate.opsForSet().members(paymentDetailKey);

            double totalAmount = 0.0;
            double minAmount = Double.MAX_VALUE;
            double maxAmount = Double.MIN_VALUE;
            Map<String, Long> methodCount = new HashMap<>();

            if (paymentIds != null && !paymentIds.isEmpty()) {
                for (Object paymentId : paymentIds) {
                    String paymentKeyDetail = "payment:" + paymentId;
                    PaymentInfo paymentInfo = (PaymentInfo) paymentRedisTemplate.opsForValue().get(paymentKeyDetail);
                    if (paymentInfo != null) {
                        double amount = paymentInfo.getAmount();
                        totalAmount += amount;
                        minAmount = Math.min(minAmount, amount);
                        maxAmount = Math.max(maxAmount, amount);

                        // 统计支付方式
                        String paymentMethod = paymentInfo.getPaymentMethod();
                        methodCount.put(paymentMethod, methodCount.getOrDefault(paymentMethod, 0L) + 1);
                    }
                }
            }

            double avgAmount = totalPayments > 0 ? totalAmount / totalPayments : 0.0;

            // 构建支付统计
            PaymentStatistics paymentStats = new PaymentStatistics();
            paymentStats.setUserId(userId);
            paymentStats.setTotalPayments(totalPayments);
            paymentStats.setTotalAmount(totalAmount);
            paymentStats.setAvgAmount(avgAmount);
            paymentStats.setMinAmount(minAmount == Double.MAX_VALUE ? 0.0 : minAmount);
            paymentStats.setMaxAmount(maxAmount == Double.MIN_VALUE ? 0.0 : maxAmount);
            paymentStats.setMethodCount(methodCount);

            return paymentStats;

        } catch (Exception e) {
            log.error("查询支付统计失败", e);
            throw new RedisCrossDatabaseQueryException("查询支付统计失败", e);
        }
    }

    /**
     * 聚合统计信息
     */
    private UserOrderAggregationResult aggregateStatistics(Long userId, OrderStatistics orderStats, 
            ProductStatistics productStats, PaymentStatistics paymentStats) {
        try {
            UserOrderAggregationResult result = new UserOrderAggregationResult();
            result.setUserId(userId);

            // 聚合订单统计
            result.setTotalOrders(orderStats.getTotalOrders());
            result.setTotalOrderAmount(orderStats.getTotalAmount());
            result.setAvgOrderAmount(orderStats.getAvgAmount());
            result.setOrderStatusCount(orderStats.getStatusCount());

            // 聚合商品统计
            result.setTotalProducts(productStats.getTotalProducts());
            result.setTotalProductAmount(productStats.getTotalPrice());
            result.setAvgProductPrice(productStats.getAvgPrice());
            result.setProductCategoryCount(productStats.getCategoryCount());

            // 聚合支付统计
            result.setTotalPayments(paymentStats.getTotalPayments());
            result.setTotalPaymentAmount(paymentStats.getTotalAmount());
            result.setAvgPaymentAmount(paymentStats.getAvgAmount());
            result.setPaymentMethodCount(paymentStats.getMethodCount());

            // 计算综合统计
            calculateComprehensiveStatistics(result);

            return result;

        } catch (Exception e) {
            log.error("聚合统计信息失败", e);
            throw new RedisCrossDatabaseQueryException("聚合统计信息失败", e);
        }
    }

    /**
     * 计算综合统计
     */
    private void calculateComprehensiveStatistics(UserOrderAggregationResult result) {
        try {
            ComprehensiveStatistics comprehensiveStats = new ComprehensiveStatistics();

            // 计算综合金额
            comprehensiveStats.setTotalAmount(result.getTotalOrderAmount() + result.getTotalProductAmount());

            // 计算综合数量
            comprehensiveStats.setTotalCount(result.getTotalOrders() + result.getTotalProducts() + result.getTotalPayments());

            // 计算平均金额
            comprehensiveStats.setAvgAmount(comprehensiveStats.getTotalCount() > 0 ? 
                    comprehensiveStats.getTotalAmount() / comprehensiveStats.getTotalCount() : 0.0);

            result.setComprehensiveStatistics(comprehensiveStats);

        } catch (Exception e) {
            log.error("计算综合统计失败", e);
        }
    }

    /**
     * 复杂聚合查询
     */
    public ComplexAggregationResult executeComplexAggregation(ComplexAggregationRequest request) {
        try {
            ComplexAggregationResult result = new ComplexAggregationResult();
            result.setRequestId(request.getRequestId());
            result.setStartTime(new Date());

            // 执行复杂聚合查询
            List<Map<String, Object>> aggregationResults = new ArrayList<>();

            for (AggregationQuery query : request.getQueries()) {
                try {
                    List<Map<String, Object>> queryResults = executeAggregationQuery(query);
                    aggregationResults.addAll(queryResults);
                } catch (Exception e) {
                    log.error("执行聚合查询失败: {}", query.getQueryType(), e);
                }
            }

            // 处理聚合结果
            result.setAggregationResults(aggregationResults);
            result.setTotalCount(aggregationResults.size());
            result.setEndTime(new Date());
            result.setStatus(AggregationStatus.SUCCESS);

            return result;

        } catch (Exception e) {
            log.error("执行复杂聚合查询失败", e);
            throw new RedisCrossDatabaseQueryException("执行复杂聚合查询失败", e);
        }
    }

    /**
     * 执行聚合查询
     */
    private List<Map<String, Object>> executeAggregationQuery(AggregationQuery query) {
        try {
            List<Map<String, Object>> results = new ArrayList<>();

            switch (query.getQueryType()) {
                case ORDER_STATISTICS:
                    results = executeOrderStatisticsQuery(query);
                    break;
                case PRODUCT_STATISTICS:
                    results = executeProductStatisticsQuery(query);
                    break;
                case PAYMENT_STATISTICS:
                    results = executePaymentStatisticsQuery(query);
                    break;
                default:
                    log.warn("不支持的聚合查询类型: {}", query.getQueryType());
                    break;
            }

            return results;

        } catch (Exception e) {
            log.error("执行聚合查询失败", e);
            throw new RedisCrossDatabaseQueryException("执行聚合查询失败", e);
        }
    }

    /**
     * 执行订单统计查询
     */
    private List<Map<String, Object>> executeOrderStatisticsQuery(AggregationQuery query) {
        try {
            List<Map<String, Object>> results = new ArrayList<>();

            // 实现订单统计查询逻辑
            Map<String, Object> orderStats = new HashMap<>();
            orderStats.put("totalOrders", 100);
            orderStats.put("totalAmount", 10000.0);
            orderStats.put("avgAmount", 100.0);

            results.add(orderStats);

            return results;

        } catch (Exception e) {
            log.error("执行订单统计查询失败", e);
            throw new RedisCrossDatabaseQueryException("执行订单统计查询失败", e);
        }
    }

    /**
     * 执行商品统计查询
     */
    private List<Map<String, Object>> executeProductStatisticsQuery(AggregationQuery query) {
        try {
            List<Map<String, Object>> results = new ArrayList<>();

            // 实现商品统计查询逻辑
            Map<String, Object> productStats = new HashMap<>();
            productStats.put("totalProducts", 50);
            productStats.put("totalPrice", 5000.0);
            productStats.put("avgPrice", 100.0);

            results.add(productStats);

            return results;

        } catch (Exception e) {
            log.error("执行商品统计查询失败", e);
            throw new RedisCrossDatabaseQueryException("执行商品统计查询失败", e);
        }
    }

    /**
     * 执行支付统计查询
     */
    private List<Map<String, Object>> executePaymentStatisticsQuery(AggregationQuery query) {
        try {
            List<Map<String, Object>> results = new ArrayList<>();

            // 实现支付统计查询逻辑
            Map<String, Object> paymentStats = new HashMap<>();
            paymentStats.put("totalPayments", 80);
            paymentStats.put("totalAmount", 8000.0);
            paymentStats.put("avgAmount", 100.0);

            results.add(paymentStats);

            return results;

        } catch (Exception e) {
            log.error("执行支付统计查询失败", e);
            throw new RedisCrossDatabaseQueryException("执行支付统计查询失败", e);
        }
    }
}

/**
 * Redis事件驱动服务
 */
@Service
public class RedisEventDrivenService {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Autowired
    private RedisTemplate<String, Object> cacheRedisTemplate;

    @Autowired
    private RedisAggregationQueryService aggregationQueryService;

    private final String REDIS_EVENT_QUEUE_PREFIX = "redis_cross_db_query.event.";
    private final String REDIS_EVENT_CACHE_PREFIX = "redis_event_cache:";

    /**
     * 发布Redis跨库查询事件
     */
    public void publishRedisCrossDatabaseQueryEvent(RedisCrossDatabaseQueryEvent event) {
        try {
            // 设置事件ID
            if (event.getEventId() == null) {
                event.setEventId(UUID.randomUUID().toString());
            }

            // 设置时间戳
            event.setTimestamp(new Date());

            // 发布到消息队列
            String queueName = REDIS_EVENT_QUEUE_PREFIX + event.getEventType();
            rabbitTemplate.convertAndSend(queueName, event);

            log.info("发布Redis跨库查询事件成功: {}", event.getEventId());

        } catch (Exception e) {
            log.error("发布Redis跨库查询事件失败", e);
            throw new RedisCrossDatabaseQueryException("发布Redis跨库查询事件失败", e);
        }
    }

    /**
     * 处理用户信息更新事件
     */
    @RabbitListener(queues = "redis_cross_db_query.event.user.updated")
    public void handleUserUpdatedEvent(RedisUserUpdatedEvent event) {
        try {
            log.info("处理Redis用户信息更新事件: {}", event.getUserId());

            // 清除相关缓存
            clearUserRelatedCache(event.getUserId());

            // 更新聚合数据
            updateUserAggregatedData(event.getUserId());

            // 发布数据更新事件
            RedisDataUpdatedEvent dataUpdatedEvent = new RedisDataUpdatedEvent();
            dataUpdatedEvent.setEventId(UUID.randomUUID().toString());
            dataUpdatedEvent.setEventType("REDIS_USER_DATA_UPDATED");
            dataUpdatedEvent.setUserId(event.getUserId());
            dataUpdatedEvent.setTimestamp(new Date());

            publishRedisCrossDatabaseQueryEvent(dataUpdatedEvent);

        } catch (Exception e) {
            log.error("处理Redis用户信息更新事件失败", e);
        }
    }

    /**
     * 处理订单创建事件
     */
    @RabbitListener(queues = "redis_cross_db_query.event.order.created")
    public void handleOrderCreatedEvent(RedisOrderCreatedEvent event) {
        try {
            log.info("处理Redis订单创建事件: {}", event.getOrderId());

            // 清除相关缓存
            clearOrderRelatedCache(event.getOrderId());

            // 更新用户聚合数据
            updateUserAggregatedData(event.getUserId());

            // 发布数据更新事件
            RedisDataUpdatedEvent dataUpdatedEvent = new RedisDataUpdatedEvent();
            dataUpdatedEvent.setEventId(UUID.randomUUID().toString());
            dataUpdatedEvent.setEventType("REDIS_ORDER_DATA_UPDATED");
            dataUpdatedEvent.setOrderId(event.getOrderId());
            dataUpdatedEvent.setUserId(event.getUserId());
            dataUpdatedEvent.setTimestamp(new Date());

            publishRedisCrossDatabaseQueryEvent(dataUpdatedEvent);

        } catch (Exception e) {
            log.error("处理Redis订单创建事件失败", e);
        }
    }

    /**
     * 处理支付完成事件
     */
    @RabbitListener(queues = "redis_cross_db_query.event.payment.completed")
    public void handlePaymentCompletedEvent(RedisPaymentCompletedEvent event) {
        try {
            log.info("处理Redis支付完成事件: {}", event.getPaymentId());

            // 清除相关缓存
            clearPaymentRelatedCache(event.getPaymentId());

            // 更新订单聚合数据
            updateOrderAggregatedData(event.getOrderId());

            // 更新用户聚合数据
            updateUserAggregatedData(event.getUserId());

            // 发布数据更新事件
            RedisDataUpdatedEvent dataUpdatedEvent = new RedisDataUpdatedEvent();
            dataUpdatedEvent.setEventId(UUID.randomUUID().toString());
            dataUpdatedEvent.setEventType("REDIS_PAYMENT_DATA_UPDATED");
            dataUpdatedEvent.setPaymentId(event.getPaymentId());
            dataUpdatedEvent.setOrderId(event.getOrderId());
            dataUpdatedEvent.setUserId(event.getUserId());
            dataUpdatedEvent.setTimestamp(new Date());

            publishRedisCrossDatabaseQueryEvent(dataUpdatedEvent);

        } catch (Exception e) {
            log.error("处理Redis支付完成事件失败", e);
        }
    }

    /**
     * 清除用户相关缓存
     */
    private void clearUserRelatedCache(Long userId) {
        try {
            String pattern = REDIS_EVENT_CACHE_PREFIX + "user_*:" + userId;
            Set<String> keys = cacheRedisTemplate.keys(pattern);

            if (keys != null && !keys.isEmpty()) {
                cacheRedisTemplate.delete(keys);
            }

            log.info("清除Redis用户相关缓存成功: {}", userId);

        } catch (Exception e) {
            log.error("清除Redis用户相关缓存失败", e);
        }
    }

    /**
     * 清除订单相关缓存
     */
    private void clearOrderRelatedCache(Long orderId) {
        try {
            String pattern = REDIS_EVENT_CACHE_PREFIX + "order_*:" + orderId;
            Set<String> keys = cacheRedisTemplate.keys(pattern);

            if (keys != null && !keys.isEmpty()) {
                cacheRedisTemplate.delete(keys);
            }

            log.info("清除Redis订单相关缓存成功: {}", orderId);

        } catch (Exception e) {
            log.error("清除Redis订单相关缓存失败", e);
        }
    }

    /**
     * 清除支付相关缓存
     */
    private void clearPaymentRelatedCache(Long paymentId) {
        try {
            String pattern = REDIS_EVENT_CACHE_PREFIX + "payment_*:" + paymentId;
            Set<String> keys = cacheRedisTemplate.keys(pattern);

            if (keys != null && !keys.isEmpty()) {
                cacheRedisTemplate.delete(keys);
            }

            log.info("清除Redis支付相关缓存成功: {}", paymentId);

        } catch (Exception e) {
            log.error("清除Redis支付相关缓存失败", e);
        }
    }

    /**
     * 更新用户聚合数据
     */
    private void updateUserAggregatedData(Long userId) {
        try {
            // 异步更新用户聚合数据
            CompletableFuture.runAsync(() -> {
                try {
                    aggregationQueryService.aggregateUserOrderStatistics(userId);
                    log.info("更新Redis用户聚合数据成功: {}", userId);
                } catch (Exception e) {
                    log.error("更新Redis用户聚合数据失败: {}", userId, e);
                }
            });

        } catch (Exception e) {
            log.error("更新Redis用户聚合数据失败", e);
        }
    }

    /**
     * 更新订单聚合数据
     */
    private void updateOrderAggregatedData(Long orderId) {
        try {
            // 异步更新订单聚合数据
            CompletableFuture.runAsync(() -> {
                try {
                    // 这里可以添加订单聚合数据更新逻辑
                    log.info("更新Redis订单聚合数据成功: {}", orderId);
                } catch (Exception e) {
                    log.error("更新Redis订单聚合数据失败: {}", orderId, e);
                }
            });

        } catch (Exception e) {
            log.error("更新Redis订单聚合数据失败", e);
        }
    }
}

/**
 * Redis微服务数据查询管理服务
 */
@Service
public class RedisMicroserviceDataQueryManagementService {

    @Autowired
    private RedisMultiInstanceQueryService multiInstanceQueryService;

    @Autowired
    private RedisAggregationQueryService aggregationQueryService;

    @Autowired
    private RedisEventDrivenService eventDrivenService;

    @Autowired
    private RedisTemplate<String, Object> cacheRedisTemplate;

    private final String REDIS_QUERY_CACHE_PREFIX = "redis_query_cache:";
    private final long REDIS_QUERY_CACHE_EXPIRE = 1800; // 30分钟

    /**
     * 执行Redis跨库查询
     */
    public RedisCrossDatabaseQueryResult executeRedisCrossDatabaseQuery(RedisCrossDatabaseQueryRequest request) {
        try {
            RedisCrossDatabaseQueryResult result = new RedisCrossDatabaseQueryResult();
            result.setRequestId(request.getRequestId());
            result.setStartTime(new Date());

            // 验证请求
            validateRedisQueryRequest(request);

            // 选择查询策略
            RedisQueryStrategy strategy = selectRedisQueryStrategy(request);
            result.setStrategy(strategy);

            // 执行查询
            switch (strategy) {
                case MULTI_INSTANCE_QUERY:
                    result = executeMultiInstanceQuery(request);
                    break;
                case AGGREGATION_QUERY:
                    result = executeAggregationQuery(request);
                    break;
                case EVENT_DRIVEN:
                    result = executeEventDrivenQuery(request);
                    break;
                case HYBRID:
                    result = executeHybridQuery(request);
                    break;
                default:
                    throw new IllegalArgumentException("不支持的Redis查询策略: " + strategy);
            }

            result.setStatus(RedisQueryStatus.SUCCESS);
            result.setEndTime(new Date());

            log.info("执行Redis跨库查询成功: 请求ID={}, 策略={}", request.getRequestId(), strategy);
            return result;

        } catch (Exception e) {
            log.error("执行Redis跨库查询失败", e);
            throw new RedisCrossDatabaseQueryException("执行Redis跨库查询失败", e);
        }
    }

    /**
     * 验证Redis查询请求
     */
    private void validateRedisQueryRequest(RedisCrossDatabaseQueryRequest request) {
        if (request.getRequestId() == null || request.getRequestId().trim().isEmpty()) {
            throw new IllegalArgumentException("请求ID不能为空");
        }

        if (request.getQueryType() == null) {
            throw new IllegalArgumentException("查询类型不能为空");
        }

        if (request.getParameters() == null) {
            request.setParameters(new HashMap<>());
        }
    }

    /**
     * 选择Redis查询策略
     */
    private RedisQueryStrategy selectRedisQueryStrategy(RedisCrossDatabaseQueryRequest request) {
        try {
            // 根据查询类型选择策略
            switch (request.getQueryType()) {
                case USER_ORDER_QUERY:
                    return RedisQueryStrategy.MULTI_INSTANCE_QUERY;
                case USER_ORDER_AGGREGATION:
                    return RedisQueryStrategy.AGGREGATION_QUERY;
                case COMPLEX_AGGREGATION:
                    return RedisQueryStrategy.AGGREGATION_QUERY;
                case SEARCH_RESULTS:
                    return RedisQueryStrategy.HYBRID;
                default:
                    return RedisQueryStrategy.MULTI_INSTANCE_QUERY;
            }

        } catch (Exception e) {
            log.error("选择Redis查询策略失败", e);
            return RedisQueryStrategy.MULTI_INSTANCE_QUERY; // 默认策略
        }
    }

    /**
     * 执行多实例查询
     */
    private RedisCrossDatabaseQueryResult executeMultiInstanceQuery(RedisCrossDatabaseQueryRequest request) {
        try {
            RedisCrossDatabaseQueryResult result = new RedisCrossDatabaseQueryResult();
            result.setRequestId(request.getRequestId());
            result.setStrategy(RedisQueryStrategy.MULTI_INSTANCE_QUERY);

            // 根据查询类型执行不同的多实例查询
            switch (request.getQueryType()) {
                case USER_ORDER_QUERY:
                    Long userId = Long.valueOf(request.getParameters().get("userId").toString());
                    UserOrderQueryResult userOrderQuery = multiInstanceQueryService.queryUserOrderInfo(userId);
                    result.setData(userOrderQuery);
                    break;

                default:
                    throw new IllegalArgumentException("不支持的多实例查询类型: " + request.getQueryType());
            }

            return result;

        } catch (Exception e) {
            log.error("执行多实例查询失败", e);
            throw new RedisCrossDatabaseQueryException("执行多实例查询失败", e);
        }
    }

    /**
     * 执行聚合查询
     */
    private RedisCrossDatabaseQueryResult executeAggregationQuery(RedisCrossDatabaseQueryRequest request) {
        try {
            RedisCrossDatabaseQueryResult result = new RedisCrossDatabaseQueryResult();
            result.setRequestId(request.getRequestId());
            result.setStrategy(RedisQueryStrategy.AGGREGATION_QUERY);

            // 根据查询类型执行不同的聚合查询
            switch (request.getQueryType()) {
                case USER_ORDER_AGGREGATION:
                    Long userId = Long.valueOf(request.getParameters().get("userId").toString());
                    UserOrderAggregationResult userOrderAggregation = aggregationQueryService.aggregateUserOrderStatistics(userId);
                    result.setData(userOrderAggregation);
                    break;

                case COMPLEX_AGGREGATION:
                    ComplexAggregationRequest complexRequest = (ComplexAggregationRequest) request.getParameters().get("complexRequest");
                    ComplexAggregationResult complexResult = aggregationQueryService.executeComplexAggregation(complexRequest);
                    result.setData(complexResult);
                    break;

                default:
                    throw new IllegalArgumentException("不支持的聚合查询类型: " + request.getQueryType());
            }

            return result;

        } catch (Exception e) {
            log.error("执行聚合查询失败", e);
            throw new RedisCrossDatabaseQueryException("执行聚合查询失败", e);
        }
    }

    /**
     * 执行事件驱动查询
     */
    private RedisCrossDatabaseQueryResult executeEventDrivenQuery(RedisCrossDatabaseQueryRequest request) {
        try {
            RedisCrossDatabaseQueryResult result = new RedisCrossDatabaseQueryResult();
            result.setRequestId(request.getRequestId());
            result.setStrategy(RedisQueryStrategy.EVENT_DRIVEN);

            // 发布查询事件
            RedisCrossDatabaseQueryEvent event = new RedisCrossDatabaseQueryEvent();
            event.setEventId(UUID.randomUUID().toString());
            event.setEventType("REDIS_CROSS_DATABASE_QUERY");
            event.setRequestId(request.getRequestId());
            event.setQueryType(request.getQueryType());
            event.setParameters(request.getParameters());
            event.setTimestamp(new Date());

            eventDrivenService.publishRedisCrossDatabaseQueryEvent(event);

            // 等待事件处理完成
            Thread.sleep(1000);

            result.setData("Redis事件已发布，请稍后查询结果");

            return result;

        } catch (Exception e) {
            log.error("执行事件驱动查询失败", e);
            throw new RedisCrossDatabaseQueryException("执行事件驱动查询失败", e);
        }
    }

    /**
     * 执行混合查询
     */
    private RedisCrossDatabaseQueryResult executeHybridQuery(RedisCrossDatabaseQueryRequest request) {
        try {
            RedisCrossDatabaseQueryResult result = new RedisCrossDatabaseQueryResult();
            result.setRequestId(request.getRequestId());
            result.setStrategy(RedisQueryStrategy.HYBRID);

            // 根据查询类型执行混合查询
            switch (request.getQueryType()) {
                case SEARCH_RESULTS:
                    RedisSearchRequest searchRequest = (RedisSearchRequest) request.getParameters().get("searchRequest");
                    RedisSearchResult searchResult = executeRedisSearch(searchRequest);
                    result.setData(searchResult);
                    break;

                default:
                    throw new IllegalArgumentException("不支持的混合查询类型: " + request.getQueryType());
            }

            return result;

        } catch (Exception e) {
            log.error("执行混合查询失败", e);
            throw new RedisCrossDatabaseQueryException("执行混合查询失败", e);
        }
    }

    /**
     * 执行Redis搜索
     */
    private RedisSearchResult executeRedisSearch(RedisSearchRequest request) {
        try {
            RedisSearchResult result = new RedisSearchResult();

            // 构建搜索查询
            String searchKey = request.getSearchKey();
            Set<Object> searchResults = cacheRedisTemplate.opsForSet().members(searchKey);

            if (searchResults == null || searchResults.isEmpty()) {
                result.setDocuments(new ArrayList<>());
                result.setTotalCount(0);
                return result;
            }

            // 处理搜索结果
            List<Object> documents = new ArrayList<>();
            for (Object searchResult : searchResults) {
                if (request.getKeyword() != null && !request.getKeyword().trim().isEmpty()) {
                    if (searchResult.toString().contains(request.getKeyword())) {
                        documents.add(searchResult);
                    }
                } else {
                    documents.add(searchResult);
                }
            }

            // 构建结果
            result.setDocuments(documents);
            result.setTotalCount(documents.size());
            result.setFrom(request.getFrom());
            result.setSize(request.getSize());

            return result;

        } catch (Exception e) {
            log.error("执行Redis搜索失败", e);
            throw new RedisCrossDatabaseQueryException("执行Redis搜索失败", e);
        }
    }

    /**
     * 异步执行Redis跨库查询
     */
    @Async
    public CompletableFuture<RedisCrossDatabaseQueryResult> executeRedisCrossDatabaseQueryAsync(
            RedisCrossDatabaseQueryRequest request) {
        try {
            RedisCrossDatabaseQueryResult result = executeRedisCrossDatabaseQuery(request);
            return CompletableFuture.completedFuture(result);
        } catch (Exception e) {
            return CompletableFuture.failedFuture(e);
        }
    }

    /**
     * 获取Redis查询结果
     */
    public RedisCrossDatabaseQueryResult getRedisQueryResult(String requestId) {
        try {
            // 从缓存获取
            String cacheKey = REDIS_QUERY_CACHE_PREFIX + requestId;
            RedisCrossDatabaseQueryResult cachedResult = (RedisCrossDatabaseQueryResult) cacheRedisTemplate.opsForValue().get(cacheKey);

            if (cachedResult != null) {
                return cachedResult;
            }

            // 从数据库获取
            throw new RedisCrossDatabaseQueryException("Redis查询结果不存在: " + requestId);

        } catch (Exception e) {
            log.error("获取Redis查询结果失败", e);
            throw new RedisCrossDatabaseQueryException("获取Redis查询结果失败", e);
        }
    }

    /**
     * 缓存Redis查询结果
     */
    public void cacheRedisQueryResult(String requestId, RedisCrossDatabaseQueryResult result) {
        try {
            String cacheKey = REDIS_QUERY_CACHE_PREFIX + requestId;
            cacheRedisTemplate.opsForValue().set(cacheKey, result, Duration.ofSeconds(REDIS_QUERY_CACHE_EXPIRE));

        } catch (Exception e) {
            log.error("缓存Redis查询结果失败", e);
        }
    }

    /**
     * 获取Redis查询统计信息
     */
    public RedisQueryStatistics getRedisQueryStatistics(Date startTime, Date endTime) {
        try {
            RedisQueryStatistics statistics = new RedisQueryStatistics();
            statistics.setStartTime(startTime);
            statistics.setEndTime(endTime);

            // 统计查询次数
            statistics.setTotalQueries(500); // 实际应用中需要从数据库统计

            // 统计查询策略使用情况
            Map<RedisQueryStrategy, Long> strategyCount = new HashMap<>();
            strategyCount.put(RedisQueryStrategy.MULTI_INSTANCE_QUERY, 200L);
            strategyCount.put(RedisQueryStrategy.AGGREGATION_QUERY, 150L);
            strategyCount.put(RedisQueryStrategy.EVENT_DRIVEN, 50L);
            strategyCount.put(RedisQueryStrategy.HYBRID, 100L);
            statistics.setStrategyCount(strategyCount);

            // 统计查询类型使用情况
            Map<RedisQueryType, Long> typeCount = new HashMap<>();
            typeCount.put(RedisQueryType.USER_ORDER_QUERY, 150L);
            typeCount.put(RedisQueryType.USER_ORDER_AGGREGATION, 100L);
            typeCount.put(RedisQueryType.COMPLEX_AGGREGATION, 50L);
            typeCount.put(RedisQueryType.SEARCH_RESULTS, 200L);
            statistics.setTypeCount(typeCount);

            // 统计平均响应时间
            statistics.setAverageResponseTime(50.0); // 50ms

            // 统计成功率
            statistics.setSuccessRate(0.999); // 99.9%

            return statistics;

        } catch (Exception e) {
            log.error("获取Redis查询统计信息失败", e);
            throw new RedisCrossDatabaseQueryException("获取Redis查询统计信息失败", e);
        }
    }
}

/**
 * Redis跨库查询性能优化服务
 */
@Service
public class RedisCrossDatabaseQueryPerformanceOptimizationService {

    @Autowired
    private RedisTemplate<String, Object> cacheRedisTemplate;

    @Autowired
    private CaffeineCache localCache;

    private final String REDIS_PERFORMANCE_CACHE_PREFIX = "redis_performance_cache:";

    /**
     * 缓存Redis查询性能数据
     */
    public void cacheRedisQueryPerformanceData(String requestId, Object data) {
        String cacheKey = REDIS_PERFORMANCE_CACHE_PREFIX + requestId;

        try {
            // 写入本地缓存
            localCache.put(cacheKey, data);

            // 写入Redis缓存
            String redisCacheKey = "redis_cache:" + cacheKey;
            cacheRedisTemplate.opsForValue().set(redisCacheKey, data, Duration.ofHours(1));

        } catch (Exception e) {
            log.error("缓存Redis查询性能数据失败", e);
        }
    }

    /**
     * 获取缓存的Redis查询性能数据
     */
    public Object getCachedRedisQueryPerformanceData(String requestId) {
        String cacheKey = REDIS_PERFORMANCE_CACHE_PREFIX + requestId;

        try {
            // 从本地缓存获取
            Object cachedData = localCache.getIfPresent(cacheKey);
            if (cachedData != null) {
                return cachedData;
            }

            // 从Redis获取
            String redisCacheKey = "redis_cache:" + cacheKey;
            Object redisData = cacheRedisTemplate.opsForValue().get(redisCacheKey);
            if (redisData != null) {
                localCache.put(cacheKey, redisData);
                return redisData;
            }

        } catch (Exception e) {
            log.error("获取缓存的Redis查询性能数据失败", e);
        }

        return null;
    }

    /**
     * 批量处理Redis查询请求
     */
    public List<RedisCrossDatabaseQueryResult> batchProcessRedisQueryRequests(
            List<RedisCrossDatabaseQueryRequest> requests) {
        List<RedisCrossDatabaseQueryResult> results = new ArrayList<>();

        try {
            // 按查询类型分组
            Map<RedisQueryType, List<RedisCrossDatabaseQueryRequest>> typeGroups = requests.stream()
                    .collect(Collectors.groupingBy(RedisCrossDatabaseQueryRequest::getQueryType));

            // 并行处理各类型
            typeGroups.entrySet().parallelStream().forEach(entry -> {
                RedisQueryType queryType = entry.getKey();
                List<RedisCrossDatabaseQueryRequest> typeRequests = entry.getValue();

                try {
                    List<RedisCrossDatabaseQueryResult> typeResults = processRedisTypeRequests(queryType, typeRequests);

                    synchronized (results) {
                        results.addAll(typeResults);
                    }

                } catch (Exception e) {
                    log.error("处理Redis查询类型失败: {}", queryType, e);
                }
            });

        } catch (Exception e) {
            log.error("批量处理Redis查询请求失败", e);
        }

        return results;
    }

    /**
     * 处理Redis类型请求
     */
    private List<RedisCrossDatabaseQueryResult> processRedisTypeRequests(RedisQueryType queryType, 
            List<RedisCrossDatabaseQueryRequest> requests) {
        List<RedisCrossDatabaseQueryResult> results = new ArrayList<>();

        for (RedisCrossDatabaseQueryRequest request : requests) {
            try {
                RedisCrossDatabaseQueryResult result = processRedisQueryRequest(request);
                results.add(result);
            } catch (Exception e) {
                log.error("处理Redis查询请求失败: {}", request.getRequestId(), e);
                RedisCrossDatabaseQueryResult errorResult = new RedisCrossDatabaseQueryResult();
                errorResult.setRequestId(request.getRequestId());
                errorResult.setStatus(RedisQueryStatus.FAILED);
                errorResult.setErrorMessage(e.getMessage());
                results.add(errorResult);
            }
        }

        return results;
    }

    /**
     * 处理Redis查询请求
     */
    private RedisCrossDatabaseQueryResult processRedisQueryRequest(RedisCrossDatabaseQueryRequest request) {
        // 实现Redis查询处理逻辑
        RedisCrossDatabaseQueryResult result = new RedisCrossDatabaseQueryResult();
        result.setRequestId(request.getRequestId());
        result.setStatus(RedisQueryStatus.SUCCESS);
        result.setData("Redis查询成功");
        return result;
    }

    /**
     * 预热Redis查询性能缓存
     */
    @PostConstruct
    public void warmupRedisQueryPerformanceCache() {
        try {
            // 预热常用Redis查询性能数据
            List<String> commonRequestIds = Arrays.asList("redis_req_1", "redis_req_2", "redis_req_3");

            for (String requestId : commonRequestIds) {
                try {
                    String cacheKey = REDIS_PERFORMANCE_CACHE_PREFIX + requestId;
                    Object performanceData = new Object();
                    cacheRedisQueryPerformanceData(requestId, performanceData);
                } catch (Exception e) {
                    log.error("预热Redis查询性能缓存失败: {}", requestId, e);
                }
            }

        } catch (Exception e) {
            log.error("预热Redis查询性能缓存失败", e);
        }
    }

    /**
     * 清理过期缓存
     */
    @Scheduled(fixedRate = 300000) // 5分钟
    public void cleanupExpiredCache() {
        try {
            // 清理本地缓存
            localCache.cleanUp();

            // 清理Redis过期缓存
            cleanupRedisExpiredCache();

        } catch (Exception e) {
            log.error("清理过期缓存失败", e);
        }
    }

    /**
     * 清理Redis过期缓存
     */
    private void cleanupRedisExpiredCache() {
        try {
            Set<String> cacheKeys = cacheRedisTemplate.keys("redis_cache:" + REDIS_PERFORMANCE_CACHE_PREFIX + "*");

            for (String key : cacheKeys) {
                Long ttl = cacheRedisTemplate.getExpire(key);
                if (ttl != null && ttl <= 0) {
                    cacheRedisTemplate.delete(key);
                }
            }

        } catch (Exception e) {
            log.error("清理Redis过期缓存失败", e);
        }
    }
}