Построение эффективных запросов в микросервисной архитектуре: Стратегии и практики

@RestController
@RequestMapping("/orders")
public class OrderApiComposer {
    
    private final OrderService orderService;
    private final KitchenService kitchenService;
    private final DeliveryService deliveryService;
    private final AccountingService accountingService;
    
    // Конструктор с инъекцией зависимостей
    
    @GetMapping("/{orderId}")
    public OrderDetails findOrder(@PathVariable Long orderId) {
        // Параллельные запросы к сервисам с использованием CompletableFuture
        CompletableFuture<Order> orderFuture = 
            CompletableFuture.supplyAsync(() -> orderService.findOrder(orderId));
        
        CompletableFuture<KitchenStatus> kitchenFuture = 
            CompletableFuture.supplyAsync(() -> kitchenService.findStatus(orderId));
        
        CompletableFuture<DeliveryInfo> deliveryFuture = 
            CompletableFuture.supplyAsync(() -> deliveryService.findDeliveryInfo(orderId));
        
        CompletableFuture<PaymentStatus> paymentFuture = 
            CompletableFuture.supplyAsync(() -> accountingService.findPaymentStatus(orderId));
        
        // Ожидаем завершения всех запросов
        CompletableFuture.allOf(orderFuture, kitchenFuture, deliveryFuture, paymentFuture)
            .join();
            
        // Объединение результатов
        return new OrderDetails(
            orderFuture.join(),
            kitchenFuture.join(),
            deliveryFuture.join(),
            paymentFuture.join()
        );
    }
}

@GetMapping("/{orderId}")
public OrderDetails findOrderWithResilience(@PathVariable Long orderId) {
    // Параллельные запросы с обработкой ошибок
    CompletableFuture<Order> orderFuture = 
        CompletableFuture.supplyAsync(() -> {
            try {
                return orderService.findOrder(orderId);
            } catch (Exception e) {
                log.error("Error fetching order", e);
                return null; // или fallback-значение
            }
        });
    
    // Аналогичные вызовы для других сервисов
    
    // Принятие решения на основе полученных данных
    Order order = orderFuture.join();
    if (order == null) {
        throw new OrderNotFoundException(orderId);
    }
    
    // Формирование результата с учетом возможных null-значений
    return new OrderDetails.Builder()
        .withOrder(order)
        .withKitchenStatus(kitchenFuture.join()) // может быть null
        .withDeliveryInfo(deliveryFuture.join()) // может быть null
        .withPaymentStatus(paymentFuture.join()) // может быть null
        .build();
}

// Сервис запросов, поддерживающий представление для истории заказов
@Service
public class OrderHistoryViewService {
    
    private final OrderHistoryRepository repository;
    
    // Обработка события создания заказа
    @EventListener
    public void handleOrderCreated(OrderCreatedEvent event) {
        // Создание записи в представлении истории заказов
        OrderHistoryItem item = new OrderHistoryItem();
        item.setOrderId(event.getOrderId());
        item.setCustomerId(event.getCustomerId());
        item.setRestaurantId(event.getRestaurantId());
        item.setRestaurantName(event.getRestaurantName());
        item.setItems(event.getItems());
        item.setStatus(event.getStatus());
        item.setCreationDate(event.getCreationTime());
        
        repository.save(item);
    }
    
    // Обработка события обновления статуса заказа
    @EventListener
    public void handleOrderStatusUpdated(OrderStatusChangedEvent event) {
        OrderHistoryItem item = repository.findByOrderId(event.getOrderId())
            .orElseThrow(() -> new ItemNotFoundException(event.getOrderId()));
        
        item.setStatus(event.getNewStatus());
        repository.save(item);
    }
    
    // API для запроса истории заказов
    public List<OrderHistoryItem> findOrderHistory(
            Long customerId, 
            Pageable pageable, 
            OrderHistoryFilter filter) {
        return repository.findByCustomerIdAndFilterCriteria(
            customerId, 
            filter.getMaxAge(), 
            filter.getStatus(), 
            filter.getKeywords(),
            pageable
        );
    }
}

@Component
public class OrderGraphQLResolver implements GraphQLQueryResolver {
    
    private final OrderApiComposer orderApiComposer;
    private final OrderHistoryViewService orderHistoryService;
    
    public Order order(String id) {
        return orderApiComposer.findOrder(Long.valueOf(id));
    }
    
    public List<Order> orderHistory(
            String customerId, 
            OrderHistoryFilter filter,
            PageInput page) {
        Pageable pageable = PageRequest.of(
            page.getNumber(), 
            page.getSize(), 
            Sort.by(Sort.Direction.DESC, "creationDate")
        );
        
        return orderHistoryService.findOrderHistory(
            Long.valueOf(customerId), 
            pageable, 
            filter
        );
    }
}

@GetMapping("/restaurants")
public PagedResult<Restaurant> findRestaurants(
        @RequestParam(required = false) String cursor,
        @RequestParam(defaultValue = "20") int pageSize) {
    
    // Курсор может содержать закодированные данные о последнем элементе
    RestaurantCursor decodedCursor = cursor != null 
        ? RestaurantCursor.decode(cursor) 
        : RestaurantCursor.initial();
    
    List<Restaurant> restaurants = restaurantRepository
        .findRestaurantsAfter(decodedCursor.getLastId(), pageSize);
    
    // Генерация курсора для следующей страницы
    String nextCursor = restaurants.size() == pageSize 
        ? RestaurantCursor.encode(restaurants.get(restaurants.size() - 1).getId())
        : null;
    
    return new PagedResult<>(restaurants, nextCursor);
}

public PagedResult<OrderSummary> getOrderHistory(Long customerId, String cursor, int limit) {
    // Декодируем информацию о последней позиции в каждом сервисе
    Map<String, String> servicePositions = cursor != null 
        ? CursorDecoder.decode(cursor) 
        : Collections.emptyMap();
    
    // Запрашиваем дополнительные элементы для последующей фильтрации
    int fetchSize = limit * 2;
    
    // Получаем данные из нескольких сервисов с учетом их курсоров
    List<Order> orders = orderService
        .getOrdersByCustomer(customerId, servicePositions.get("orders"), fetchSize);
    List<Payment> payments = paymentService
        .getPaymentsByCustomer(customerId, servicePositions.get("payments"), fetchSize);
    
    // Объединяем и сортируем результаты
    List<OrderSummary> combined = combineAndSort(orders, payments);
    
    // Ограничиваем количество результатов
    List<OrderSummary> page = combined.stream().limit(limit).collect(Collectors.toList());
    
    // Формируем курсор для следующего запроса
    String nextCursor = combined.size() > limit 
        ? createCursor(page.get(page.size() - 1), orders, payments)
        : null;
    
    return new PagedResult<>(page, nextCursor);
}

@Cacheable(value = "restaurants", key = "#location.zipCode", condition = "#location != null")
public List<Restaurant> findNearbyRestaurants(Location location) {
    // Ресурсоемкий запрос к сервису ресторанов с геопространственным поиском
    return restaurantClient.findNearbyRestaurants(location);
}

@GetMapping("/orders/{id}")
public OrderSummary getOrderSummary(@PathVariable Long id, @RequestParam Set<String> fields) {
    Order order = orderService.findOrder(id);
    
    // Селективное включение полей на основе запроса клиента
    OrderSummary summary = new OrderSummary(order.getId());
    
    if (fields.contains("status")) {
        summary.setStatus(order.getStatus());
    }
    
    if (fields.contains("items")) {
        summary.setItems(order.getItems());
    }
    
    // и т.д.
    
    return summary;
}

@PostMapping("/reports/generate")
public ReportJob startReportGeneration(@RequestBody ReportRequest request) {
    // Начинаем асинхронную генерацию отчета
    String jobId = reportService.scheduleReportGeneration(request);
    
    // Возвращаем идентификатор задания для последующего получения результата
    return new ReportJob(jobId, "/reports/status/" + jobId);
}
 
@GetMapping("/reports/status/{jobId}")
public ReportStatus checkReportStatus(@PathVariable String jobId) {
    // Проверка состояния генерации отчета
    return reportService.getReportStatus(jobId);
}

@RestController
@RequestMapping("/v1/orders")  // Версионирование в URL
public class OrderControllerV1 {
    // Первая версия API
}
 
@RestController
@RequestMapping("/v2/orders")  // Новая версия с изменениями
public class OrderControllerV2 {
    // Вторая версия API с новыми функциями
}

@GetMapping("/orders/{id}")
public ResponseEntity<?> getOrder(
        @PathVariable Long id,
        @RequestHeader(name = "API-Version", defaultValue = "1") int version) {
    
    if (version == 1) {
        return ResponseEntity.ok(orderMapperV1.toDto(orderService.findOrder(id)));
    } else if (version == 2) {
        return ResponseEntity.ok(orderMapperV2.toDto(orderService.findOrder(id)));
    }
    
    return ResponseEntity.badRequest().body("Unsupported API version");
}

@RunWith(SpringRunner.class)
@SpringBootTest
@AutoConfigureStubRunner(
    ids = "com.example:order-service:+:stubs:8090",
    stubsMode = StubRunnerProperties.StubsMode.LOCAL)
public class OrderClientTests {
    
    @Autowired
    private OrderClient orderClient;
    
    @Test
    public void shouldReturnOrderDetails() {
        // Вызов клиента, который будет взаимодействовать со сгенерированной заглушкой
        Order order = orderClient.getOrder(123L);
        
        assertThat(order.getId()).isEqualTo(123);
        assertThat(order.getStatus()).isEqualTo("DELIVERED");
        assertThat(order.getTotalAmount()).isEqualTo(35.50);
        assertThat(order.getItems()).hasSize(1);
    }
}

@GetMapping("/orders/{customerId}")
public Flux<OrderSummary> getCustomerOrders(@PathVariable String customerId) {
    return orderRepository.findByCustomerId(customerId)
        .flatMap(order -> Mono.zip(
            Mono.just(order),
            kitchenClient.getStatus(order.getId()),
            paymentClient.getStatus(order.getId())
        ))
        .map(tuple -> {
            Order order = tuple.getT1();
            KitchenStatus kitchenStatus = tuple.getT2();
            PaymentStatus paymentStatus = tuple.getT3();
            return new OrderSummary(order, kitchenStatus, paymentStatus);
        })
        .onErrorResume(e -> {
            log.error("Error processing order", e);
            return Flux.empty();
        });
}

@CacheConfig(cacheNames = "orders")
@Service
public class OrderServiceWithCache {
    @Cacheable(key = "#orderId", unless = "#result == null")
    @CachePut(key = "#result.id", condition = "#result != null")
    public Order findOrder(Long orderId) {
        return orderRepository.findById(orderId).orElse(null);
    }
}

@EventListener
public void handleOrderUpdated(OrderUpdatedEvent event) {
    cacheManager.getCache("orders").evict(event.getOrderId());
    // Альтернативный подход — обновление кэша
    cacheManager.getCache("orders").put(event.getOrderId(), event.getOrder());
}

@GetMapping("/orders/{id}")
public ResponseEntity<Order> getOrder(
        @PathVariable Long id,
        @RequestHeader(value = "If-Modified-Since", required = false) 
            @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime ifModifiedSince) {
    
    Order order = orderService.findOrder(id);
    
    if (ifModifiedSince != null && !order.getLastModified().isAfter(ifModifiedSince)) {
        return ResponseEntity.status(HttpStatus.NOT_MODIFIED).build();
    }
    
    return ResponseEntity.ok()
        .lastModified(order.getLastModified().toInstant(ZoneOffset.UTC).toEpochMilli())
        .body(order);
}

@Bean
public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
    // Создаем локальный кэш с тайм-аутом 60 секунд
    CaffeineCacheManager localCacheManager = new CaffeineCacheManager();
    localCacheManager.setCaffeine(Caffeine.newBuilder()
        .expireAfterWrite(60, TimeUnit.SECONDS)
        .maximumSize(1000));
    
    // Создаем распределенный Redis-кэш с тайм-аутом 30 минут
    RedisCacheManager redisCacheManager = RedisCacheManager.builder(redisConnectionFactory)
        .cacheDefaults(RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(30)))
        .build();
    
    // Комбинируем оба уровня
    return new CompositeCacheManager(localCacheManager, redisCacheManager);
}

// Real-time запрос с тайм-аутом
@GetMapping("/products/{id}/availability")
public Mono<ProductAvailability> checkAvailability(@PathVariable String id) {
    return productRepository.findById(id)
        .map(product -> new ProductAvailability(product.getId(), product.isInStock()))
        .timeout(Duration.ofMillis(200))  // Строгий тайм-аут для real-time запроса
        .onErrorResume(e -> Mono.just(new ProductAvailability(id, false)));
}
 
// Batch запрос через асинхронный API
@PostMapping("/reports")
public Mono<ReportJob> generateReport(@RequestBody ReportRequest request) {
    return Mono.fromCallable(() -> {
        String jobId = UUID.randomUUID().toString();
        // Запускаем асинхронную задачу
        reportExecutor.execute(() -> reportService.generateReport(jobId, request));
        return new ReportJob(jobId, "/reports/status/" + jobId);
    });
}

// Сервис каталога товаров использует Elasticsearch для поиска
@Service
public class ProductSearchService {
    private final ElasticsearchOperations elasticsearchTemplate;
    
    public Page<Product> searchProducts(String query, Pageable pageable) {
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
            .withQuery(QueryBuilders.multiMatchQuery(query, "name", "description", "categories"))
            .withPageable(pageable)
            .build();
            
        return elasticsearchTemplate.search(searchQuery, Product.class);
    }
}
 
// Сервис истории заказов использует Cassandra для временных рядов
@Repository
public interface OrderHistoryRepository extends CassandraRepository<OrderHistoryEntry, OrderHistoryKey> {
    @Query("SELECT * FROM order_history WHERE customer_id = ?0 AND order_date >= ?1 AND order_date <= ?2")
    List<OrderHistoryEntry> findByCustomerIdAndDateRange(
        UUID customerId, LocalDate startDate, LocalDate endDate);
}
 
// Сервис рекомендаций использует графовую базу данных Neo4j
@Repository
public interface ProductRecommendationRepository extends Neo4jRepository<Product, Long> {
    @Query("MATCH (p:Product)<-[:PURCHASED]-(c:Customer)-[:PURCHASED]->(rec:Product) " +
           "WHERE p.id = $productId " +
           "RETURN rec, COUNT(c) as customerCount " +
           "ORDER BY customerCount DESC LIMIT 5")
    List<Product> findRecommendedProducts(@Param("productId") Long productId);
}

@Service
public class FederatedQueryService {
    private final Connection federatedConnection;
    
    public List<CustomerInsights> getCustomerInsights(String dateRange) {
        String query = """
            SELECT 
                c.id, c.name, c.segment,
                COUNT(o.id) as total_orders,
                SUM(o.amount) as total_spend,
                AVG(o.amount) as avg_order_value,
                MAX(p.category) as top_category
            FROM customers c
            JOIN orders o ON c.id = o.customer_id
            JOIN order_products op ON o.id = op.order_id
            JOIN products p ON op.product_id = p.id
            WHERE o.created_at BETWEEN ? AND ?
            GROUP BY c.id, c.name, c.segment
            ORDER BY total_spend DESC
            """;
            
        try (PreparedStatement stmt = federatedConnection.prepareStatement(query)) {
            // Разбор и установка параметров dateRange
            // ...
            
            ResultSet rs = stmt.executeQuery();
            List<CustomerInsights> results = new ArrayList<>();
            while (rs.next()) {
                // Формирование результатов
                // ...
            }
            return results;
        } catch (SQLException e) {
            throw new QueryExecutionException("Failed to execute federated query", e);
        }
    }
}

@Service
public class ConflictResolutionService {
    public <T extends Timestamped> T resolveConflict(T local, T remote) {
        return local.getLastUpdated().isAfter(remote.getLastUpdated()) ? local : remote;
    }
}

public class VersionedData<T> {
    private T data;
    private Map<String, Integer> vectorClock;
    
    public boolean happenedBefore(VersionedData<T> other) {
        // Проверка причинно-следственной связи по векторным часам
        return vectorClock.entrySet().stream()
                .allMatch(e -> other.vectorClock.getOrDefault(e.getKey(), 0) >= e.getValue())
            && vectorClock.size() <= other.vectorClock.size();
    }
    
    public VersionedData<T> merge(VersionedData<T> other, BiFunction<T, T, T> dataMerger) {
        // Слияние данных и объединение векторных часов
        Map<String, Integer> mergedClock = new HashMap<>(vectorClock);
        other.vectorClock.forEach((k, v) -> 
            mergedClock.put(k, Math.max(mergedClock.getOrDefault(k, 0), v)));
        
        return new VersionedData<>(dataMerger.apply(data, other.data), mergedClock);
    }
}

public class GCounter {  // Растущий счётчик
    private final Map<String, Integer> counters = new HashMap<>();
    private final String nodeId;
    
    public void increment() {
        counters.put(nodeId, counters.getOrDefault(nodeId, 0) + 1);
    }
    
    public int value() {
        return counters.values().stream().mapToInt(Integer::intValue).sum();
    }
    
    public void merge(GCounter other) {
        other.counters.forEach((id, count) -> 
            counters.put(id, Math.max(counters.getOrDefault(id, 0), count)));
    }
}

@Component
public class DynamicQueryRouter {
    private final Map<String, ReactiveQueryExecutor> queryExecutors;
    
    public Mono<QueryResult> routeQuery(Query query) {
        return Mono.defer(() -> {
            // Анализ запроса для определения оптимального маршрута
            String routeKey = queryRoutingService.determineRouteKey(query);
            ReactiveQueryExecutor executor = queryExecutors.get(routeKey);
            
            if (executor == null) {
                return Mono.error(new QueryRoutingException("No executor found for: " + routeKey));
            }
            
            return executor.execute(query)
                .timeout(query.getTimeout())
                .retryWhen(Retry.backoff(3, Duration.ofMillis(100)))
                .onErrorResume(e -> fallbackStrategy.execute(query, e));
        });
    }
}

@RefreshScope
@ConfigurationProperties(prefix = "query.config")
@Component
public class QueryConfigurationProperties {
    private Map<String, QueryProfile> profiles = new HashMap<>();
    
    public static class QueryProfile {
        private Duration timeout;
        private int maxResults;
        private boolean cacheEnabled;
        private Duration cacheExpiry;
        // Геттеры и сеттеры
    }
    
    public QueryProfile getProfileFor(String queryType) {
        return profiles.getOrDefault(queryType, defaultProfile());
    }
    
    private QueryProfile defaultProfile() {
        QueryProfile profile = new QueryProfile();
        profile.setTimeout(Duration.ofSeconds(5));
        profile.setMaxResults(100);
        profile.setCacheEnabled(true);
        profile.setCacheExpiry(Duration.ofMinutes(5));
        return profile;
    }
}

@Service
public class SecureQueryService {
    public List<Product> searchProducts(String searchTerm) {
        // Валидация входных данных
        validateSearchInput(searchTerm);
        
        // Использование параметризованных запросов вместо конкатенации строк
        return productRepository.findByNameContaining(searchTerm);
    }
    
    private void validateSearchInput(String input) {
        if (input == null || input.matches(".*[;'\"].*")) {
            throw new InvalidInputException("Invalid search input");
        }
    }
}

@Service
public class DataFilteringService {
    public <T> List<T> applySecurityFilters(List<T> results, Authentication auth) {
        // Фильтрация на основе прав пользователя
        return results.stream()
                .filter(item -> securityEvaluator.hasAccess(auth, item))
                .collect(Collectors.toList());
    }
}

@Component
public class SecurityContextPropagator {
    private final JwtEncoder jwtEncoder;
    
    public String createDownstreamToken(Authentication authentication) {
        // Создание токена с ограниченным набором разрешений для использования в downstream-запросах
        JwtClaimsSet claims = JwtClaimsSet.builder()
                .subject(authentication.getName())
                .claim("authorities", getReducedAuthorities(authentication))
                .claim("on_behalf_of", authentication.getName())
                .expiresAt(Instant.now().plusSeconds(300)) // Короткое время жизни
                .build();
        
        return jwtEncoder.encode(JwtEncoderParameters.from(claims)).getTokenValue();
    }
    
    private List<String> getReducedAuthorities(Authentication authentication) {
        // Создание минимального набора прав, необходимых для downstream-запросов
        return authentication.getAuthorities().stream()
                .map(GrantedAuthority::getAuthority)
                .filter(authority -> authority.startsWith("READ_") || authority.startsWith("VIEW_"))
                .collect(Collectors.toList());
    }
}

@GetMapping("/mobile/products")
public CompressedProductList getProductsForMobile(
        @RequestParam int page, 
        @RequestParam(defaultValue = "10") int size,
        @RequestParam(required = false) String lastSyncTimestamp) {
    
    // Инкрементальная синхронизация — передаются только изменения
    LocalDateTime lastSync = lastSyncTimestamp != null 
            ? LocalDateTime.parse(lastSyncTimestamp) 
            : LocalDateTime.MIN;
    
    List<Product> changedProducts = productRepository
            .findByLastModifiedAfter(lastSync, PageRequest.of(page, size));
    
    // Компрессия ответа
    return new CompressedProductList(
            changedProducts,
            compressionService.compress(changedProducts),
            LocalDateTime.now().toString()
    );
}

@GetMapping("/dashboard/sales-stats")
public Flux<ChunkResponse> getDashboardData(
        @RequestParam String timeRange,
        @RequestParam List<String> metrics) {
    
    // Разбиение запроса на независимые части для прогрессивной загрузки
    return Flux.fromIterable(metrics)
            .flatMap(metric -> {
                Mono<MetricData> dataMono = calculateMetric(metric, timeRange)
                        .timeout(Duration.ofSeconds(3))
                        .onErrorResume(e -> Mono.just(MetricData.empty(metric)));
                
                return dataMono.map(data -> new ChunkResponse(metric, data));
            })
            .delayElements(Duration.ofMillis(100)); // Прогрессивная отдача результатов
}

@Aspect
@Component
public class QueryLoggingAspect {
    private static final Logger log = LoggerFactory.getLogger(QueryLoggingAspect.class);
    
    @Around("@annotation(LogQuery)")
    public Object logQueryExecution(ProceedingJoinPoint joinPoint) throws Throwable {
        String queryName = joinPoint.getSignature().getName();
        String serviceName = environment.getProperty("spring.application.name");
        String traceId = MDC.get("traceId"); // ID для связывания логов разных сервисов
        
        log.info("Query {} started in service {} [trace: {}]", queryName, serviceName, traceId);
        long startTime = System.currentTimeMillis();
        
        try {
            Object result = joinPoint.proceed();
            long executionTime = System.currentTimeMillis() - startTime;
            
            log.info("Query {} completed in {}ms [trace: {}]", queryName, executionTime, traceId);
            return result;
        } catch (Exception e) {
            log.error("Query {} failed: {} [trace: {}]", queryName, e.getMessage(), traceId);
            throw e;
        }
    }
}

@Component
public class QueryHealthIndicator implements HealthIndicator {
    private final DatabaseClient dbClient;
    private final RestTemplate externalServiceClient;
    
    @Override
    public Health health() {
        Health dbHealth = checkDatabaseHealth();
        Health dependenciesHealth = checkDependenciesHealth();
        
        if (dbHealth.getStatus() == Status.UP && dependenciesHealth.getStatus() == Status.UP) {
            return Health.up().build();
        }
        
        return Health.down()
                .withDetail("database", dbHealth)
                .withDetail("dependencies", dependenciesHealth)
                .build();
    }
    
    private Health checkDatabaseHealth() {
        try {
            // Простой запрос для проверки доступности базы данных
            dbClient.execute("SELECT 1").fetch().one();
            return Health.up().build();
        } catch (Exception e) {
            return Health.down().withException(e).build();
        }
    }
    
    private Health checkDependenciesHealth() {
        // Проверка внешних зависимостей
        // ...
    }
}

@Component
public class QueryMetricsCollector {
    private final MeterRegistry registry;
    
    public void recordQueryExecution(String queryName, long duration, boolean success) {
        Timer.builder("query.execution")
                .tag("name", queryName)
                .tag("status", success ? "success" : "failure")
                .register(registry)
                .record(duration, TimeUnit.MILLISECONDS);
    }
    
    public void incrementQueryCount(String queryName) {
        Counter.builder("query.count")
                .tag("name", queryName)
                .register(registry)
                .increment();
    }
}

@Component
public class TracingInterceptor implements ClientHttpRequestInterceptor {
    private final Tracer tracer;
    
    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, 
                                        ClientHttpRequestExecution execution) throws IOException {
        
        Span span = tracer.buildSpan("outbound-request")
                .withTag("url", request.getURI().toString())
                .withTag("method", request.getMethodValue())
                .start();
        
        try (Scope scope = tracer.activateSpan(span)) {
            // Добавление трассировочных заголовков в исходящий запрос
            tracer.inject(span.context(), Format.Builtin.HTTP_HEADERS, 
                          new HttpHeadersCarrier(request.getHeaders()));
            
            // Выполнение запроса и запись результата
            long startTime = System.currentTimeMillis();
            ClientHttpResponse response = execution.execute(request, body);
            span.setTag("status", response.getStatusCode().value());
            span.setTag("duration_ms", System.currentTimeMillis() - startTime);
            
            return response;
        } catch (Exception e) {
            span.setTag("error", true);
            span.log(Map.of("event", "error", "message", e.getMessage()));
            throw e;
        } finally {
            span.finish();
        }
    }
}

@Service
public class ResilientQueryService {
  @CircuitBreaker(name = "restaurantService", fallbackMethod = "getDefaultRestaurants")
  public List<Restaurant> findNearbyRestaurants(Location location) {
      return restaurantClient.findNearby(location);
  }
  
  public List<Restaurant> getDefaultRestaurants(Location location, Exception e) {
      log.warn("Using fallback for restaurant service: {}", e.getMessage());
      // Возврат списка популярных ресторанов или кэшированных результатов
      return cachedRestaurantRepository.getPopularRestaurants();
  }
}

@Component
public class QueryThrottler {
  private final RateLimiter rateLimiter = RateLimiter.create(50.0); // 50 запросов в секунду
  
  public <T> T executeWithThrottling(Supplier<T> queryExecution) {
      if (!rateLimiter.tryAcquire(100, TimeUnit.MILLISECONDS)) {
          throw new ThrottlingException("Query rate limit exceeded");
      }
      return queryExecution.get();
  }
}

@Component
public class PriorityQueryExecutor {
  @Qualifier("priorityExecutor")
  private final Executor highPriorityExecutor;
  
  @Qualifier("defaultExecutor")
  private final Executor defaultExecutor;
  
  public <T> CompletableFuture<T> execute(Supplier<T> task, QueryPriority priority) {
      Executor executor = (priority == QueryPriority.HIGH) 
          ? highPriorityExecutor 
          : defaultExecutor;
      
      return CompletableFuture.supplyAsync(task, executor);
  }
}

@Aspect
@Component
public class QueryMetricsAspect {
  private final DistributionSummary latencySummary;
  private final Counter successCounter;
  private final Counter errorCounter;
  
  public QueryMetricsAspect(MeterRegistry registry) {
      this.latencySummary = DistributionSummary.builder("query.latency")
          .publishPercentiles(0.5, 0.95, 0.99)
          .register(registry);
      this.successCounter = registry.counter("query.result", "status", "success");
      this.errorCounter = registry.counter("query.result", "status", "error");
  }
  
  @Around("@annotation(measuredQuery)")
  public Object measureQueryPerformance(ProceedingJoinPoint joinPoint, 
                                        MeasuredQuery measuredQuery) throws Throwable {
      long startTime = System.nanoTime();
      try {
          Object result = joinPoint.proceed();
          successCounter.increment();
          return result;
      } catch (Exception e) {
          errorCounter.increment();
          throw e;
      } finally {
          long duration = System.nanoTime() - startTime;
          latencySummary.record(duration / 1_000_000.0); // в миллисекундах
      }
  }
}