{"id":100,"date":"2024-02-15T05:00:00","date_gmt":"2024-02-15T05:00:00","guid":{"rendered":"https:\/\/imcodinggenius.com\/?p=100"},"modified":"2024-02-15T05:00:00","modified_gmt":"2024-02-15T05:00:00","slug":"reactive-programming-in-kotlin-a-step-by-step-guide","status":"publish","type":"post","link":"https:\/\/imcodinggenius.com\/?p=100","title":{"rendered":"Reactive Programming in Kotlin: A Step-by-Step Guide"},"content":{"rendered":"

In this article, we are going to tackle Reactive Programming in Kotlin<\/strong>. We will start with what exactly Reactive Programming<\/strong> is, how we could use it to our advantage, and what techniques we can use in Kotlin<\/strong>. I am going to explain everything in simple terms to make this article beginner-friendly<\/strong> (considering you know the basics of Kotlin, of course).<\/p>\n

In some future articles<\/strong>, we will put that knowledge into action on the example of the Ktor project<\/strong>, emphasizing the Reactive approach. So don\u2019t forget to follow me on LinkedIn<\/a> to not miss out <\/p>\n

Reactive Programming<\/h2>\n

If you try to search for what Reactive Programming<\/strong> is, you will sooner or later find The Reactive Manifesto,<\/a><\/strong> which is cited by almost everyone. <\/p>\n

And in most articles, there will be something like the following diagram:<\/p>\n

\n<\/div>\n

For the beginner, all of these definitions and explanations are vague and unclear<\/strong>. It is absolutely possible to learn it and speak about it, for example, in an interview with zero understanding whatsoever. Instead, let\u2019s connect it to concepts that are present in software development<\/strong>, and don\u2019t worry if you are not familiar with them. <\/p>\n

Let\u2019s take a look at another diagram that represents the concepts:<\/p>\n

\n<\/div>\n

The key concepts in the Observer Pattern<\/strong> are \u201csubjects<\/strong>\u201d and \u201cobservers<\/strong>\u201c. When a subject\u2019s state changes<\/strong>, it notifies<\/strong> all its observers, allowing them to react accordingly.<\/p>\n

The Iterator Pattern<\/strong> introduces a way to access elements of some object, most likely a collection, sequentially without exposing its internal implementation.<\/p>\n

And as a cherry on top, Reactive Programming is tight with Functional Programming<\/strong> so, in essence, let\u2019s define what Reactive Programming is in these terms. Reactive Programming leverages the Observer\u2019s one-to-many notification<\/strong> and the Iterator\u2019s sequential access<\/strong>, but extends them to handle continuous data flows and asynchronous interactions<\/strong> without defining \u201cwhat\u201d to do with data but \u201chow\u201d to iterate.<\/p>\n

Streams<\/h2>\n

All mentioned before leads us to another core concept: Streams<\/strong>. If you are familiar with the Flows, it is basically them, if not we\u2019ll cover them later anyway. So, a Stream is a sequence of data objects<\/strong> that can be consumed and processed asynchronously. What is more, you can also merge, filter, combine, and transform them to handle data successfully.<\/p>\n

Now let\u2019s check what Kotlin can offer in terms of the Reactive Approach. We will start with asynchronicity, and the best solution for this is Coroutines and especially Flows. But before that, let\u2019s discuss types of streams.<\/p>\n

\u201cCold\u201d and \u201cHot\u201d Streams<\/h2>\n

In terms of emitting data, we have two types of streams<\/strong>. On the one hand, \u201ccold<\/strong>\u201d streams are streams that can only emit data when there is someone who could consume it, in other words, if there is any observer attached<\/strong>. This basically means that no data would be missed and the whole chain of the items consumed. <\/p>\n

On the other hand, we have \u201chot<\/strong>\u201d streams. They are not dependent on any observable<\/strong> attached and start emitting items as soon as they are created. And here is the key difference, you could \u201cmiss<\/strong>\u201d values using \u201chot\u201d streams if they are not handled carefully. <\/p>\n

Kotlin Coroutines <\/h2>\n

Quick dive into Coroutines basics, and then we will, Coroutines allow us to create an asynchronous code execution<\/strong> just like threads, but they are not bound to any particular thread<\/strong> and without callbacks.<\/p>\n

Now for the real part, the Reactive Programming Coroutines library can offer 3 options: <\/p>\n

Channels<\/p>\n

StateFlow<\/p>\n

SharedFlow<\/p>\n

Both StateFlow and SharedFlow are evolutions of the Flow<\/strong> which is generally a Stream I\u2019ve mentioned before. Flow represents a sequence of values that can be computed asynchronously<\/strong>. But firstly, let\u2019s start from Channels.<\/p>\n

Channels<\/h2>\n

The first notable object is Chanel<\/strong>. As documentation states, Chanel provides communication between coroutines. But in terms of our topic, Chanel is a \u201chot\u201d Stream in which each individual value could consume only one observer<\/strong>. <\/p>\n

Nevertheless, it can have more the one observer, but the values would be delivered to the first awaited. If there are many observers that wait for the value to be delivered, some collectors will get suspended. Now let\u2019s check a simple code example: <\/p>\n

import kotlinx.coroutines.channels.Channel
\nimport kotlinx.coroutines.delay
\nimport kotlinx.coroutines.isActive
\nimport kotlinx.coroutines.launch
\nimport kotlinx.coroutines.runBlocking<\/p>\n

suspend fun fetchStockPrice(): Double {
\n delay(1000) \/\/ Simulate API call delay
\n return Math.random() * 100
\n}<\/p>\n

fun main() = runBlocking {
\n \/\/ Create a Chanel to hold stock prices
\n val stockPrices = Channel<Double>()<\/p>\n

\/\/ Launch a coroutine to fetch prices every second
\n launch {
\n while (isActive) {
\n val price = fetchStockPrice()
\n stockPrices.send(price)
\n delay(1000)
\n }
\n }<\/p>\n

\/\/ Launch a coroutine to consume and display prices
\n launch {
\n for (price in stockPrices) {
\n println(«Current Stock Price: $$price»)
\n }
\n }<\/p>\n

delay(Long.MAX_VALUE)
\n}<\/p>\n

This example simulates a stock price ticker application that fetches prices from an API in real time and displays them to the user. <\/p>\n

We used Channel to handle the asynchronous data flow and transfer data from one Coroutine to another!<\/p>\n

SharedFlow<\/h2>\n

The SharedFlow is a Stream in all of its glory. <\/p>\n

It is a hot<\/strong> stream, that can have multiple numbers of observers.<\/strong> We can check it out with the following code example:<\/p>\n

import kotlinx.coroutines.delay
\nimport kotlinx.coroutines.flow.MutableSharedFlow
\nimport kotlinx.coroutines.flow.filter
\nimport kotlinx.coroutines.flow.launchIn
\nimport kotlinx.coroutines.flow.onEach
\nimport kotlinx.coroutines.launch
\nimport kotlinx.coroutines.runBlocking<\/p>\n

data class Item(val name: String, val price: Double)<\/p>\n

fun main() = runBlocking {
\n \/\/ SharedFlow to hold the cart items
\n val cartItems = MutableSharedFlow<List<Item>>()<\/p>\n

\/\/ Launch a coroutine to print the cart on SharedFlow
\n launch {
\n cartItems.collect { items ->
\n println(«Cart Updated: $items»)
\n }
\n }<\/p>\n

\/\/ Launch another coroutine to trigger order confirmation when the cart is full
\n launch {
\n cartItems.filter { it.size >= 3 } \/\/ Filter for 3 or more items
\n .onEach { println(«Order Confirmation triggered!») }
\n .launchIn(this)
\n }<\/p>\n

\/\/ Launch a coroutine to simulate adding items to the cart
\n launch {
\n var updatedItems = listOf(Item(«Apple», 1.50))
\n cartItems.emit(updatedItems)
\n delay(1000)
\n updatedItems = updatedItems + Item(«Milk», 2.00)
\n cartItems.emit(updatedItems)
\n delay(1000)
\n updatedItems = updatedItems + Item(«Bread», 3.00)
\n cartItems.emit(updatedItems)
\n }<\/p>\n

delay(Long.MAX_VALUE)
\n}<\/p>\n

In the example above, we created a shopping cart application where multiple components need to react to changes in the cart items. <\/p>\n

SharedFlow provides a centralized way to share updates efficiently. And we can witness multiple observers at the same time.<\/p>\n

StateFlow<\/h2>\n

The StateFlow is similar to SharedFlow. However, it is a somewhat cold<\/strong> stream because it requires some initial value<\/strong> on creation, and it always holds a value<\/strong>. <\/p>\n

This basically means that it always has a value to observe. Here\u2019s a good example:<\/p>\n

import kotlinx.coroutines.delay
\nimport kotlinx.coroutines.flow.*
\nimport kotlinx.coroutines.launch
\nimport kotlinx.coroutines.runBlocking<\/p>\n

enum class PlayerState {
\n Playing,
\n Paused,
\n Stopped
\n}<\/p>\n

fun main() = runBlocking {
\n \/\/ StateFlow to hold the current player state
\n val playerState = MutableStateFlow(PlayerState.Stopped)<\/p>\n

\/\/ Launch a coroutine to print state based on StateFlow
\n launch {
\n playerState.collect { state ->
\n println(«Player State: $state»)
\n }
\n }<\/p>\n

\/\/ Launch a coroutine to simulate user actions
\n launch {
\n \/\/ Play\/pause\/stop actions update the state
\n playerState.emit(PlayerState.Playing)
\n delay(2000)
\n playerState.emit(PlayerState.Paused)
\n delay(1000)
\n playerState.emit(PlayerState.Stopped)
\n }<\/p>\n

delay(Long.MAX_VALUE)
\n}<\/p>\n

For this example, we use a music player application where the current playing state needs to be tracked. StateFlow provides a single source of truth for this state, with an initial value.<\/p>\n

Other Reactive options available<\/h2>\n

The most popular alternatives are ReactiveX libraries<\/strong>. The main competitor is RxJava for Java basically and it\u2019s widely used especially in Android Development<\/strong>. Unfortunately, RxKotlin<\/strong> has almost zero popularity these days due to its extensive RxJava presence. <\/p>\n

RxJava provides extensive tools for Reactive programming, but due to its limited integration with Kotlin Coroutines<\/strong>, I recommend using Coroutines but keep in mind that this powerful tool is also available.<\/p>\n

There are also lots of libraries tightly connected to Spring Boot<\/strong>. There are Spring WebFlux, and Project Reactor.<\/strong> They are provided tools in applications for building reactive systems in JVM Backend Development,<\/strong> but not that popular in Kotlin. <\/p>\n

Summary<\/h2>\n

And that\u2019s all for this article about Reactive Programming in Kotlin with Coroutines and Flows.<\/p>\n

In the upcoming articles, we will get back to this topic and learn how to apply this knowledge with Ktor, so don\u2019t forget to join the free newsletter to not miss it!<\/p>\n

Lastly, if you would like to learn more about Flows, then you can find lots of useful information on the official documentation<\/a> of Kotlin.<\/p>\n

The post Reactive Programming in Kotlin: A Step-by-Step Guide<\/a> appeared first on Codersee | Kotlin, Ktor, Spring<\/a>.<\/p>","protected":false},"excerpt":{"rendered":"

In this article, we are going to tackle Reactive Programming in Kotlin. We will start with what exactly Reactive Programming is, how we could use it to our advantage, and what techniques we can use in Kotlin. I am going to explain everything in simple terms to make this article … <\/p>\n

Read More<\/a><\/div>\n","protected":false},"author":1,"featured_media":101,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-100","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-news"],"_links":{"self":[{"href":"https:\/\/imcodinggenius.com\/index.php?rest_route=\/wp\/v2\/posts\/100"}],"collection":[{"href":"https:\/\/imcodinggenius.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/imcodinggenius.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/imcodinggenius.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/imcodinggenius.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=100"}],"version-history":[{"count":0,"href":"https:\/\/imcodinggenius.com\/index.php?rest_route=\/wp\/v2\/posts\/100\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/imcodinggenius.com\/index.php?rest_route=\/wp\/v2\/media\/101"}],"wp:attachment":[{"href":"https:\/\/imcodinggenius.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=100"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/imcodinggenius.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=100"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/imcodinggenius.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=100"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}