Reaktívne programovanie java. Reaktívne programovanie v Objective-C

Chcem vám povedať o modernej programovacej disciplíne, ktorá spĺňa rastúce požiadavky na škálovateľnosť, odolnosť voči chybám a rýchlu odozvu a je nenahraditeľná vo viacjadrových prostrediach aj v cloud computing, ako aj predstaviť na ňom otvorený online kurz, ktorý sa začne už o pár dní.

Ak ste ešte nepočuli o reaktívne programovanie, Všetko je v poriadku. Ide o rýchlo sa rozvíjajúcu disciplínu, ktorá kombinuje súbežnosť s udalosťami riadenou a asynchrónnou. Reaktivita je súčasťou každej webovej služby a distribuovaného systému a je jadrom mnohých vysokovýkonných systémov s vysokým stupňom paralelizmu. V skratke, autori kurzu navrhujú považovať reaktívne programovanie za prirodzené rozšírenie funkcionálneho programovania (s funkciami vyššieho rádu) na paralelné systémy s distribuovaným stavom, koordinované a riadené asynchrónnymi dátovými tokmi vymieňanými aktívnymi subjektmi, resp. herci.

Zrozumiteľnejšími slovami je to popísané v Reaktívnom manifeste, nižšie z neho prerozprávam hlavné ustanovenia a celý preklad je uverejnený na Habré. Ako hovorí Wikipedia, termín reaktívne programovanie existuje už dlho a praktické aplikácie rôznou mierou exotiky, no nový impulz pre vývoj a distribúciu dostal pomerne nedávno, vďaka úsiliu autorov Reaktívneho manifestu, iniciatívnej skupiny z Typesafe Inc. Typesafe je v komunite funkcionálneho programátora známa ako spoločnosť založená autormi vynikajúceho jazyka Scala a revolučnej paralelnej platformy Akka. Teraz stavajú svoju spoločnosť ako tvorcu prvej prúdovej platformy na svete navrhnutej na vývoj novej generácie. Ich platforma vám umožňuje rýchlo rozvíjať komplex používateľské rozhrania a poskytuje novú úroveň abstrakcie v porovnaní s paralelným výpočtom a multithreadingom, čím znižuje ich vlastné riziká prostredníctvom garantovaného predvídateľného škálovania. Uvádza do praxe myšlienky Reaktívneho manifestu a umožňuje vývojárom pochopiť a vytvoriť aplikácie, ktoré zodpovedajú dnešným potrebám.

Túto platformu a reaktívne programovanie môžete spoznať účasťou na online kurze Reactive Principles Massive Open. Tento kurz je pokračovaním kurzu Martina Oderského „Princípy funkčného programovania v Scale“, ktorý mal viac ako 100 000 účastníkov a preukázal jednu z najvyšších mier úspešnosti Masívneho otvoreného online kurzu jeho účastníkov na svete. Spolu s tvorcom jazyka Scala nový kurz vyučujú Eric Meyer, ktorý vyvinul Rx framework pre reaktívne programovanie pod .NET, a Roland Kuhn, ktorý v súčasnosti vedie vývojový tím Akka v Typesafe. Kurz pokrýva kľúčové prvky reaktívneho programovania a ukazuje, ako sa používajú pri navrhovaní systémov riadených udalosťami, ktoré sú škálovateľné a odolné voči chybám. Učebný materiál je ilustrovaný krátke programy a je sprevádzaný súborom úloh, z ktorých každá je softvérovým projektom. V prípade úspešného splnenia všetkých úloh získavajú účastníci certifikáty (účasť a certifikáty sú samozrejme bezplatné). Kurz trvá 7 týždňov a začína už tento pondelok 4. novembra. Podrobný prehľad, ako aj úvodné video sú k dispozícii na stránke kurzu: https://www.coursera.org/course/reactive.

Pre tých, ktorí majú záujem alebo pochybujú, ponúkam výstižné zhrnutie základných pojmov Reaktívneho manifestu. Jeho autori zaznamenávajú výrazné zmeny v požiadavkách na aplikácie pre posledné roky. Dnes sú aplikácie nasadené v akomkoľvek prostredí od mobilné zariadenia do cloudových klastrov s tisíckami viacjadrových procesorov. Tieto prostredia kladú nové požiadavky softvér a technológie. Architektúry predchádzajúcej generácie sa zameriavali na spravované servery a kontajnery, škálovanie prostredníctvom dodatočného drahého hardvéru, proprietárnych riešení a paralelné počítanie prostredníctvom multithreadingu. V súčasnosti sa vyvíja nová architektúra, ktorá má štyri kľúčové vlastnosti, ktoré čoraz viac prevládajú v spotrebiteľskom aj podnikovom priemyselnom prostredí. Systémy s touto architektúrou sú: riadené udalosťami, škálovateľné, odolné voči chybám (Resilient) a majú rýchlu odozvu, t.j. responzívny (Responsive). To poskytuje bezproblémovú používateľskú skúsenosť v reálnom čase podporovanú samoopraviteľným, škálovateľným zásobníkom aplikácií, ktorý je pripravený na nasadenie vo viacjadrových a cloudových prostrediach. Každá zo štyroch charakteristík reaktívnej architektúry sa vzťahuje na celý technologický zásobník, čo ich odlišuje od prepojení vo vrstvených architektúrach. Pozrime sa na ne trochu podrobnejšie.


Udalosťami riadené aplikácie predpokladajú asynchrónne komponentné komunikácie a implementujú ich voľne prepojený dizajn: odosielateľ a príjemca správy nemusia vedieť ani jeden o druhom, ani o spôsobe prenosu správy, čo im umožňuje sústrediť sa na obsah komunikácie. Okrem toho, že voľne spojené komponenty výrazne zlepšujú udržiavateľnosť, rozšíriteľnosť a vývoj systému, asynchrónnosť a neblokovanie ich interakcie môže tiež uvoľniť významnú časť zdrojov, skrátiť čas odozvy a poskytnúť O viac priepustnosť v porovnaní s tradičnými aplikáciami. Je to vďaka udalosti riadenej povahe, že ostatné funkcie reaktívnej architektúry sú možné.

Škálovateľnosť v rámci reaktívneho programovania ide o reakciu systému na zmenu záťaže, t.j. elasticita, dosiahnutá schopnosťou pridávať alebo uvoľňovať výpočtové uzly podľa potreby. Vďaka nízkej väzbe, asynchrónnemu zasielaniu správ a transparentnosti umiestnenia sa metóda nasadenia a topológia aplikácie stávajú rozhodnutím o čase nasadenia a podliehajú konfigurácii a adaptívnym algoritmom reagujúcim na zaťaženie. teda počítačová sieť sa stáva súčasťou aplikácie, ktorá má pôvodne explicitne distribuovaný charakter.

odolnosť proti chybám Súčasťou návrhu sa stáva aj reaktívna architektúra, čo ju výrazne odlišuje od tradičných prístupov k zabezpečeniu nepretržitej dostupnosti systému prostredníctvom redundancie servera a núdzového prepnutia. Odolnosť takéhoto systému je dosiahnutá jeho schopnosťou správne reagovať na zlyhania jednotlivých komponentov, izolovať tieto zlyhania uložením ich kontextu vo forme správ, ktoré ich spôsobili, a odovzdať tieto správy ďalšiemu komponentu, ktorý môže rozhodnúť o spôsobe zvládnuť chybu. Tento prístup vám umožňuje udržiavať obchodnú logiku aplikácie čistú, oddeľujúc od nej logiku odstraňovania porúch, ktorá je formulovaná v explicitnej deklaratívnej forme na registráciu, izoláciu a spracovanie zlyhaní prostredníctvom samotného systému. Na vybudovanie takýchto samoopravných systémov sú komponenty usporiadané hierarchicky a problém je eskalovaný na úroveň, ktorá ho dokáže vyriešiť.

A nakoniec schopnosť reagovať- je to schopnosť systému reagovať na vstup používateľa bez ohľadu na zaťaženie a poruchy, takéto aplikácie zapájajú používateľa do interakcie, vytvárajú pocit úzke spojenie so systémom a dostatočným vybavením na vykonávanie aktuálnych úloh. Schopnosť odozvy je dôležitá nielen v systémoch v reálnom čase, ale je potrebná aj pre širokú škálu aplikácií. Navyše systém, ktorý nie je schopný rýchlo reagovať ani v čase zlyhania, nemožno považovať za odolný voči poruchám. Odozva sa dosahuje použitím pozorovateľných modelov, tokov udalostí a stavových klientov. Pozorovateľné modely vysielajú udalosti, keď sa ich stav zmení, a poskytujú interakciu medzi používateľmi a systémami v reálnom čase, zatiaľ čo toky udalostí poskytujú abstrakciu, na ktorej je táto interakcia postavená prostredníctvom neblokujúcich asynchrónnych transformácií a komunikácií.

Reaktívne aplikácie teda predstavujú vyvážený prístup k riešeniu širokého spektra problémov moderného vývoja softvéru. Postavené na udalostiami riadenom základe poskytujú nástroje potrebné na zaručenie škálovateľnosti a odolnosti voči chybám a podporujú plnohodnotnú responzívnu používateľskú skúsenosť. To všetko autori očakávajú viac systémy budú dodržiavať zásady reaktívneho manifestu.

Okrem toho dávam plán kurzu bez prekladu. Pre prípad, že ste sa dočítali až sem a stále ste zvedaví.

1. týždeň: Prehľad princípov funkcionálneho programovania: substitučný model, for-výrazy a ako súvisia s monádami. Predstavuje novú implementáciu for-výrazov: generátory náhodných hodnôt. Ukazuje, ako sa to dá použiť pri náhodnom testovaní, a poskytuje prehľad nástroja ScalaCheck, ktorý túto myšlienku implementuje.

2. týždeň: Funkčné programovanie a premenlivý stav. Čo robí objekt premenlivým? Ako to ovplyvňuje substitučný model. Rozšírený príklad: Simulácia digitálnych obvodov

3. týždeň: futures. Predstavuje futures ako ďalšiu monádu s výrazmi for ako konkrétnou syntaxou. Ukazuje, ako možno zložiť futures, aby sa zabránilo blokovaniu vlákien. Diskutuje o riešení chýb krížového vlákna.

4. týždeň: Reaktívne spracovanie prúdu. Zovšeobecnenie futures na reaktívne výpočty cez toky. operátorov streamov.

5. týždeň:Herci. Predstavuje model aktéra, hercov ako zapuzdrené jednotky konzistencie, asynchrónne odovzdávanie správ, rozoberá rôzne sémantiky doručovania správ (maximálne raz, aspoň raz, presne raz) a prípadnú konzistentnosť.

6. týždeň: dozor. Predstavuje reifikáciu zlyhania, hierarchické spracovanie zlyhania, vzor jadra chýb, monitorovanie životného cyklu, pojednáva o prechodnom a pretrvávajúcom stave.

7. týždeň: Vzory konverzácie. Diskutuje o riadení konverzačného stavu medzi aktérmi a vzoroch pre riadenie toku, smerovanie správ do skupín aktérov na zvýšenie odolnosti alebo vyrovnávanie záťaže, potvrdenie prijatia na dosiahnutie spoľahlivého doručenia.

Svet vývoja OOP všeobecne a jazyk Java zvlášť žije veľmi aktívnym životom. Má svoje vlastné módne trendy a dnes budeme analyzovať jeden z hlavných trendov sezóny - rámec ReactiveX. Ak sa stále vzďaľujete od tejto vlny - sľubujem, že sa vám bude páčiť! Je to určite lepšie ako džínsy s vysokým pásom :).

Reaktívne programovanie

Len čo jazyky OOP dozreli na masové používanie, vývojári si uvedomili, ako často chýbajú možnosti jazykov podobných C. Keďže písanie kódu v štýle funkcionálneho programovania vážne ničí kvalitu kódu OOP, a tým aj udržiavateľnosť projektu, bol vynájdený hybrid - reaktívne programovanie.

Paradigma reaktívneho vývoja je založená na myšlienke neustáleho sledovania zmien v stave objektu. Ak sa takéto zmeny vyskytli, všetky zainteresované objekty by mali dostať už aktualizované údaje a pracovať iba s nimi, pričom zabudnú na staré.

Dobrým príkladom nápadu reaktívneho programovania je tabuľka Excel. Ak prepojíte niekoľko buniek jedným vzorcom, výsledok výpočtu sa zmení pri každej zmene údajov v týchto bunkách. Pre účtovníctvo je takáto dynamická zmena údajov bežná vec, no pre programátorov skôr výnimkou.

A = 3; b = 4; c=a+b; Fl(c); a = 1; F2(c);

V tomto príklade budú funkcie F1 a F2 pracovať s rôznymi hodnotami premennej C. Často sa vyžaduje, aby obe funkcie mali len najaktuálnejšie údaje - reaktívne programovanie vám umožní okamžite volať F1 s novým parametre bez zmeny logiky samotných funkcií. Táto štruktúra kódu dáva aplikácii schopnosť okamžite reagovať na akékoľvek zmeny, vďaka čomu bude rýchla, flexibilná a pohotová.

ReactiveX

Implementácia nápadov reaktívneho programovania od nuly môže byť dosť problematická – existujú úskalia a zaberie to dosť času. Preto pre mnohých vývojárov zostala táto paradigma iba teoretickým materiálom, kým sa neobjavil ReactiveX.

Rámec ReactiveX je reaktívny programovací nástroj, ktorý funguje so všetkými populárnymi jazykmi OOP. Sami tvorcovia to nazývajú multiplatformové API pre asynchrónny vývoj, založené na vzore Observer.

Ak je pojem „reaktívne programovanie“ akýmsi teoretickým modelom, potom vzor Pozorovateľ je hotový mechanizmus na sledovanie zmien v programe. A musíte ich sledovať pomerne často: načítavanie a aktualizácia údajov, upozornenia na udalosti atď.

Vzor Observer existuje približne tak dlho ako samotný OOP. Objekt, ktorého stav sa môže meniť, sa nazýva vydavateľ (populárny preklad výrazu Observable). Všetci ostatní účastníci, ktorí majú záujem o tieto zmeny, sú predplatiteľmi (Pozorovateľ, Predplatiteľ). Ak chcete dostávať upozornenia, predplatitelia sa zaregistrujú u vydavateľa výslovným uvedením svojho ID. Vydavateľ z času na čas generuje upozornenia, ktoré vydavateľ zasiela na zoznam registrovaných predplatiteľov.

V skutočnosti tvorcovia ReactiveX neprišli s ničím prevratným, len pohodlne implementovali vzor. A hoci mnohé OOP jazyky, a najmä Java, majú hotové implementácie vzoru, tento rámec má dodatočné „ladenie“, ktoré mení „Pozorovateľa“ na veľmi silný nástroj.

RxAndroid

Port knižnice ReactiveX pre svet Androidu sa nazýva rxAndroid a je pripojený ako vždy cez Gradle.

Kompilovať "io.reactivex:rxandroid:1.1.0"

Vydavateľ, ktorý generuje upozornenia, je tu špecifikovaný pomocou triedy Observable. Vydavateľ môže mať viacero predplatiteľov, na ich implementáciu použijeme triedu Subscriber. Predvolené správanie pre Pozorovateľné je vydať jednu alebo viac správ predplatiteľom a potom ukončiť alebo vydať chybové hlásenie. Správy môžu byť premenné aj celočíselné objekty.

Rx.Observable myObserv = rx.Observable.create(new rx.Observable.OnSubscribe () ( @Override public void call (Predplatiteľúčastník) ( subscriber.onNext("Ahoj"); subscriber.onNext("svet"); subscriber.onCompleted(); ) ));

V tomto prípade vydavateľ myObserv najprv odošle reťazec hello a message a potom správu o úspechu. Vydavateľ môže volať metódy onNext() , onCompleted() a onEror(), takže predplatitelia ich musia mať definované.

Predplatiteľ mySub = nový predplatiteľ () (... @Override public void onNext(String value) (Log.e("got data", " " + value);) );

Všetko je pripravené na prácu. Zostáva spojiť objekty navzájom - a "Ahoj, svet!" v reaktívnom programovaní je pripravený!

MyObserv.subscribe(mySub);

Musím povedať, že to bol veľmi jednoduchý príklad. ReactiveX má veľa možností pre správanie všetkých účastníkov vzoru: filtrovanie, zoskupovanie, spracovanie chýb. Výhody reaktívneho programovania môžete pocítiť len tak, že si ho vyskúšate v praxi. Poďme k úlohe vážnejšie.

Pokračovanie dostupné len pre členov

Možnosť 1. Pripojte sa ku komunite „stránky“ a prečítajte si všetky materiály na stránke

Členstvo v komunite počas určeného obdobia vám umožní prístup ku VŠETKÝM materiálom Hackerov, zvýši vašu osobnú kumulatívnu zľavu a umožní vám získať profesionálne hodnotenie Xakep Score!

Choď.

Reaktívne programovanie na prvý pohľad znie ako názov rodiacej sa paradigmy, ale v skutočnosti sa vzťahuje na metódu programovania, ktorá využíva na prácu s asynchrónnymi dátovými tokmi prístup riadený udalosťami. Na základe neustále aktuálnych údajov na ne reaktívne systémy reagujú vykonaním série udalostí.
Reaktívne programovanie sa riadi vzorom návrhu Observer, ktorý možno definovať nasledovne: ak dôjde k zmene stavu v jednom objekte, všetky ostatné objekty sú náležite upozornené a aktualizované. Takže namiesto dotazovania udalostí na zmeny sa udalosti posúvajú asynchrónne, aby ich pozorovatelia mohli spracovať. V tomto príklade sú pozorovatelia funkcie, ktoré sa vykonajú pri odoslaní udalosti. A spomínaný dátový tok je skutočne pozorovateľný.

Takmer všetky jazyky a rámce používajú tento prístup vo svojom ekosystéme a najnovšie verzie Java nie sú výnimkou. V tomto článku vysvetlím, ako možno použiť reaktívne programovanie pomocou najnovšej verzie JAX-RS vo funkcionalite Java EE 8 a Java 8.

Reaktívny manifest

Reaktívny manifest uvádza štyri základné aspekty, podľa ktorých musí byť aplikácia flexibilnejšia, voľnejšie prepojená a ľahko škálovateľná, a preto musí byť reaktívna. Hovorí, že aplikácia musí byť responzívna, flexibilná (a teda škálovateľná), odolná a riadená správami.

Základným cieľom je skutočne citlivá aplikácia. Povedzme, že máte aplikáciu, ktorá má jedno veľké vlákno spracúvajúce požiadavky používateľov, a keď je práca hotová, toto vlákno posiela odpovede späť pôvodným žiadateľom. Keď aplikácia dostane viac požiadaviek, než dokáže spracovať, tento tok sa stane prekážkou a aplikácia stratí svoju bývalú odozvu. Aby aplikácia zostala responzívna, musí byť škálovateľná a odolná. Odolná aplikácia je tá, ktorá má funkciu automatického obnovenia. Podľa skúseností väčšiny vývojárov iba architektúra riadená správami umožňuje, aby bola aplikácia škálovateľná, robustná a pohotová.

Reaktívne programovanie bolo predstavené v jazykoch Java 8 a Java EE 8. Jazyk Java zaviedol pojmy ako CompletionStage a jeho implementácia CompletableFuture a Java začala tieto funkcie používať v špecifikáciách, ako je Reactive Client API v JAX-RS.

JAX-RS 2.1 Reactive Client API

Pozrime sa, ako možno použiť reaktívne programovanie v aplikáciách Java EE 8. Na pochopenie procesu potrebujete základné znalosti Java EE API.

JAX-RS 2.1 predstavil nový spôsob vytvorenia reaktívneho REST klienta. Predvolená implementácia vyvolávača ponúkaného JAX-RS je synchrónna, čo znamená, že vytváraný klient odošle blokovacie volanie do koncového bodu servera. Príklad implementácie je uvedený vo výpise 1.

Odpoveď odpovede = ClientBuilder.newClient() .target("http://localhost:8080/service-url") .request() .get();
Počnúc verziou 2.0 poskytuje JAX-RS podporu pre vytváranie asynchrónneho vyvolávača na klientskom rozhraní API jednoduchým volaním metódy async(), ako je uvedené vo výpise 2.

Budúcnosť odpoveď = ClientBuilder.newClient() .target("http://localhost:8080/service-url") .request() .async() .get();
Použitie asynchrónneho vyvolávača na klientovi vráti budúcu inštanciu typu javax.ws.rs.core.Response . To môže mať za následok vyžiadanie odpovede, volanie future.get() alebo registráciu spätného volania, ktoré sa zavolá, keď bude dostupná odpoveď HTTP. Obidve implementácie sú vhodné pre asynchrónne programovanie, ale veci majú tendenciu byť komplikovanejšie, ak chcete zoskupiť spätné volania alebo pridať podmienené prípady k týmto minimám asynchrónneho vykonávania.

JAX-RS 2.1 poskytuje reaktívny spôsob na prekonanie týchto problémov s novým JAX-RS Reactive Client API pre zostavenie klienta. Je to také jednoduché ako volanie metódy rx() počas zostavovania klienta. Vo výpise 3 metóda rx() vracia reaktívny vyvolávač, ktorý existuje počas vykonávania klienta, a klient vracia odpoveď s typom CompletionStage.rx() , ktorý umožňuje prechod zo synchrónneho vyvolávača na asynchrónny vyvolávač jednoduchým hovor.

Fáza dokončenia odpoveď = ClientBuilder.newClient() .target("http://localhost:8080/service-url") .request() .rx() .get();
Fáza dokončenia<Т>je nové rozhranie zavedené v Java 8. Predstavuje výpočet, ktorý môže byť krokom v rámci väčšieho výpočtu, ako už názov napovedá. Toto je jediná reaktivita Java 8, ktorá sa dostala do JAX-RS.
Po prijatí inštancie odpovede môžem zavolať AcceptAsync() , kde môžem poskytnúť časť kódu, ktorý sa vykoná asynchrónne, keď bude odpoveď k dispozícii, ako je uvedené vo výpise 4.

Response.thenAcceptAsync(res -> ( Teplota t = res.readEntity(Temperature.class); //robte veci s t ));
Pridanie reaktivity ku koncovému bodu REST

Reaktívny prístup nie je v JAX-RS obmedzený na stranu klienta; dá sa použiť aj na strane servera. Ako príklad si najprv vytvorím jednoduchý skript, v ktorom si môžem vyžiadať zoznam miest pre jeden cieľ. Pre každú polohu vykonám samostatný hovor s údajmi o polohe do iného bodu, aby som získal hodnoty teploty. Interakcia destinácií bude taká, ako je znázornené na obrázku 1.

Obrázok 1. Interakcia medzi destináciami

Najprv len definujem model domény a potom služby pre každý model. Výpis 5 ukazuje, ako je definovaná trieda Forecast, ktorá zahŕňa triedy Location a Temperature.

Public class Temperature ( private Double temperature; private String scale; // getters & setters ) public class Location ( String name; public Location() () public Location (String name) ( this.name = name; ) // getters & setters ) public class Forecast ( private Location location; private Temperature temperature; public Forecast(Location location) ( this.location = location; ) public Forecast setTemperature(final Temperature temperature) ( this.temperature = teplota; return this; ) // getters )
Na zabalenie zoznamu predpovedí je vo výpise 6 implementovaná trieda ServiceResponse.

Verejná trieda ServiceResponse( súkromný dlhý čas spracovania; súkromný zoznam prognózy = nový ArrayList<>(); public void setProcessingTime(long processingTime) ( this.processingTime = processingTime; ) public ServiceResponse forecasts(List predpovede) ( this.forecasts = predpovede; vrátiť toto; ) // getters )
LocationResource, zobrazený vo výpise 7, definuje tri vzory umiestnení vrátených s cestou/umiestnením .

@Path("/location") public class LocationResource ( @GET @Produces(MediaType.APPLICATION_JSON) public Response getLocations() ( Zoznam miesta = nový ArrayList<>(); Locations.add(new Location("Londýn")); Locations.add(new Location("Istanbul")); Locations.add(new Location("Praha")); return Response.ok(new GenericEntity >(umiestnenia)()).build(); ))
TemperatureResource , zobrazený vo výpise 8, vracia náhodne vygenerovanú hodnotu teploty medzi 30 a 50 pre dané miesto. Do implementácie bolo pridané oneskorenie 500 ms na simuláciu čítania snímača.

@Path("/temperature") public class TemperatureResource ( @GET @Path("/(city)") @Produces(MediaType.APPLICATION_JSON) public Response getAverageTemperature(@PathParam("city") String cityName) ( Teplota teploty = new Temperature(); temperature.setTemperature((double) (new Random().nextInt(20) + 30)); temperature.setScale("Celsius"); try ( Thread.sleep(500); ) catch (InterruptedException ignorovaná) ( ignored.printStackTrace(); ) return Response.ok(temperature).build(); ) )
Najprv ukážem implementáciu synchrónneho ForecastResource (pozri Výpis 9), ktorý vracia všetky miesta. Potom pre každú polohu zavolá službu teploty, aby získal hodnoty v stupňoch Celzia.

@Path("/forecast") verejná trieda ForecastResource ( @Uri("location") private WebTarget locationTarget; @Uri("temperature/(city)") private WebTarget temperatureTarget; @GET @Produces(MediaType.APPLICATION_JSON) public Response getLocationsWithTemperature () ( long startTime = System.currentTimeMillis(); ServiceResponse response = new ServiceResponse(); List Locations = locationTarget .request() .get(new GenericType >()()); forEach(location -> ( Teplota teplota = teplotaTarget .resolveTemplate("mesto", location.getName()) .request() .get(Temperature.class); response.getForecasts().add(new Forecast(location) .setTemperature (teplota)); )); long endTime = System.currentTimeMillis(); response.setProcessingTime(endTime - startTime); return Response.ok(response).build(); ))
Keď je predpovedaný cieľ vyžiadaný ako /forecast , dostanete výstup podobný výpisu 10. Všimnite si, že spracovanie požiadavky trvalo 1,533 ms, čo je logické, pretože vyžiadanie teplôt z troch rôznych miest synchrónne sčítava až 1,5 ms.

( "predpovede": [ ( "miesto": ( "meno": "Londýn" ), "teplota": ( "mierka": "Celsius", "teplota": 33) ), ( "miesto": ( "meno" ": "Istanbul" ), "teplota": ( "stupnica": "Celsius", "teplota": 38) ), ( "miesto": ( "názov": "Praha" ), "teplota": ( "stupnica" ": "Celsius", "teplota": 46 ) ) ], "čas spracovania": 1533 )
Zatiaľ ide všetko podľa plánu. Je čas zaviesť reaktívne programovanie na strane servera, kde je možné paralelne volať do každého miesta po prijatí všetkých miest. To môže jasne zlepšiť synchrónny tok znázornený vyššie. Toto sa vykonáva vo výpise 11, ktorý zobrazuje definíciu reaktívnej verzie predpovednej služby.

@Path("/reactiveForecast") verejná trieda ForecastReactiveResource ( @Uri("location") private WebTarget locationTarget; @Uri("temperature/(city)") private WebTarget temperatureTarget; @GET @Produces(MediaType.APPLICATION_JSON) public void getLocationsWithTemperature (@Suspended final AsyncResponse async) ( long startTime = System.currentTimeMillis(); // Vytvorenie fázy na získanie umiestnení CompletionStage > locationCS = locationTarget.request() .rx() .get(new GenericType >() ()); // Vytvorením samostatnej fázy vo fáze miest, // opísanej vyššie, zhromaždite zoznam predpovedí // ako v jednom veľkom konečnom štádiu CompletionStage. > forecastCS = locationCS.thenCompose(locations -> ( // Vytvorenie fázy na získanie predpovedí // ako zoznam CompletionStage List > forecastList = // Streamujte miesta a spracujte každé z nich // samostatne locations.stream().map(location -> ( // Vytvorte krok na získanie // teplôt iba jedného mesta // podľa názvu final CompletionStage tempCS = temperatureTarget .resolveTemplate("mesto", location.getName()) .request() .rx() .get(Temperature.class); // Potom vytvorte CompletableFuture, ktorá // obsahuje inštanciu predpovede s // umiestnením a hodnotou teploty return CompletableFuture.completedFuture(new Forecast(location)) .thenCombine(tempCS, Forecast::setTemperature); )).collect(Collectors.toList()); // Vráti konečnú inštanciu CompletableFuture, kde // všetky prezentované skompletizovateľné budúce objekty sú // dokončené return CompletableFuture.allOf(forecastList.toArray(new CompletableFuture)) .thenApply(v -> forecastList.stream() .map(CompletionStage::toCompletableFuture ) .map(CompletableFuture::join) .collect(Collectors.toList())); )); // Vytvorte inštanciu ServiceResponse, ktorá // obsahuje úplný zoznam predpovedí // spolu s časom spracovania. // Vytvorte jeho budúcnosť a skombinujte ju s // forecastCS na získanie predpovedí // a vložte do služby odpoveď CompletableFuture.completedFuture(new ServiceResponse()) .thenCombine(forecastCS, ServiceResponse::forecasts) .whenCompleteAsync((response, throwable) - > ( response.setProcessingTime(System.currentTimeMillis() - startTime); async.resume(response); )); ))
Reaktívna implementácia sa môže zdať na prvý pohľad komplikovaná, no po bližšom pohľade si všimnete, že je celkom jednoduchá. V implementácii ForecastReactiveResource najskôr uskutočním klientske volanie do lokalizačných služieb pomocou JAX-RS Reactive Client API. Ako som spomenul vyššie, ide o doplnok pre Java EE 8 a pomáha vytvoriť reaktívne volanie jednoducho pomocou metódy rx().

Teraz vytváram novú fázu založenú na polohe, aby som zhromaždil zoznam predpovedí. Budú uložené ako zoznam prognóz v jednej veľkej fáze dokončenia s názvom forecastCS. Nakoniec vytvorím odpoveď na servisné volanie iba pomocou forecastCS .

Teraz zhromaždíme prognózy ako zoznam etáp dokončenia definovaných v premennej forecastList . Na vytvorenie fázy dokončenia pre každú predpoveď odovzdám údaje o polohe a potom vytvorím premennú tempCS, opäť pomocou rozhrania JAX-RS Reactive Client API, ktoré volá službu teploty s názvom mesta. Tu používam metódu resolveTemplate() na zostavenie klienta, čo mi umožňuje odovzdať názov mesta staviteľovi ako parameter.

Ako posledný krok streamovania zavolám CompletableFuture.completedFuture() , pričom ako parameter odovzdám novú inštanciu Forecast. Kombinujem túto budúcnosť s fázou tempCS, aby som mal hodnotu teploty pre iterované miesta.

Metóda CompletableFuture.allOf() vo výpise 11 konvertuje zoznam štádií dokončenia na forecastCS . Vykonaním tohto kroku sa vráti veľká splniteľná budúcnosť, keď budú dokončené všetky dodané splniteľné futures.

Odpoveď služby je inštanciou triedy ServiceResponse, takže vytvorím dokončenú budúcnosť a potom zreťazím fázu dokončenia forecastCS so zoznamom prognóz a vypočítam čas odozvy služby.

Samozrejme, reaktívne programovanie iba núti stranu servera, aby sa vykonávala asynchrónne; strana klienta bude blokovať, kým server nepošle odpoveď späť žiadateľovi. Na prekonanie tohto problému je možné použiť Server Sent Events (SSE) na odoslanie čiastočnej odpovede hneď, ako je k dispozícii, takže hodnoty teploty pre každé miesto sa odosielajú klientovi jedna po druhej. Výstup ForecastReactiveResource bude podobný výpisu 12. Ako je uvedené vo výstupe, čas spracovania je 515 ms, čo je ideálny čas vykonania na získanie hodnôt teploty z jedného miesta.

( "predpovede": [ ( "miesto": ( "meno": "Londýn" ), "teplota": ( "mierka": "Celsius", "teplota": 49) ), ( "miesto": ( "meno" ": "Istanbul" ), "teplota": ( "stupnica": "Celsius", "teplota": 32 ) ), ( "miesto": ( "názov": "Praha" ), "teplota": ( "stupnica" ": "Celsius", "teplota": 45 ) ) ], "čas spracovania": 515 )
Záver

V príkladoch v tomto článku som najprv ukázal synchrónny spôsob získavania predpovedí pomocou služieb polohy a teploty. Potom som prešiel na reaktívny prístup, aby som medzi servisnými volaniami vykonal asynchrónne spracovanie. Keď používate JAX-RS Reactive Client API v Java EE 8 spolu s triedami CompletionStage a CompletableFuture dostupnými v Java 8, sila asynchrónneho spracovania sa uvoľní prostredníctvom reaktívneho programovania.

Reaktívne programovanie je viac než len implementácia asynchrónneho modelu zo synchrónneho; zjednodušuje tiež koncepty, ako je fáza hniezdenia. Čím viac sa bude používať, tým ľahšie bude spravovať zložité scenáre v paralelnom programovaní.

Ďakujem za tvoju pozornosť. Ako vždy uvítame vaše pripomienky a otázky.

Môžete pomôcť a previesť nejaké prostriedky na rozvoj stránky

Skontrolujte informácie. Je potrebné skontrolovať správnosť faktov a spoľahlivosť informácií uvedených v tomto článku. Na diskusnej stránke by mali byť vysvetlenia ... Wikipedia

Interaktivita je koncept, ktorý odhaľuje povahu a stupeň interakcie medzi objektmi. Používa sa v oblastiach: teória informácie, informatika a programovanie, telekomunikačné systémy, sociológia, priemyselný dizajn a iné. Vo ... ... Wikipédii

Tento článok by mal byť wikiifikovaný. Naformátujte ho prosím podľa pravidiel formátovania článkov. Tento výraz má iné významy, pozri Electromash (významy) ... Wikipedia

cudzie psychoterapeutické techniky- HĹBKOVÉ TECHNIKY Aktívna psychoterapia (Od Reichmanna). Analýza bytia (Binswanger). Analýza osudu (Sondi). Rozbor postavy (W. Reich). Analýza I (H. Kohut, E. Erickson). Analytická terapia hrou (M. Klein). Rodinná analytická terapia (Richter).… … Veľká psychologická encyklopédia

knihy

  • Reaktívne programovanie v C++. Navrhovanie paralelných a asynchrónnych aplikácií, Pai Praseed, Abraham Peter. Navrhovanie paralelných a asynchrónnych aplikácií pomocou knižnice RxCpp a moderného jazyka C++ 17 Podporované nástroje paralelného programovania Collaborative…
  • , Nurkevich T., Christensen B.. V týchto dňoch, keď sú programy asynchrónne a rýchla odozva je najdôležitejšou vlastnosťou, reaktívne programovanie pomôže písať spoľahlivejší, lepšie škálovateľný a rýchlejší kód.…
  • Reaktívne programovanie s RxJava, Tomas Nurkevich, Ben Christensen. V dnešnej dobe, keď sú programy asynchrónne a rýchla odozva je najdôležitejšou vlastnosťou, vám reaktívne programovanie pomôže napísať spoľahlivejší, lepšie škálovateľný a rýchlejší kód.…

Princípy reaktívneho programovania nie sú nové a možno ich vysledovať až k kľúčovej práci Jima Graya a Pata Hellanda o tandemovom systéme v 70. a 80. rokoch.

Títo ľudia výrazne predbehli dobu. Až za posledných 5-10 rokov bol technický priemysel nútený revidovať existujúce „osvedčené postupy“ pre rozvoj podnikového systému. Naučila sa aplikovať poznatky o reaktívnych princípoch dnešného sveta multi-core a cloud computingu.

Základom pre reaktívny systém je odovzdávanie správ, ktoré vytvára časovú hranicu medzi komponentmi, umožňuje ich časové oddelenie pomocou paralelizmu a priestoru, ktorý rozdeľuje záťaž a poskytuje mobilitu. Toto oddelenie je požiadavkou na úplnú izoláciu medzi komponentmi a tvorí základ pre stabilitu a odolnosť systémov.

Základy reaktívneho programovania

Toto programovanie sa zameriava na tok informácií a šírenie zmien údajov. Pri používaní programovacích jazykov je ľahké oddeliť statické a dynamické toky, zatiaľ čo základný model bude automaticky šíriť zmeny vo všetkých tokoch údajov. Jednoducho povedané, v programovaní Rx, vysielané jedným komponentom a základná štruktúra poskytovaná knižnicami Rx, prenesie tieto zmeny do iného komponentu zaregistrovaného na prijímanie týchto zmien. Reaktívne programovanie Rx pozostáva z troch kľúčových bodov.

Hlavné funkcie komponentov:

  1. Pozorovateľné nie sú nič iné ako prúdy údajov. Pozorovateľné zhromažďuje údaje, ktoré možno prenášať z jedného prúdu do druhého. V zásade vydávajú údaje periodicky alebo len raz za svoj životný cyklus na základe konfigurácií. Existujú rôzne operátory, ktoré môžu pomôcť pozorovateľovi odoslať niektoré špecifické údaje na základe určitých udalostí.
  2. Pozorovatelia spotrebúvajú dátový tok emitovaný pozorovateľným. Pozorovatelia sa prihlasujú pomocou metódy reaktívneho programovania subscribeOn() na prijímanie údajov odovzdávaných pozorovateľným objektom. Kedykoľvek pozorovateľ odošle údaje, všetci registrovaní pozorovatelia dostanú údaje v spätnom volaní onNext(). Tu môžu vykonávať rôzne operácie, ako je analýza odpovede JSON alebo aktualizácia používateľského rozhrania. Ak je chyba spôsobená pozorovateľným, pozorovateľ ju dostane v onError().
  3. Plánovače (schedule) je komponent v Rx, ktorý hovorí pozorovateľom a pozorovateľom, na ktorom vlákne by mali bežať. Pomocou metódy observOn() môžete povedať pozorovateľom, ktoré vlákno by mali sledovať. Alternatívne možno použiť schedOn() na to, aby ste povedali pozorovateľnému, na ktorom vlákne by mali bežať.

Pri reaktívnom programovaní pomocou RxJava predvolené jadrové vlákna ako Schedulers.newThread() vytvoria nové pozadie. Schedulers.io() spustí kód na I/O vlákne.

Hlavnými výhodami Rx sú zvýšené využitie výpočtových zdrojov na viacjadrovom a viacprocesorovom hardvéri, zlepšený výkon znížením počtu bodov a zlepšený výkon znížením počtu serializačných bodov podľa Amdahlovho zákona a Güntherovho zákona o univerzálnej škálovateľnosti.

Druhou výhodou je vysoká produktivita pre vývojárov, pretože tradičné programovacie paradigmy majú problém poskytnúť jednoduchý a udržiavateľný prístup k asynchrónnym a neblokujúcim výpočtom a IO. Funkčné reaktívne programovanie zvláda tieto úlohy, pretože zvyčajne eliminuje potrebu explicitnej koordinácie medzi aktívnymi komponentmi.

Tam, kde sa vyskytuje Rx, vzniká proces vytvárania komponentov a skladba pracovných tokov. Ak chcete naplno využiť výhody asynchrónneho vykonávania, je dôležité povoliť spätný tlak, aby ste sa vyhli nadmernému využívaniu alebo skôr neobmedzenej spotrebe zdrojov. Aby sa zabezpečil stabilný stav, pokiaľ ide o tok údajov, spätný tlak založený na záťaži vysiela dopyt prúdiaci proti prúdu a prijíma správy.

Hlavné výhody systému sú teda:

  1. Zvýšený výkon – vďaka schopnosti rýchlo a konzistentne spracovávať obrovské množstvá dát.
  2. Vylepšené UX – vďaka tomu, že aplikácia lepšie reaguje na používateľa.
  3. Zjednodušené úpravy a aktualizácie – vďaka čitateľnejšiemu a ľahšie predvídateľnému kódu.

Ale aj keď je Reaktívne programovanie veľmi užitočná vec pri budovaní moderného softvéru, na premýšľanie o systéme na vyššej úrovni musíte použiť iný nástroj - Reactive Architecture pre proces navrhovania reaktívnych systémov. Tiež je dôležité si uvedomiť, že existuje veľa programovacích paradigiem a Rx je len jednou z nich, ako každý nástroj, nie je určený pre všetky prípady použitia.

Stabilita reaktívneho systému

Odolnosť je schopnosť reagovať na zlyhanie a je prirodzenou funkčnou vlastnosťou systému. Potrebuje vývoj, nielen spätné doplnenie systému. Odolnosť reaktívneho javascriptového programovania presahuje toleranciu chýb a nie je to spôsobené degradáciou, ale v prípade zlyhania sa môže úplne opraviť.

To si vyžaduje izoláciu komponentov a kontrolu porúch, aby sa predišlo šíreniu porúch na susedné komponenty, čo môže viesť ku kaskádovým scenárom katastrofických porúch. Kľúčom k budovaniu odolných systémov je teda to, že ich možno charakterizovať ako správy odosielané iným komponentom, ktoré pôsobia ako supervízory a sú riadené z bezpečného kontextu mimo zlyhaného komponentu.

Tu, keďže sú riadené správami, tieto zariadenia sa vzďaľujú od tesne prepojených, krehkých, hlboko vnorených synchrónnych volacích reťazcov, ktoré sú väčšinou ignorované. Cieľom je oddeliť riešenie porúch od reťazca hovorov, napríklad oslobodením klienta od zodpovednosti za spracovanie zlyhania servera.

Keďže väčšina systémov je vo svojej podstate zložitá, jedným z najdôležitejších aspektov je zabezpečiť, aby architektúra systému zaisťovala minimálnu degradáciu výkonu pri vývoji aj údržbe komponentov a zároveň znížila náhodnú zložitosť na minimum. Je to dôležité, pretože v priebehu životného cyklu systému, ak nie je správne navrhnutý, bude čoraz ťažšie udržať ho v chode a bude potrebné viac času a úsilia na pochopenie, aby bolo možné izolovať a opraviť problémy.

Reaktívne systémy predstavujú najproduktívnejšiu systémovú architektúru v kontexte viacjadrových, cloudových a mobilných architektúr:

  1. Izolácia porúch ponúka prepážky medzi komponentmi, čím predchádza kaskádovým poruchám a obmedzuje rozsah a závažnosť porúch.
  2. Hierarchie supervízorov ponúkajú viacero úrovní ochrany v kombinácii so schopnosťami samoopravy, čo eliminuje mnoho dočasných zlyhaní akýchkoľvek prevádzkových nákladov na vyšetrenie.
  3. Preskakovanie správ a transparentnosť umiestnenia vám umožňujú deaktivovať a nahradiť komponenty bez ovplyvnenia skúseností koncového používateľa. To znižuje náklady na poruchy, ich relatívnu naliehavosť a zdroje potrebné na ich diagnostiku a opravu.
  4. Replikácia znižuje riziko straty údajov a znižuje dopad zlyhania na dostupnosť získavania a ukladania informácií.
  5. Elasticita umožňuje šetriť zdroje pri kolísaní využívania, čím sa minimalizujú prevádzkové náklady pri nízkej záťaži a riziko zlyhania alebo naliehavé investície do škálovateľnosti pri zvyšovaní záťaže.

Webové aplikácie môžu výrazne ťažiť z vývojového štýlu Rx, ktorý vám umožňuje zostaviť pracovné toky žiadosť-odpoveď, ktoré zahŕňajú vetvenie do servisných volaní, asynchrónne získavanie prostriedkov a kompozíciu odpovedí a následné triedenie pre klienta. V poslednej dobe sa udalosti push-to-server a webové sokety v praxi stávajú čoraz bežnejšími a robiť to vo veľkom rozsahu si vyžaduje efektívny spôsob ukladania mnohých otvorených pripojení a tam, kde IO nie je blokované.

Existujú na to nástroje ako Streams a Futures, ktoré uľahčujú neblokovacie a asynchrónne konverzie a posúvajú ich klientom. Data Access Layer Reactive Programming - Aktualizuje a dopytuje dáta v efektívnom zdroji, najlepšie pomocou SQL alebo NoSQL databáz s asynchrónnymi ovládačmi.

Webové aplikácie tiež profitujú z vývoja reaktívneho systému pre veci, ako je distribuované ukladanie do vyrovnávacej pamäte, konzistencia údajov a viacuzlové upozornenia. Tradičné webové aplikácie zvyčajne používajú stojace uzly. Akonáhle však programátori začnú používať Server-Sent-Events (SSE) a WebSockets, tieto uzly sa stanú funkčnými, pretože minimálne udržiavajú stav pripojenia klienta a podľa toho sa im odosielajú upozornenia push. Vyžaduje si to vývoj reaktívneho systému, pretože toto je oblasť, kde je dôležité oslovovanie príjemcov prostredníctvom správ.

Podstata reaktívneho programovania Java

Nie je povinné používať Rx v reaktívnych systémoch. Pretože programovanie Rx a reaktívne systémy nie sú to isté. Hoci sa často používajú zameniteľne, nie sú presnými synonymami a odrážajú rôzne veci. Systémy predstavujú ďalšiu úroveň „reaktivity“. Táto úroveň zahŕňa špecifické dizajnové a architektonické rozhodnutia, ktoré vám umožňujú vytvárať robustné a flexibilné aplikácie.

Veľmi dobrý nápad – kombinácia metód – však prináša aplikáciám ešte viac výhod, pretože ich robí ešte viac prepojenými, umožňuje efektívnejšie využívanie zdrojov a poskytuje nižšiu latenciu. Pokiaľ ide o obrovské množstvo údajov alebo multitasking, často je potrebné asynchrónne spracovanie, aby systémy boli rýchle a pohotové.

V Jave, dedičstve starého objektovo orientovaného programovania, môže byť asynchrónia skutočne komplikovaná a sťažuje pochopenie a údržbu kódu. Rx je teda obzvlášť užitočný pre toto „čisto“ objektovo orientované prostredie, pretože uľahčuje prácu s asynchrónnymi vláknami.

Vo svojich najnovších vydaniach, počnúc Java 8, samotná Java urobila niekoľko pokusov o implementáciu natívnej reaktivity, ale tieto pokusy dnes nie sú medzi vývojármi veľmi obľúbené. Existuje však niekoľko živých a pravidelne aktualizovaných implementácií tretích strán pre reaktívne programovanie Java, ktoré môžu zachrániť situáciu, a preto ich ocenia najmä vývojári Java.

V typickej aplikácii je bežné opakovane vykonávať niektoré reaktívne programovacie operácie pomocou RxJava, takže musíte porovnať rýchlosť, využitie CPU a pamäte s rovnakými operáciami, ktoré boli implementované s korutínmi Kotlin a RxJava. Toto je počiatočný test výkonu.

Vždy, keď sa použije nový nástroj, ktorý bude široko používaný v celom kóde, je dôležité pochopiť, či to ovplyvní celkový výkon aplikácie, skôr než sa rozhodneme, či sa ho oplatí používať. Prax používania dáva krátku odpoveď: vo väčšine prípadov by používatelia mali zvážiť nahradenie RxJava s coroutines Kotlin, najmä v systéme Android.

Reaktívne programovanie pomocou RxJava sa dá stále použiť v obmedzenom počte prípadov a v týchto prípadoch je možné kombinovať RxJava aj korutíny.

Jednoduché dôvody:

  1. Poskytujú oveľa väčšiu flexibilitu ako bežný Rx.
  2. Poskytuje bohatú sadu operátorov na kolekciách, ktoré budú vyzerať rovnako ako operátori RxJava.
  3. Reaktívne programovanie Kotlin môže v prípade potreby interagovať pomocou rxjava.
  4. Sú veľmi ľahké a efektívne vzhľadom na vyššie využitie CPU na zber odpadu zo všetkých objektov vytvorených RxJava.

Reaktívne rozšírenia

Reactive Extensions (ReactiveX alebo RX) je knižnica, ktorá dodržiava princípy Rx, t. j. skladanie asynchrónnych programov a programov založených na udalostiach pomocou pozorovateľnej sekvencie. Tieto knižnice poskytujú mnoho rozhraní a metód, ktoré pomáhajú vývojárom písať čistý a jednoduchý kód.

Reaktívne rozšírenia sú dostupné v niekoľkých jazykoch. Programátori sa obzvlášť zaujímajú o RxJava a RxAndroid, pretože android je najviac zameraná oblasť.

Reaktívne programovanie pomocou RxJava je implementáciou rozšírenia Java Reactive od Netflixu. V podstate ide o knižnicu, ktorá skladá asynchrónne udalosti podľa vzoru pozorovateľa.

Je možné vytvárať asynchrónne prenosy, transformovať ich a konzumovať ich pozorovateľom v rôznych dátových tokoch. Knižnica ponúka širokú škálu úžasných operátorov, ako je mapa, spojenie a filter, ktoré možno použiť na dátový tok. Keď programátor začne používať skutočné príklady kódu, dozvie sa viac o operátoroch a konverziách.

Multithreading v aplikáciách pre Android

Android" class="if uuid-2938324" src="/misc/i/gallery/73564/2938324.jpg" />

Android Reactive Programming (RxAndroid) je špecifické pre platformu Android s niekoľkými pridanými triedami na vrchole RxJava. Presnejšie, plánovače sú predstavené v RxAndroid (AndroidSchedulers.mainThread()), ktorý hrá dôležitú úlohu pri podpore konceptu multithreadingu v aplikáciách pre Android.

Odborníci okrem iného radia používať iba knižnicu RxJava. Aj vďaka veľkému množstvu plánovačov používaných pri programovaní androidov.

Nižšie je uvedený zoznam plánovačov a ich súhrn:

  1. Schedulers.io() – Používa sa na vykonávanie neintenzívnych operácií, ako sú sieťové volania, čítanie diskov/súborov, operácie s databázou a ktoré udržiava skupinu vlákien.
  2. AndroidSchedulers.mainThread() – poskytuje prístup k hlavnej téme vlákna/používateľského rozhrania. Zvyčajne v tomto vlákne prebiehajú operácie, ako je aktualizácia používateľského rozhrania, interakcia s používateľom. Odborníci odporúčajú používateľom, aby s týmto streamom nevykonávali žiadne intenzívne operácie, pretože to môže spôsobiť zlyhanie aplikácie alebo dialógové okno ANR.
  3. Schedulers.newThread() - Pomocou tohto sa vytvorí nové vlákno vždy, keď je naplánovaná úloha. Vo všeobecnosti sa odporúča nepoužívať rozvrh pre veľmi dlhé úlohy. Vlákna vytvorené pomocou newThread() sa znova nepoužijú.
  4. Schedulers.computation() - Tento plán možno použiť na vykonávanie operácií náročných na CPU, na spracovanie obrovských údajov centra reaktívneho programovania, na spracovanie bitových máp. Počet vlákien vytvorených pomocou tohto plánovača úplne závisí od počtu dostupných jadier CPU.
  5. Schedulers.single() – Tento plánovač vykoná všetky úlohy v nasledujúcom poradí, ktoré možno použiť, keď je potrebné sekvenčné vykonávanie.
  6. Schedulers.immediate() – Tento plánovač vykoná úlohu okamžite synchrónnym blokovaním hlavného vlákna.
  7. Schedulers.trampoline() - Spúšťa úlohy v režime Prvý dnu-prvý von. Všetky naplánované úlohy sa spustia jedna po druhej, čím sa obmedzí počet vlákien na pozadí na jedno.
  8. Schedulers.from () - umožňuje vám vytvoriť plánovač z vykonávateľa s obmedzením počtu vytvorených vlákien. Keď je oblasť vlákien zaneprázdnená, úlohy budú zaradené do frontu.

Teraz, keď máte dobré zázemie v RxJava a RxAndroid, môžete prejsť na niekoľko príkladov kódu, aby ste lepšie pochopili tento koncept. Ak chcete začať, musíte do projektov build.gradle pridať závislosti RxJava a RxAndroid a synchronizovať projekt.

Programovanie.

Pozorovateľ je prihlásený na odber pozorovateľného objektu, aby mohol začať prijímať údaje dvoma spôsobmi:

  1. SubscribeOn(Schedulers.io()) – povie Observable, aby spustilo úlohu na vlákne na pozadí.
  2. ObservOn(AndroidSchedulers.mainThread()) – povie pozorovateľovi, aby prijímal údaje o vlákne používateľského rozhrania systému Android.

To je všetko, takže programátor môže napísať svoj prvý reaktívny programovací program s RxJava.

Podniky a dodávatelia middlewaru začali používať Reactive a v rokoch 2016-2018 došlo k obrovskému nárastu záujmu spoločností o prijatie tejto paradigmy.

Rx ponúka výkon vývojárov prostredníctvom efektívnosti zdrojov na úrovni komponentov pre internú logiku a transformáciu toku údajov, zatiaľ čo reaktívne systémy ponúkajú výkon pre architektov a DevOps prostredníctvom odolnosti a pružnosti na úrovni systému. Používajú sa na vytváranie „Cloud Native“ a iných rozsiahlych distribuovaných systémov. V praxi sa vo veľkej miere používajú aj knihy reaktívneho programovania Java s metódami, ktoré umožňujú kombinovať princípy návrhu reaktívneho systému.



Načítava...
2023 •
Hore