Что такое событийно-управляемая архитектура и когда её применяют?

Событийно-управляемая архитектура (Event-Driven Architecture)

Это архитектурный паттерн, где компоненты взаимодействуют через события. Вместо прямых вызовов между компонентами они создают события при изменении своего состояния, а другие компоненты на эти события реагируют.

Основные компоненты

// Определение события
public class UserRegisteredEvent {
    private String userId;
    private String email;
    private LocalDateTime createdAt;
    
    // getters, setters
}

// Publisher - генерирует события
@Service
public class UserService {
    @Autowired
    private ApplicationEventPublisher eventPublisher;
    
    public void registerUser(UserDTO dto) {
        User user = new User(dto);
        userRepository.save(user);
        
        // Публикуем событие
        UserRegisteredEvent event = new UserRegisteredEvent(
            user.getId(), user.getEmail(), LocalDateTime.now()
        );
        eventPublisher.publishEvent(event);
    }
}

// Listener - реагирует на события
@Service
public class EmailNotificationService {
    @EventListener
    public void onUserRegistered(UserRegisteredEvent event) {
        // Отправляем приветственное письмо
        sendWelcomeEmail(event.getEmail());
    }
}

Архитектурные паттерны

1. Broker Pattern — компоненты связаны через message broker

// RabbitMQ example
@Service
public class OrderService {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    public void createOrder(Order order) {
        orderRepository.save(order);
        // Отправляем событие в очередь
        rabbitTemplate.convertAndSend("order.exchange", 
            "order.created", order);
    }
}

@Service
public class InventoryService {
    @RabbitListener(queues = "inventory.queue")
    public void handleOrderCreated(Order order) {
        // Резервируем товары
        reserveInventory(order);
    }
}

2. Mediator Pattern — центральный медиатор координирует события

// При необходимости более сложной логики
@Service
public class OrderMediator {
    @EventListener
    public void onOrderCreated(OrderCreatedEvent event) {
        // Координируем действия нескольких сервисов
        inventoryService.reserve(event.getOrderId());
        paymentService.charge(event.getOrderId());
        notificationService.sendConfirmation(event);
    }
}

Когда применяют

Идеально подходит для:

1. Микросервисная архитектура — слабая связанность между сервисами
2. Real-time системы — потребность в быстром отклике на изменения
3. Асинхронная обработка — когда не нужен немедленный результат
4. Сложные бизнес-процессы — орхестрация множества действий
5. Масштабируемые системы — горизонтальное расширение

Преимущества

• Слабая связанность — компоненты не зависят друг от друга напрямую
• Масштабируемость — легко добавлять новые обработчики
• Асинхронность — не блокирует основной поток
• Гибкость — один event может обрабатываться разными сервисами

Недостатки

• Сложность отладки — сложнее отследить логику между компонентами
• Гарантии доставки — нужно учитывать потенциальные потери событий
• Задержки — асинхронность может привести к откладываниям
• Распределённые транзакции — saga pattern для обеспечения консистентности

Практический пример с Kafka

@Service
public class PaymentEventService {
    @Autowired
    private KafkaTemplate<String, PaymentEvent> kafkaTemplate;
    
    public void processPayment(Payment payment) {
        // Сохраняем платёж
        paymentRepository.save(payment);
        
        // Публикуем событие в Kafka
        PaymentEvent event = new PaymentEvent(
            payment.getId(), 
            payment.getAmount(), 
            LocalDateTime.now()
        );
        kafkaTemplate.send("payment-events", event.getPaymentId(), event);
    }
}

@Service
public class ReportingService {
    @KafkaListener(topics = "payment-events")
    public void generateReport(PaymentEvent event) {
        // Генерируем отчёты на основе события
        reportRepository.save(createReport(event));
    }
}

Событийно-управляемая архитектура - это мощный подход для создания гибких, масштабируемых систем, особенно в контексте микросервисов и real-time приложений.