Как оркестратор поможет в присвоении уникальных номеров на каждый запрос

Ответ

Как оркестратор помогает в присвоении уникальных номеров на каждый запрос

Оркестратор (Orchestrator) — это компонент системы, который координирует операции, включая присвоение уникальных идентификаторов для каждого запроса. Это критически важно для трейсинга, логирования и отладки в распределённых системах.

1. Что такое Оркестратор

Оркестратор — это центральный компонент, отвечающий за:

• Координацию запросов через систему
• Генерацию и управление идентификаторами
• Маршрутизацию и обработку
• Отслеживание статуса операций

public class RequestOrchestrator {
    private final AtomicLong requestCounter = new AtomicLong(0);
    private final ThreadLocal<String> requestId = new ThreadLocal<>();
    
    // Уникальный номер для каждого запроса
    public String generateRequestId() {
        long id = requestCounter.incrementAndGet();
        String requestId = "REQ-" + System.currentTimeMillis() + "-" + id;
        this.requestId.set(requestId);
        return requestId;
    }
    
    // Получить текущий ID запроса
    public String getCurrentRequestId() {
        return requestId.get();
    }
    
    // Очистить ID при завершении запроса
    public void clearRequestId() {
        requestId.remove();
    }
}

2. UUID и Уникальные идентификаторы

import java.util.UUID;
import java.util.concurrent.atomic.AtomicLong;

public class UniqueRequestIdGenerator {
    // UUID v4 - случайный
    public static String generateUUIDv4() {
        return UUID.randomUUID().toString();
    }
    
    // UUID v1 - на основе времени и MAC адреса
    public static String generateUUIDv1() {
        return UUID.randomUUID().toString();
    }
    
    // Последовательный ID (для логов)
    private static final AtomicLong sequenceCounter = new AtomicLong(0);
    
    public static long generateSequentialId() {
        return sequenceCounter.incrementAndGet();
    }
    
    // Комбинированный ID: временная метка + последовательность
    public static String generateHybridId() {
        long timestamp = System.currentTimeMillis();
        long sequence = generateSequentialId();
        return timestamp + "-" + sequence;
    }
    
    // Snowflake ID (как в Twitter) - распределённый ID
    static class SnowflakeIdGenerator {
        private static final long EPOCH = 1609459200000L; // 2021-01-01
        private static final int WORKER_ID_BITS = 10;
        private static final int SEQUENCE_BITS = 12;
        private static final long WORKER_ID_MASK = (1L << WORKER_ID_BITS) - 1;
        private static final long SEQUENCE_MASK = (1L << SEQUENCE_BITS) - 1;
        
        private long workerId;
        private long sequence = 0;
        private long lastTimestamp = -1;
        
        public SnowflakeIdGenerator(long workerId) {
            if (workerId < 0 || workerId > WORKER_ID_MASK) {
                throw new IllegalArgumentException("Worker ID out of range");
            }
            this.workerId = workerId;
        }
        
        public synchronized long nextId() {
            long timestamp = System.currentTimeMillis();
            
            if (timestamp < lastTimestamp) {
                throw new RuntimeException("Clock moved backwards");
            }
            
            if (timestamp == lastTimestamp) {
                sequence = (sequence + 1) & SEQUENCE_MASK;
                if (sequence == 0) {
                    timestamp = waitNextMillis(lastTimestamp);
                }
            } else {
                sequence = 0;
            }
            
            lastTimestamp = timestamp;
            
            return ((timestamp - EPOCH) << (WORKER_ID_BITS + SEQUENCE_BITS))
                | (workerId << SEQUENCE_BITS)
                | sequence;
        }
        
        private long waitNextMillis(long lastTimestamp) {
            long timestamp = System.currentTimeMillis();
            while (timestamp <= lastTimestamp) {
                timestamp = System.currentTimeMillis();
            }
            return timestamp;
        }
    }
    
    public static void main(String[] args) {
        // Примеры использования
        System.out.println("UUID v4: " + generateUUIDv4());
        System.out.println("Sequential: " + generateSequentialId());
        System.out.println("Hybrid: " + generateHybridId());
        
        SnowflakeIdGenerator snowflake = new SnowflakeIdGenerator(1);
        System.out.println("Snowflake: " + snowflake.nextId());
    }
}

3. Оркестратор с Присвоением ID (Spring Framework)

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.UUID;

@Component
public class RequestIdInterceptor implements HandlerInterceptor {
    private static final String REQUEST_ID_HEADER = "X-Request-ID";
    private static final ThreadLocal<String> requestIdHolder = new ThreadLocal<>();
    
    @Override
    public boolean preHandle(HttpServletRequest request, 
                            HttpServletResponse response, 
                            Object handler) {
        // Получить ID из заголовка или сгенерировать новый
        String requestId = request.getHeader(REQUEST_ID_HEADER);
        if (requestId == null || requestId.isEmpty()) {
            requestId = UUID.randomUUID().toString();
        }
        
        // Сохранить ID в ThreadLocal
        requestIdHolder.set(requestId);
        
        // Добавить ID в ответ
        response.setHeader(REQUEST_ID_HEADER, requestId);
        
        return true;
    }
    
    @Override
    public void afterCompletion(HttpServletRequest request,
                               HttpServletResponse response,
                               Object handler,
                               Exception ex) {
        // Очистить ThreadLocal
        requestIdHolder.remove();
    }
    
    // Получить текущий Request ID
    public static String getCurrentRequestId() {
        return requestIdHolder.get();
    }
}

4. Оркестратор для асинхронной обработки

import java.util.concurrent.*;
import java.util.UUID;

public class AsyncRequestOrchestrator {
    private final ExecutorService executorService;
    private final ConcurrentHashMap<String, RequestContext> activeRequests;
    
    static class RequestContext {
        String requestId;
        long startTime;
        String status;
        Object result;
        
        RequestContext(String requestId) {
            this.requestId = requestId;
            this.startTime = System.currentTimeMillis();
            this.status = "PROCESSING";
        }
    }
    
    public AsyncRequestOrchestrator(int threadPoolSize) {
        this.executorService = Executors.newFixedThreadPool(threadPoolSize);
        this.activeRequests = new ConcurrentHashMap<>();
    }
    
    // Обработать асинхронный запрос
    public String submitRequest(Callable<Object> task) {
        String requestId = UUID.randomUUID().toString();
        RequestContext context = new RequestContext(requestId);
        
        activeRequests.put(requestId, context);
        
        executorService.submit(() -> {
            try {
                Object result = task.call();
                context.result = result;
                context.status = "COMPLETED";
            } catch (Exception e) {
                context.status = "FAILED";
                context.result = e.getMessage();
            } finally {
                activeRequests.remove(requestId);
            }
        });
        
        return requestId;
    }
    
    // Получить статус запроса
    public RequestContext getRequestStatus(String requestId) {
        return activeRequests.get(requestId);
    }
    
    public void shutdown() {
        executorService.shutdown();
    }
}

5. Оркестратор с MDC (Mapped Diagnostic Context) для логирования

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import java.util.UUID;

public class LoggingOrchestrator {
    private static final Logger logger = LoggerFactory.getLogger(LoggingOrchestrator.class);
    private static final String REQUEST_ID_KEY = "requestId";
    
    // Инициализировать контекст запроса
    public static void initializeRequestContext() {
        String requestId = UUID.randomUUID().toString();
        MDC.put(REQUEST_ID_KEY, requestId);
        logger.info("Request started");
    }
    
    // Логирование с ID
    public static void logInfo(String message) {
        logger.info(message);
        // Лог будет содержать requestId автоматически
    }
    
    // Очистить контекст
    public static void clearRequestContext() {
        logger.info("Request completed");
        MDC.clear();
    }
    
    // Пример использования
    public static void processRequest() throws Exception {
        initializeRequestContext();
        try {
            logInfo("Processing step 1");
            Thread.sleep(100);
            
            logInfo("Processing step 2");
            Thread.sleep(100);
            
            logInfo("Processing completed");
        } finally {
            clearRequestContext();
        }
    }
}

6. Распределённый Оркестратор (для микросервисов)

import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

public class DistributedRequestOrchestrator {
    private final String serviceName;
    private final ConcurrentHashMap<String, RequestMetadata> requestMetadata;
    
    static class RequestMetadata {
        String requestId;
        String parentRequestId;  // Для отслеживания цепочки запросов
        String serviceName;
        long startTime;
        String status;
        
        RequestMetadata(String requestId, String parentRequestId, String serviceName) {
            this.requestId = requestId;
            this.parentRequestId = parentRequestId;
            this.serviceName = serviceName;
            this.startTime = System.currentTimeMillis();
            this.status = "STARTED";
        }
    }
    
    public DistributedRequestOrchestrator(String serviceName) {
        this.serviceName = serviceName;
        this.requestMetadata = new ConcurrentHashMap<>();
    }
    
    // Создать новый запрос
    public String createRequest(String parentRequestId) {
        String requestId = UUID.randomUUID().toString();
        RequestMetadata metadata = new RequestMetadata(requestId, parentRequestId, serviceName);
        requestMetadata.put(requestId, metadata);
        return requestId;
    }
    
    // Отслеживание цепочки запросов
    public String getRequestChain(String requestId) {
        RequestMetadata metadata = requestMetadata.get(requestId);
        if (metadata != null && metadata.parentRequestId != null) {
            return metadata.parentRequestId + " -> " + metadata.serviceName + ":" + requestId;
        }
        return serviceName + ":" + requestId;
    }
    
    // Пример микросервисной архитектуры
    public static void main(String[] args) {
        DistributedRequestOrchestrator gateway = new DistributedRequestOrchestrator("API-Gateway");
        DistributedRequestOrchestrator userService = new DistributedRequestOrchestrator("UserService");
        DistributedRequestOrchestrator orderService = new DistributedRequestOrchestrator("OrderService");
        
        // API Gateway получает запрос
        String originalRequestId = gateway.createRequest(null);
        System.out.println("Original Request: " + originalRequestId);
        
        // Пробрасывает в UserService
        String userServiceRequestId = userService.createRequest(originalRequestId);
        System.out.println("UserService chain: " + userService.getRequestChain(userServiceRequestId));
        
        // UserService вызывает OrderService
        String orderServiceRequestId = orderService.createRequest(userServiceRequestId);
        System.out.println("OrderService chain: " + orderService.getRequestChain(orderServiceRequestId));
    }
}

7. Оркестратор для Batch обработки

import java.util.concurrent.*;
import java.util.UUID;

public class BatchRequestOrchestrator {
    private final int batchSize;
    private final BlockingQueue<String> requestQueue;
    private final ConcurrentHashMap<String, Long> requestTimestamps;
    
    public BatchRequestOrchestrator(int batchSize) {
        this.batchSize = batchSize;
        this.requestQueue = new LinkedBlockingQueue<>();
        this.requestTimestamps = new ConcurrentHashMap<>();
    }
    
    // Добавить запрос в очередь
    public String enqueueRequest() throws InterruptedException {
        String requestId = UUID.randomUUID().toString();
        requestQueue.put(requestId);
        requestTimestamps.put(requestId, System.currentTimeMillis());
        return requestId;
    }
    
    // Получить батч для обработки
    public java.util.List<String> dequeueBatch() throws InterruptedException {
        java.util.List<String> batch = new java.util.ArrayList<>();
        requestQueue.drainTo(batch, batchSize);
        return batch;
    }
    
    // Получить время обработки запроса
    public long getProcessingTime(String requestId) {
        Long startTime = requestTimestamps.get(requestId);
        if (startTime != null) {
            return System.currentTimeMillis() - startTime;
        }
        return -1;
    }
    
    public static void main(String[] args) throws InterruptedException {
        BatchRequestOrchestrator orchestrator = new BatchRequestOrchestrator(100);
        
        // Добавить запросы
        for (int i = 0; i < 500; i++) {
            String requestId = orchestrator.enqueueRequest();
            System.out.println("Enqueued: " + requestId);
        }
        
        // Обработать батчи
        java.util.List<String> batch = orchestrator.dequeueBatch();
        System.out.println("\nBatch size: " + batch.size());
        
        // Время обработки
        Thread.sleep(1000);
        System.out.println("Processing time for first request: " + 
            orchestrator.getProcessingTime(batch.get(0)) + " ms");
    }
}

8. Сравнение ID генерирования

Лучшие практики

1. Используйте UUID для глобальных идентификаторов
2. Используйте Snowflake для распределённых систем
3. Применяйте MDC для логирования с контекстом
4. Пробрасывайте Request ID через все слои приложения
5. Отслеживайте цепочку запросов в микросервисной архитектуре
6. Очищайте контекст при завершении запроса (ThreadLocal)
7. Используйте оркестратор для координации асинхронных операций

Оркестратор обеспечивает полный контроль над жизненным циклом запроса и его идентификацией в системе.