Kom i gang med RxJava 2 for Android

Hvis du er en Android-utvikler, kan du ha hørt gode ting om RxJava, en populær åpen kildekodeimplementering av ReactiveX-biblioteket som bringer reaktiv programmering til Java Virtual Machine (JVM).

RxJava er designet for å ta smerten ut av å jobbe med asynkron datastrøm - selv om RxJavas definisjon av "data" er ganske bred. Fordi RxJava er et JVM-kompatibelt bibliotek, kan du bruke det på et bredt spekter av plattformer, men i denne serien vil jeg vise deg hvordan du bruker RxJava 2 for Android-utvikling.

Ved slutten av denne serien har du mestret alle RxJava 2-essensialene, slik at du kan begynne å lage svært reaktive programmer som kan behandle et bredt spekter av synkron og asynkron data-alt ved hjelp av kode som er mer konsistent og håndterlig enn du vanligvis ville være Kunne oppnå med Java alene.

I tillegg til å gi en introduksjon til RxJava nykommere, hvis du er en RxJava 1 veteran som ønsker å gjøre spranget til RxJava 2, vil denne serien bidra til å gjøre denne overgangen så glatt som mulig. Mens oppgradering til den nyeste versjonen av et bibliotek kanskje ikke høres ut som en stor avtale, er RxJava 2 ikke den typiske oppdateringen, det er en fullstendig omskrivning av RxJava. Med så mye forandring er det lett å bli forvirret, så det tar litt tid å gjøre seg kjent med RxJava 2 fra en nybegynnerperspektiv, og du kan spare mye tid og frustrasjon i det lange løp.

I dette første innlegget vil jeg dekke hva RxJava er og de viktigste fordelene det tilbyr Android-utviklere. Vi vil også ta en grundig titt på kjernekomponentene til noen RxJava prosjekt: observatører, observer, og abonnementer. Ved slutten av denne opplæringen har du opprettet en enkel "Hello World" -stil applikasjon som inneholder alle disse kjernekomponentene.

De andre store byggeblokkene til RxJava er operatører, så i del to vil jeg utforske de forskjellige måtene du kan bruke operatører til å transformere, kombinere, filtrere og manipulere programmets data.

I den siste tråden beveger vi oss utover Kjerne RxJava-biblioteket og tar en titt på RxAndroid, et helt bibliotek som er pakket med alle de Android-spesifikke utvidelsene, du må låse opp det fulle potensialet for reaktiv programmering for Android.

Vi har mye å dekke, så la oss starte med det viktigste:

Hva er RxJava, uansett?

RxJava er et bibliotek som lar deg lage programmer i den reaktive programmeringsstilen. Kjernen gir reaktiv programmering en ren og effektiv måte å behandle og reagere på strømmer av sanntidsdata, inkludert data med dynamiske verdier.

Disse datastrømmene er ikke nødvendigvis ha å ta form av tradisjonelle datatyper, da RxJava behandler alt som en datastrøm, alt fra variabler til egenskaper, cacher og til og med brukerinnspillingshendelser som klikk og swipes.

Dataene som sendes ut av hver strøm kan enten være en verdi, en feil eller et "fullført" signal, selv om du ikke nødvendigvis må implementere de to siste. Når du har opprettet datastrømmende strømmer, kombinerer du dem med reaktive objekter som forbruker og deretter oppfører seg på disse dataene, og utfører forskjellige handlinger avhengig av hva strømmen har sendt ut. RxJava inneholder en hel masse nyttige operatører for å jobbe med bekker, noe som gjør det enkelt å gjøre ting som filtrering, kartlegging, forsinkelse, telling og mye mer.

For å opprette denne arbeidsflyten av datastrømmer og objekter som reagerer på dem, utvider RxJava Observer-programvareutformingsmønsteret. I hovedsak, i RxJava har du observer objekter som avgir en datastrøm og deretter avslutter, og Observer objekter som abonnerer på observers. en Observer mottar varsel hver gang de tildeles observer avgir en verdi, en feil eller et ferdig signal.

Så på et svært høyt nivå handler RxJava om:

• Opprette en observer.
• Gir det observer noen data som skal sendes ut.
• Opprette en Observer.
• Tilordne Observer til en observer.
• Å gi Observer Oppgaver å utføre når det mottar et utslipp fra det som er tildelt observer.

Hvorfor RxJava?

Læring av ny teknologi krever tid og krefter, og som et data-orientert bibliotek er RxJava ikke alltid den enkleste API for å få tak i.

For å hjelpe deg med å avgjøre om Læring RxJava er verdt den første investeringen, la oss utforske noen av de viktigste fordelene ved å legge RxJava-biblioteket til Android-prosjektene dine.

Mer konsistent, lesbar kode

Kode som er kompleks, verbose og vanskelig å lese er alltid dårlige nyheter. Mysig kode er mer utsatt for feil og andre ineffektiviteter, og hvis det oppstår feil, vil du ha en mye tøffere tid sporing ned kilden til disse feilene hvis koden er et rot.

Selv om prosjektet ditt bygger uten feil, kan komplisert kode fortsatt komme tilbake for å hjemsøke deg - vanligvis når du bestemmer deg for å slippe en oppdatering til appen ditt noen få måneder nedover linjen, starte opp prosjektet ditt, og konfronteres umiddelbart med en vegg av vanskelig, forvirrende kode!

RxJava forenkler koden som kreves for å håndtere data og hendelser ved å tillate deg å beskrive hva du vil oppnå, i stedet for å skrive en liste over instruksjoner for appen din for å jobbe gjennom. RxJava gir også en standard arbeidsflyt som du kan bruke til å håndtere alle data og hendelser i hele applikasjonen din - opprett en observer, opprett en Observer, tildel observerbar observatør, skyll og gjenta. Denne formelle tilnærmingen gir en veldig lett, menneskelig lesbar kode.

Multithreading Made Easy

Moderne Android-applikasjoner må kunne multi-oppgave. I det minste vil brukerne forvente at de kan fortsette å samhandle med App-brukergrensesnittet ditt, mens applikasjonen utfører noe arbeid i bakgrunnen, for eksempel å administrere en nettverkstilkobling, laste ned en fil eller spille av musikk. Problemet er at Android er enkeltgjenget som standard, så hvis appen din kommer til å gå til flere oppgaver, må du opprette noen flere tråder.

Ut av boksen gir Android en rekke måter å opprette flere tråder, for eksempel tjenester og IntentServices, men ingen av disse løsningene er spesielt enkle å implementere, og de kan raskt resultere i komplisert, verbose kode som er utsatt for feil.

RxJava tar sikte på å skape multi-threaded Android apps, ved å tilby spesialplanleggere og operatører. Disse gir deg en enkel måte å spesifisere tråden der arbeid skal utføres og tråden der resultatene av dette arbeidet skal legges opp. RxJava 2.0 inneholder en rekke planleggere som standard, inkludert Schedulers.newThread, som er særlig nyttig som det skaper en ny tråd.

For å endre tråden der arbeid utføres, trenger du bare å endre hvor en observatør abonnerer på en observerbar, ved hjelp av subscribeOn operatør. For eksempel lager vi her en ny tråd og angir at arbeidet skal utføres på denne nye tråden:  

observable.subscribeOn (Schedulers.newThread ())

Et annet langvarig problem med multithreading på Android er at du bare kan oppdatere appens brukergrensesnitt fra hovedtråden. Vanligvis må du opprette en dedikert når du trenger å legge ut resultatene av litt bakgrunnsarbeid til appens brukergrensesnitt handler.

Nok en gang har RxJava en mye enklere løsning. Du kan bruke observeOn operatør for å angi at en observabel skal sende sine varsler ved hjelp av en annen planlegger, som i hovedsak lar deg sende observable data til tråden etter eget valg, inkludert hovedbruddstrengen.

Dette betyr at med bare to kodelinjer kan du opprette en ny tråd og sende resultatene av arbeidet som utføres på denne tråden til Android hovedbruker-tråden:

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

Ok, så teknisk sett vi snyder litt her, som AndroidSchedulers.mainThread er bare tilgjengelig som en del av RxAndroid-biblioteket, som vi ikke vil se på før tredje tre. Men dette eksemplet gir deg et glimt inn i RxJava og RxAndroids makt for å forenkle et område med Android-utvikling som er kjent for å være altfor komplisert.

Økt fleksibilitet

Observables avgir sine data på en måte som helt skjuler måten dataene ble opprettet på. Siden observatørene dine ikke engang kan se hvordan dataene ble opprettet, er du fri til å implementere observers på hvilken måte du vil.

Når du har implementert din observers, RxJava gir et stort utvalg av operatører som du kan bruke til å filtrere, flette og transformere dataene som sendes ut av disse observers. Du kan til og med kjede flere og flere operatører sammen til du har opprettet nøyaktig Datastrømmen din søknad trenger. 

Du kan for eksempel kombinere data fra flere strømmer, filtrere den nylig sammenslåtte strømmen, og deretter bruke de resulterende dataene som input for en påfølgende datastrøm. Og husk at i RxJava stort sett alt blir behandlet som en datastrøm, så du kan til og med bruke disse operatørene til ikke-tradisjonelle "data", for eksempel klikkhendelser. 

Opprett mer responsive apper

Borte er de dagene da en app kunne komme seg unna med å laste inn en innholdsside og deretter vente på at brukeren trykker på neste knapp. I dag må din typiske mobilapp være i stand til å reagere på et stadig voksende utvalg av hendelser og data, ideelt i sanntid. For eksempel må din typiske sosiale nettverksprogram stadig lytte etter innkommende liker, kommentarer og vennsforespørsler, mens du administrerer en nettverkstilkobling i bakgrunnen og svarer umiddelbart når brukeren tapper eller sveiper skjermen.

RxJava-biblioteket ble designet for å kunne håndtere et bredt spekter av data og hendelser samtidig og i sanntid, noe som gjør det til et kraftig verktøy for å skape den typen svært responsive applikasjoner som moderne mobile brukere forventer.

Legge til RxJava til Android Studio

Hvis du har bestemt at RxJava har noe å tilby Android-utviklingspraksis, er det første skrittet til å bli en RxJava-mester, å legge til biblioteket for prosjektet ditt.

Opprett et nytt Android Studio-prosjekt med de ønskede innstillingene, og åpne deretter modulnivået ditt build.gradle fil og legg til den nyeste versjonen av io.reactivex.rxjava2: rxjava som en avhengighet. 

På tidspunktet for skriving var RxJava 2.0.5 den siste utgivelsen, så min build.gradle filen ser slik ut:

avhengigheter compile fileTree (dir: 'libs', inkluderer: ['* .jar']) androidTestCompile ('com.android.support.test.espresso: espressokjerne: 2.2.2', ekskluder gruppe: 'com. android.support ', modul:' support-annotations ') kompilere' com.android.support:appcompat-v7:25.1.0 'testCompile' juni: juni: 4,12 'kompilere' io.reactivex.rxjava2: rxjava: 2.0. 5 '

Når du blir bedt om det, klikk Synkroniser nå.

Deretter åpner du Hoved aktivitet fil og legg til importen må du begynne å jobbe med kjernen RxJava-funksjonene:

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

Hvis du migrerer fra RxJava 1, kan denne importen ikke være det du hadde forventet, da RxJava 1 brukte et helt annet pakke navn (rx For å være presis).

Dette er imidlertid ikke en vilkårlig navneendring: De forskjellige pakkenavnene gir deg muligheten til å bruke RxJava 1 og RxJava 2 side om side i samme prosjekt. Hvis du er halvveis gjennom et prosjekt som bruker RxJava 1, kan du legge til RxJava 2-biblioteket og begynne å bruke de oppdaterte 2 funksjonene umiddelbart uten å bryte noen av din RxJava 1-kode.

Hvis du starter din RxJava-reise med versjon 2, så vær oppmerksom på at hvis du støter på noen RxJava-opplæringer eller kode ved hjelp av rx pakke navn, så er dette RxJava 1 kode og er usannsynlig å være kompatibel med versjon 2 biblioteket.

Bygningsblokker av RxJava

Så langt har vi bare sett på RxJava på et svært høyt nivå. Det er på tide å bli mer spesifikk og ta en grundig titt på to av de viktigste komponentene som vil kaste opp tid og tid igjen gjennom ditt RxJava-arbeid: Observers og observers.

Ved slutten av denne delen vil du ikke bare ha en solid forståelse av disse to kjerneelementene, men du har opprettet et fullt fungerende program bestående av en observer som sender data og en Observer som reagerer på disse utslippene.

Lag en observer

en observer ligner en Iterable i det, gitt en sekvens, vil det iterere gjennom den sekvensen og avgir hvert element, selv om observers begynner vanligvis ikke å sende data til en Observer abonnerer på dem.

Hver gang en observer sender ut et element, det underretter det tildelt Observer bruker onNext () metode. En gang en observer har overført alle sine verdier, avslutter den ved å ringe enten:

• onComplete: Kalt om operasjonen var en suksess.
• onError: Kalt hvis en Unntak ble kastet.

La oss se på et eksempel. Her skaper vi en Observerbar som avgir tallene 1, 2, 3 og 4, og avsluttes deretter.

observer observerbar = Observable.create (new ObservableOnSubscribe() @Overtrid offentlig tomt abonnement (ObservableEmitter e) kaster unntak // Bruk onNext til å sende ut hvert element i strømmen // e.onNext (1); e.onNext (2); e.onNext (3); e.onNext (4); // Når Observable har sendt ut alle elementer i sekvensen, ring på Komplett // e.onComplete (); );

Merk at i dette eksemplet staver jeg ut nøyaktig hva som skjer, så ikke la mengden kode sette deg av! Dette er mye mer kode enn du vanligvis bruker til å lage observers i dine virkelige RxJava prosjekter.

Lag en observatør

Observers er objekter du tilordner til en observer, bruker abonnere() operatør. En gang en Observer abonnerer på en observer, det vil reagere når det er Observer avgir ett av følgende:

• onNext: The observer har gitt ut en verdi.
• onError: Det har oppstått en feil.
• onComplete: The observer har avsluttet alle sine verdier.

La oss lage en Observer som er abonnert på vår 1, 2, 3, 4 observer. For å holde ting enkelt, dette Observer vil reagere på onNext, onError og onComplete ved å skrive ut en melding til Android Studio Logcat Monitor:

Observer observatør = ny observatør() @Overtrid offentlig tomgang på Abonnement (Disponibel 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!"); ; // Opprett abonnementet vårt // observable.subscribe (observatør);

Åpne Android Studio's Logcat Monitor ved å velge Android Monitor kategorien nederst i Android Studio-vinduet (der markøren er plassert i skjermbildet nedenfor) og deretter velge logcat tab.

For å sette denne koden på prøve, fest enten din fysiske Android-enhet til utviklingsmaskinen eller kjør prosjektet ditt på en kompatibel AVD. Så snart appen din vises på skjermen, bør du se dataene som sendes ut av Observable.

Opprette en observerbar med mindre kode

Selv om prosjektet vårt sender data, er koden vi bruker, ikke akkurat konsis, spesielt koden vi bruker til å lage vår observer.  

Heldigvis gir RxJava en rekke bekvemmelighetsmetoder som lar deg lage en observer bruker mye mindre kode:

1. Observable.just ()

Du kan bruke .bare() operatør for å konvertere et hvilket som helst objekt til en observer. Resultatet observer vil da sende det opprinnelige objektet og fullføre.

For eksempel, her lager vi en observer som vil sende ut en enkelt streng til alle sine observatører:

observer observerbar = Observable.just ("Hello World!");

2. Observable.from ()

De .fra() operatør lar deg konvertere en samling objekter til en observerbar strøm. Du kan konvertere en matrise til en observer ved hjelp av Observable.fromArray, en Callable inn i en observer ved hjelp av Observable.fromCallable, og en Iterable inn i en observer ved hjelp av Observable.fromIterable.

3. Observable.range ()

Du kan bruke .område() operatør for å sende ut et rekke sekvensielle heltall. Det første heltallet du gir er den opprinnelige verdien, og den andre er antall heltall du vil sende ut. For eksempel:

observer observerbar = Observable.range (0, 5);

4. Observable.interval ()

Denne operatøren oppretter en observer som avgir en uendelig sekvens av stigende heltall, med hver utslipp separert av et tidsintervall valgt av deg. For eksempel:

observer observerbar = Observable.interval (1, TimeUnit.SECONDS)

5. Observable.empty ()

De tømme() operatør oppretter en observer som avgir ingen gjenstander, men avsluttes normalt, noe som kan være nyttig når du raskt må opprette en observer til testformål.  

observer observerbar = Observable.empty ();

Konklusjon

I denne artikkelen dekket vi de grunnleggende byggeblokkene til RxJava.

På dette punktet vet du hvordan du lager og jobber med observatører og observer, og hvordan du oppretter et abonnement slik at din observer kan begynne å sende data. Vi så også kort på noen få operatører som lar deg lage en rekke forskjellige observer, bruker mye mindre kode.

Operatørene er imidlertid ikke bare en praktisk måte å kutte ned på koden du trenger å skrive! Opprette en Observer og en observer er enkelt nok, men operatører er der du virkelig begynner å se hva som er mulig med RxJava. 

Så i neste innlegg, vil vi utforske noen av RxJavas mest kraftfulle operatører, inkludert operatører som endelig kan gjøre multi-threading på Android en smertefri opplevelse. Hold deg oppdatert for å lære den virkelige kraften til RxJava-biblioteket.

I mellomtiden kan du sjekke ut noen av våre andre innlegg og kurs om Android-utvikling her på Envato Tuts+!

Observerbare dataflowdiagrammer er hentet fra ReactiveX-dokumentasjonen, og lisensiert under Creative Commons Attribution 3.0-lisens.