Memulai dengan RxJava 2 untuk Android

() translation by (you can also view the original English article)

Jika anda seorang pengembang Android, anda mungkin pernah mendengar hal baik tentang RxJava, sebuah implementasi sumber terbuka yang populer dari perpustakaan ReactiveX yang membawa pemrograman reaktif ke Java Virtual Machine (JVM).

RxJava dirancang untuk menghilangkan rasa sakit akibat bekerja dengan arus data asinkron - walaupun seperti yang akan anda lihat, definisi "data" RxJava cukup luas. Karena RxJava itu merupakan perpustakaan yang kompatibel dengan JVM, anda dapat menggunakannya pada berbagai platform, namun dalam rangkaian ini saya akan menunjukkan cara menggunakan RxJava 2 untuk pengembangan Android.

Pada akhir seri ini anda akan menguasai semua hal penting RxJava 2 sehingga anda dapat mulai membuat aplikasi yang sangat reaktif yang dapat memproses berbagai data sinkron dan asinkron-semuanya yang menggunakan kode yang lebih ringkas dan mudah diatur daripada biasanya mampu mencapainya dengan Java saja.

Selain memberikan pendahuluan untuk pendatang baru RxJava, jika anda adalah veteran RxJava 1 yang ingin membuat lompatan ke RxJava 2, maka rangkaian ini akan membantu membuat transisi ini semulus mungkin. Sementara meng-upgrade ke versi terbaru dari sebuah perpustakaan mungkin tidak terdengar seperti masalah besar, RxJava 2 bukanlah update khas anda-ia adalah penulisan ulang RxJava yang lengkap. Dengan begitu banyak perubahan, anda mudah menjadi bingung, jadi meluangkan waktu untuk membiasakan diri dengan RxJava 2 dari perspektif pemula bisa menghemat banyak waktu dan frustrasi dalam jangka panjang.

Dalam posting pertama ini, saya akan meliput apa itu RxJava dan manfaat utamanya yang ia tawarkan bagi pengembang Android. Kita juga akan melihat secara mendalam komponen inti dari berbagai Proyek RxJava: Observers, Observables, dan subscriptions. Pada akhir tutorial ini, anda akan menciptakan aplikasi bergaya "Hello World" sederhana yang mencakup semua komponen inti ini.

Blok bangunan utama RxJava lainnya adalah operator, sehingga pada bagian kedua saya akan mengeksplorasi berbagai cara untuk menggunakan operator untuk mengubah, menggabungkan, memfilter dan memanipulasi data aplikasi anda.

Dalam angsuran terakhir, kita akan bergerak melampaui perpustakaan inti RxJava dan melihat-lihat RxAndroid, keseluruhan perpustakaan yang dikemas dengan semua ekstensi khusus android yang anda perlukan untuk membuka potensi penuh pemrograman reaktif untuk Android.

Kita akan membahasa banyak hal, jadi mari kita mulai dengan hal-hal penting:

Apa itu RxJava?

RxJava adalah perpustakaan yang memungkinkan anda membuat aplikasi dalam gaya pemrograman reaktif. Pada intinya, pemrograman reaktif menyediakan cara pemrosesan dan reaksi yang bersih dan efisien terhadap arus data real-time, termasuk data dengan nilai dinamis.

Aliran data ini belum tentu harus mengambil bentuk tipe data tradisional, karena RxJava cukup banyak memperlakukan semuanya sebagai arus data - mulai dari variabel hingga properti, cache, dan bahkan events masukan pengguna seperti klik dan gesekan.

Data yang dipancarkan oleh setiap aliran dapat berupa nilai, kesalahan, atau sinyal "komplit", walaupun anda tidak perlu menerapkan dua hal terakhir. Setelah membuat aliran pemancar data,anda menggabungkannya dengan objek reaktif yang mengkonsumsi dan kemudian bertindak berdasarkan data ini, melakukan tindakan yang berbeda bergantung pada apa yang telah dipancarkan oleh arus. RxJava meliputi sejumlah operator yang berguna untuk bekerja dengan aliran, sehingga mudah untuk melakukan hal-hal seperti filtering, pemetaan, menunda, penghitungan, dan banyak lagi.

Untuk membuat alur data stream dan objek yang bereaksi terhadapnya, RxJava memperluas pola perancangan perangkat lunak Observer. Intinya, di RxJava, anda miliki objek Observable yang memancarkan aliran data dan kemudian berhenti, dan objek Observer yang berlangganan menjadi Observable. Observer menerima pemberitahuan setiap kali mereka menugaskan Observable memancarkan nilai, kesalahan, atau sinyal yang telah komplit.

Jadi pada tingkat yang sangat tinggi, RxJava adalah tentang:

Membuat Observable.
Memberikan beberapa data Observable untuk dipancarkan.
Membuat Observer.
Menetapkan Observer menjadi Observable.
Memberi tugas Observer untuk melakukan setiap kali menerima emisi dari Observable yang ditugaskan.

Mengapa RxJava?

Belajar teknologi baru membutuhkan waktu dan usaha, dan karena perpustakaan berorientasi data, RxJava tidak selalu menjadi API yang paling mudah untuk diatasi.

Untuk membantu anda memutuskan apakah belajar RxJava layak untuk investasi awal, mari jelajahi beberapa manfaat utama untuk menambahkan perpustakaan RxJava ke proyek Android anda.

Lebih ringkas, kode yang dapat dibaca

Kode yang rumit, verbose dan sulit dibaca adalah selalu kabar buruk. Kode Messy lebih rentan terhadap bug dan inefisiensi lainnya, dan jika ada kesalahan yang terjadi makaanda akan memiliki waktu yang jauh lebih sulit untuk melacak sumber kesalahan ini jika kode anda berantakan.

Bahkan jika proyek anda tidak dibangun tanpa ada kesalahan, kode yang rumit masih bisa kembali menghantui anda-biasanya saat anda memutuskan untuk merilis pembaruan ke aplikasi anda beberapa bulan ke bawah, boot proyek anda, dan segera dihadapkan dengan dinding. kusut, membingungkan kode!

RxJava menyederhanakan kode yang diperlukan untuk menangani data dan events dengan memungkinkan anda mendeskripsikan apa yang ingin anda capai, daripada menulis daftar instruksi untuk aplikasi anda. RxJava juga menyediakan alur kerja standar yang dapat anda gunakan untuk menangani semua data dan events di seluruh aplikasi anda-buatlah Observable, buat Observer, menetapkan observable ke observer, rinsen dan ulangi. Pendekatan formulaik ini membuat kode yang mudah dibaca dan mudah dibaca manusia.

Multithreading Made Easy

Aplikasi android modern harus bisa multi task. Paling tidak, pengguna anda akan berharap untuk dapat terus berinteraksi dengan UI aplikasi anda saat aplikasi anda melakukan beberapa pekerjaan di latar belakang, seperti mengelola koneksi jaringan, mendownload file, atau bermain musik. Masalahnya adalah bahwa Android adalah single-threaded secara default, jadi jika aplikasi anda pernah berhasil multi-task maka anda perlu membuat beberapa thread tambahan.

Di luar kotak, android memang menyediakan sejumlah cara untuk membuat thread tambahan, seperti layanan dan IntentServices, namun tidak satupun dari solusi ini sangat mudah diterapkan, dan mereka dapat dengan cepat menghasilkan kompleks, kode verbose yang rentan terhadap kesalahan.

RxJava bertujuan untuk menghilangkan rasa sakit dari pembuatan aplikasi Android multi-threaded, dengan menyediakan penjadwal dan operator khusus. Ia memberi anda cara mudah untuk menentukan thread dimana pekerjaan harus dilakukan dan thread di mana hasil dari pekerjaan ini harus diposting. RxJava 2.0 mencakup sejumlah penjadwal secara default, termasuk Schedulers.newThread, yang terutama berguna karena menciptakan thread baru.

Untuk mengubah thread tempat di mana pekerjaan dilakukan, anda hanya perlu mengubah tempat observer berlangganan ke observable, dengan menggunakan operator subscribeOn. Sebagai contoh, di sini kita membuat thread baru dan menentukan bahwa pekerjaan harus dilakukan pada thread baru ini:

1	observable.subscribeOn(Schedulers.newThread())

Masalah lama lainnya dengan multithreading di Android adalah anda hanya dapat memperbarui UI aplikasi anda dari untaian utama. Biasanya, kapan pun anda perlu mengeposkan hasil beberapa karya latar ke UI aplikasi anda, anda harus membuat Handler yang berdedikas.

Sekali lagi, RxJava memiliki solusi yang jauh lebih mudah. Anda bisa menggunakan operator observeOn untuk menentukan bahwa Observable harus mengirimkan notifikasinya menggunakan scheduler yang berbeda, yang pada dasarnya memungkinkan anda mengirim data Observable anda ke thread pilihan anda, termasuk thread UI utama.

Ini berarti bahwa dengan hanya dua baris kode, anda dapat membuat thread baru dan mengirim hasil kerja yang dilakukan di thread ini ke thread utama Android:

1	.subscribeOn(Schedulers.newThread())
2	.observeOn(AndroidSchedulers.mainThread())

Baiklah, secara teknis kita curang sedikit disini, karena AndroidSchedulers.mainThread hanya tersedia sebagai bagian dari perpustakaan RxAndroid, yang tidak akan kita lihat sampai bagian tiga. Namun, contoh ini memang memberi anda sekilas kekuatan RxJava dan RxAndroid untuk menyederhanakan area pengembangan Android yang dikenal terlalu rumit.

Peningkatan Fleksibilitas

Observables memancarkan data mereka dengan cara yang sepenuhnya menyembunyikan cara data dibuat. Karena observers anda bahkan tidak dapat melihat bagaimana data dibuat, anda bebas untuk menerapkannya Observables anda dengan cara apapun yang anda inginkan.

Setelah anda menerapkan Observables anda, RxJava menyediakan operator dalam jumlah besar yang dapat anda gunakan untuk menyaring, menggabungkan dan mengubah data yang sedang dipancarkan oleh Observables. Anda bahkan bisa menjerumuskan lebih dan lebih banyak operator bersamaan sampai anda menciptakan aliran data yang tepat dibutuhkan aplikasi anda.

Misalnya, anda dapat menggabungkan data dari beberapa aliran, memfilter arus yang baru digabungkan, lalu menggunakan data yang dihasilkan sebagai masukan untuk arus data berikutnya. Dan ingat bahwa di RxJava, hampir semua hal diperlakukan sebagai aliran data, jadi anda bahkan dapat menerapkan operator ini ke "data" non-tradisional, seperti events klik.

Membuat Aplikasi yang Lebih Responsif

Gone adalah hari-hari ketika sebuah aplikasi bisa lolos dengan memuat halaman konten dan kemudian menunggu pengguna untuk mengetuk tombol Berikutnya. Saat ini, aplikasi seluler khas anda harus dapat bereaksi terhadap berbagai peristiwa dan data yang terus berkembang, idealnya secara real time. Misalnya, aplikasi jejaring sosial khas anda harus terus mendengarkan keinginan masuk, komentar, dan permintaan pertemanan, sambil mengelola koneksi jaringan di latar belakang dan merespon segera kapan pun pengguna mengetuk atau menggesek layar.

Perpustakaan RxJava dirancang untuk dapat mengelola berbagai data dan events secara bersamaan dan secara real time, menjadikannya alat yang ampuh untuk menciptakan jenis aplikasi yang sangat responsif yang diharapkan oleh pengguna ponsel modern.

Menambahkan RxJava ke Android Studio

Jika anda telah memutuskan bahwa RxJava memang memiliki sesuatu untuk ditawarkan pada praktik pengembangan Android anda, maka langkah pertama untuk menjadi master RxJava adalah menambahkan perpustakaan ke proyek anda.

Buat proyek Android Studio baru dengan pengaturan pilihan anda, dan kemudian buka file module-level build.gradle dan tambahkan versi terbaru dari io.reactivex.rxjava2:rxjava sebagai ketergantungan.

Pada saat penulisan, RxJava 2.0.5 merupakan rilis terbaru, jadi file build.gradle saya terlihat seperti ini:

dependencies {
  compile fileTree(dir: 'libs', include: ['*.jar'])

  androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
      exclude group: 'com.android.support', module: 'support-annotations'
  })

  compile 'com.android.support:appcompat-v7:25.1.0'
  testCompile 'junit:junit:4.12'

  compile 'io.reactivex.rxjava2:rxjava:2.0.5'
}

Saat diminta, klik Sync sekarang.

Selanjutnya, buka file MainActivity anda dan tambahkan impor yang anda perlukan untuk mulai bekerja dengan fitur inti RxJava:

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;

Jika anda bermigrasi dari RxJava 1, maka impor ini tidak mungkin bukan yang anda harapkan, karena RxJava 1 menggunakan nama paket yang sama sekali berbeda (rx tepatnya).

Namun, ini bukan perubahan nama yang sewenang-wenang: nama paket yang berbeda memberi anda pilihan untuk menggunakan RxJava 1 dan RxJava 2 berdampingan dalam proyek yang sama. Jika anda setengah jalan melalui proyek yang menggunakan RxJava 1, anda dapat menambahkan perpustakaan RxJava 2 dan mulai menggunakan fitur 2 yang diperbarui dengan segera, tanpa melanggar kode RxJava 1 anda.

Jika anda memulai perjalanan RxJava anda dengan versi 2, maka perlu disadari bahwa jika anda menemukan tutorial atau kode RxJava menggunakan nama paket rx, maka ini adalah kode RxJava 1 dan sepertinya tidak kompatibel dengan library versi 2.

Building Blocks RxJava

Sejauh ini, kita hanya melihat RxJava pada tingkat yang sangat tinggi. Sudah waktunya untuk lebih spesifik dan melihat secara mendalam dua komponen terpenting yang akan muncul berkali-kali selama pekerjaan RxJava anda: Observers dan Observables.

Pada akhir bagian ini, anda tidak hanya akan memiliki pemahaman yang solid tentang kedua komponen inti ini, namun anda akan berhasil menciptakan aplikasi yang berfungsi penuh yang terdiri dari sebuah Observable yang memancarkan data dan observer yang bereaksi terhadap emisi ini.

Membuat `Observable`

Observable mirip dengan Iterable dalam hal itu, diberi urutan, ia akan iterate melalui urutan itu dan memancarkan setiap item, walaupun Observables biasanya tidak mulai memancarkan data sampai Observer berlangganan pada mereka.

Setiap kali Observable memancarkan item, ia memberi tahu Observer yang ditugaskan menggunakan metode onNext(). Saat Observable telah mentransmisikan semua nilainya, ia berakhir dengan memanggil:

onComplete: Disebut jika operasi itu sukses.
onError: Disebut jika Pengecualian dilemparkan

Mari kita lihat sebuah contoh. Di sini, kita menciptakan sebuah Observable yang memancarkan angka 1, 2, 3 dan 4, dan kemudian berakhir.

Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
  @Override

  public void subscribe(ObservableEmitter<Integer> e) throws Exception {
      //Use onNext to emit each item in the stream//
      e.onNext(1);
      e.onNext(2);
      e.onNext(3);
      e.onNext(4);

      //Once the Observable has emitted all items in the sequence, call onComplete//
      e.onComplete();
  }
 }
);

Perhatikan bahwa dalam contoh ini saya menguraikan dengan tepat apa yang terjadi, jadi jangan biarkan jumlah kode membuat anda pergi! Hal ini memungkinkan lebih banyak kode daripada yang biasa anda gunakan untuk membuat Observables dalam proyek-proyek RxJava kehidupan nyata anda.

Buat Pengamat

Observers adalah objek yang anda tetapkan untuk Observable, menggunakan subscribe() operator. Saat Observer berlangganan ke Observable, itu akan bereaksi setiap kali nya Observer memancarkan salah satu dari berikut ini:

onNext: Observable telah memancarkan nilai
onError: Sebuah kesalahan telah terjadi.
onComplete: Observable telah selesai memancarkan semua nilainya.

Mari buat sebuah Observer yang berlangganan ke Observable 1, 2, 3, 4 kita. Untuk membantu menjaga hal-hal sederhana, Observer akan bereaksi terhadap onNext, onError dan onComplete dengan mencetak pesan ke Android Studio Logcat Monitor:

Observer<Integer> observer = new Observer<Integer>() {
  @Override
  public void onSubscribe(Disposable d) {
      Log.e(TAG, "onSubscribe: ");
  }

  @Override
  public void onNext(Integer value) {
      Log.e(TAG, "onNext: " + value);
  }

  @Override
  public void onError(Throwable e) {
      Log.e(TAG, "onError: ");
  }

  @Override
  public void onComplete() {
      Log.e(TAG, "onComplete: All Done!");
  }
};

//Create our subscription//
observable.subscribe(observer);

Buka Monitor Logcat Android Studio dengan memilih tab Android Monitor dari bagian bawah jendela Android Studio (tempat kursor diposisikan di tangkapan layar di bawah) dan kemudian pilih Logcat tab.

Untuk menguji kode ini, lampirkan perangkat Android fisik anda ke mesin pengembangan anda atau jalankan proyek anda di AVD yang kompatibel. Begitu aplikasi anda muncul di layar, anda harus melihat data yang dipancarkan oleh Observable anda.

Reactive Programming Observer Observable

Menciptakan Observable dengan Kode Less

Meskipun proyek kami memancarkan data dengan sukses, kode yang kami gunakan tidak begitu ringkas - terutama kode yang kami gunakan untuk membuat Observable kita.

Syukurlah, RxJava menyediakan sejumlah metode kenyamanan yang memungkinkan anda untuk membuat Observable menggunakan kode Less.

1. Observable.just()

Anda bisa menggunakan operator .just() untuk mengubah objek menjadi Observable. Hasil Observable kemudian akan memancarkan objek asli dan selesai.

Sebagai contoh, di sini kita menciptakan sebuah Observable yang akan memancarkan satu senar ke semua Observers:

1	Observable<String> observable = Observable.just("Hello World!");

2. `Observable.from()`

Operator .from() memungkinkan anda mengubah kumpulan objek menjadi aliran yang dapat diamati. Anda dapat mengubah sebuah array menjadi Observable menggunakan Observable.fromArray, a Callable menjadi Observable menggunakan Observable.fromCallable, dan Iterable menjadi Observable menggunakan Observable.fromIterable.

3. `Observable.range()`

Anda bisa menggunakan operator .range() untuk memancarkan berbagai bilangan bulat berurutan. Inti pertama yang anda berikan adalah nilai awal, dan yang kedua adalah jumlah bilangan bulat yang ingin anda pancarkan. Sebagai contoh:

1	Observable<Integer> observable = Observable.range(0, 5);

4. `Observable.interval()`

Operator ini menciptakan sebuah Observable yang memancarkan urutan tak berhingga bilangan bulat naik, dengan setiap emisi dipisahkan oleh interval waktu yang dipilih oleh anda. Sebagai contoh:

1	Observable<Long> observable = Observable.interval(1, TimeUnit.SECONDS)

5. `Observable.empty()`

Operator empty() menciptakan sebuah Observable yang tidak memancarkan item tapi berakhir secara normal, yang bisa berguna bila anda perlu membuat sebuah Observable untuk tujuan pengujian.

1	Observable<String> observable = Observable.empty();

Kesimpulan

Pada artikel ini, kita membahas blok bangunan dasar RxJava.

Pada titik ini, anda tahu cara membuat dan bekerja dengan Observers dan Observables, dan cara membuat langganan sehingga Observables anda bisa mulai memancarkan data. Kita juga sempat melihat beberapa operator yang memungkinkan anda untuk membuat berbagai macam Observables yang berbeda menggunakan kode Less.

Namun, operator bukan hanya cara praktis untuk mengurangi jumlah kode yang perlu anda tulis! Membuat Observer dan Observable cukup sederhana, tapi operator adalah tempat anda benar-benar mulai melihat apa yang mungkin dilakukan dengan RxJava.

Jadi di posting selanjutnya, kita akan menjajaki beberapa operator RxJava yang paling kuat, termasuk operator yang akhirnya bisa membuat multithreading di android menjadi pengalaman bebas rasa sakit. Nantikan untuk belajar kekuatan nyata perpustakaan RxJava.

Sementara itu, lihat beberapa tulisan dan kursus kami yang lain tentang pengembangan Android di sini, di Envato Tuts+!