streamalism.org

1. Bemutatkozás

Az RxJava egy Reactive Extensions Java megvalósítás, amely lehetővé teszi számunkra, hogy eseményvezérelt és aszinkron alkalmazásokat írjunk. További információ az RxJava használatáról itt található intro cikkünkben található.

Az RxJava 2-t a semmiből írták át, ami több új funkciót hozott; némelyik a keretrendszer előző verziójában létező kérdésekre adott válaszként jött létre.

Az egyik ilyen tulajdonság a io.reactivex.Folyékony.

2. Megfigyelhető vs.. Folyékony

Az RxJava előző verziójában csak egy alaposztály működött az ellennyomás-tudatos és a túlnyomás-tudatlan források kezelésére - Megfigyelhető.

Az RxJava 2 világosan megkülönböztette a kétféle forrást - az ellennyomás-tudatos forrásokat most egy külön osztály használja - Folyékony.

Megfigyelhető a források nem támogatják az ellennyomást. Emiatt olyan forrásokra kell használnunk, amelyeket pusztán fogyasztunk és nem tudunk befolyásolni.

Továbbá, ha nagyszámú elemmel foglalkozunk, az ellennyomáshoz kapcsolódó két lehetséges forgatókönyv fordulhat elő, a Megfigyelhető.

Használata esetén ún “hideg Megfigyelhető“, az eseményeket lustán bocsátják ki, ezért biztonságban vagyunk a megfigyelők túlcsordulásától.

Ha a “forró Megfigyelhető” ez azonban továbbra is eseményeket bocsát ki, még akkor is, ha a fogyasztó nem képes lépést tartani.

3. A. Létrehozása Folyékony

Különböző módon lehet létrehozni a Folyékony. Számunkra kényelmesen ezek a módszerek hasonlóak a Megfigyelhető az RxJava első verziójában.

3.1. Egyszerű Folyékony

Hozhatunk létre a Folyékony használni a éppen() módszer hasonlóan, mint amivel tudnánk Megfigyelhető:

Flowable integerFlowable = Flowable.just (1, 2, 3, 4);

Annak ellenére, hogy a éppen() meglehetősen egyszerű, nem túl gyakori a Folyékony statikus adatokból, és tesztelési célokra használják.

3.2. Folyékony tól től Megfigyelhető

Amikor van egy Megfigyelhető könnyen átalakíthatjuk Folyékony használni a toflowable () módszer:

Megfigyelhető egész szám: Megfigyelhető = Megfigyelhető.just (1, 2, 3); Flowable integerFlowable = integerObservable .toFlowable (BackpressureStrategy.BUFFER);

Figyelje meg, hogy az átalakítás elvégzéséhez gazdagítanunk kell a Megfigyelhető val,-vel EllennyomásStrategy. A következő szakaszban ismertetjük az elérhető stratégiákat.

3.3. Folyékony tól től FlowableOnSubscribe

Az RxJava 2 funkcionális interfészt vezetett be FlowableOnSubscribe, amely a Folyékony hogy a fogyasztó feliratkozása után eseményeket bocsát ki.

Ennek köszönhetően minden ügyfél ugyanazon eseményeket kapja meg, ami FlowableOnSubscribe ellennyomás-biztonságos.

Amikor megvan a FlowableOnSubscribe felhasználhatjuk a Folyékony:

FlowableOnSubscribe flowableOnSubscribe = flowable -> flowable.onNext (1); Flowable integerFlowable = Folyékony .create (flowableOnSubscribe, BackpressureStrategy.BUFFER);

A dokumentáció még sok más módszert ismertet a létrehozáshoz Folyékony.

4. FolyékonyEllennyomásStrategy

Néhány módszer, mint toflowable () vagy teremt() vegyen egy EllennyomásStrategy érvként.

A EllennyomásStrategy egy felsorolás, amely meghatározza az ellennyomás viselkedését, amelyet a sajátunkra alkalmazunk Folyékony.

Gyorsítótárba helyezheti vagy eldobhatja az eseményeket, vagy egyáltalán nem valósíthat meg semmilyen viselkedést, az utolsó esetben mi leszünk felelősek annak meghatározásáért, az ellennyomás-operátorok használatával.

EllennyomásStrategy hasonló Ellennyomás mód jelen van az RxJava előző verziójában.

Öt különböző stratégia áll rendelkezésre az RxJava 2-ben.

4.1. Puffer

Ha a EllennyomásStrategy.BUFFER, a forrás az összes eseményt pufferolja, amíg az előfizető el nem tudja fogyasztani őket:

public void thenAllValuesAreBufferedAndReceived () {List testList = IntStream.range (0, 100000) .boxed () .collect (Collectors.toList ()); Megfigyelhető megfigyelhető = Megfigyelhető.fromIterable (testList); TestSubscriber testSubscriber = megfigyelhető .Flowable (BackpressureStrategy.BUFFER) .observeOn (Schedulers.computation ()). Test (); testSubscriber.awaitTerminalEvent (); Fogadott listaInts = testSubscriber.getEvents () .get (0) .stream () .mapToInt (objektum -> (int) objektum) .boxed () .collect (Collectors.toList ()); assertEquals (testList, kapottInts); }

Hasonló a hivatkozáshoz onBackpressureBuffer () módszer be Folyékony, de nem teszi lehetővé a pufferméret vagy az onOverflow művelet kifejezett meghatározását.

4.2. Csepp

Használhatjuk a EllennyomásStrategy.DROP pufferelés helyett elvetni azokat az eseményeket, amelyek nem fogyaszthatók el.

Ez megint hasonló a használathoz onBackpressureDrop() tovább Folyékony:

public void whenDropStrategyUsed_thenOnBackpressureDropped () {Megfigyelhető megfigyelhető = Megfigyelhető.fromIterable (testList); TestSubscriber testSubscriber = megfigyelhető .Flowable (BackpressureStrategy.DROP) .observeOn (Schedulers.computation ()) .test (); testSubscriber.awaitTerminalEvent (); Fogadott listaInts = testSubscriber.getEvents () .get (0) .stream () .mapToInt (objektum -> (int) objektum) .boxed () .collect (Collectors.toList ()); assertThat (kapottInts.size () <testList.size ()); assertThat (! kapottInts.contains (100000)); }

4.3. Legújabb

Használni a EllennyomásStrategy.LABBB arra kényszeríti a forrást, hogy csak a legújabb eseményeket őrizze meg, felülírva ezzel a korábbi értékeket, ha a fogyasztó nem képes lépést tartani:

public void whenLatestStrategyUsed_thenTheLastElementReceived () {Megfigyelhető megfigyelhető = Megfigyelhető.FromIterable (testList); TestSubscriber testSubscriber = megfigyelhető .toFlowable (BackpressureStrategy.LATEST) .observeOn (Schedulers.computation ()) .test (); testSubscriber.awaitTerminalEvent (); Fogadott listaInts = testSubscriber.getEvents () .get (0) .stream () .mapToInt (objektum -> (int) objektum) .boxed () .collect (Collectors.toList ()); assertThat (kapottInts.size () <testList.size ()); assertThat (kapottInts.contains (100000)); }

BackpressureStrategy.LATEST és BackpressureStrategy.DROP nagyon hasonlóan néz ki, ha megnézzük a kódot.

Azonban, EllennyomásStrategy.LEGYEBB felülírja azokat az elemeket, amelyeket előfizetőnk nem tud kezelni, és csak a legújabbakat fogja megtartani, innen a név.

EllennyomásStrategy.DROP, másrészt elveti azokat az elemeket, amelyek nem kezelhetők. Ez azt jelenti, hogy a legújabb elemek nem feltétlenül kerülnek kibocsátásra.

4.4. Hiba

Amikor a EllennyomásStrategy.ERROR, egyszerűen ezt mondjuk nem számítunk az ellennyomás bekövetkezésére. Következésképpen a MissingBackpressureException dobni kell, ha a fogyasztó nem tud lépést tartani a forrással:

public void whenErrorStrategyUsed_thenExceptionIsThrown () {Megfigyelhető megfigyelhető = Megfigyelhető.tartomány (1, 100000); TestSubscriber előfizető = megfigyelhető. ToFlowable (BackpressureStrategy.ERROR) .observeOn (Schedulers.computation ()) .test (); subscriber.awaitTerminalEvent (); subscriber.assertError (MissingBackpressureException.class); }

4.5. Hiányzó

Ha a EllennyomásStrategy, a forrás eldobás vagy pufferelés nélkül fogja tolni az elemeket.

A downstreamnek ebben az esetben a túlcsordulásokkal kell megküzdenie:

public void whenMissingStrategyUsed_thenException () {Megfigyelhető megfigyelhető = Megfigyelhető.tartomány (1, 100000); TestSubscriber előfizető = megfigyelhető .toFlowable (BackpressureStrategy.MISSING) .observeOn (Schedulers.computation ()) .test (); subscriber.awaitTerminalEvent (); subscriber.assertError (MissingBackpressureException.class); }

Tesztjeink során kivételt képezünk Hiányzó ellennyomás-kivétel mindkettőnek HIBA és HIÁNYZÓ stratégiák. Mivel mindketten ilyen kivételeket vetnek fel, amikor a forrás belső puffere túlcsordul.

Érdemes azonban megjegyezni, hogy mindkettőjüknek más a célja.

Akkor használjuk az előbbit, amikor egyáltalán nem számítunk ellennyomásra, és azt akarjuk, hogy a forrás kivételt tegyen arra az esetre, ha ez bekövetkezik.

Ez utóbbi használható, ha nem akarunk alapértelmezett viselkedést megadni a Folyékony. És a későbbiekben definiálni fogjuk az ellennyomás-operátorokat.

5. Összefoglalás

Ebben az oktatóanyagban bemutattuk az RxJava-ban bevezetett új osztályt 2 hívott Folyékony.

További információért a Folyékony önmagában és az API-ján hivatkozhatunk a dokumentációra.

Mint mindig, az összes kódminta megtalálható a GitHubon.