Getting gang med ReactiveX på Android
48
Del
7
Del
Dette Cyber mandag Envato Tuts + Kursene vil bli redusert til bare $ 3. Ikke gå glipp av.
Innledning
Utvikling av en kompleks Android app som har massevis av nettverkstilkoblinger, brukerinteraksjon, og animasjoner betyr ofte å skrive kode som er full av nøstede callbacks. Slik kode, også kalt tilbakeringing helvete RxJava er en JVM implementering av ReactiveX, utviklet av Netflix, og er svært populær blant Java-utviklere. I denne opplæringen vil du lære hvordan du bruker RxJava bindinger for Android, eller RxAndroid for kort, i Android-prosjekter. For å bruke RxAndroid i en Android Studio prosjekt, legge det som en kompilering avhengighet i app modulens build.gradle Når du arbeider med ReactiveX, vil du bruke observables og observatører i stor utstrekning. Du kan tenke på en observerbar som et objekt som avgir data og en observatør som et objekt som bruker disse dataene. I RxJava og RxAndroid, observatører er forekomster av Observer grensesnitt, og målbare parametere er forekomster av observer klassen. Den observer klasse har mange statiske metoder, kalt operatører, for å skape Observer stedene. Følgende kode viser deg hvordan du bruker den bare operatøren å lage en veldig enkel observer som avgir et enkelt String Den observer vi nettopp opprettet vil avgi sine data kun når den har minst én observatør. For å opprette en observatør, du lage en klasse som implementerer Observer grensesnittet. The Observer Grensesnittet har intuitivt oppkalt metoder for å håndtere de ulike typer varslinger det kan motta fra observerbare. Her er en observatør som kan skrive ut String slippes ut av den observer vi opprettet tidligere: Hvis du vil tilordne en observatør til en observerbar, bør du bruke abonnere metoden, som returnerer et abonnement objekt. Følgende kode gjør myObserver observere myObservable: Så snart en observatør er lagt til den observerbare, den avgir sine data. Derfor, hvis du kjøre koden nå, vil du se Hei trykt i Android Studio logcat vindu. Du har kanskje lagt merke til at vi ikke fikk bruke onCompleted og onError metoder i myObserver. Ettersom disse metodene er ofte brukes, har du også muligheten til å bruke den Action1 grensesnittet, som inneholder en enkelt metode som heter call of Action1. ≪ String > myAction = new Action1 < String > () {Override public void samtale (String s) {Log.d ("My Handling", s); }}; Når du passerer en forekomst av Action1 til abonnere metoden, blir samtalen metoden påberopt når de observer avgir data For å løsne en observatør fra . sin observerbar mens den observer fortsatt utslipp data, kan du ringe unsubscribe metoden på abonnements objektet Nå som du vet hvordan du oppretter observatører og målbare parametere, la meg vise deg hvordan du bruker ReactiveX operatører som kan skape, forandre, og utføre andre operasjoner på målbare parametere. La oss begynne med å lage en litt mer avansert observer, en som avgir elementer fra en rekke Integer stedene. For å gjøre dette, må du bruke den fra operatøren, som kan generere en observerbar fra matriser og lister Når du kjører denne koden, vil du se hver av tallene i matrisen skrives etter hverandre Hvis du er kjent med Javascript, Ruby. eller Kotlin, kan du bli kjent med overordnede funksjoner som kart og filter, som kan brukes når du arbeider med arrays. ReactiveX har operatører som kan utføre lignende operasjoner på målbare parametere. Men fordi Java 7 har ikke lambdaene og overordnede funksjoner, må vi gjøre det med klasser som simulerer lambdaene. For å simulere en lambda som tar ett argument, må du lage en klasse som implementerer func1 grensesnittet Her er hvordan du kan bruke kartet operatøren til torget hvert element av myArrayObservable. Legg merke til at ringe til kartet operatøren returnerer en ny observer, det endrer ikke det opprinnelige observerbare. Hvis du abonnerer på myArrayObservable nå, vil du motta ratene av tallene. Operatører kan kjedes. For eksempel bruker følgende kode blokk hoppe operatøren å hoppe over de to første tallene, og deretter filteret operatøren å ignorere oddetall: De observatører og observables vi opprettet i de forrige avsnittene jobbet på en enkelt tråd, Android UI tråden. I denne delen vil jeg vise deg hvordan du bruker ReactiveX å administrere flere tråder og hvordan ReactiveX løser problemet med tilbakeringing helvete. Anta at du har en metode som heter fetchData som kan brukes til å hente data fra en API. La oss si at det tar en URL som parameter og returnerer innholdet i svaret som en String. Følgende kodebiten viser hvordan det kunne brukes Denne metoden behov å kjøre på sin egen tråd, fordi Android ikke tillater nettverksoperasjoner på UI tråden. Dette betyr at du vil enten lage en AsyncTask eller opprette en tråd som bruker en Handler. Med ReactiveX, men du har et tredje alternativ som er litt mer konsis. Bruke subscribeOn og observeOn operatører, kan du eksplisitt angi hvilke gjenger bør kjøre bakgrunnen jobb og som tråden skal håndtere oppdateringer i brukergrensesnittet. Følgende kode oppretter en tilpasset observer bruker opprette operatør. Når du oppretter en observerbar på denne måten, må du implementere Observable.OnSubscribe grensesnittet og kontrollere hva den avgir ved å ringe onNext, onError, og onCompleted metoder selv Når den observer er klar, kan du bruke subscribeOn og observeOn å spesifisere gjengene den skal bruke og abonnere på den Du kan fortsatt tenke at det reaktive tilnærmingen er ikke drastisk bedre enn å bruke AsyncTask eller Handler klasser. Du har rett, du trenger egentlig ikke ReactiveX hvis du har til å administrere bare én bakgrunn jobb. Nå vurdere et scenario som vil resultere i en kompleks kodebase hvis du brukte den konvensjonelle tilnærmingen. La oss si at du må hente data fra to (eller flere) nettsteder i parallell og oppdatere en Vis kun når alle forespørsler har fullført. Hvis du følger den konvensjonelle tilnærmingen, ville du må skrive masse unødvendig kode for å sørge for at anmodninger gjennomført uten feil. Tenk et annet scenario der du må starte en bakgrunnsjobb bare etter en annen bakgrunn jobb har fullført. Ved hjelp av den konvensjonelle tilnærmingen, vil dette resultere i nestet callbacks. Med ReactiveX operatører, begge scenarier kan håndteres med svært lite kode. For eksempel, hvis du må bruke fetchData å hente innholdet av to nettsteder, forgrunnen eksempel Google og Yahoo, ville du opprette to Observer gjenstander, og bruke subscribeOn metode for å få dem til å kjøre på forskjellige tråder. For å håndtere den første scenario der både forespørsler må kjøres parallelt, kan du bruke zip operatør og abonnere på observer den returnerer På samme måte å håndtere det andre scenariet, kan du bruke concat føreren å kjøre trådene en etter en RxAndroid har en klasse som heter ViewObservable som gjør det enkelt å håndtere hendelser assosiert med Se stedene. Følgende kodebiten viser deg hvordan du oppretter en ViewObservable som kan brukes til å håndtere klikk hendelsene i en knapp Du kan nå abonnere på clicksObservable og bruke noen av operatørene du lærte om i forrige avsnitt. For eksempel, hvis du vil at app å hoppe over de første fire klikk på knappen og begynne å reagere fra femte klikk utover, kan du bruke følgende gjennomføring: I denne opplæringen, lært deg hvordan du bruker ReactiveX er observatører, målbare, og operatører til å håndtere flere asynkrone operasjoner og hendelser. Som arbeider med ReactiveX innebærer funksjonelle, reaktiv programmering, et programmeringsparadigme mest Android-utviklere er ikke vant til, ikke være for hard mot deg selv hvis du ikke får det riktig første gang. Du bør også vite at ReactiveX koden vil være mye mer lesbar hvis du bruker et moderne programmeringsspråk, slik som Kotlin, som støtter overordnede funksjoner. Hvis du vil vite mer om reaktive extensions, oppfordrer jeg deg til å bla tilgjengelige ressurser på ReactiveX.
, er ikke bare lang og vanskelig å forstå, men også utsatt for feil. ReactiveX tilbyr en alternativ tilnærming som er både klar og konsis, for å administrere asynkrone oppgaver og hendelser.
1. Sette opp RxAndroid
kompilering 'io.reactivex: rxandroid: 0.25.0'.
2. Grunnleggende om Observatører og målbare
observer. ≪ String > myObservable = Observable.just ("Hello"); //Avgir "Hello"
Observer < String > myObserver = new Observer < String > () {Override public void onCompleted () {//Kalt når den observer har ingen flere data det avgis}Override public void onError (Throwable e) {//Kalt når de observerbare møter en feil }Override public void onNext (String s) {//Kalt hver gang den observer avgir data Log.d ("MY observatør", s); }};
Abonnement mySubscription = myObservable.subscribe (myObserver);
Abonnement mySubscription = myObservable.subscribe (myAction1);.
mySubscription.unsubscribe ();
3. Bruke Operatører
observer. ≪ Integer > myArrayObservable = Observable.from (new Integer [] {1, 2, 3, 4, 5, 6}); //Avgir hvert element i matrisen, ett om timemyArrayObservable.subscribe (ny Action1 < Integer > () {Override public void samtale (Integer i) {Log.d ("My handling", String.valueOf (i)); //Skriver ut antall mottatte}});
MyArrayObservable = myArrayObservable. kartet (ny func1 < Integer, Integer > () {//inngang og utgang er begge IntegerOverride offentlig Integer samtale (heltall heltall) {return heltall * heltall; //Square antall}});
myArrayObservable .skip (2) //Hopp de to første elementene .filter (ny func1 < heltall, boolsk > () {Override offentlig boolsk samtale (heltall heltall) {//Ignorerer alle element som returnerer false avkastning heltall% 2 == 0;}}); //Avgir 4 og 6
4. Håndtering Asynchronous Jobs
String content = fetchData ("http://www.google.com."); //Henter innholdet på google.com som en streng
observer. ≪ String > fetchFromGoogle = Observable.create (ny Observable.OnSubscribe < String > () {Override public void samtale (Subscriber <? super String > abonnent) {try {String data = fetchData ("http://www.google.com"); subscriber.onNext (data); //Emit innholdet i URL subscriber.onCompleted (); //Ikke noe mer å avgi} catch (Exception e) {subscriber.onError (e); //I tilfelle det er nettverksfeil }}});
fetchFromGoogle .subscribeOn (Schedulers.newThread ()) //Opprett en ny. Tråd .observeOn (AndroidSchedulers.mainThread ()) //Bruk UI tråden .subscribe (ny Action1 < String > () {Override public void samtale (String s) {view.setText (view.getText () + "\\ n "+ s); //Endre en Vis}});
FetchFromGoogle = fetchFromGoogle. subscribeOn (Schedulers.newThread ()); fetchFromYahoo = fetchFromYahoo.subscribeOn (Schedulers.newThread ());
//Hent fra både simultaneouslyObservable. < String > zippet = Observable.zip (fetchFromGoogle, fetchFromYahoo, ny Func2 < String, String, String > () {Override public String samtale (String google, String yahoo) {//Gjør noe med resultatene av begge trådene tilbake google + "\\ n "+ yahoo;}});
observer. < String > sammenkjedede = Observable.concat (fetchFromGoogle, fetchFromYahoo); //Emit resultat etter hverandre
5. Håndtering Hendelser
Button MyButton = (Button) findViewById (R.id.my_button.); //Opprett en knapp fra en layoutObservable < OnClickEvent > clicksObservable = ViewObservable.clicks (MyButton); //Opprett en ViewObservable for knapp
clicksObservable .skip (4) //Hopp de første 4 klikk. abonnere (ny Action1 < OnClickEvent > () {"! klikket"Override public void samtale (OnClickEvent onClickEvent) {Log.d ("Klikk handling",); //Skrevet ut fra den femte klikk utover}});
Konklusjon