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

/**
 * 服务间调用服务
 */
@Service
public class InterServiceCallService {

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private FeignClientRegistry feignClientRegistry;

    @Autowired
    private CircuitBreakerRegistry circuitBreakerRegistry;

    private final String USER_SERVICE_URL = "http://user-service";
    private final String ORDER_SERVICE_URL = "http://order-service";
    private final String PRODUCT_SERVICE_URL = "http://product-service";
    private final String PAYMENT_SERVICE_URL = "http://payment-service";

    /**
     * 跨服务查询用户订单信息
     */
    public UserOrderInfo getUserOrderInfo(Long userId) {
        try {
            // 1. 获取用户信息
            UserInfo userInfo = getUserInfo(userId);

            // 2. 获取用户订单列表
            List<OrderInfo> orders = getUserOrders(userId);

            // 3. 获取订单商品信息
            List<OrderProductInfo> orderProducts = getOrderProducts(orders);

            // 4. 聚合数据
            UserOrderInfo userOrderInfo = aggregateUserOrderInfo(userInfo, orders, orderProducts);

            return userOrderInfo;

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

    /**
     * 获取用户信息
     */
    private UserInfo getUserInfo(Long userId) {
        try {
            String url = USER_SERVICE_URL + "/api/users/" + userId;

            ResponseEntity<UserInfo> response = restTemplate.getForEntity(url, UserInfo.class);

            if (response.getStatusCode().is2xxSuccessful()) {
                return response.getBody();
            } else {
                throw new ServiceCallException("获取用户信息失败: " + response.getStatusCode());
            }

        } catch (Exception e) {
            log.error("获取用户信息失败", e);
            throw new ServiceCallException("获取用户信息失败", e);
        }
    }

    /**
     * 获取用户订单列表
     */
    private List<OrderInfo> getUserOrders(Long userId) {
        try {
            String url = ORDER_SERVICE_URL + "/api/orders?userId=" + userId;

            ResponseEntity<List<OrderInfo>> response = restTemplate.exchange(
                    url, HttpMethod.GET, null, new ParameterizedTypeReference<List<OrderInfo>>() {});

            if (response.getStatusCode().is2xxSuccessful()) {
                return response.getBody();
            } else {
                throw new ServiceCallException("获取用户订单列表失败: " + response.getStatusCode());
            }

        } catch (Exception e) {
            log.error("获取用户订单列表失败", e);
            throw new ServiceCallException("获取用户订单列表失败", e);
        }
    }

    /**
     * 获取订单商品信息
     */
    private List<OrderProductInfo> getOrderProducts(List<OrderInfo> orders) {
        try {
            List<OrderProductInfo> orderProducts = new ArrayList<>();

            for (OrderInfo order : orders) {
                String url = PRODUCT_SERVICE_URL + "/api/products/order/" + order.getId();

                ResponseEntity<List<ProductInfo>> response = restTemplate.exchange(
                        url, HttpMethod.GET, null, new ParameterizedTypeReference<List<ProductInfo>>() {});

                if (response.getStatusCode().is2xxSuccessful()) {
                    List<ProductInfo> products = response.getBody();
                    for (ProductInfo product : products) {
                        OrderProductInfo orderProduct = new OrderProductInfo();
                        orderProduct.setOrderId(order.getId());
                        orderProduct.setProductId(product.getId());
                        orderProduct.setProductName(product.getName());
                        orderProduct.setProductPrice(product.getPrice());
                        orderProduct.setQuantity(product.getQuantity());
                        orderProducts.add(orderProduct);
                    }
                }
            }

            return orderProducts;

        } catch (Exception e) {
            log.error("获取订单商品信息失败", e);
            throw new ServiceCallException("获取订单商品信息失败", e);
        }
    }

    /**
     * 聚合用户订单信息
     */
    private UserOrderInfo aggregateUserOrderInfo(UserInfo userInfo, List<OrderInfo> orders, 
            List<OrderProductInfo> orderProducts) {
        try {
            UserOrderInfo userOrderInfo = new UserOrderInfo();
            userOrderInfo.setUserId(userInfo.getId());
            userOrderInfo.setUserName(userInfo.getName());
            userOrderInfo.setUserEmail(userInfo.getEmail());
            userOrderInfo.setUserPhone(userInfo.getPhone());

            // 聚合订单信息
            List<OrderDetailInfo> orderDetails = new ArrayList<>();
            for (OrderInfo order : orders) {
                OrderDetailInfo orderDetail = new OrderDetailInfo();
                orderDetail.setOrderId(order.getId());
                orderDetail.setOrderNo(order.getOrderNo());
                orderDetail.setOrderStatus(order.getStatus());
                orderDetail.setOrderAmount(order.getAmount());
                orderDetail.setCreateTime(order.getCreateTime());

                // 聚合商品信息
                List<OrderProductInfo> orderProductsForOrder = orderProducts.stream()
                        .filter(op -> op.getOrderId().equals(order.getId()))
                        .collect(Collectors.toList());
                orderDetail.setProducts(orderProductsForOrder);

                orderDetails.add(orderDetail);
            }

            userOrderInfo.setOrders(orderDetails);

            return userOrderInfo;

        } catch (Exception e) {
            log.error("聚合用户订单信息失败", e);
            throw new CrossDatabaseQueryException("聚合用户订单信息失败", e);
        }
    }

    /**
     * 并行查询多个服务
     */
    public CompletableFuture<MultiServiceQueryResult> queryMultipleServicesAsync(
            MultiServiceQueryRequest request) {
        try {
            CompletableFuture<UserInfo> userFuture = CompletableFuture.supplyAsync(() -> {
                return getUserInfo(request.getUserId());
            });

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

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

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

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

            return allFutures.thenApply(v -> {
                MultiServiceQueryResult result = new MultiServiceQueryResult();
                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("并行查询多个服务失败", e);
            CompletableFuture<MultiServiceQueryResult> failedFuture = new CompletableFuture<>();
            failedFuture.completeExceptionally(e);
            return failedFuture;
        }
    }

    /**
     * 获取推荐商品
     */
    private List<ProductInfo> getRecommendedProducts(Long userId) {
        try {
            String url = PRODUCT_SERVICE_URL + "/api/products/recommend?userId=" + userId;

            ResponseEntity<List<ProductInfo>> response = restTemplate.exchange(
                    url, HttpMethod.GET, null, new ParameterizedTypeReference<List<ProductInfo>>() {});

            if (response.getStatusCode().is2xxSuccessful()) {
                return response.getBody();
            } else {
                throw new ServiceCallException("获取推荐商品失败: " + response.getStatusCode());
            }

        } catch (Exception e) {
            log.error("获取推荐商品失败", e);
            throw new ServiceCallException("获取推荐商品失败", e);
        }
    }

    /**
     * 获取用户支付信息
     */
    private List<PaymentInfo> getUserPayments(Long userId) {
        try {
            String url = PAYMENT_SERVICE_URL + "/api/payments?userId=" + userId;

            ResponseEntity<List<PaymentInfo>> response = restTemplate.exchange(
                    url, HttpMethod.GET, null, new ParameterizedTypeReference<List<PaymentInfo>>() {});

            if (response.getStatusCode().is2xxSuccessful()) {
                return response.getBody();
            } else {
                throw new ServiceCallException("获取用户支付信息失败: " + response.getStatusCode());
            }

        } catch (Exception e) {
            log.error("获取用户支付信息失败", e);
            throw new ServiceCallException("获取用户支付信息失败", e);
        }
    }

    /**
     * 使用Feign客户端查询
     */
    public UserOrderInfo getUserOrderInfoWithFeign(Long userId) {
        try {
            // 获取Feign客户端
            UserServiceClient userServiceClient = feignClientRegistry.getClient(UserServiceClient.class);
            OrderServiceClient orderServiceClient = feignClientRegistry.getClient(OrderServiceClient.class);
            ProductServiceClient productServiceClient = feignClientRegistry.getClient(ProductServiceClient.class);

            // 调用服务
            UserInfo userInfo = userServiceClient.getUserById(userId);
            List<OrderInfo> orders = orderServiceClient.getOrdersByUserId(userId);

            // 获取订单商品信息
            List<OrderProductInfo> orderProducts = new ArrayList<>();
            for (OrderInfo order : orders) {
                List<ProductInfo> products = productServiceClient.getProductsByOrderId(order.getId());
                for (ProductInfo product : products) {
                    OrderProductInfo orderProduct = new OrderProductInfo();
                    orderProduct.setOrderId(order.getId());
                    orderProduct.setProductId(product.getId());
                    orderProduct.setProductName(product.getName());
                    orderProduct.setProductPrice(product.getPrice());
                    orderProduct.setQuantity(product.getQuantity());
                    orderProducts.add(orderProduct);
                }
            }

            // 聚合数据
            return aggregateUserOrderInfo(userInfo, orders, orderProducts);

        } catch (Exception e) {
            log.error("使用Feign客户端查询失败", e);
            throw new CrossDatabaseQueryException("使用Feign客户端查询失败", e);
        }
    }
}

/**
 * 数据聚合服务
 */
@Service
public class DataAggregationService {

    @Autowired
    private InterServiceCallService interServiceCallService;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private ElasticsearchTemplate elasticsearchTemplate;

    private final String AGGREGATION_CACHE_PREFIX = "aggregation_cache:";
    private final long AGGREGATION_CACHE_EXPIRE = 1800; // 30分钟

    /**
     * 聚合用户完整信息
     */
    public UserCompleteInfo aggregateUserCompleteInfo(Long userId) {
        try {
            // 从缓存获取
            String cacheKey = AGGREGATION_CACHE_PREFIX + "user_complete:" + userId;
            UserCompleteInfo cachedInfo = (UserCompleteInfo) redisTemplate.opsForValue().get(cacheKey);

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

            // 并行查询多个服务
            CompletableFuture<UserInfo> userFuture = CompletableFuture.supplyAsync(() -> {
                return interServiceCallService.getUserInfo(userId);
            });

            CompletableFuture<List<OrderInfo>> ordersFuture = CompletableFuture.supplyAsync(() -> {
                return interServiceCallService.getUserOrders(userId);
            });

            CompletableFuture<List<ProductInfo>> productsFuture = CompletableFuture.supplyAsync(() -> {
                return interServiceCallService.getRecommendedProducts(userId);
            });

            CompletableFuture<List<PaymentInfo>> paymentsFuture = CompletableFuture.supplyAsync(() -> {
                return interServiceCallService.getUserPayments(userId);
            });

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

            allFutures.get(); // 等待完成

            // 聚合数据
            UserCompleteInfo userCompleteInfo = new UserCompleteInfo();
            userCompleteInfo.setUserId(userId);
            userCompleteInfo.setUserInfo(userFuture.get());
            userCompleteInfo.setOrders(ordersFuture.get());
            userCompleteInfo.setRecommendedProducts(productsFuture.get());
            userCompleteInfo.setPayments(paymentsFuture.get());

            // 计算统计信息
            calculateUserStatistics(userCompleteInfo);

            // 缓存结果
            redisTemplate.opsForValue().set(cacheKey, userCompleteInfo, 
                    Duration.ofSeconds(AGGREGATION_CACHE_EXPIRE));

            return userCompleteInfo;

        } catch (Exception e) {
            log.error("聚合用户完整信息失败", e);
            throw new CrossDatabaseQueryException("聚合用户完整信息失败", e);
        }
    }

    /**
     * 计算用户统计信息
     */
    private void calculateUserStatistics(UserCompleteInfo userCompleteInfo) {
        try {
            UserStatistics statistics = new UserStatistics();

            // 订单统计
            List<OrderInfo> orders = userCompleteInfo.getOrders();
            if (orders != null && !orders.isEmpty()) {
                statistics.setTotalOrders(orders.size());
                statistics.setTotalOrderAmount(orders.stream()
                        .mapToDouble(OrderInfo::getAmount)
                        .sum());

                // 按状态统计
                Map<String, Long> statusCount = orders.stream()
                        .collect(Collectors.groupingBy(OrderInfo::getStatus, Collectors.counting()));
                statistics.setOrderStatusCount(statusCount);

                // 按时间统计
                Map<String, Long> timeCount = orders.stream()
                        .collect(Collectors.groupingBy(order -> 
                                order.getCreateTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate().toString(), 
                                Collectors.counting()));
                statistics.setOrderTimeCount(timeCount);
            }

            // 支付统计
            List<PaymentInfo> payments = userCompleteInfo.getPayments();
            if (payments != null && !payments.isEmpty()) {
                statistics.setTotalPayments(payments.size());
                statistics.setTotalPaymentAmount(payments.stream()
                        .mapToDouble(PaymentInfo::getAmount)
                        .sum());

                // 按支付方式统计
                Map<String, Long> paymentMethodCount = payments.stream()
                        .collect(Collectors.groupingBy(PaymentInfo::getPaymentMethod, Collectors.counting()));
                statistics.setPaymentMethodCount(paymentMethodCount);
            }

            userCompleteInfo.setStatistics(statistics);

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

    /**
     * 聚合订单详细信息
     */
    public OrderDetailInfo aggregateOrderDetailInfo(Long orderId) {
        try {
            // 从缓存获取
            String cacheKey = AGGREGATION_CACHE_PREFIX + "order_detail:" + orderId;
            OrderDetailInfo cachedInfo = (OrderDetailInfo) redisTemplate.opsForValue().get(cacheKey);

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

            // 并行查询
            CompletableFuture<OrderInfo> orderFuture = CompletableFuture.supplyAsync(() -> {
                return interServiceCallService.getOrderInfo(orderId);
            });

            CompletableFuture<List<ProductInfo>> productsFuture = CompletableFuture.supplyAsync(() -> {
                return interServiceCallService.getOrderProducts(orderId);
            });

            CompletableFuture<UserInfo> userFuture = CompletableFuture.supplyAsync(() -> {
                OrderInfo order = orderFuture.join();
                return interServiceCallService.getUserInfo(order.getUserId());
            });

            CompletableFuture<List<PaymentInfo>> paymentsFuture = CompletableFuture.supplyAsync(() -> {
                return interServiceCallService.getOrderPayments(orderId);
            });

            // 等待完成
            CompletableFuture<Void> allFutures = CompletableFuture.allOf(
                    orderFuture, productsFuture, userFuture, paymentsFuture);
            allFutures.get();

            // 聚合数据
            OrderDetailInfo orderDetailInfo = new OrderDetailInfo();
            orderDetailInfo.setOrderInfo(orderFuture.get());
            orderDetailInfo.setProducts(productsFuture.get());
            orderDetailInfo.setUserInfo(userFuture.get());
            orderDetailInfo.setPayments(paymentsFuture.get());

            // 缓存结果
            redisTemplate.opsForValue().set(cacheKey, orderDetailInfo, 
                    Duration.ofSeconds(AGGREGATION_CACHE_EXPIRE));

            return orderDetailInfo;

        } catch (Exception e) {
            log.error("聚合订单详细信息失败", e);
            throw new CrossDatabaseQueryException("聚合订单详细信息失败", e);
        }
    }

    /**
     * 聚合商品销售统计
     */
    public ProductSalesStatistics aggregateProductSalesStatistics(Long productId, Date startTime, Date endTime) {
        try {
            // 从缓存获取
            String cacheKey = AGGREGATION_CACHE_PREFIX + "product_sales:" + productId + ":" + 
                    startTime.getTime() + ":" + endTime.getTime();
            ProductSalesStatistics cachedStats = (ProductSalesStatistics) redisTemplate.opsForValue().get(cacheKey);

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

            // 并行查询
            CompletableFuture<ProductInfo> productFuture = CompletableFuture.supplyAsync(() -> {
                return interServiceCallService.getProductInfo(productId);
            });

            CompletableFuture<List<OrderInfo>> ordersFuture = CompletableFuture.supplyAsync(() -> {
                return interServiceCallService.getProductOrders(productId, startTime, endTime);
            });

            CompletableFuture<List<PaymentInfo>> paymentsFuture = CompletableFuture.supplyAsync(() -> {
                return interServiceCallService.getProductPayments(productId, startTime, endTime);
            });

            // 等待完成
            CompletableFuture<Void> allFutures = CompletableFuture.allOf(
                    productFuture, ordersFuture, paymentsFuture);
            allFutures.get();

            // 聚合数据
            ProductSalesStatistics statistics = new ProductSalesStatistics();
            statistics.setProductInfo(productFuture.get());
            statistics.setTotalOrders(ordersFuture.get().size());
            statistics.setTotalSales(ordersFuture.get().stream()
                    .mapToDouble(OrderInfo::getAmount)
                    .sum());
            statistics.setTotalPayments(paymentsFuture.get().size());
            statistics.setTotalPaymentAmount(paymentsFuture.get().stream()
                    .mapToDouble(PaymentInfo::getAmount)
                    .sum());

            // 计算趋势
            calculateSalesTrend(statistics, ordersFuture.get());

            // 缓存结果
            redisTemplate.opsForValue().set(cacheKey, statistics, 
                    Duration.ofSeconds(AGGREGATION_CACHE_EXPIRE));

            return statistics;

        } catch (Exception e) {
            log.error("聚合商品销售统计失败", e);
            throw new CrossDatabaseQueryException("聚合商品销售统计失败", e);
        }
    }

    /**
     * 计算销售趋势
     */
    private void calculateSalesTrend(ProductSalesStatistics statistics, List<OrderInfo> orders) {
        try {
            // 按日期分组统计
            Map<String, Double> dailySales = orders.stream()
                    .collect(Collectors.groupingBy(order -> 
                            order.getCreateTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate().toString(),
                            Collectors.summingDouble(OrderInfo::getAmount)));

            statistics.setDailySalesTrend(dailySales);

            // 按周分组统计
            Map<String, Double> weeklySales = orders.stream()
                    .collect(Collectors.groupingBy(order -> {
                        LocalDate date = order.getCreateTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
                        return date.getYear() + "-W" + date.get(WeekFields.ISO.weekOfYear());
                    }, Collectors.summingDouble(OrderInfo::getAmount)));

            statistics.setWeeklySalesTrend(weeklySales);

            // 按月分组统计
            Map<String, Double> monthlySales = orders.stream()
                    .collect(Collectors.groupingBy(order -> {
                        LocalDate date = order.getCreateTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
                        return date.getYear() + "-" + String.format("%02d", date.getMonthValue());
                    }, Collectors.summingDouble(OrderInfo::getAmount)));

            statistics.setMonthlySalesTrend(monthlySales);

        } catch (Exception e) {
            log.error("计算销售趋势失败", e);
        }
    }

    /**
     * 使用Elasticsearch聚合查询
     */
    public SearchResult aggregateSearchResults(SearchRequest request) {
        try {
            // 构建搜索查询
            BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();

            if (request.getKeyword() != null && !request.getKeyword().trim().isEmpty()) {
                boolQuery.must(QueryBuilders.multiMatchQuery(request.getKeyword(), 
                        "name", "description", "tags"));
            }

            if (request.getCategory() != null) {
                boolQuery.filter(QueryBuilders.termQuery("category", request.getCategory()));
            }

            if (request.getPriceMin() != null) {
                boolQuery.filter(QueryBuilders.rangeQuery("price").gte(request.getPriceMin()));
            }

            if (request.getPriceMax() != null) {
                boolQuery.filter(QueryBuilders.rangeQuery("price").lte(request.getPriceMax()));
            }

            // 构建聚合查询
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.query(boolQuery);
            searchSourceBuilder.from(request.getFrom());
            searchSourceBuilder.size(request.getSize());

            // 添加聚合
            searchSourceBuilder.aggregation(AggregationBuilders.terms("category_agg")
                    .field("category")
                    .size(10));

            searchSourceBuilder.aggregation(AggregationBuilders.range("price_agg")
                    .field("price")
                    .addRange("0-100", 0, 100)
                    .addRange("100-500", 100, 500)
                    .addRange("500-1000", 500, 1000)
                    .addRange("1000+", 1000, Double.MAX_VALUE));

            searchSourceBuilder.aggregation(AggregationBuilders.stats("price_stats")
                    .field("price"));

            // 执行搜索
            SearchRequest searchRequest = new SearchRequest("products");
            searchRequest.source(searchSourceBuilder);

            SearchResponse response = elasticsearchTemplate.search(searchRequest, RequestOptions.DEFAULT);

            // 处理结果
            SearchResult result = new SearchResult();
            result.setTotalHits(response.getHits().getTotalHits().value);
            result.setTook(response.getTook().millis());

            // 处理搜索结果
            List<SearchHit> hits = Arrays.asList(response.getHits().getHits());
            List<ProductInfo> products = hits.stream()
                    .map(hit -> {
                        Map<String, Object> source = hit.getSourceAsMap();
                        ProductInfo product = new ProductInfo();
                        product.setId(Long.valueOf(source.get("id").toString()));
                        product.setName(source.get("name").toString());
                        product.setDescription(source.get("description").toString());
                        product.setPrice(Double.valueOf(source.get("price").toString()));
                        product.setCategory(source.get("category").toString());
                        return product;
                    })
                    .collect(Collectors.toList());

            result.setProducts(products);

            // 处理聚合结果
            Map<String, Object> aggregations = new HashMap<>();
            response.getAggregations().asMap().forEach((name, agg) -> {
                aggregations.put(name, agg);
            });
            result.setAggregations(aggregations);

            return result;

        } catch (Exception e) {
            log.error("使用Elasticsearch聚合查询失败", e);
            throw new CrossDatabaseQueryException("使用Elasticsearch聚合查询失败", e);
        }
    }
}

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

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private DataAggregationService dataAggregationService;

    private final String EVENT_QUEUE_PREFIX = "cross_db_query.event.";
    private final String EVENT_CACHE_PREFIX = "event_cache:";

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

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

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

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

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

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

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

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

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

            publishCrossDatabaseQueryEvent(dataUpdatedEvent);

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

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

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

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

            // 更新商品聚合数据
            updateProductAggregatedData(event.getProductId());

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

            publishCrossDatabaseQueryEvent(dataUpdatedEvent);

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

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

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

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

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

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

            publishCrossDatabaseQueryEvent(dataUpdatedEvent);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * 更新订单聚合数据
     */
    private void updateOrderAggregatedData(Long orderId) {
        try {
            // 异步更新订单聚合数据
            CompletableFuture.runAsync(() -> {
                try {
                    dataAggregationService.aggregateOrderDetailInfo(orderId);
                    log.info("更新订单聚合数据成功: {}", orderId);
                } catch (Exception e) {
                    log.error("更新订单聚合数据失败: {}", orderId, e);
                }
            });

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

    /**
     * 更新商品聚合数据
     */
    private void updateProductAggregatedData(Long productId) {
        try {
            // 异步更新商品聚合数据
            CompletableFuture.runAsync(() -> {
                try {
                    Date endTime = new Date();
                    Date startTime = new Date(endTime.getTime() - 30L * 24 * 60 * 60 * 1000); // 30天前
                    dataAggregationService.aggregateProductSalesStatistics(productId, startTime, endTime);
                    log.info("更新商品聚合数据成功: {}", productId);
                } catch (Exception e) {
                    log.error("更新商品聚合数据失败: {}", productId, e);
                }
            });

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

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

    @Autowired
    private InterServiceCallService interServiceCallService;

    @Autowired
    private DataAggregationService dataAggregationService;

    @Autowired
    private EventDrivenService eventDrivenService;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    private final String QUERY_CACHE_PREFIX = "query_cache:";
    private final long QUERY_CACHE_EXPIRE = 1800; // 30分钟

    /**
     * 执行跨库查询
     */
    public CrossDatabaseQueryResult executeCrossDatabaseQuery(CrossDatabaseQueryRequest request) {
        try {
            CrossDatabaseQueryResult result = new CrossDatabaseQueryResult();
            result.setRequestId(request.getRequestId());
            result.setStartTime(new Date());

            // 验证请求
            validateQueryRequest(request);

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

            // 执行查询
            switch (strategy) {
                case SERVICE_CALL:
                    result = executeServiceCallQuery(request);
                    break;
                case DATA_AGGREGATION:
                    result = executeDataAggregationQuery(request);
                    break;
                case EVENT_DRIVEN:
                    result = executeEventDrivenQuery(request);
                    break;
                case HYBRID:
                    result = executeHybridQuery(request);
                    break;
                default:
                    throw new IllegalArgumentException("不支持的查询策略: " + strategy);
            }

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

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

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

    /**
     * 验证查询请求
     */
    private void validateQueryRequest(CrossDatabaseQueryRequest 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<>());
        }
    }

    /**
     * 选择查询策略
     */
    private QueryStrategy selectQueryStrategy(CrossDatabaseQueryRequest request) {
        try {
            // 根据查询类型选择策略
            switch (request.getQueryType()) {
                case USER_ORDER_INFO:
                    return QueryStrategy.SERVICE_CALL;
                case USER_COMPLETE_INFO:
                    return QueryStrategy.DATA_AGGREGATION;
                case ORDER_DETAIL_INFO:
                    return QueryStrategy.DATA_AGGREGATION;
                case PRODUCT_SALES_STATISTICS:
                    return QueryStrategy.DATA_AGGREGATION;
                case SEARCH_RESULTS:
                    return QueryStrategy.HYBRID;
                default:
                    return QueryStrategy.SERVICE_CALL;
            }

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

    /**
     * 执行服务调用查询
     */
    private CrossDatabaseQueryResult executeServiceCallQuery(CrossDatabaseQueryRequest request) {
        try {
            CrossDatabaseQueryResult result = new CrossDatabaseQueryResult();
            result.setRequestId(request.getRequestId());
            result.setStrategy(QueryStrategy.SERVICE_CALL);

            // 根据查询类型执行不同的服务调用
            switch (request.getQueryType()) {
                case USER_ORDER_INFO:
                    Long userId = Long.valueOf(request.getParameters().get("userId").toString());
                    UserOrderInfo userOrderInfo = interServiceCallService.getUserOrderInfo(userId);
                    result.setData(userOrderInfo);
                    break;

                case ORDER_DETAIL_INFO:
                    Long orderId = Long.valueOf(request.getParameters().get("orderId").toString());
                    OrderDetailInfo orderDetailInfo = interServiceCallService.getOrderDetailInfo(orderId);
                    result.setData(orderDetailInfo);
                    break;

                default:
                    throw new IllegalArgumentException("不支持的服务调用查询类型: " + request.getQueryType());
            }

            return result;

        } catch (Exception e) {
            log.error("执行服务调用查询失败", e);
            throw new CrossDatabaseQueryException("执行服务调用查询失败", e);
        }
    }

    /**
     * 执行数据聚合查询
     */
    private CrossDatabaseQueryResult executeDataAggregationQuery(CrossDatabaseQueryRequest request) {
        try {
            CrossDatabaseQueryResult result = new CrossDatabaseQueryResult();
            result.setRequestId(request.getRequestId());
            result.setStrategy(QueryStrategy.DATA_AGGREGATION);

            // 根据查询类型执行不同的数据聚合
            switch (request.getQueryType()) {
                case USER_COMPLETE_INFO:
                    Long userId = Long.valueOf(request.getParameters().get("userId").toString());
                    UserCompleteInfo userCompleteInfo = dataAggregationService.aggregateUserCompleteInfo(userId);
                    result.setData(userCompleteInfo);
                    break;

                case ORDER_DETAIL_INFO:
                    Long orderId = Long.valueOf(request.getParameters().get("orderId").toString());
                    OrderDetailInfo orderDetailInfo = dataAggregationService.aggregateOrderDetailInfo(orderId);
                    result.setData(orderDetailInfo);
                    break;

                case PRODUCT_SALES_STATISTICS:
                    Long productId = Long.valueOf(request.getParameters().get("productId").toString());
                    Date startTime = (Date) request.getParameters().get("startTime");
                    Date endTime = (Date) request.getParameters().get("endTime");
                    ProductSalesStatistics statistics = dataAggregationService.aggregateProductSalesStatistics(
                            productId, startTime, endTime);
                    result.setData(statistics);
                    break;

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

            return result;

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

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

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

            eventDrivenService.publishCrossDatabaseQueryEvent(event);

            // 等待事件处理完成（实际应用中可能需要更复杂的等待机制）
            Thread.sleep(1000);

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

            return result;

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

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

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

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

            return result;

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

    /**
     * 异步执行跨库查询
     */
    @Async
    public CompletableFuture<CrossDatabaseQueryResult> executeCrossDatabaseQueryAsync(
            CrossDatabaseQueryRequest request) {
        try {
            CrossDatabaseQueryResult result = executeCrossDatabaseQuery(request);
            return CompletableFuture.completedFuture(result);
        } catch (Exception e) {
            return CompletableFuture.failedFuture(e);
        }
    }

    /**
     * 获取查询结果
     */
    public CrossDatabaseQueryResult getQueryResult(String requestId) {
        try {
            // 从缓存获取
            String cacheKey = QUERY_CACHE_PREFIX + requestId;
            CrossDatabaseQueryResult cachedResult = (CrossDatabaseQueryResult) redisTemplate.opsForValue().get(cacheKey);

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

            // 从数据库获取（实际应用中需要存储查询结果）
            throw new CrossDatabaseQueryException("查询结果不存在: " + requestId);

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

    /**
     * 缓存查询结果
     */
    public void cacheQueryResult(String requestId, CrossDatabaseQueryResult result) {
        try {
            String cacheKey = QUERY_CACHE_PREFIX + requestId;
            redisTemplate.opsForValue().set(cacheKey, result, Duration.ofSeconds(QUERY_CACHE_EXPIRE));

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

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

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

            // 统计查询策略使用情况
            Map<QueryStrategy, Long> strategyCount = new HashMap<>();
            strategyCount.put(QueryStrategy.SERVICE_CALL, 500L);
            strategyCount.put(QueryStrategy.DATA_AGGREGATION, 300L);
            strategyCount.put(QueryStrategy.EVENT_DRIVEN, 100L);
            strategyCount.put(QueryStrategy.HYBRID, 100L);
            statistics.setStrategyCount(strategyCount);

            // 统计查询类型使用情况
            Map<QueryType, Long> typeCount = new HashMap<>();
            typeCount.put(QueryType.USER_ORDER_INFO, 400L);
            typeCount.put(QueryType.USER_COMPLETE_INFO, 300L);
            typeCount.put(QueryType.ORDER_DETAIL_INFO, 200L);
            typeCount.put(QueryType.PRODUCT_SALES_STATISTICS, 100L);
            statistics.setTypeCount(typeCount);

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

            // 统计成功率
            statistics.setSuccessRate(0.95); // 95%

            return statistics;

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

/**
 * 微服务数据查询优化服务
 */
@Service
public class MicroserviceDataQueryOptimizationService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private CaffeineCache localCache;

    @Autowired
    private MicroserviceDataQueryManagementService queryManagementService;

    private final String OPTIMIZATION_CACHE_PREFIX = "optimization_cache:";

    /**
     * 优化跨库查询性能
     */
    public QueryOptimizationResult optimizeCrossDatabaseQueryPerformance(
            CrossDatabaseQueryRequest request) {
        try {
            QueryOptimizationResult result = new QueryOptimizationResult();
            result.setRequestId(request.getRequestId());
            result.setStartTime(new Date());

            // 1. 分析查询模式
            QueryPatternAnalysis patternAnalysis = analyzeQueryPattern(request);
            result.setPatternAnalysis(patternAnalysis);

            // 2. 优化缓存策略
            CacheOptimizationResult cacheOptimization = optimizeCacheStrategy(request, patternAnalysis);
            result.setCacheOptimization(cacheOptimization);

            // 3. 优化查询策略
            QueryStrategyOptimizationResult strategyOptimization = optimizeQueryStrategy(request, patternAnalysis);
            result.setStrategyOptimization(strategyOptimization);

            // 4. 优化数据聚合
            AggregationOptimizationResult aggregationOptimization = optimizeAggregationStrategy(request, patternAnalysis);
            result.setAggregationOptimization(aggregationOptimization);

            result.setStatus(OptimizationStatus.COMPLETED);
            result.setEndTime(new Date());

            log.info("优化跨库查询性能完成: 请求ID={}", request.getRequestId());
            return result;

        } catch (Exception e) {
            log.error("优化跨库查询性能失败", e);
            throw new CrossDatabaseQueryException("优化跨库查询性能失败", e);
        }
    }

    /**
     * 分析查询模式
     */
    private QueryPatternAnalysis analyzeQueryPattern(CrossDatabaseQueryRequest request) {
        try {
            QueryPatternAnalysis analysis = new QueryPatternAnalysis();
            analysis.setRequestId(request.getRequestId());
            analysis.setQueryType(request.getQueryType());

            // 分析查询频率
            analysis.setQueryFrequency(analyzeQueryFrequency(request.getQueryType()));

            // 分析查询复杂度
            analysis.setQueryComplexity(analyzeQueryComplexity(request));

            // 分析数据量
            analysis.setDataVolume(analyzeDataVolume(request));

            // 分析响应时间
            analysis.setResponseTime(analyzeResponseTime(request.getQueryType()));

            return analysis;

        } catch (Exception e) {
            log.error("分析查询模式失败", e);
            throw new CrossDatabaseQueryException("分析查询模式失败", e);
        }
    }

    /**
     * 分析查询频率
     */
    private QueryFrequency analyzeQueryFrequency(QueryType queryType) {
        try {
            // 从缓存获取查询频率统计
            String cacheKey = OPTIMIZATION_CACHE_PREFIX + "frequency:" + queryType.name();
            QueryFrequency cachedFrequency = (QueryFrequency) redisTemplate.opsForValue().get(cacheKey);

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

            // 计算查询频率（实际应用中需要从数据库统计）
            QueryFrequency frequency = new QueryFrequency();
            frequency.setQueryType(queryType);
            frequency.setDailyCount(1000);
            frequency.setHourlyCount(100);
            frequency.setMinuteCount(10);

            // 缓存结果
            redisTemplate.opsForValue().set(cacheKey, frequency, Duration.ofHours(1));

            return frequency;

        } catch (Exception e) {
            log.error("分析查询频率失败", e);
            return new QueryFrequency();
        }
    }

    /**
     * 分析查询复杂度
     */
    private QueryComplexity analyzeQueryComplexity(CrossDatabaseQueryRequest request) {
        try {
            QueryComplexity complexity = new QueryComplexity();

            // 分析参数数量
            complexity.setParameterCount(request.getParameters().size());

            // 分析查询类型复杂度
            switch (request.getQueryType()) {
                case USER_ORDER_INFO:
                    complexity.setComplexityLevel(ComplexityLevel.MEDIUM);
                    complexity.setServiceCount(3);
                    break;
                case USER_COMPLETE_INFO:
                    complexity.setComplexityLevel(ComplexityLevel.HIGH);
                    complexity.setServiceCount(4);
                    break;
                case ORDER_DETAIL_INFO:
                    complexity.setComplexityLevel(ComplexityLevel.MEDIUM);
                    complexity.setServiceCount(3);
                    break;
                case PRODUCT_SALES_STATISTICS:
                    complexity.setComplexityLevel(ComplexityLevel.HIGH);
                    complexity.setServiceCount(3);
                    break;
                case SEARCH_RESULTS:
                    complexity.setComplexityLevel(ComplexityLevel.LOW);
                    complexity.setServiceCount(1);
                    break;
                default:
                    complexity.setComplexityLevel(ComplexityLevel.MEDIUM);
                    complexity.setServiceCount(2);
                    break;
            }

            return complexity;

        } catch (Exception e) {
            log.error("分析查询复杂度失败", e);
            return new QueryComplexity();
        }
    }

    /**
     * 分析数据量
     */
    private DataVolume analyzeDataVolume(CrossDatabaseQueryRequest request) {
        try {
            DataVolume volume = new DataVolume();

            // 根据查询类型估算数据量
            switch (request.getQueryType()) {
                case USER_ORDER_INFO:
                    volume.setEstimatedRecords(100);
                    volume.setDataSizeKB(50);
                    break;
                case USER_COMPLETE_INFO:
                    volume.setEstimatedRecords(500);
                    volume.setDataSizeKB(200);
                    break;
                case ORDER_DETAIL_INFO:
                    volume.setEstimatedRecords(200);
                    volume.setDataSizeKB(100);
                    break;
                case PRODUCT_SALES_STATISTICS:
                    volume.setEstimatedRecords(1000);
                    volume.setDataSizeKB(500);
                    break;
                case SEARCH_RESULTS:
                    volume.setEstimatedRecords(50);
                    volume.setDataSizeKB(20);
                    break;
                default:
                    volume.setEstimatedRecords(100);
                    volume.setDataSizeKB(50);
                    break;
            }

            return volume;

        } catch (Exception e) {
            log.error("分析数据量失败", e);
            return new DataVolume();
        }
    }

    /**
     * 分析响应时间
     */
    private ResponseTime analyzeResponseTime(QueryType queryType) {
        try {
            ResponseTime responseTime = new ResponseTime();

            // 根据查询类型估算响应时间
            switch (queryType) {
                case USER_ORDER_INFO:
                    responseTime.setAverageTime(500);
                    responseTime.setP95Time(800);
                    responseTime.setP99Time(1200);
                    break;
                case USER_COMPLETE_INFO:
                    responseTime.setAverageTime(800);
                    responseTime.setP95Time(1200);
                    responseTime.setP99Time(2000);
                    break;
                case ORDER_DETAIL_INFO:
                    responseTime.setAverageTime(600);
                    responseTime.setP95Time(900);
                    responseTime.setP99Time(1500);
                    break;
                case PRODUCT_SALES_STATISTICS:
                    responseTime.setAverageTime(1000);
                    responseTime.setP95Time(1500);
                    responseTime.setP99Time(2500);
                    break;
                case SEARCH_RESULTS:
                    responseTime.setAverageTime(200);
                    responseTime.setP95Time(300);
                    responseTime.setP99Time(500);
                    break;
                default:
                    responseTime.setAverageTime(500);
                    responseTime.setP95Time(800);
                    responseTime.setP99Time(1200);
                    break;
            }

            return responseTime;

        } catch (Exception e) {
            log.error("分析响应时间失败", e);
            return new ResponseTime();
        }
    }

    /**
     * 优化缓存策略
     */
    private CacheOptimizationResult optimizeCacheStrategy(CrossDatabaseQueryRequest request, 
            QueryPatternAnalysis analysis) {
        try {
            CacheOptimizationResult result = new CacheOptimizationResult();
            result.setRequestId(request.getRequestId());

            // 根据查询模式优化缓存策略
            if (analysis.getQueryFrequency().getDailyCount() > 1000) {
                result.setRecommendedCacheExpire(3600); // 1小时
                result.setRecommendedCacheSize(1000);
                result.setRecommendedCacheStrategy("LRU");
            } else if (analysis.getQueryFrequency().getDailyCount() > 100) {
                result.setRecommendedCacheExpire(1800); // 30分钟
                result.setRecommendedCacheSize(500);
                result.setRecommendedCacheStrategy("LFU");
            } else {
                result.setRecommendedCacheExpire(600); // 10分钟
                result.setRecommendedCacheSize(100);
                result.setRecommendedCacheStrategy("FIFO");
            }

            // 根据数据量优化缓存策略
            if (analysis.getDataVolume().getDataSizeKB() > 100) {
                result.setRecommendedCompression(true);
                result.setRecommendedCompressionLevel(6);
            } else {
                result.setRecommendedCompression(false);
            }

            return result;

        } catch (Exception e) {
            log.error("优化缓存策略失败", e);
            throw new CrossDatabaseQueryException("优化缓存策略失败", e);
        }
    }

    /**
     * 优化查询策略
     */
    private QueryStrategyOptimizationResult optimizeQueryStrategy(CrossDatabaseQueryRequest request, 
            QueryPatternAnalysis analysis) {
        try {
            QueryStrategyOptimizationResult result = new QueryStrategyOptimizationResult();
            result.setRequestId(request.getRequestId());

            // 根据查询复杂度优化策略
            if (analysis.getQueryComplexity().getComplexityLevel() == ComplexityLevel.HIGH) {
                result.setRecommendedStrategy(QueryStrategy.DATA_AGGREGATION);
                result.setRecommendedParallelism(4);
                result.setRecommendedTimeout(5000);
            } else if (analysis.getQueryComplexity().getComplexityLevel() == ComplexityLevel.MEDIUM) {
                result.setRecommendedStrategy(QueryStrategy.SERVICE_CALL);
                result.setRecommendedParallelism(2);
                result.setRecommendedTimeout(3000);
            } else {
                result.setRecommendedStrategy(QueryStrategy.SERVICE_CALL);
                result.setRecommendedParallelism(1);
                result.setRecommendedTimeout(1000);
            }

            // 根据响应时间优化策略
            if (analysis.getResponseTime().getP95Time() > 1000) {
                result.setRecommendedAsync(true);
                result.setRecommendedBatchSize(10);
            } else {
                result.setRecommendedAsync(false);
                result.setRecommendedBatchSize(50);
            }

            return result;

        } catch (Exception e) {
            log.error("优化查询策略失败", e);
            throw new CrossDatabaseQueryException("优化查询策略失败", e);
        }
    }

    /**
     * 优化聚合策略
     */
    private AggregationOptimizationResult optimizeAggregationStrategy(CrossDatabaseQueryRequest request, 
            QueryPatternAnalysis analysis) {
        try {
            AggregationOptimizationResult result = new AggregationOptimizationResult();
            result.setRequestId(request.getRequestId());

            // 根据数据量优化聚合策略
            if (analysis.getDataVolume().getEstimatedRecords() > 1000) {
                result.setRecommendedAggregationType(AggregationType.BATCH);
                result.setRecommendedBatchSize(100);
                result.setRecommendedParallelism(4);
            } else if (analysis.getDataVolume().getEstimatedRecords() > 100) {
                result.setRecommendedAggregationType(AggregationType.STREAM);
                result.setRecommendedBatchSize(50);
                result.setRecommendedParallelism(2);
            } else {
                result.setRecommendedAggregationType(AggregationType.MEMORY);
                result.setRecommendedBatchSize(20);
                result.setRecommendedParallelism(1);
            }

            // 根据查询频率优化聚合策略
            if (analysis.getQueryFrequency().getDailyCount() > 1000) {
                result.setRecommendedPreAggregation(true);
                result.setRecommendedPreAggregationInterval(300); // 5分钟
            } else {
                result.setRecommendedPreAggregation(false);
            }

            return result;

        } catch (Exception e) {
            log.error("优化聚合策略失败", e);
            throw new CrossDatabaseQueryException("优化聚合策略失败", e);
        }
    }

    /**
     * 预热查询缓存
     */
    @PostConstruct
    public void warmupQueryCache() {
        try {
            // 预热常用查询
            List<QueryType> commonQueryTypes = Arrays.asList(
                    QueryType.USER_ORDER_INFO, 
                    QueryType.ORDER_DETAIL_INFO, 
                    QueryType.SEARCH_RESULTS);

            for (QueryType queryType : commonQueryTypes) {
                try {
                    String cacheKey = OPTIMIZATION_CACHE_PREFIX + "warmup:" + queryType.name();
                    Object warmupData = new Object();
                    redisTemplate.opsForValue().set(cacheKey, warmupData, Duration.ofHours(1));
                } catch (Exception e) {
                    log.error("预热查询缓存失败: {}", queryType, e);
                }
            }

        } catch (Exception e) {
            log.error("预热查询缓存失败", 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 = redisTemplate.keys(OPTIMIZATION_CACHE_PREFIX + "*");

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

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