David's Blog

Using RxKotlin in Kotlin A Comprehensive Guide

By David Li on 2023-05-03T14:16:44.927Z

Using RxKotlin in Kotlin: A Comprehensive Guide

RxKotlin is a library that brings the power of Reactive Extensions (Rx) to the Kotlin programming language. Rx is a popular and powerful framework for composing asynchronous and event-based programs by using observable sequences. In this article, we will explore the basics of RxKotlin, the advantages it provides, and how to use it effectively in your Kotlin projects.

Table of Contents

  1. Introduction to Reactive Programming
  2. Setting up RxKotlin
  3. Core Components of RxKotlin
  4. Creating Observables
  5. Transforming and Filtering Observables
  6. Combining Observables
  7. Error Handling
  8. Schedulers
  9. Conclusion

Introduction to Reactive Programming

Reactive programming is a programming paradigm that deals with data streams and the propagation of change. This means that it emphasizes the idea of data flow, and how the data changes over time. Reactive programming allows developers to express complex data flows and transformations with a concise and expressive syntax.

RxKotlin is an implementation of Rx for Kotlin, which is a statically-typed programming language that runs on the Java Virtual Machine (JVM) and can be used to develop Android applications. Kotlin offers many modern language features, such as extension functions, higher-order functions, and null safety, which make it an excellent choice for working with Rx.

Setting up RxKotlin

To get started with RxKotlin, you need to add the following dependencies to your project’s build.gradle file:

dependencies {
    implementation 'io.reactivex.rxjava2:rxkotlin:2.4.0'
    implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'

The first dependency is for RxKotlin, and the second one is for RxAndroid, which provides Android-specific bindings for RxJava.

Core Components of RxKotlin

There are three core components in the RxKotlin library:

  1. Observable: Represents a stream of data or events. Observables emit items over time, which can be consumed by observers.
  2. Observer: Receives and processes the items emitted by an observable. An observer can react to events like onNext, onError, and onComplete.
  3. Operator: A function that can be used to transform, filter, or combine observables.

Creating Observables

There are several ways to create observables in RxKotlin. Here are some common methods:


The just operator creates an observable that emits a single item and then completes.

val observable = Observable.just("Hello, RxKotlin!")


The fromIterable operator creates an observable that emits the items from an iterable, such as a list or a set.

val numbers = listOf(1, 2, 3, 4, 5)
val observable = Observable.fromIterable(numbers)


The create operator allows you to create a custom observable by providing an emitter.

val observable = Observable.create<String> { emitter ->

Transforming and Filtering Observables

RxKotlin provides a rich set of operators for transforming and filtering observables. Here are some common ones:


The map operator applies a function to each item emitted by an observable and emits the result.

val numbers = Observable.fromIterable(listOf(1, 2, 3, 4, 5))
val squares = numbers.map { it * it }


The filter operator filters the items emitted by an observable based on a predicate function.

val evenNumbers = numbers.filter { it % 2 == 0 }

Combining Observables

RxKotlin also provides operators for combining observables, such as merge, concat, and zip.


The merge operator combines multiple observables into a single observable that emits the items from all the input observables.

val observable1 = Observable.just(1, 2, 3)
val observable2 = Observable.just(4, 5, 6)
val mergedObservable = Observable.merge(observable1, observable2)


The zip operator combines the emissions of multiple observables based on an aggregation function.

val names = Observable.just("Alice", "Bob", "Charlie")
val ages = Observable.just(30, 25, 35)

val zippedObservable = Observable.zip(names, ages, BiFunction<String, Int, String> { name, age ->
    "$name is $age years old"

Error Handling

RxKotlin provides a set of operators for handling errors in observables, such as onErrorReturn, onErrorResumeNext, and retry.


The onErrorReturn operator allows you to emit a default item when an error occurs.

val numbers = Observable.create<Int> { emitter ->
    emitter.onError(RuntimeException("Something went wrong!"))

val errorHandledObservable = numbers.onErrorReturn { -1 }


The retry operator allows you to automatically resubscribe to an observable when an error occurs, effectively retrying the operation.

val errorProneObservable = Observable.create<String> { emitter ->
    emitter.onError(RuntimeException("Something went wrong!"))

val retriedObservable = errorProneObservable.retry(3)


Schedulers in RxKotlin allow you to control the threading of your observables and observers. By default, RxKotlin uses the Schedulers.computation() scheduler, which is backed by a fixed pool of worker threads. You can change the scheduler used by an observable or observer by using the subscribeOn and observeOn operators, respectively.

val backgroundObservable = Observable.just("Hello")

In the example above, the observable will emit items on the I/O scheduler and the observer will consume the items on the main Android thread.


In this article, we have introduced the basics of RxKotlin, a powerful library for reactive programming in Kotlin. We have covered the core components of the library, including observables, observers, and operators, as well as some common use cases such as transforming, filtering, and combining observables.

By using RxKotlin in your Kotlin projects, you can take advantage of the expressive and concise syntax of the language to create complex and efficient asynchronous data flows. To learn more about RxKotlin, you can refer to the official documentation and RxJava repositories on GitHub.

© Copyright 2024 by FriendlyUsers Tech Blog. Built with ♥ by FriendlyUser. Last updated on 2024-02-29.