Event Driven Architecture with Spring Boot 4.x and Kafka 4.x

Preface

1. What This Book Is
2. Who This Book Is For
3. How to Use This Book
4. A Note on Kafka 4.x
5. A Note on Spring Boot 4

Why Event-Driven Architecture?

1. Overview
2. The Monolith: A Love Story
3. When the Monolith Starts to Hurt
4. The Microservices Escape (And Its New Problems)
5. Thinking in Events
6. EDA vs Messaging vs Reactive: Clearing the Confusion
7. A Tale of Two Services
8. When EDA Is the Right Choice (And When It Isn’t)
9. Common Mistakes and Summary

Apache Kafka from the Ground Up

1. Overview
2. What Kafka Is (And Isn’t)
3. Topics, Partitions, and Offsets
4. Producers: Writing to Kafka
5. Consumers and Consumer Groups
6. Brokers, Replication, and Leader Election
7. KRaft Mode: Kafka Without ZooKeeper
8. Retention: What Kafka Does With Old Messages
9. Running Kafka Locally with Docker Compose
10. Running Kafka in Production: Managed Services
11. Common Mistakes and Summary

Spring Boot 4 + Kafka

1. Overview
2. Spring Kafka: What It Gives You
3. Project Setup
4. Sending Events with KafkaTemplate
5. Receiving Events with @KafkaListener
6. JSON Serialization with Jackson
7. Error Handling and Dead Letter Topics
8. Putting It Together: The Notification Service
9. Common Mistakes and Summary

CQRS: Separating Reads from Writes

1. Overview
2. The Problem: One Model Trying to Do Everything
3. Command vs Query: The Core Idea
4. CQRS Without Event Sourcing
5. The Command Side: Handling Writes
6. The Query Side: Building Read Models
7. Eventual Consistency Between Write and Read Models
8. When CQRS Pays Off (and When It Doesn’t)
9. Common Mistakes and Summary

Event Sourcing

1. Overview
2. The Problem With Saving State
3. Event Sourcing Fundamentals
4. The Event Store
5. GDPR and the Right to Erasure
6. Aggregates and Rehydration
7. Snapshots
8. Implementing with Spring Boot
9. When Event Sourcing Fits
10. Common Mistakes and Summary

CQRS + Event Sourcing Together

1. Overview
2. Why They Belong Together
3. The Write Side: Event Sourcing with Commands
4. The Read Side: Multiple Independent Projections
5. Replaying and Rebuilding: The Superpower
6. Full Stack Implementation: Running the Pattern
7. Operational Concerns: Running This in Production

The Saga Pattern

1. Overview
2. The Distributed Transaction Problem
3. What Is a Saga?
4. Choreography Sagas
5. Orchestration Sagas
6. Compensating Transactions
7. Building a Saga with Spring Boot
8. Choreography vs Orchestration
9. Testing Sagas
10. Common Mistakes and Summary

Eventual Consistency

1. Overview
2. The Consistency Spectrum
3. The CAP Theorem in Practice
4. Measuring the Consistency Window
5. Designing Around Consistency Gaps
6. Conflict Resolution
7. Communicating Consistency to Users
8. Common Mistakes and Summary

The Outbox Pattern

1. Overview
2. The Dual-Write Problem
3. The Outbox Pattern
4. Implementing the Outbox
5. Polling Relay
6. Change Data Capture
7. Cleanup and Operations
8. Testing the Outbox Pattern
9. Common Mistakes and Summary

Idempotency and Duplicate Handling

1. Overview
2. At-Least-Once Means Duplicates
3. Natural Idempotency
4. Idempotency Keys
5. Deduplication in Practice
6. Database-Level Idempotency
7. Exactly-Once Semantics
8. Common Mistakes and Summary

Schema Evolution

1. Overview
2. The Schema Problem
3. Avro Basics
4. Confluent Schema Registry
5. Compatibility Rules
6. Evolving Schemas Safely
7. Spring Boot Avro Integration
8. Testing Schema Compatibility
9. Common Mistakes and Summary

Observability

1. Overview
2. Why Observability Is Different
3. Distributed Tracing with OpenTelemetry
4. Propagating Context Through Kafka
5. Kafka Metrics
6. Logging Correlation
7. Building the Observability Stack
8. Securing Kafka in Production
9. Disaster Recovery and Multi-Region
10. Common Mistakes and Summary

Testing Event-Driven Systems

1. Overview
2. The Testing Challenge
3. Unit Testing Event Handlers
4. Integration Testing with EmbeddedKafka
5. Contract Testing
6. Testcontainers
7. Testing Error Paths
8. Testing the Outbox Pattern
9. Testing Event Sourcing Aggregates
10. Mistakes and Summary

Cache Coherence in Distributed Read Models

1. Overview
2. The Cache Invalidation Problem
3. Cache-Aside vs. Write-Through in an EDA Context
4. Event-Driven Cache Invalidation
5. Read-Your-Writes Consistency
6. Redis and Kafka: A Complete Pattern
7. Handling Cache Stampede on Event Bursts
8. Common Mistakes and Summary

Migrating to Event-Driven Architecture

1. Overview
2. The Strangler Fig Pattern
3. CDC as a Migration Bridge
4. The Anti-Corruption Layer
5. Common Mistakes and Summary

Multi-Tenant Event-Driven Systems

1. Overview
2. Isolation Models
3. Quota Management
4. Topic Lifecycle Governance
5. Common Mistakes and Summary

Glossary