В чем разница между синхронным и асинхронным общением сервисов?

Разница между синхронным и асинхронным общением сервисов

Это фундаментальные паттерны коммуникации в микросервисной архитектуре, определяющие, как сервисы взаимодействуют друг с другом.

Синхронное общение (Synchronous Communication)

Синхронное общение — это прямое взаимодействие между сервисами, при котором один сервис отправляет запрос и ждёт ответа перед продолжением выполнения.

Характеристики:

• Вызывающий сервис блокируется и ждёт ответа
• Есть прямое соединение между сервисами
• Ответ получается в синхронном потоке
• Немедленная обратная связь

// Синхронный вызов между сервисами
@Service
public class OrderService {
    @Autowired
    private RestTemplate restTemplate; // или WebClient
    
    public Order createOrder(OrderRequest request) {
        // 1. Создаём заказ
        Order order = new Order();
        order.setCustomerId(request.getCustomerId());
        order.setTotalAmount(request.getTotalAmount());
        
        // 2. СИНХРОННО вызываем сервис платежей
        // Ждём ответа перед продолжением
        PaymentResponse payment = restTemplate.postForObject(
            "http://payment-service/api/payments",
            new PaymentRequest(order.getTotalAmount()),
            PaymentResponse.class
        );
        
        if (!payment.isSuccessful()) {
            throw new PaymentException("Платёж не прошёл");
        }
        
        order.setPaymentId(payment.getId());
        order.setStatus("CONFIRMED");
        
        // 3. СИНХРОННО вызываем сервис уведомлений
        restTemplate.postForObject(
            "http://notification-service/api/emails",
            new EmailRequest(request.getEmail()),
            Void.class
        );
        
        // 4. Сохраняем заказ
        return orderRepository.save(order);
    }
}

Диаграмма синхронного запроса:

Client      Order Service     Payment Service     Notification Service
  |              |                  |                     |
  |--POST /orders-->|                |                     |
  |                 |--POST /payments-->|                   |
  |                 |<--Response--------|                   |
  |                 |--POST /emails-------->|                |
  |                 |<--Response-----------|
  |<--Response-----|                |                     |

Примеры технологий:

• REST API (HTTP)
• gRPC
• WebSocket (для некоторых сценариев)

Плюсы синхронного общения

// 1. Простота реализации и отладки
@Service
public class SimpleOrderService {
    // Легко понять поток выполнения
    public void processOrder(Order order) {
        paymentService.processPayment(order);
        inventoryService.reduceStock(order);
        notificationService.sendEmail(order);
    }
}

// 2. Гарантированная доставка результата
public Order createOrder(OrderRequest request) {
    Order order = orderService.create(request);
    // Знаем результат сразу
    return order;
}

// 3. Легкая обработка ошибок
public void transferMoney(String from, String to, double amount) {
    try {
        accountService.debitAccount(from, amount);
        accountService.creditAccount(to, amount);
    } catch (InsufficientFundsException e) {
        // Обработка ошибок в одном месте
    }
}

Минусы синхронного общения

// 1. Проблема с задержками и зависимостями
@Service
public class SlowOrderService {
    public Order createOrder(OrderRequest request) {
        // Если Payment Service медленный, весь заказ ждёт
        // Общее время = сумма всех времён ответов
        paymentResponse = slowPaymentService.process(request);
        // ~1000ms
        
        emailResponse = emailService.send(request);
        // ~500ms
        
        // Total: ~1500ms, хотя email отправляется параллельно
    }
}

// 2. Проблема с масштабируемостью
// 100 заказов/сек × 1.5 сек = 150 соединений одновременно
// Ресурсы исчерпаны

// 3. Жёсткие связи между сервисами
@Service
public class TightlyCoupled {
    @Autowired
    private PaymentService paymentService;
    @Autowired
    private NotificationService notificationService;
    @Autowired
    private AnalyticsService analyticsService;
    // Если один сервис упал - вся цепочка сломалась
}

// 4. Проблема каскадного отказа (Cascading Failure)
public void handleOrder() {
    try {
        paymentService.process(); // Может быть медленным
    } catch (TimeoutException e) {
        // Тайм-ауты и отказы распространяются
    }
}

Асинхронное общение (Asynchronous Communication)

Асинхронное общение — это непрямое взаимодействие через промежуточное звено (Message Broker), при котором сервисы не ждут друг друга.

Характеристики:

• Вызывающий сервис не блокируется
• Связь опосредована (через очередь сообщений)
• Слабая связанность между сервисами
• Событийная архитектура

// Асинхронное общение с RabbitMQ
@Service
public class AsyncOrderService {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    public Order createOrder(OrderRequest request) {
        // 1. Создаём и сохраняем заказ
        Order order = new Order();
        order.setCustomerId(request.getCustomerId());
        order.setStatus("PENDING");
        order = orderRepository.save(order);
        
        // 2. АСИНХРОННО отправляем событие в очередь
        // Не ждём ответа!
        OrderCreatedEvent event = new OrderCreatedEvent(
            order.getId(),
            request.getCustomerId(),
            request.getTotalAmount()
        );
        
        rabbitTemplate.convertAndSend(
            "orders.exchange",
            "order.created",
            event
        );
        
        // 3. Сразу возвращаем результат
        return order;
    }
}

// Payment Service слушает события
@Service
public class PaymentListener {
    @RabbitListener(queues = "payment.queue")
    public void handleOrderCreated(OrderCreatedEvent event) {
        // Обрабатывает событие асинхронно
        PaymentResult result = processPayment(event.getTotalAmount());
        
        if (result.isSuccessful()) {
            // Отправляет ответное событие
            publishPaymentProcessedEvent(result);
        } else {
            publishPaymentFailedEvent(event.getOrderId());
        }
    }
}

// Notification Service тоже слушает
@Service
public class NotificationListener {
    @RabbitListener(queues = "notification.queue")
    public void handlePaymentProcessed(PaymentProcessedEvent event) {
        sendEmail(event.getCustomerId(), "Платёж принят");
    }
}

Диаграмма асинхронного обмена:

Order Service              RabbitMQ              Payment Service
  |                      (Message Broker)           |
  |--Order Created Event-->|                        |
  |<--ACK (fast)-----------|                        |
  | (продолжает работу)   |--Event-->|              |
  |                       |          |--Processing--|
  |                       |<--Payment Ready Event--|

Notification Service       RabbitMQ                 |
  |                         |<-Event-|
  |<--Event-|              |
  |         |--Send Email--|

Примеры технологий:

• RabbitMQ
• Apache Kafka
• AWS SQS/SNS
• Apache ActiveMQ

Плюсы асинхронного общения

// 1. Высокая скорость ответа
public Order createOrder(OrderRequest request) {
    Order order = orderRepository.save(request);
    // Возвращаем сразу (~10ms)
    // Обработка происходит в фоне
    rabbitTemplate.convertAndSend("order.queue", order);
    return order;
}

// 2. Слабая связанность
// Payment Service может быть офлайн, Order Service работает
public void publishEvent(OrderCreatedEvent event) {
    rabbitTemplate.convertAndSend(
        "orders.exchange",
        "order.created",
        event
    );
    // Не зависит от доступности Payment Service
}

// 3. Масштабируемость
// Можно запустить несколько инстансов Payment Service
// Все они обрабатывают события параллельно

// 4. Устойчивость к сбоям
// Если Payment Service упал, сообщения остаются в очереди
// Обрабатываются, когда сервис вернулся

Минусы асинхронного общения

// 1. Сложность отладки и отслеживания
public void processOrder(Order order) {
    // Когда произойдёт платёж? Где была ошибка?
    publishEvent(new OrderCreatedEvent(order));
    // Нужна распределённая трассировка
}

// 2. Гарантия доставки требует努力
public void handlePayment(OrderCreatedEvent event) {
    // Что если обработчик упал после обработки?
    // Нужно идемпотентное обработчика
    paymentService.processPayment(event.getOrderId());
    // Может быть обработано дважды!
}

// 3. Сложность обработки ошибок
public void publishEvent(Event event) {
    try {
        rabbitTemplate.convertAndSend("exchange", "key", event);
    } catch (Exception e) {
        // Как обработать? Retry? Dead Letter Queue?
        // Нужна стратегия
    }
}

// 4. Результат не гарантирован сразу
public OrderDto createOrder(OrderRequest request) {
    Order order = orderRepository.save(request);
    // Платёж ещё не обработан!
    return new OrderDto(order);
    // Клиент видит "PENDING", а не "CONFIRMED"
}

Сравнение

Когда использовать

Синхронное:

• Финансовые транзакции (ACID гарантии)
• Запросы с немедленным результатом
• Простые микросервисы
• Внутренние API

Асинхронное:

• Отправка email/SMS
• Обработка больших объёмов данных
• Некритичные операции
• Высоконагруженные системы
• Event-driven архитектура

Гибридный подход

@Service
public class HybridOrderService {
    // Критичное: синхронно
    PaymentResponse payment = paymentService.processPayment(order);
    
    if (!payment.isSuccessful()) {
        throw new PaymentException();
    }
    
    // Некритичное: асинхронно
    rabbitTemplate.convertAndSend(
        "orders.exchange",
        "order.confirmed",
        new OrderConfirmedEvent(order)
    );
}