In questo articolo spiegherò le basi di RxJava attraverso degli esempi. Questo articolo è per i principianti di RxJava. D’altra parte, se sai già qualcosa su RxJava, questo articolo è buono per rivedere le tue conoscenze.

RxJava è un’implementazione Java VM di ReactiveX una libreria per comporre programmi asincroni e basati su eventi usando sequenze osservabili.

I componenti di RxJava sono Observables e Subscribers. Observable è usato per emettere elementi e Subscriber è usato per consumare quegli elementi. Forse alcuni di voi penseranno: “Hmmm questo è così simile al pattern standard Observable”. E sì, lo è, ma RxJava lo fa molto meglio e ha più opzioni. Per esempio, gli Observable spesso non iniziano ad emettere elementi finché qualcuno non si iscrive a loro. Questa è una grande caratteristica perché in questo modo dovresti salvare le tue prestazioni.

RxJava funziona così. Subscriber si iscrive a Observable, poi Observable chiama Subscriber.onNext() per qualsiasi numero di elementi, se qualcosa va storto ecco Subsciber.onError() e se tutto finisce bene, ecco Subscriber.onCompleted(). Vedi che è facile!

Stai zitto! Dammi dei codici fantasiosi!

Esempio 1

In questo esempio creeremo Observable e Subscriber di base, e poi li collegheremo, e vedremo cosa succederà. Allarme spoiler! Qualcosa di fantastico…

Creiamo un osservabile di base:

L’osservabile creato emette la stringa “Blue Factory” e poi completa. La stringa “Blue Factory” sarà ricevuta dal metodo Subscribers onNext(). Ora creiamo Subscriber.

Subscriber riceve il valore della stringa sul metodo onNext() e lo stampa, inoltre la stringa “Ho finito” viene stampata quando viene chiamato il metodo onCompleted().

Ora collegali.

Risultato:

I/System.out: Blue Factory

I/System.out: Ho finito

Quando la sottoscrizione avviene, myObservable chiama i metodi mySubscription onNext() e onComplited(). I risultati sono gli output “Blue factory” e “I’m done”, dopo di che tutto si ferma e termina.

Posso farlo più semplice?

Certo! Puoi farlo!

Potresti notare che una creazione di myObservable ha troppo codice e sembra disordinata. RxJava ci dà alcune scorciatoie fantasiose.

Alcune di queste scorciatoie sono metodi come Observable.just() e Observable.from();

Observable.just() emette solo un singolo elemento e Observable.from() emette un elemento per uno dalla lista degli elementi.

Stai zitto! Dammi un po’ di codice fantasioso!

Esempio 2

In questo esempio faremo la stessa cosa dell’Esempio 1, ma ora con meno codice.

Creiamo il nostro nuovo osservabile fantasioso e bello:

Wow! Sembra che il nostro Observable abbia perso un po’ di peso!
Creiamo Subscriber:

Subscriber è uguale!
Ora collegali, e aspetta che la magia accada!

Risultato:

I/System.out: Blue Factory
I/System.out: Ho finito

Come vedete, riusciamo a completare il nostro compito, e a fare esattamente la stessa cosa con meno codice.
Stai zitto! Dammi un po’ di codice fantasioso!

Esempio 3

In questo esempio faremo qualcosa di leggermente diverso con Observable.from(). L’idea è quella di stampare le stringhe “Blue”, “Factory”, “Blog”, “Post”.
Ricordiamoci cos’è Observable.from(). Observable.from() riceve la lista degli elementi ed emette un elemento alla volta, quindi Observable.from() è esattamente ciò di cui abbiamo bisogno!
Prima creeremo ArrayList con Stringhe:

Creiamo l’Observable.from(), che ne dite?

Come potete vedere, Observable.from() riceve come argomento ArrayList carica di stringhe. Ora, creiamo Subscriber e colleghiamoli, e aspettiamo la magia.

Risultato:

I/System.out: Blu
I/System.out: Factory
I/System.out: Blog
I/System.out: Post

Come vedete, abbiamo di nuovo svolto con successo il nostro compito!
Tutto quello che avete imparato fino ad ora sono puri trucchi di base, ma ora faremo qualche trucco più “difficile”!

Cosa sono gli Operatori in Rx?

Gli Operatori sono metodi creati per risolvere le trasformazioni e gestire i problemi delle chiamate API. Vi mostrerò un semplice esempio di trasformazione con Map, e forse in qualche altro articolo esempi di gestione delle chiamate API con Retrofit, RxJava su pattern architettonico MVP.

Per esempio appendiamo la nostra stringa “Blue Factory” con “Blog Post”. Possiamo farlo in diversi modi.

Primo modo:

Possiamo farlo in Observable, ma Observable è supposto per emettere elementi, non per cambiarli.
Secondo modo:

Stessa storia, Subscriber non doveva cambiare gli elementi. Operator è un passo aggiuntivo tra Observable e Subscriber, dove l’oggetto può essere trasformato.
Allora facciamolo nel modo giusto!
Stai zitto! Dammi un po’ di codice fantasioso!

Esempio 4

Prima creiamo Observable:

Nota che myObservable emette solo un oggetto invariato.
Ora creiamo Operator, per questo esempio la soluzione migliore è usare Map operator. L’operatore Map può trasformare il nostro oggetto in un modo che ci piace e restituirlo a Subscriber.

Nella chiamata degli operatori (String s) viene fatta la trasformazione della Stringa “Blue Factory”.
Ecco il Sottoscrittore:

Risultato:

I/System.out: Blue Factory Blog Post

Questo esempio rappresenta una piccola frazione di ciò che gli operatori possono fare. Per esempio, l’operatore Map può essere impilato più volte come nell’esempio qui sotto:
Stai zitto! Dammi un po’ di codice fantastico!

Esempio 5

Gli operatori possono anche cambiare il tipo di elemento emesso come nell’esempio seguente:
Stai zitto! Dammi un po’ di codice fantastico!

Esempio 6

In questo esempio Observable emetterà la stringa “5” e l’Operatore la trasformerà nell’intero 5. Creiamo Observable.

Notare che il tipo myObservable è Observable e Observable emette String.
Creiamo l’operatore Map!

Notare che il metodo Map operator call(String s) riceve String e ritorna Integer.
Creiamo Subscriber e colleghiamoli.

Il tipo Subscriber è lo stesso del tipo Observable, e gli operatori che ritornano (Integer).
Qui vi mostro solo una piccola parte del quadro. Con gli operatori potete fare tutto ciò che volete! E la parte migliore è che RxJava ha un’abbondanza di diversi operatori. Qui potete controllare tutti gli operatori: https://github.com/ReactiveX/RxJava/wiki/Alphabetical-List-of-Observable-Operators.

In conclusione gli operatori sono potenti per la trasformazione degli oggetti e la lucidatura dei dati, e dopo tutto questo, il tuo codice sarà bello e pulito!

Cosa posso fare con RXJava?

Puoi fare tutto quello che vuoi perché il tuo Observable può essere tutto, può essere: Stringa, Intero, chiamata API, click, ecc. Man mano che progredisci come sviluppatore Android userai RxJava soprattutto per le chiamate API e per i widget Android. RxJava fornisce una facile gestione delle API, perché non c’è bisogno di preoccuparsi del threading e si possono concatenare alcune richieste e ottenere il risultato su un singolo Sottoscrittore. Con RxJava è possibile gestire il comportamento di alcuni widget, ad esempio cosa farà il widget dopo essere stato premuto cinque volte, oppure è possibile creare Observable che emette una stringa ogni 4 secondi dall’input EditText, e molte altre cose fantasiose. Spero che questo articolo vi dia le basi di RxJava e spero che continuerete ad esplorare RxJava in futuro.