I den här artikeln kommer jag att förklara grunderna i RxJava med hjälp av exempel. Den här artikeln är för RxJava nybörjare. Å andra sidan, om du redan vet något om RxJava är den här artikeln bra för att se över dina kunskaper.

RxJava är en Java VM-implementering av ReactiveX ett bibliotek för att komponera asynkrona och händelsebaserade program med hjälp av observerbara sekvenser.

Byggstenarna i RxJava är Observables och Subscribers. Observable används för att sända objekt och Subscriber används för att konsumera dessa objekt. Kanske några av er kommer att tänka: ”Hmmm det här är så likt standardmönstret för Observable”. Ja, det är det, men RxJava gör det mycket bättre och har fler alternativ. Observables börjar till exempel ofta inte skicka ut objekt förrän någon prenumererar på dem. Detta är en bra funktion eftersom du på detta sätt bör spara dina prestationer.

RxJava fungerar så här. Subscriber prenumererar på Observable, sedan anropar Observable Subscriber.onNext() för ett valfritt antal objekt, om något går fel är här Subsciber.onError() och om allt slutar bra är här Subscriber.onCompleted(). Du ser att det här är enkelt!

Tystnad! Ge mig lite tjusiga koder!

Exempel 1

I det här exemplet kommer vi att skapa grundläggande Observable och Subscriber, och sedan kommer vi att koppla ihop dem och se vad som kommer att hända. Spoiler alert! Något häftigt…

Låt oss skapa en grundläggande Observable:

Den skapade Observable skickar ut ”Blue Factory”-strängen och avslutas sedan. ”Blue Factory”-strängen kommer att tas emot av prenumerantens onNext()-metod. Nu skapar vi Subscriber.

Subscriber tar emot String-värdet på onNext()-metoden och skriver ut det, även String ”I’m done” skrivs ut när onCompleted()-metoderna kallas.

Länk nu ihop dem.

Resultat:

I/System.out: Blue Factory

I/System.out: Jag är klar

När prenumerationen sker kallar myObservable metoderna mySubscription onNext() och onComplited(). Resultaten är utgångarna ”Blue factory” och ”I’m done”, därefter stannar allt och avslutas.

Kan jag göra det enklare?

Självklart! Du kan göra det!

Du kanske märker att en skapelse av myObservable har för mycket kod och det ser rörigt ut. RxJava ger oss några fina genvägar.

Några av dessa genvägar är metoder som Observable.just() och Observable.from();

Observable.just() avger bara ett enskilt objekt och Observable.from() avger ett objekt efter ett från en lista med objekt.

Tystnad! Ge mig lite fin kod!

Exempel 2

I det här exemplet kommer vi att göra samma sak som i exempel 1, men nu med mindre kod.

Låt oss skapa vår nya fina, snygga Observable:

Wow! Det verkar som om vår Observable har tappat lite vikt!
Låt oss skapa Subscriber:

Subscriber är samma!
Länk nu ihop dem och vänta på att magin ska ske!

Resultat:

I/System.out: Blue Factory
I/System.out: I’m done

Som du ser lyckas vi slutföra vår uppgift och göra exakt samma sak med mindre kod.
Tyst! Ge mig lite finare kod!

Exempel 3

I det här exemplet ska vi göra något lite annorlunda med Observable.from(). Tanken är att skriva ut strängarna ”Blue”, ”Factory”, ”Blog”, ”Post”.
Låt oss påminna oss om vad Observable.from() är. Observable.from() tar emot objektlistan och skickar ut objekt för objekt, så Observable.from() är precis vad vi behöver!
Först ska vi skapa ArrayList med strängar:

Låt oss skapa denna Observable.from(), ska vi?

Som du kan se får Observable.from() som argument ArrayList laddad med Strings. Nu ska vi skapa Subscriber och koppla ihop dem och vänta på magin.

Resultat:

I/System.out: Blue
I/System.out: Factory
I/System.out: Blog
I/System.out: Factory
I/System.out: Blog
I/System.out: Factory

Som du ser har vi lyckats med vår uppgift igen!
Allt du har lärt dig hittills är rena grundtricks, men nu ska vi göra några ”svårare” tricks!

Vad är Operatorer i Rx?

Operatorer är metoder som skapats för att lösa transformationer och hantera problem med API-anrop. Jag kommer att visa dig ett enkelt exempel på omvandling med Map, och kanske i några ytterligare artiklar exempel på hantering av API-anrop med Retrofit, RxJava on MVP architectural pattern.

För exempel låt oss lägga till vår ”Blue Factory” String med ” Blog Post”. Vi kan göra det på flera sätt.

Första sättet:

Vi kan göra det i Observable, men Observable är tänkt att emittera objekt, inte att ändra dem.
Det andra sättet:

Samma historia, Subscriber skulle inte ändra objekt.
Lösningen är att lägga till ytterligare ett steg, genom att lägga till Operator. Operator är ytterligare ett steg mellan Observable och Subscriber, där objektet kan omvandlas.
Så låt oss göra det på rätt sätt!
Tystnad! Ge mig lite fin kod!

Exempel 4

Först skapar vi Observable:

Bemärk att myObservable bara avger ett oförändrat objekt.
Nu skapar vi Operator, för det här exemplet är den bästa lösningen att använda Map-operatören. Map-operatören kan omvandla vårt objekt på ett sätt som vi vill och returnera det till Subscriber.

I operatörens anrop (String s) metod omvandling av String ”Blue Factory” görs.
Och här är Subscriber:

Resultat:

I/System.out: Blue Factory Blog Post

Detta exempel representerar en liten del av vad operatorer kan göra. Map-operatorn kan till exempel staplas flera gånger som i exemplet nedan:
Shut up! Ge mig lite fin kod!

Exempel 5

Operatorer kan också ändra typ av emitterat objekt som i exemplet nedan:
Tystnad! Ge mig lite finare kod!

Exempel 6

I det här exemplet kommer Observable att sända strängen ”5” och Operator kommer att omvandla den till heltalet 5. Låt oss skapa Observable.

Bemärk att typen myObservable är Observable och att Observable avger String.
Låt oss skapa Map operator!

Bemärk att Map operator call(String s) metoden tar emot String och returnerar Integer.
Låt oss skapa Subscriber och koppla ihop dem.

Subscriber typ är samma som Observable typ, och Operators återlämnande typ (Integer).
Här visar jag dig bara en liten del av bilden. Med operatörerna kan du göra allt du vill! Och det bästa med detta är att RxJava har ett överflöd av olika operatorer. Här kan du kontrollera alla operatörer: https://github.com/ReactiveX/RxJava/wiki/Alphabetical-List-of-Observable-Operators.

Slutningsvis är operatorer kraftfulla för objekttransformation och datapolering, och efter allt detta kommer din kod att se snygg och ren ut!

Vad kan jag göra med RXJava?

Du kan göra allt du vill eftersom din Observable kan vara allting, den kan vara: Det kan vara sträng, heltal, API-anrop, klick osv. När du utvecklas som Android-utvecklare kommer du att använda RxJava främst för API-anrop och för Android-widgetar. RxJava ger enkel API-hantering, eftersom du inte behöver oroa dig för threading och du kan kedja några förfrågningar och få resultatet på en enda prenumerant. Med RxJava kan du hantera vissa widgetbeteenden, t.ex. vad widgeten kommer att göra efter att du har tryckt på den fem gånger, eller så kan du skapa en observabel som skickar ut en sträng var 4:e sekund från en EditText-inmatning, och så många andra smarta saker. Jag hoppas att den här artikeln ger dig grunderna i RxJava och jag hoppas att du kommer att fortsätta utforska RxJava i framtiden.