Event-driven Architecture in Kotlin: From Coroutines to Reactive Streams

Event-driven Architecture in Kotlin: Why It's Not Just a Trendy Buzzword

Imagine your application is a perfectly tuned mechanism. Every gear knows when to turn, every piston knows when to move. But what if one day you need to add a new part without stopping the entire machine? In traditional synchronous architecture, this often turns into a nightmare: rewriting entire modules, testing endless call chains, and sleepless nights.

This is where event-driven architecture in Kotlin comes onto the scene — a paradigm where components communicate through events rather than direct calls. Kotlin, with its coroutines and reactive streams, provides ideal tools for this. In this article, we won't just talk about theory — we'll write real code, break down Kotlin Flow and Channels, and I'll show you how to build a flexible, scalable system that won't fall apart under the first load.

What is Event-Driven Architecture in Simple Terms

In the classic approach (imagine microservices calling each other via REST), each request is a rigid connection. Service A calls Service B, waits for a response, and if B goes down — everything breaks. In event-driven architecture, it's different: components publish events (e.g., "Order Created") and subscribe to them. No one waits for anyone, no one calls anyone directly.

The beauty of Kotlin is that it allows you to implement this model natively, without connecting bulky frameworks. Coroutines provide lightweight threads, while Channel and Flow are ready-made buses for events.

Let's look at a simple example — your own EventBus in Kotlin:

import kotlinx.coroutines.*\nimport kotlinx.coroutines.channels.*\n\nclass SimpleEventBus {\n    private val events = Channel<Any>(Channel.UNLIMITED)\n\n    suspend fun publish(event: Any) {\n        events.send(event)\n    }\n\n    suspend fun subscribe(handler: suspend (Any) -> Unit) {\n        for (event in events) {\n            handler(event)\n        }\n    }\n}\n\n// Usage\nfun main() = runBlocking {\n    val bus = SimpleEventBus()\n    \n    launch {\n        bus.subscribe { event ->\n            println("Event received: $event")\n        }\n    }\n    \n    delay(100)\n    bus.publish("Hello, Event-Driven!")\n    delay(100)\n}

This code is the foundation. We create a channel that works like an asynchronous queue. The publisher puts an event, the subscriber picks it up. It's simple, but the power of event-driven architecture in Kotlin is already visible here: the subscriber and publisher know nothing about each other.

Kotlin Flow: Reactive Streams for Events

Channel is great, but for real projects you often need more: cold and hot streams, transformations, error handling. This is where Kotlin Flow comes into play — a reactive library built directly into the language.

Flow is ideal for asynchronous programming in Kotlin when events are generated continuously. For example, currency exchange rate updates, news feeds, or UI state changes.

Cold vs Hot Streams

It's important to understand the difference:

\n
• Cold Stream — starts working only when someone subscribes to it. Each subscriber gets their own data stream.
\n
• Hot Stream — works constantly, regardless of subscribers. Late subscribers miss older events.
\n

For event-driven architecture, hot streams are usually needed. In Kotlin, they are implemented via SharedFlow or StateFlow.

Example — a notification system:

import kotlinx.coroutines.*\nimport kotlinx.coroutines.flow.*\n\ndata class Notification(val userId: String, val message: String)\n\nclass NotificationService {\n    private val _notifications = MutableSharedF