RxSwift — apa itu, fitur dan pemrograman reaktif

Apa itu RxSwift?

RxSwift adalah port Swift dari pustaka ReactiveX (Rx) yang dibuat oleh Microsoft untuk .NET pada tahun 2012. Ide utama Rx adalah menyajikan setiap sumber data asinkron sebagai urutan Observable yang dapat diterapkan operator fungsional. Dalam pengembangan iOS, RxSwift digunakan untuk menghubungkan event UI (tekanan tombol, input teks, gestur) dengan logika aplikasi tanpa delegat eksplisit dan target-action.

Pustaka ini terdiri dari tiga modul: RxSwift (inti — Observable, Operator, Scheduler), RxCocoa (integrasi dengan UIKit — ekstensi rx untuk UIButton, UITextField, UITableView) dan RxRelay (Subject tanpa event terminal). Pembagian ini memungkinkan penggunaan inti di Swift server dan pengujian, menghubungkan lapisan UI hanya untuk aplikasi iOS.

Menurut survei Stack Overflow, 2025, RxSwift masuk dalam 5 besar pustaka pihak ketiga paling banyak digunakan untuk iOS. Alasan utama popularitasnya adalah penanganan seragam semua pola asinkron: permintaan jaringan melalui URLSession, animasi melalui UIViewPropertyAnimator, notifikasi melalui NotificationCenter dan delegat melalui DelegateProxy — semuanya direduksi menjadi Observable dengan siklus hidup yang dapat diprediksi.

Filosofi Pemrograman Reaktif

Pemrograman Reaktif adalah paradigma di mana program bereaksi terhadap perubahan data, bukan mempollingnya. Alih-alih menulis “ambil data → proses → perbarui UI”, pengembang mendeskripsikan rantai transformasi: “ketika data berubah, terapkan filter, lalu map, lalu perbarui UI”. RxSwift mengimplementasikan paradigma ini melalui rantai Observable dengan eksekusi malas — tidak ada yang terjadi sampai subscriber muncul.

Komponen Utama RxSwift: Observable, Subject, Disposable

Observable adalah tipe fundamental RxSwift yang merepresentasikan urutan event dalam waktu. Observable dapat mengirim tiga jenis event: next (nilai baru), error (kesalahan, mengakhiri aliran) dan completed (penyelesaian sukses). Ada finite Observable (berakhir setelah mengirim semua nilai) dan infinite Observable (misalnya event UI — tidak pernah berakhir).

Siklus Hidup Observable

Siklus hidup Observable mencakup tiga tahap: pembuatan (create, just, from), transformasi (operator map, filter, flatMap) dan subscription (subscribe). Tanpa subscription, Observable tidak melakukan tindakan apa pun — ini adalah urutan malas. Setelah subscription, Observable mulai mengirim event ke subscriber sampai selesai atau subscriber membatalkan subscription melalui Disposable.

import RxSwift

// Membuat Observable dari array
let numbers = Observable.from([1, 2, 3, 4, 5])

// Transformasi melalui operator
let squared = numbers
    .filter { $0 % 2 == 0 }
    .map { $0 * $0 }

// Berlangganan dengan penanganan event
let disposable = squared
    .subscribe(onNext: { print($0) },
               onError: { print("Error: \($0)") },
               onCompleted: { print("Done") })

Subject adalah tipe yang sekaligus merupakan Observable (dapat di-subscribe) dan Observer (dapat dikirim event). RxSwift menyediakan empat jenis Subject: PublishSubject (hanya event baru), BehaviorSubject (dengan nilai awal), ReplaySubject (buffering N event terakhir) dan AsyncSubject (hanya nilai terakhir sebelum selesai). Subject berguna untuk integrasi kode imperatif (closure, delegat) ke dalam rantai reaktif.

Disposable adalah token pembatalan subscription. Ketika subscriber tidak lagi ingin menerima event, ia memanggil disposable.dispose(). Dalam praktiknya, DisposeBag digunakan: koleksi Disposable yang secara otomatis membatalkan semua subscription saat deinisialisasi pemilik (misalnya UIViewController). Ini mencegah kebocoran memori yang tak terhindarkan saat mengelola subscription secara manual.

Operator Transformasi dan Filtrasi Aliran

Operator RxSwift adalah fungsi yang menerima satu Observable dan mengembalikan Observable lain, mentransformasi aliran data. Dengan menggabungkan operator, pengembang membangun rantai pemrosesan deklaratif tanpa variabel perantara dan race condition. Semua operator bersifat malas: rantai dibangun saat deskripsi, dieksekusi saat subscription.

Operator Transformasi mengubah setiap event dalam aliran. map menerapkan fungsi ke setiap elemen, flatMap membuka Observable dari setiap elemen menjadi satu aliran datar, scan mengakumulasi hasil antara (analog reduce, tetapi dengan emisi setiap langkah). buffer mengelompokkan elemen berdasarkan waktu atau jumlah, window membagi aliran menjadi Observable bersarang per jendela.

// Contoh rantai operator: pencarian dengan debounce
searchTextField.rx.text
    .orEmpty
    .debounce(.milliseconds(300), scheduler: MainScheduler.instance)
    .distinctUntilChanged()
    .flatMapLatest { query -> Observable<[String]> in
        return apiService.search(query)
    }
    .bind(to: tableView.rx.items(cellIdentifier: "Cell")) { _, item, cell in
        cell.textLabel?.text = item
    }
    .disposed(by: disposeBag)

Operator Filtrasi hanya melewatkan event yang memenuhi kondisi. filter memisahkan berdasarkan predikat, distinctUntilChanged hanya melewatkan nilai yang berbeda dari sebelumnya, take dan takeWhile membatasi jumlah event. skip dan skipWhile melewatkan N event pertama atau event hingga kondisi terpenuhi. Untuk penanganan error digunakan catchError (menangkap dan mengganti) dan retry (mengulang urutan saat error).

Operator Kombinasi menggabungkan beberapa Observable menjadi satu. combineLatest menggabungkan nilai terakhir dari beberapa aliran ke dalam tuple, zip menggabungkan elemen berpasangan dengan indeks yang sama, merge menggabungkan beberapa aliran menjadi satu dalam urutan kedatangan event. withLatestFrom menggabungkan event dari aliran utama dengan nilai terakhir dari aliran lain — berguna untuk event UI dengan status saat ini.

Schedulers dan Manajemen Thread Eksekusi

Scheduler di RxSwift adalah abstraksi di atas thread eksekusi (atau antrian). Scheduler menentukan di thread mana pembuatan event, transformasi, dan subscription dilakukan. Berbeda dengan GCD di mana pengembang secara eksplisit menunjukkan DispatchQueue, RxSwift menggunakan dua parameter: subscribeOn (di thread mana Observable dijalankan) dan observeOn (di thread mana subscriber dipanggil).

MainScheduler dan BackgroundScheduler

MainScheduler menjalankan kode di thread utama — wajib untuk pembaruan UIKit (semua perubahan UI harus terjadi di main thread). SerialDispatchQueueScheduler membungkus antrian GCD sekuensial, ConcurrentDispatchQueueScheduler membungkus antrian paralel. Untuk tugas latar belakang digunakan ConcurrentDispatchQueueScheduler dengan qos: .background atau .utility.

// Pola tipikal: kerja latar + UI di main
apiService.fetchData()
    .subscribeOn(ConcurrentDispatchQueueScheduler(qos: .background))
    .observeOn(MainScheduler.instance)
    .subscribe(onNext: { data in
        self.tableView.reloadData()
        self.loadingIndicator.stopAnimating()
    })
    .disposed(by: disposeBag)

Penggunaan Scheduler yang benar mencegah pemblokiran UI saat permintaan jaringan dan komputasi berat. subscribeOn memengaruhi seluruh upstream (semua operator hingga observeOn dijalankan pada penjadwal yang ditentukan). observeOn mengganti downstream — semua operator setelah observeOn dijalankan pada penjadwal yang ditentukan. Dalam rantai bisa ada beberapa observeOn untuk beralih antar thread di berbagai tahap transformasi.

SerialDispatchQueueScheduler menjamin pemrosesan event sekuensial, yang penting untuk keamanan thread sumber daya bersama. Untuk operasi berat (pemrosesan gambar, parsing JSON) gunakan ConcurrentDispatchQueueScheduler — RxSwift akan mempertahankan urutan event dalam satu Observable, tetapi Observable yang berbeda dapat diproses secara paralel.

Penerapan Praktis RxSwift di iOS

RxSwift dalam proyek iOS paling sering digunakan untuk menghubungkan UI dengan data melalui rantai reaktif. RxCocoa menyediakan ekstensi rx untuk semua komponen UIKit standar: rx.tap untuk UIButton, rx.text untuk UITextField, rx.selectedRow untuk UIPickerView. Ini memungkinkan penggantian @IBAction dan delegat dengan subscription deklaratif.

RxSwift dalam Kombinasi dengan MVVM

MVVM (Model-View-ViewModel) adalah pola arsitektur di mana ViewModel mengelola status dan logika bisnis, dan View berlangganan properti reaktif ViewModel. RxSwift sangat cocok dengan MVVM: ViewModel mempublikasikan Observable atau Driver untuk data, View berlangganan melalui bind. ViewModel tidak memiliki referensi ke View — ia mengembalikan Observable yang dikonsumsi View.

class LoginViewModel {
    let email = BehaviorRelay<String>(value: "")
    let password = BehaviorRelay<String>(value: "")

    var isFormValid: Observable<Bool> {
        return Observable
            .combineLatest(email, password) {
                !$0.isEmpty && $0.contains("@") && $1.count >= 6
            }
    }
}

// Di ViewController:
viewModel.isFormValid
    .bind(to: loginButton.rx.isEnabled)
    .disposed(by: disposeBag)

Permintaan jaringan adalah area aplikasi RxSwift kedua yang paling sering. URLSession.rx.response membungkus permintaan HTTP dalam Observable yang mengembalikan (response, data) saat sukses atau error saat gagal. Dalam kombinasi dengan Codable dan operator map, kita mendapatkan lapisan API reaktif yang ringkas: Observable<MyModel> tanpa callback dan penanganan error di setiap metode. Saat error jaringan, operator retry(3) secara otomatis mengulangi permintaan tiga kali dengan penundaan eksponensial.

RxSwift vs Combine

Combine adalah framework native Apple yang diperkenalkan di iOS 13. Ia menyelesaikan tugas yang sama dengan RxSwift: bekerja dengan event asinkron melalui Publisher, Subscriber, dan operator. Namun Combine memiliki perbedaan utama: pengetatan ketat error melalui tipe Failure, dukungan bawaan untuk Swift Concurrency (async/await) dan integrasi dengan SwiftUI melalui @Published dan ObservableObject.

RxSwift unggul dalam kompatibilitas mundur — mendukung iOS 8+, sementara Combine membutuhkan iOS 13+. RxSwift memiliki ekosistem ekstensi pihak ketiga yang lebih kaya (RxDataSources, RxGesture, RxAnimated) dan dokumentasi operator yang mendetail. Untuk proyek yang mendukung versi iOS lama, RxSwift tetap menjadi satu-satunya pilihan.

Untuk proyek baru dengan iOS 13+, Apple merekomendasikan Combine. Ia terintegrasi erat dengan SwiftUI, memiliki ukuran biner lebih kecil dan dukungan resmi. Namun migrasi kode RxSwift yang ada ke Combine memerlukan penulisan ulang semua Observable → Publisher, dan ekosistem RxCocoa tidak memiliki padanan lengkap di Combine — UIKit tidak memiliki Publisher native untuk semua komponen UI.