streamalism.org

1. Prehľad

V tomto tutoriáli sa chystáme preskúmať použitie Reaktívne rozšírenia (Rx) v idiomatickom jazyku Kotlin pomocou knižnice RxKotlin.

RxKotlin ako taký nie je implementáciou Reactive Extensions. Namiesto toho je to väčšinou zbierka metód rozšírenia. To znamená, že RxKotlin rozširuje RxJava knižnica s API navrhnutá s ohľadom na Kotlin.

Preto použijeme koncepty z nášho článku Úvod do RxJava a tiež koncept Tekuté látky sme predstavili v samostatnom článku.

2. Nastavenie RxKotlin

Ak chcete použiť RxKotlin v našom projekte Maven, budeme musieť pridať rxkotlin závislosť na našom pom.xml:

 io.reactivex.rxjava2 rxkotlin 2.3.0 

Alebo pre projekt Gradle náš build.gradle:

implementácia 'io.reactivex.rxjava2: rxkotlin: 2.3.0'

Tu používame RxKotlin 2.x, ktorý je zameraný na RxJava 2. Projekty používajúce RxJava 1 by mali používať RxKotlin 1.x. Pre obe verzie platia rovnaké koncepty.

Upozorňujeme, že RxKotlin závisí od RxJava, ale neaktualizuje závislosť často na najnovšie vydanie. Odporúčame teda výslovne zahrnúť konkrétnu verziu RxJava, od ktorej budeme závisieť, ako je podrobne uvedené v našom článku o RxJava.

3. Tvorba Pozorovateľnés v RxKotlin

RxKotlin obsahuje množstvo metód rozšírenia, ktoré je potrebné vytvoriť Pozorovateľné a Tekutý predmety zo zbierok.

Najmä každý typ poľa má a toObservable () metóda a a toFlowable () metóda:

val pozorovateľné = listOf (1, 1, 2, 3) .toObservable () observable.test (). assertValues ​​(1, 1, 2, 3)

val flowable = listOf (1, 1, 2, 3) .toFlowable () flowable.buffer (2) .test (). assertValues ​​(listOf (1, 1), listOf (2, 3))

3.1. Dokončiteľnés

RxKotlin tiež poskytuje niektoré metódy na vytváranie Dokončiteľné inštancie. Najmä môžeme konvertovať Akcias, Vyvolávateľnás, Budúcnosťs a funkcie nulovej aritity do Dokončiteľné metódou rozšírenia toCompletable:

var value = 0 val completable = {value = 3} .toCompletable () assertFalse (completable.test (). isCancelled ()) assertEquals (3, hodnota)

4. Pozorovateľné a Tekutý do Mapa a Multimap

Keď máme Pozorovateľné alebo Tekutý ktorý vyrába Pár inštancie, môžeme ich transformovať do a Slobodný pozorovateľný, ktorý produkuje a Mapa:

val list = listOf (Pair ("a", 1), Pair ("b", 2), Pair ("c", 3), Pair ("a", 4)) val pozorovatelny = list.toObservable () val map = observable.toMap () assertEquals (mapOf (Pair ("a", 4), Pair ("b", 2), Pair ("c", 3)), map.blockingGet ())

Ako vidíme v predchádzajúcom príklade, mapovať prepíše hodnoty emitované skôr na neskoršie hodnoty, ak majú rovnaký kľúč.

Ak chceme zhromaždiť všetky hodnoty spojené s kľúčom do kolekcie, použijeme toMultimap namiesto toho:

val list = listOf (Pair ("a", 1), Pair ("b", 2), Pair ("c", 3), Pair ("a", 4)) val pozorovatelny = list.toObservable () val map = observable.toMultimap () assertEquals (mapOf (Pair ("a", listOf (1, 4)), Pair ("b", listOf (2)), Pair ("c", listOf (3))), map.blockingGet ())

5. Kombinovanie Pozorovateľnés a Tekutýs

Jedným z predajných miest Rx je možnosť kombinovať Pozorovateľnés a Tekutýs rôznymi spôsobmi. RxJava skutočne poskytuje množstvo operátorov priamo z krabice.

Okrem toho obsahuje RxKotlin niekoľko ďalších rozširujúcich metód kombinovania Pozorovateľnés a podobne.

5.1. Kombinácia pozorovateľných emisií

Keď máme Pozorovateľné ktorý vyžaruje iné Pozorovateľnés, môžeme použiť jednu z metód rozšírenia v RxKotlin na kombináciu emitovaných hodnôt.

Najmä mergeAll kombinuje pozorovateľné s flatMap:

val predmet = PublishSubject.create() val pozorovateľný = subject.mergeAll ()

Čo by bolo rovnaké ako:

val observable = subject.flatMap {it}

Výsledný Pozorovateľné vydá všetky hodnoty zdroja Pozorovateľnés v bližšie neurčenom poradí.

Podobne concatAll používa concatMap (hodnoty sú emitované v rovnakom poradí ako zdroje), zatiaľ čo switchLatest používa switchMap (hodnoty sú emitované od posledného emitovaného Pozorovateľné).

Ako sme už videli, sú uvedené všetky vyššie uvedené metódy Tekutý tiež zdroje, s rovnakou sémantikou.

5.2. Kombinovanie Dokončiteľnés,Možnos a Slobodnýs

Keď máme Pozorovateľné ktorý vydáva prípady Dokončiteľné, Možnoalebo Slobodný, môžeme ich skombinovať s príslušnými mergeAllXs metóda ako napríklad mergeAllMaybes:

val predmet = PublishSubject.create() val Observable = subject.mergeAllMaybes () subject.onNext (Možná.Jasne (1)) Subjekt.onNext (Možno.Pravda (2)) Subjekt.onNext (Možno.Prázdné ()) Subjekt.onNext (Možno.error ( Výnimka ("chyba"))) subject.onNext (Možná.názov (3)) pozorovatelný.test (). AssertValues ​​(1, 2) .assertError (Výnimka :: class.java)

5.3. Kombinovanie Iterables z Pozorovateľnés

Pre zbierky Pozorovateľné alebo Tekutý inštancie namiesto toho má RxKotlin niekoľko ďalších operátorov, zlúčiť a mergeDelayError. Oba majú účinok kombinujúci všetky Pozorovateľnés alebo Tekutýs do jedného, ​​ktorý bude emitovať všetky hodnoty v poradí:

val observables = mutableListOf (Observable.just ("first", "second")) val observable = observables.merge () observables.add (Observable.just ("third", "quarter")) observable.test (). assertValues („prvý“, „druhý“, „tretí“, „štvrtý“)

Rozdiel medzi týmito dvoma operátormi - ktoré sú priamo odvodené od operátorov s rovnakým menom v RxJava - je ich zaobchádzanie s chybami.

The zlúčiť metóda vydáva chyby hneď, ako ich emituje zdroj:

// ... observables.add (Observable.error (Exception ("e"))) observables.add (Observable.just ("fifth")) // ... observable.test (). assertValues ​​("first" , „druhý“, „tretí“, „štvrtý“)

Keďže mergeDelayError vydá ich na konci streamu:

// ... observables.add (Observable.error (Exception ("e"))) observables.add (Observable.just ("fifth")) // ... observable.test (). assertValues ​​("first" , „druhý“, „tretí“, „štvrtý“, „piaty“)

6. Zaobchádzanie s hodnotami rôznych typov

Pozrime sa teraz na metódy rozšírenia v RxKotlin, ktoré sa zaoberajú hodnotami rôznych typov.

Toto sú varianty metód RxJava, ktoré využívajú upravené Kotlinove generiky. Môžeme predovšetkým:

• prenášať emitované hodnoty z jedného typu na druhýalebo
• odfiltrovať hodnoty, ktoré nie sú určitého typu

Mohli by sme napríklad odhodiť Pozorovateľné z Číslos jednému z Ints:

val Observable = Observable.just (1, 1, 2, 3) observable.cast (). test (). assertValues ​​(1, 1, 2, 3)

Tu je obsadenie zbytočné. Ak však kombinujeme rôzne pozorovateľné dohromady, mohlo by to byť potrebné.

S typu, namiesto toho môžeme filtrovať hodnoty, ktoré nie sú typu, ktorý očakávame:

val observable = Observable.just (1, "a", 2, "a") observable.ofType (). test (). assertValues ​​(1, 2)

Ako vždy, obsadenie a typu sú použiteľné pre obidve Pozorovateľnés a Tekutýs.

Ďalej Možno podporuje aj tieto metódy. The Slobodný trieda namiesto toho iba podporuje obsadenie.

7. Ďalšie pomocné metódy

Nakoniec RxKotlin obsahuje niekoľko pomocných metód. Poďme sa rýchlo pozrieť.

Môžeme použiť prihlásiť sa na odber namiesto prihlásiť sa na odber - umožňuje pomenované parametre:

Observable.just (1) .subscribeBy (onNext = {println (it)})

Podobne môžeme použiť blokovanie predplatného blockingSubscribeBy.

RxKotlin navyše obsahuje niektoré metódy, ktoré napodobňujú tie v RxJava, ale obchádzajú obmedzenie odvodenia Kotlinovho typu.

Napríklad pri použití Pozorovateľný # zip, s uvedením zips nevyzerá tak skvele:

Observable.zip (Observable.just (1), Observable.just (2), BiFunction {a, b -> a + b})

Takže Dodáva RxKotlin Pozorovateľné # zip pre idiomatické použitie:

Observables.zip (Observable.just (1), Observable.just (2)) {a, b -> a + b}

Všimnite si konečné „s“ v Pozorovateľné. Podobne máme Tekuté látky, jednotlivé látky, a Maybes.

8. Závery

V tomto článku sme dôkladne preskúmali knižnicu RxKotlin, ktorá rozširuje RxJavu, aby jej API vyzeralo skôr ako idiomatický Kotlin.

Ďalšie informácie nájdete na stránke RxKotlin GitHub. Pre viac príkladov odporúčame testy RxKotlin.

Implementáciu všetkých týchto príkladov a útržkov kódu nájdete v projekte GitHub ako projekt Maven a Gradle, takže by malo byť ľahké ho importovať a spustiť tak, ako je.