Penjelasan Reactive programming

Reactive programming atau pemrograman reaktif adalah suatu model algoritma pemrograman dengan melihat data sebagai aliran yang dapat diproses. Pada umumnya, data tersebut berupa list. Pemrograman reaktif disebut juga pemrograman bergaya deklaratif. Anda mungkin pernah melihat gambar ini dalam library RxJava

Tapi apakah Anda paham gambar di atas?[2] Konsep ini memang sulit dipahami tanpa dicoba langsung dengan kode. Untuk mempermudah pemahaman Anda, saya akan mencobakannya langsung dengan bahasa Java dan Kotlin.

Misalkan Anda punya sebuah list CharSequence dengan elemen sebagai berikut:

" Meja "
"Kursi    "
"Nama: Budi"
null
"Android OS"
"Tahun: 1974"
"18 meter"

Anda ingin melakukan hal ini pada list tersebut:

Mengambil semua elemen yang tidak berisi nilai null.

Mengubah elemen tersebut menjadi String

Membersihkan semua spasi putih untuk merapikan teks.

Mengambil teks yang hanya berisi tanda titik dua (:).

Menjadikan semua huruf uppercase.

Anda dapat menciptakan algoritma berikut untuk melakukan hal tersebut:

List<CharSequence> list = ...
List<String> newList = new ArrayList<>();
for (CharSequence text : list) {
 if (text != null) {
  String s = text.toString().trim();
  if (s.contains(":")) {
   newList.add(s.toUpperCase());
  }
 }
}

Kodenya lumayan panjang, bukan? Sekarang mari kita coba dengan fitur pemrograman reaktif yang tersedia pada library Kotlin.

val list = ...
val newList = list.filter { it != null }
    .map { it.toString().trim() }
    .filter { it.contains(":") }
    .map { it.toUpperCase() }

Bagaimana? Simpel bukan? 10 baris vs 5 baris kode. Menurut saya kode kedua lebih mudah dibaca. Nah, cara saya memperlakukan data yang ada dalam list tersebut adalah contoh kecil pemrograman reaktif.

Kode Kotlin tersebut memang kelihatan simpel. Tapi bagaimana kalau kita tulis dalam Java 7? Perhatikan kode berikut:

List<String> newList = Observable.fromIterable(list)
        .filter(new Predicate<CharSequence>() {
            @Override
   public boolean test(CharSequence text) throws Throwable {
                return text != null;
   }
        })
        .map(new Function<CharSequence, String>() {
            @Override
   public String apply(CharSequence text) throws Throwable {
                return text.toString().trim();
   }
        })
        .filter(new Predicate<String>() {
            @Override
   public boolean test(String o) throws Throwable {
                return o.contains(":");
   }
        })
        .map(new Function<String, String>() {
            @Override
   public String apply(String o) throws Throwable {
                return o.toUpperCase();
            }
        })
        .toList()
        .blockingGet();

Kodenya menjadi panjang dan menggila. Sekarang mari kita convert ke Java 8:

List<String> newList = Observable.fromIterable(list)
        .filter(text -> text != null)
        .map(text -> text.toString().trim())
        .filter(o -> o.contains(":"))
        .map(String::toUpperCase)
        .toList()
        .blockingGet();

Hmm… Masih bisa diterima lah. Anda sekarang tahu bahwa pemrograman reaktif paling cocok untuk bahasa pemrograman yang sudah mendukung lambda expression, misalnya Kotlin, Javascript, dan Java 8+.

Inilah contoh lain dari pemrograman reaktif.

---

Kesimpulan

Pemrograman reaktif memang powerful. Kita tidak hanya bisa memanipulasi sebuah data, namun juga bisa memilih di thread mana data tersebut akan dimanipulasi dan ke thread mana data tersebut akan dikirim. Thread yang bekerja dalam operasi reaktif juga bisa dihentikan di tengah jalan. Anda akan tahu betapa luar biasanya faedah pemrograman reaktif jika pernah melakukan operasi yang bersifat blocking, seperti pengambilan data dari internet.

Penulusuran terkait:

reactive programming android

belajar reactive programming

reactive programming android tutorial

reactive programming java

apa itu reactive

rxjava tutorial indonesia

belajar rxandroid

medium rxjava android

Share this post