Inizia con RxJava 2 per Android

Se sei uno sviluppatore Android, allora potresti avere sentito parlare di RxJava, una popolare implementazione open-source della libreria ReactiveX che porta la programmazione reattiva alla Java Virtual Machine (JVM).

RxJava è progettato per eliminare la fatica di lavorare con flussi di dati asincroni, sebbene, come vedrete, la definizione di "dati" di RxJava sia piuttosto ampia. Poiché RxJava è una libreria compatibile con JVM, puoi usarlo su una vasta gamma di piattaforme, ma in questa serie ti mostrerò come utilizzare RxJava 2 per lo sviluppo Android.

Entro la fine di questa serie avrai padronanza di tutti gli elementi essenziali di RxJava 2 in modo da poter iniziare a creare app altamente reattive in grado di elaborare una vasta gamma di dati sincroni e asincroni, il tutto usando un codice più conciso e gestibile di quanto non sia in genere in grado di raggiungere solo con Java.

Oltre a fornire un'introduzione ai nuovi arrivati ​​RxJava, se sei un veterano di RxJava 1 che sta cercando di fare il salto a RxJava 2, questa serie contribuirà a rendere questa transizione il più agevole possibile. Mentre l'aggiornamento alla versione più recente di una libreria potrebbe non sembrare un grosso problema, RxJava 2 non è il tipico aggiornamento, è una completa riscrittura di RxJava. Con così tanti cambiamenti è facile confondersi, quindi prendersi un po 'di tempo per familiarizzare con RxJava 2 dalla prospettiva di un principiante potrebbe farti risparmiare un sacco di tempo e frustrazione a lungo andare.

In questo primo post, parlerò di ciò che RxJava è e dei principali vantaggi che offre agli sviluppatori Android. Daremo inoltre uno sguardo approfondito ai componenti principali di qualunque Progetto RxJava: Gli osservatori, osservabili, e iscrizioni. Alla fine di questo tutorial, avrai creato una semplice applicazione in stile "Hello World" che include tutti questi componenti principali.

Gli altri principali elementi costitutivi di RxJava sono gli operatori, quindi nella seconda parte esplorerò i diversi modi in cui è possibile utilizzare gli operatori per trasformare, combinare, filtrare e manipolare i dati dell'applicazione.

Nell'ultima puntata, andremo oltre la libreria RxJava di base e daremo un'occhiata a RxAndroid, un'intera libreria piena di tutte le estensioni specifiche di Android che ti serviranno per sbloccare tutto il potenziale della programmazione reattiva per Android.

Abbiamo un sacco da coprire, quindi iniziamo con l'essenziale:

Che cos'è RxJava, comunque?

RxJava è una libreria che ti consente di creare applicazioni nello stile di programmazione reattivo. Al suo interno, la programmazione reattiva fornisce un modo pulito ed efficiente di elaborare e reagire a flussi di dati in tempo reale, compresi i dati con valori dinamici.

Questi flussi di dati non necessariamente avere per assumere la forma di tipi di dati tradizionali, dato che RxJava praticamente considera tutto come un flusso di dati: tutto, dalle variabili alle proprietà, alle cache e persino agli eventi di input dell'utente come i clic e gli swip.

I dati emessi da ogni stream possono essere un valore, un errore o un segnale "completato", sebbene non sia necessario implementare gli ultimi due. Una volta creati i flussi che emettono i dati, li combini con oggetti reattivi che consumano e quindi agiscono su questi dati, eseguendo azioni diverse a seconda di ciò che il flusso ha emesso. RxJava include un sacco di utili operatori per lavorare con i flussi, rendendo facile fare cose come il filtraggio, la mappatura, il ritardo, il conteggio e molto altro.

Per creare questo flusso di lavoro di flussi di dati e oggetti che reagiscono ad essi, RxJava estende il modello di progettazione del software Observer. Essenzialmente, in RxJava hai Osservabile oggetti che emettono un flusso di dati e quindi terminano, e Osservatore oggetti che si iscrivono a OsservabileS. Un Osservatore riceve una notifica ogni volta che viene loro assegnato Osservabile emette un valore, un errore o un segnale completato.

Quindi ad un livello molto alto, RxJava è tutto su:

• Creare un Osservabile.
• Dando questo Osservabile alcuni dati da emettere.
• Creare un Osservatore.
• Assegnare il Osservatore ad Osservabile.
• Dare il Osservatore compiti da eseguire ogni volta che riceve un'emissione dal suo assegnato Osservabile.

Perché RxJava?

L'apprendimento di qualsiasi nuova tecnologia richiede tempo e fatica e, come libreria orientata ai dati, RxJava non è sempre l'API più semplice da apprendere.

Per aiutarti a decidere se l'apprendimento di RxJava vale l'investimento iniziale, esploriamo alcuni dei principali vantaggi dell'aggiunta della libreria RxJava ai tuoi progetti Android.

Codice più conciso e leggibile

Il codice è complesso, prolisso e difficile da leggere sempre cattive notizie. Il codice di messy è più incline a bug e altre inefficienze e, se si verificano errori, avrai un tempo molto più difficile rintracciare la fonte di questi errori se il tuo codice è un pasticcio.

Anche se il tuo progetto si costruisce senza errori, il codice complesso può ancora tornare a perseguitarti, tipicamente quando decidi di rilasciare un aggiornamento alla tua app qualche mese dopo la linea, avvia il tuo progetto e immediatamente si confrontano con un muro di codice confuso e confuso!

RxJava semplifica il codice necessario per gestire i dati e gli eventi, consentendo di descrivere ciò che si desidera ottenere, piuttosto che scrivere un elenco di istruzioni per l'elaborazione della propria app. RxJava fornisce anche un flusso di lavoro standard che è possibile utilizzare per gestire tutti i dati e gli eventi nell'applicazione: creare un Osservabile, creare un Osservatore, assegna l'osservabile a quell'osservatore, risciacqua e ripeti. Questo approccio formulato rende il codice molto semplice e leggibile dall'uomo.

Multithreading Made Easy

Le moderne applicazioni Android devono essere in grado di eseguire più operazioni. Per lo meno, i tuoi utenti si aspettano di poter continuare a interagire con l'interfaccia utente della tua app mentre la tua applicazione sta lavorando in background, come la gestione di una connessione di rete, il download di un file o la riproduzione di musica. Il problema è che Android è a thread singolo per impostazione predefinita, quindi se la tua app andrà in multitasking con successo allora dovrai creare dei thread aggiuntivi.

Fin dall'inizio, Android fornisce una serie di modi per creare thread aggiuntivi, come servizi e IntentServices, ma nessuna di queste soluzioni è particolarmente facile da implementare e può rapidamente generare un codice complesso e dettagliato, soggetto a errori.

RxJava si propone di eliminare la fatica di creare app Android multi-thread, fornendo programmatori e operatori speciali. Questi ti forniscono un modo semplice per specificare il thread in cui il lavoro deve essere eseguito e il thread in cui devono essere pubblicati i risultati di questo lavoro. RxJava 2.0 include un certo numero di programmatori per impostazione predefinita, inclusi Schedulers.newThread, che è particolarmente utile in quanto crea un nuovo thread.

Per cambiare il thread in cui viene eseguito il lavoro, è sufficiente modificare il punto in cui un osservatore si iscrive a un osservabile, utilizzando il comando subscribeOn operatore. Ad esempio, qui stiamo creando un nuovo thread e specificando che il lavoro deve essere eseguito su questo nuovo thread:  

observable.subscribeOn (Schedulers.newThread ())

Un altro problema di vecchia data con il multithreading su Android è che puoi aggiornare l'interfaccia utente della tua app solo dal thread principale. In genere, ogni volta che devi pubblicare i risultati di alcuni lavori in background sull'interfaccia utente della tua app, devi creare un dedicato handler.

Ancora una volta, RxJava ha una soluzione molto più semplice. Puoi usare il observeOn operatore per specificare che un Observable dovrebbe inviare le sue notifiche usando un diverso schedulatore, che essenzialmente ti permette di inviare i dati del tuo Observable al thread di tua scelta, incluso il thread principale dell'interfaccia utente.

Ciò significa che con solo due righe di codice, puoi creare un nuovo thread e inviare i risultati del lavoro eseguito su questo thread al thread dell'interfaccia utente principale di Android:

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

Ok, allora tecnicamente stiamo barando un po 'qui, come AndroidSchedulers.mainThread è disponibile solo come parte della libreria RxAndroid, che non guarderemo fino alla terza parte. Tuttavia, questo esempio ti dà un'idea della potenza di RxJava e di RxAndroid per semplificare un'area di sviluppo Android nota per essere eccessivamente complicata.

Maggiore flessibilità

Gli osservabili emettono i loro dati in un modo che nasconde completamente il modo in cui i dati sono stati creati. Dal momento che i tuoi osservatori non riescono nemmeno a vedere come sono stati creati i dati, sei libero di implementare il tuo Osservabiles in qualsiasi modo tu voglia.

Una volta implementato il tuo Osservabiles, RxJava offre una vasta gamma di operatori che puoi usare per filtrare, unire e trasformare i dati che vengono emessi da questi OsservabileS. Puoi anche concatenare sempre più operatori fino a quando non li hai creati Esattamente il flusso di dati di cui l'applicazione ha bisogno. 

Ad esempio, è possibile combinare dati da più flussi, filtrare il flusso appena unito e quindi utilizzare i dati risultanti come input per un flusso di dati successivo. E ricorda che in RxJava praticamente tutto viene trattato come un flusso di dati, quindi puoi persino applicare questi operatori a "dati" non tradizionali, come ad esempio eventi di clic. 

Crea più app reattive

Sono finiti i giorni in cui un'app poteva cavarsela con il caricamento di una pagina di contenuti e quindi aspettare che l'utente toccasse il Il prossimo pulsante. Oggi, la tua tipica app mobile deve essere in grado di reagire a una varietà sempre crescente di eventi e dati, idealmente in tempo reale. Ad esempio, la tua tipica app di social networking deve essere costantemente in ascolto di Mi piace in arrivo, commenti e richieste di amicizia, mentre gestisci una connessione di rete in background e risponde immediatamente ogni volta che l'utente tocca o fa scorrere lo schermo.

La libreria RxJava è stata progettata per essere in grado di gestire una vasta gamma di dati ed eventi contemporaneamente e in tempo reale, rendendolo un potente strumento per creare il tipo di applicazioni altamente reattive che i moderni utenti di dispositivi mobili si aspettano.

Aggiunta di RxJava ad Android Studio

Se hai deciso che RxJava ha qualcosa da offrire nella tua pratica di sviluppo Android, il primo passo per diventare un master RxJava è aggiungere la libreria al tuo progetto.

Crea un nuovo progetto Android Studio con le impostazioni di tua scelta, quindi apri il tuo livello di modulo build.gradle file e aggiungere l'ultima versione di io.reactivex.rxjava2: rxjava come dipendenza. 

Al momento della scrittura, RxJava 2.0.5 era la versione più recente, quindi la mia build.gradle il file assomiglia a questo:

dependencies compile fileTree (dir: 'libs', include: ['* .jar']) androidTestCompile ('com.android.support.test.espresso: espresso-core: 2.2.2', esclude il gruppo: 'com. android.support ', module:' support-annotations ') compila' com.android.support:appcompat-v7:25.1.0 'testCompile' junit: junit: 4.12 'compile' io.reactivex.rxjava2: rxjava: 2.0. 5 '

Quando richiesto, fare clic Sincronizza ora.

Quindi, apri il tuo Attività principale file e aggiungi le importazioni che ti serviranno per iniziare a lavorare con le funzionalità principali di RxJava:

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

Se stai migrando da RxJava 1, allora queste importazioni potrebbero non essere quelle che ti aspettavi, poiché RxJava 1 usava un nome di pacchetto completamente diverso (rx per essere precisi).

Tuttavia, questo non è un cambio di nome arbitrario: i diversi nomi di pacchetti ti danno la possibilità di usare RxJava 1 e RxJava 2 fianco a fianco nello stesso progetto. Se sei a metà di un progetto che utilizza RxJava 1, puoi aggiungere la libreria RxJava 2 e iniziare a utilizzare immediatamente le funzionalità aggiornate 2, senza interrompere il codice RxJava 1.

Se stai iniziando il tuo viaggio RxJava con la versione 2, tieni presente che se incontri qualche tutorial o codice RxJava usando il rx nome del pacchetto, quindi questo è il codice RxJava 1 ed è improbabile che sia compatibile con la libreria della versione 2.

The Building Blocks of RxJava

Finora, abbiamo solo guardato RxJava ad un livello molto alto. È ora di diventare più specifici e dare uno sguardo approfondito a due dei componenti più importanti che si ripeteranno più e più volte durante il tuo lavoro RxJava: Osservatores e OsservabileS.

Alla fine di questa sezione, non solo avrete una solida conoscenza di questi due componenti principali, ma avrete creato un'applicazione completamente funzionante composta da Osservabile che emette dati e un Osservatore che reagisce a queste emissioni.

Creare un Osservabile

Un Osservabile è simile a un iterable in questo, data una sequenza, itererà attraverso quella sequenza ed emetterà ogni oggetto, anche se OsservabileIn genere, non iniziare l'emissione di dati fino a quando Osservatore si abbona a loro.

Ogni volta un Osservabile emette un oggetto, ne notifica l'assegnazione Osservatore usando il onNext () metodo. Una volta un Osservabile ha trasmesso tutti i suoi valori, termina chiamando o:

• onComplete: Chiamato se l'operazione è stata un successo.
• onError: Chiamato se un Eccezione è stato gettato.

Diamo un'occhiata a un esempio. Qui, stiamo creando un Observable che emette i numeri 1, 2, 3 e 4, e quindi termina.

Osservabile observable = Observable.create (new ObservableOnSubscribe() @Override public void subscribe (ObservableEmitter e) genera l'eccezione // Use onNext per emettere ogni elemento nello stream // e.onNext (1); e.onNext (2); e.onNext (3); e.onNext (4); // Una volta che l'Observable ha emesso tutti gli elementi nella sequenza, chiama suComplete // e.onComplete (); );

Nota che in questo esempio sto spiegando esattamente cosa sta succedendo, quindi non lasciare che la quantità di codice ti scoraggi! Questo è molto più codice di quello che userai normalmente per creare Osservabiles nei tuoi progetti RxJava nella vita reale.

Crea un osservatore

Osservatores sono oggetti che tu assegni a un Osservabile, usando il sottoscrivi() operatore. Una volta un Osservatore è iscritto a un Osservabile, reagirà ogni volta che è Osservatore emette uno dei seguenti:

• onNext: Il Osservabile ha emesso un valore.
• onError: C'è stato un errore.
• onComplete: Il Osservabile ha finito di emettere tutti i suoi valori.

Creiamo un Osservatore questo è abbonato al nostro 1, 2, 3, 4 Osservabile. Per aiutare a mantenere le cose semplici, questo Osservatore reagirà a onNext, onError e onComplete stampando un messaggio su Android Studio Logcat Monitor:

Osservatore osservatore = nuovo osservatore() @Override public void onSubscribe (Disposable d) Log.e (TAG, "onSubscribe:");  @Override public void onNext (Valore intero) 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!"); ; // Crea il nostro abbonamento // observable.subscribe (observer);

Apri il monitor Logcat di Android Studio selezionando Monitor Android scheda dalla parte inferiore della finestra di Android Studio (dove il cursore è posizionato nello screenshot qui sotto) e quindi selezionando il logcat linguetta.

Per mettere alla prova questo codice, collega il tuo dispositivo fisico Android al tuo computer di sviluppo o esegui il tuo progetto su un AVD compatibile. Non appena la tua app appare sullo schermo, dovresti vedere i dati emessi dal tuo Observable.

Creare un osservabile con meno codice

Sebbene il nostro progetto stia emettendo dati con successo, il codice che stiamo usando non è esattamente conciso, in particolare il codice che stiamo usando per creare il nostro Osservabile.  

Fortunatamente, RxJava fornisce una serie di metodi di convenienza che ti consentono di creare un Osservabile usando molto meno codice:

1. Observable.just ()

Puoi usare il .appena() operatore per convertire qualsiasi oggetto in un Osservabile. Il risultato Osservabile emetterà quindi l'oggetto originale e completo.

Ad esempio, qui stiamo creando un Osservabile che emetterà una singola stringa a tutti i suoi Gli osservatori:

Osservabile observable = Observable.just ("Hello World!");

2. Observable.from ()

Il .a partire dal() operatore consente di convertire una raccolta di oggetti in un flusso osservabile. È possibile convertire un array in un Osservabile utilizzando Observable.fromArray, un callable in un Osservabile utilizzando Observable.fromCallable, e un iterable in un Osservabile utilizzando Observable.fromIterable.

3. Observable.range ()

Puoi usare il .gamma() operatore per emettere un intervallo di numeri sequenziali. Il primo numero intero che fornisci è il valore iniziale, mentre il secondo è il numero di numeri interi che desideri emettere. Per esempio:

Osservabile osservabile = Observable.range (0, 5);

4. Observable.interval ()

Questo operatore crea un Osservabile che emette una sequenza infinita di interi ascendenti, con ogni emissione separata da un intervallo di tempo scelto da te. Per esempio:

Osservabile osservabile = Observable.interval (1, TimeUnit.SECONDS)

5. Observable.empty ()

Il vuoto() l'operatore crea un Osservabile che non emette elementi ma termina normalmente, il che può essere utile quando è necessario creare rapidamente un Osservabile a scopo di test.  

Osservabile osservabile = Observable.empty ();

Conclusione

In questo articolo abbiamo trattato i componenti fondamentali di RxJava.

A questo punto, sai come creare e lavorare con Gli osservatori e osservabili, e come creare un abbonamento in modo che il tuo osservabili può iniziare a emettere dati. Abbiamo anche esaminato brevemente alcuni operatori che consentono di creare una gamma di diversi osservabili, usando molto meno codice.

Tuttavia, gli operatori non sono solo un modo pratico per ridurre la quantità di codice che è necessario scrivere! Creare un Osservatore e un Osservabile è abbastanza semplice, ma gli operatori sono dove realmente inizi a vedere cosa è possibile con RxJava. 

Quindi nel prossimo post esploreremo alcuni degli operatori più potenti di RxJava, inclusi gli operatori che possono finalmente rendere multi-threading su Android un'esperienza senza problemi. Resta sintonizzato per scoprire il vero potere della libreria RxJava.

Nel frattempo, dai un'occhiata ad alcuni dei nostri altri post e corsi sullo sviluppo di Android qui su Envato Tuts+!

I diagrammi del flusso di dati osservabili sono tratti dalla documentazione di ReactiveX e sono concessi in licenza secondo la licenza Creative Commons Attribution 3.0.