Какой задачей, выполненной за последний год, гордишься?

Задача, которой я горжусь: Рефакторинг и оптимизация микросервиса платёжной системы

Контекст задачи

В последний год я гордлюсь проектом, в котором участвовал — полной оптимизацией и переаспитектурой микросервиса обработки платежей для финтех-платформы. Это была комплексная задача, затронувшая различные аспекты: архитектуру, производительность, надёжность и операционную эффективность.

Исходная ситуация

Проблемы в первоначальной реализации:

• Микросервис обрабатывал 500-700 платежей в секунду, но был нестабильным при пиковых нагрузках
• Отсутствовало должное кеширование — каждый запрос требовал обращения к БД
• Мониторинг и логирование были поверхностными — сложно было отследить причины сбоев
• Нет idempotency гарантий — дублирующиеся запросы могли привести к двойным платежам
• Синхронная архитектура замораживала потоки при ожидании внешних API

Решение: Многоуровневая оптимизация

1. Асинхронная обработка с реактивным стеком

@Service
public class PaymentProcessingService {
    // Отказались от синхронных вызовов
    // Перешли на Project Reactor (Spring WebFlux)
    
    @Autowired
    private PaymentGatewayClient paymentGateway;
    
    @Autowired
    private PaymentRepository paymentRepository;
    
    public Mono<PaymentResponse> processPayment(PaymentRequest request) {
        return Mono.defer(() -> validatePayment(request))
            .flatMap(validRequest -> savePaymentAsPending(validRequest))
            .flatMap(payment -> callExternalPaymentGateway(payment)
                .timeout(Duration.ofSeconds(30))
                .retry(3)
            )
            .flatMap(gatewayResponse -> updatePaymentStatus(gatewayResponse))
            .onErrorResume(error -> handlePaymentError(error))
            .subscribeOn(Schedulers.boundedElastic())
            .publishOn(Schedulers.parallel());
    }
    
    private Mono<PaymentRequest> validatePayment(PaymentRequest request) {
        // Валидация
        return Mono.just(request);
    }
    
    private Mono<Payment> savePaymentAsPending(PaymentRequest request) {
        return Mono.fromCallable(() -> 
            paymentRepository.save(
                Payment.builder()
                    .status(PaymentStatus.PENDING)
                    .amount(request.getAmount())
                    .idempotencyKey(request.getIdempotencyKey())
                    .build()
            )
        ).subscribeOn(Schedulers.boundedElastic());
    }
    
    private Mono<GatewayResponse> callExternalPaymentGateway(Payment payment) {
        return paymentGateway.processPaymentAsync(payment);
    }
    
    private Mono<Payment> updatePaymentStatus(GatewayResponse response) {
        return Mono.fromCallable(() -> 
            paymentRepository.updateStatus(
                response.getPaymentId(),
                response.isSuccess() ? PaymentStatus.COMPLETED : PaymentStatus.FAILED
            )
        ).subscribeOn(Schedulers.boundedElastic());
    }
    
    private Mono<PaymentResponse> handlePaymentError(Throwable error) {
        // Graceful error handling
        return Mono.error(new PaymentProcessingException("Payment failed", error));
    }
}

2. Idempotency и кеширование

@Service
public class IdempotentPaymentService {
    @Autowired
    private RedisTemplate<String, PaymentResponse> redisTemplate;
    
    @Autowired
    private PaymentRepository paymentRepository;
    
    public Mono<PaymentResponse> processPaymentIdempotently(PaymentRequest request) {
        String idempotencyKey = request.getIdempotencyKey();
        
        // Проверяем кеш
        return Mono.fromCallable(() -> 
            redisTemplate.opsForValue().get(idempotencyKey)
        )
        .switchIfEmpty(
            // Обрабатываем платёж
            processAndCache(request, idempotencyKey)
        )
        .doOnError(error -> 
            logPaymentError(request.getPaymentId(), error)
        );
    }
    
    private Mono<PaymentResponse> processAndCache(
            PaymentRequest request, 
            String idempotencyKey) {
        return processPayment(request)
            .doOnNext(response -> 
                // Кешируем результат на 24 часа
                redisTemplate.opsForValue().set(
                    idempotencyKey, 
                    response, 
                    Duration.ofHours(24)
                )
            );
    }
    
    private Mono<PaymentResponse> processPayment(PaymentRequest request) {
        // Реальная обработка платежа
        return Mono.just(new PaymentResponse());
    }
    
    private void logPaymentError(String paymentId, Throwable error) {
        // Логирование
    }
}

3. Distributed Tracing и мониторинг

@Configuration
@EnableMicrometerTracing
public class ObservabilityConfig {
    
    @Bean
    public TraceFilter traceFilter() {
        return (request, response, chain) -> {
            String traceId = UUID.randomUUID().toString();
            MDC.put("traceId", traceId);
            
            try {
                return chain.doFilter(request, response);
            } finally {
                MDC.remove("traceId");
            }
        };
    }
}

@Service
@Observed(name = "payment.processing",
          contextualName = "payment-processing",
          lowCardinalityKeyValues = {"operation", "process"})
public class PaymentMetricsService {
    private final MeterRegistry meterRegistry;
    private final Timer paymentProcessingTimer;
    private final AtomicInteger activePayments;
    
    public PaymentMetricsService(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        
        this.paymentProcessingTimer = Timer.builder("payment.processing.duration")
            .description("Время обработки платежа")
            .register(meterRegistry);
        
        this.activePayments = meterRegistry.gauge(
            "payment.active.count",
            new AtomicInteger(0)
        );
    }
    
    public <T> Mono<T> measurePaymentProcessing(
            Mono<T> mono,
            String gatewayName) {
        return mono
            .doOnSubscribe(sub -> activePayments.incrementAndGet())
            .doOnSuccess(result -> 
                recordSuccess(gatewayName)
            )
            .doOnError(error -> 
                recordError(gatewayName, error)
            )
            .doFinally(signal -> 
                activePayments.decrementAndGet()
            )
            .name("payment.processing")
            .tag("gateway", gatewayName)
            .metrics();
    }
    
    private void recordSuccess(String gatewayName) {
        meterRegistry.counter(
            "payment.success.total",
            "gateway", gatewayName
        ).increment();
    }
    
    private void recordError(String gatewayName, Throwable error) {
        meterRegistry.counter(
            "payment.error.total",
            "gateway", gatewayName,
            "error.type", error.getClass().getSimpleName()
        ).increment();
    }
}

4. Circuit Breaker и Resilience

@Service
public class ResilientPaymentGatewayClient {
    @Autowired
    private WebClient webClient;
    
    @CircuitBreaker(
        name = "paymentGateway",
        fallbackMethod = "fallbackProcessPayment"
    )
    @Retry(
        name = "paymentGateway",
        fallbackMethod = "fallbackProcessPayment"
    )
    public Mono<GatewayResponse> processPayment(Payment payment) {
        return webClient.post()
            .uri("/api/v1/payments")
            .bodyValue(payment)
            .retrieve()
            .bodyToMono(GatewayResponse.class)
            .timeout(Duration.ofSeconds(10))
            .doOnError(WebClientResponseException.class, error -> 
                logGatewayError(payment.getId(), error)
            );
    }
    
    public Mono<GatewayResponse> fallbackProcessPayment(
            Payment payment,
            Exception error) {
        // Graceful degradation
        return Mono.just(
            GatewayResponse.builder()
                .paymentId(payment.getId())
                .status("PENDING")
                .reason("Gateway unavailable, will retry")
                .build()
        );
    }
    
    private void logGatewayError(String paymentId, WebClientResponseException error) {
        log.error(
            "Payment gateway error for payment {}: status={}, body={}",
            paymentId,
            error.getStatusCode(),
            error.getResponseBodyAsString()
        );
    }
}

Результаты оптимизации

Улучшения производительности:

• Пропускная способность: с 500-700 req/s до 5,000+ req/s (7x улучшение)
• P99 latency: снижение с 2-3 секунд до 150-200ms
• Потребление памяти: сокращение на 40% за счёт асинхронной обработки
• Стабильность: нулевых потерь платежей при пиковых нагрузках

Надёжность:

• 99.99% успешная обработка платежей (4 девятки)
• Полная traceability всех платежей через distributed tracing
• Автоматическое восстановление при сбоях внешних API (circuit breaker + retry)

Операционная эффективность:

• Сокращение времени отладки на 60% благодаря распределённому трейсингу
• Proactive alerting на основе метрик
• Полный аудит всех платежей для compliance

Ключевые технологии

• Spring WebFlux — реактивная обработка
• Project Reactor — асинхронное программирование
• Redis — кеширование и idempotency
• Micrometer + Prometheus — мониторинг
• Sleuth + Zipkin — distributed tracing
• Resilience4j — circuit breaker и retry

Чему я научился

1. Асинхронное программирование требует другого мышления, но даёт огромные выигрыши в производительности
2. Idempotency — критична для финансовых систем
3. Observability важнее, чем совершенный мониторинг
4. Graceful degradation позволяет системе продолжать работу при сбоях

Эта задача научила меня балансировать между сложностью реализации и получаемыми выигрышами в производительности и надёжности.