What is Event-Driven Architecture?

Question

Accepted Answer

**Event-Driven Architecture (EDA)** — a design pattern where services communicate by producing and consuming events through a message broker, enabling loose coupling and asynchronous processing. **System Design Context:** EDA decouples producers from consumers. A producer publishes an event without knowing who will consume it. This enables independent scaling, fault isolation, and new capabilities without modifying existing services. **Key Concepts:** - **Event** — an immutable record of something that happened (fact). - **Producer** — emits events when state changes. - **Consumer** — reacts to events and performs side effects. - **Broker** — routes events between producers and consumers (Kafka, RabbitMQ). - **Event Schema** — defines the structure of events (Avro, JSON Schema, Protobuf). - **Topic/Queue** — logical channel for event delivery. **Kafka — Production Implementation:** ```java // Event definition public record OrderCreatedEvent( Long orderId, Long userId, BigDecimal total, List items, Instant timestamp ) {} // Producer with idempotency @Service @Slf4j public class OrderService { private final OrderRepository orderRepo; private final KafkaTemplate kafkaTemplate; private final ObjectMapper objectMapper; @Transactional public Order createOrder(CreateOrderRequest request) { Order order = Order.create(request); Order saved = orderRepo.save(order); OrderCreatedEvent event = new OrderCreatedEvent( saved.getId(), saved.getUserId(), saved.getTotal(), saved.getItems(), Instant.now()); kafkaTemplate.send("order-events", saved.getId().toString(), event) .addCallback( result -> log.info("Event sent: {}", saved.getId()), ex -> log.error("Failed to send event: {}", saved.getId(), ex) ); return saved; } } // Consumer with idempotency @Service @Slf4j public class NotificationListener { private final ProcessedEventRepository processedRepo; private final EmailService emailService; @KafkaListener( topics = "order-events", groupId = "notification-service", containerFactory = "kafkaListenerContainerFactory" ) public void onOrderCreated( @Payload OrderCreatedEvent event, @Header(KafkaHeaders.RECEIVED_KEY) String key, Acknowledgment ack) { String eventId = event.orderId() + "-created"; // Idempotency check if (processedRepo.existsByEventId(eventId)) { log.info("Event already processed: {}", eventId); ack.acknowledge(); return; } emailService.sendOrderConfirmation(event.userId(), event.orderId()); processedRepo.save(new ProcessedEvent(eventId)); ack.acknowledge(); } } ``` **Scaling Patterns:** - **Partitioning** — distribute events across partitions for parallel processing. - **Consumer groups** — multiple instances of a consumer share the load. - **Event replay** — reprocess events from a specific offset. **Common Pitfalls:** - **Eventual consistency** — data may be temporarily out of sync. Fix: design for idempotency, use sagas. - **Event ordering** — events may arrive out of order. Fix: partition by aggregate ID. - **Debugging complexity** — hard to trace event flow. Fix: distributed tracing, correlation IDs. - **Event versioning** — schema evolution. Fix: use Avro with schema registry. **Monitoring:** - Track **consumer lag** (how far behind consumers are). - Monitor **event processing latency** (publish to consume time). - Alert on **dead letter queue** growth. - Dashboard: Kafka consumer lag, RabbitMQ queue depth.

Java: What is Event-Driven Architecture?