In dit artikel zal ik de basis van RxJava uitleggen aan de hand van voorbeelden. Dit artikel is voor RxJava beginners. Aan de andere kant, als je al iets weet over RxJava, is dit artikel goed om je kennis te herzien.

RxJava is een Java VM implementatie van ReactiveX een bibliotheek voor het samenstellen van asynchrone en event-gebaseerde programma’s door gebruik te maken van observeerbare sequenties.

De bouwstenen van RxJava zijn Observables en Subscribers. Observable wordt gebruikt om items te emitteren en Subscriber wordt gebruikt om die items te consumeren. Misschien zullen sommigen van jullie denken: “Hmmm dit lijkt zo op het standaard Observable patroon”. En ja dat is het, maar RxJava doet het veel beter en heeft meer opties. Observables beginnen bijvoorbeeld vaak pas items te emitteren als iemand zich erop abonneert. Dit is een geweldige eigenschap omdat je op deze manier je performances kunt besparen.

RxJava werkt als volgt. Subscriber abonneert zich op Observable, dan roept Observable Subscriber.onNext() aan voor een willekeurig aantal items, als er iets fout gaat is hier Subsciber.onError() en als alles goed afloopt is hier Subscriber.onCompleted(). Zie je wel dat dit makkelijk is!

Hou je mond! Geef me wat mooie codes!

Example 1

In dit voorbeeld maken we een basis Observable en Subscriber, en dan gaan we ze koppelen, en kijken wat er gebeurt. Spoiler alert! Iets geweldigs…

Laten we een basis Observable maken:

gemaakte Observable zendt “Blue Factory” String uit en voltooit dan. De “Blue Factory”-tekenreeks wordt ontvangen met de methode OnNext() van de abonnee. Laten we nu Subscriber.

Subscriber ontvangt String waarde op onNext() methode en drukt het, ook String “Ik ben klaar” drukt wanneer onCompleted() methoden wordt aangeroepen.

Nu deze aan elkaar koppelen.

Resultaat:

I/System.out: Blue Factory

I/System.out: Ik ben klaar

Wanneer de inschrijving gebeurt, roept myObservable de methoden mySubscription onNext() en onComplited() aan. De resultaten zijn de uitgangen “Blue factory” en “I’m done”, daarna stopt alles en eindigt het.

Kan ik het eenvoudiger doen?

Natuurlijk! Je kunt het!

Je zult merken dat een creatie van myObservable te veel code heeft en het ziet er rommelig uit. RxJava geeft ons een aantal fancy snelkoppelingen.

Enkele van die snelkoppelingen zijn methoden als Observable.just() en Observable.from();

Observable.just() zendt slechts een enkel item uit en Observable.from() zendt een item per item uit een lijst van items.

Hou je mond! Geef me wat mooie code!

Voorbeeld 2

In dit voorbeeld maken we hetzelfde als in voorbeeld 1, maar nu met minder code.

Laten we onze nieuwe mooie, goed uitziende Observable maken:

Wauw! Het lijkt erop dat onze Observable wat gewicht heeft verloren!
Laten we een abonnee maken:

De abonnee is dezelfde!
Nu aan elkaar koppelen, en wachten tot de magie gebeurt!

Resultaat:

I/System.out: Blue Factory
I/System.out: Ik ben klaar

Zoals u ziet, slagen we erin onze taak te volbrengen, en precies hetzelfde te doen met minder code.
Zwijg! Geef me wat mooie code!

Voorbeeld 3

In dit voorbeeld gaan we iets anders doen met Observable.from(). Het idee is om de strings “Blue”, “Factory”, “Blog”, “Post” af te drukken.
Laten we onszelf eraan herinneren wat Observable.from() is. Observable.from() ontvangt items lijst en zendt uit op item voor een, dus Observable.from() is precies wat we nodig hebben!
Eerst zullen we ArrayList met Strings maken:

Laten we die Observable.from() maken?

Zoals u kunt zien, ontvangt Observable.from() als argument een ArrayList met Strings. Laten we nu een Subscriber maken en ze aan elkaar koppelen, en wachten op de magie.

Resultaat:

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

Zoals je ziet, hebben we onze taak weer succesvol volbracht!
Alles wat je tot nu toe geleerd hebt zijn pure basis trucs, maar nu gaan we wat “moeilijkere” trucs doen!

Wat zijn Operators in Rx?

Operators zijn methoden die gemaakt zijn om transformaties op te lossen en API aanroep problemen op te lossen. Ik zal u een eenvoudig voorbeeld voor transformatie met Map, en misschien in een aantal verdere artikelen voorbeelden van het omgaan API-oproepen met Retrofit, RxJava op MVP architectuurpatroon.

Bijvoorbeeld laten we onze “Blue Factory” String append met ” Blog Post”. We kunnen het op verschillende manieren doen.

Eerste manier:

We kunnen het in Observable doen, maar Observable is bedoeld om items te emitteren, niet om ze te wijzigen.
Tweede manier:

Hetzelfde verhaal, Subscriber werd niet verondersteld items te wijzigen.
De oplossing is om nog een stap toe te voegen, door Operator toe te voegen. Operator is een extra stap tussen Observable en Subscriber, waar objecten kunnen worden getransformeerd.
Dus laten we het op de juiste manier doen!
Zwijg! Geef me wat mooie code!

Example 4

Laten we eerst een Observable maken:

Merk op dat mijnObservable slechts één ongewijzigd item uitzendt.
Nu laten we Operator maken, voor dit voorbeeld is de beste oplossing om Map operator te gebruiken. De Map operator kan ons object transformeren op een manier die we willen en het terugsturen naar Subscriber.

In operators call (String s) methode transformatie van String “Blue Factory” wordt gedaan.
En hier is Subscriber:

Resultaat:

I/System.out: Blue Factory Blog Post

Dit voorbeeld vertegenwoordigt slechts een fractie van wat Operators kunnen doen. Map operator kan bijvoorbeeld meerdere keren worden gestapeld, zoals in onderstaand voorbeeld:
Stil op! Geef me wat mooie code!

Voorbeeld 5

Operators kunnen ook het type van het uitgezonden item veranderen, zoals in onderstaand voorbeeld:
Kop dicht! Geef me wat mooie code!

Voorbeeld 6

In dit voorbeeld zendt de Observable de String “5” uit en de Operator verandert dit in het gehele getal 5. Laten we een Observable maken.

Merk op dat myObservable van het type Observable is en dat Observable String uitzendt.
Laten we Map operator maken!

Merk op dat Map operator call(String s) methode String ontvangt en Integer teruggeeft.
Laten we Subscriber maken en ze koppelen.

Subscriber type is hetzelfde als Observable type, en Operators returning type (Integer).
Hier laat ik u slechts een klein deel van het plaatje zien. Met operatoren kun je alles doen wat je wilt! En het beste hieraan is dat RxJava een overvloed aan verschillende Operators heeft. Hier kun je alle operatoren bekijken: https://github.com/ReactiveX/RxJava/wiki/Alphabetical-List-of-Observable-Operators.

In conclusie Operators zijn krachtig voor object transformatie en data polijsten, en na dit alles, zal je code er mooi en schoon uitzien!

Wat kan ik doen met RXJava?

Je kunt alles doen wat je wilt, omdat je Observable alles kan zijn, het kan zijn: String, Integer, API call, klik, enz. Naarmate je verder komt als Android ontwikkelaar zul je RxJava vooral gebruiken voor API calls en voor android widgets. RxJava biedt gemakkelijke API afhandeling, omdat je je geen zorgen hoeft te maken over threading en je kunt een paar requests aan elkaar rijgen en het resultaat op een enkele Subscriber krijgen. Met RxJava kun je widget gedrag afhandelen, bijvoorbeeld wat een widget zal doen nadat hij vijf keer is ingedrukt, of je kunt een Observable maken die elke 4 seconden een String uitzendt van EditText input, en zo veel andere leuke dingen. Ik hoop dat dit artikel je de basis van RxJava geeft en ik hoop dat je RxJava in de toekomst zult blijven verkennen.