Reaktív programozás java. Reaktív programozás az Objective-C-ben

Egy modern programozási tudományágról szeretnék beszélni, amely megfelel a skálázhatóság, a hibatűrés és a gyors reagálás iránti növekvő igényeknek, és nélkülözhetetlen mind többmagos környezetben, mind felhő alapú számítástechnika, valamint egy nyílt online tanfolyamot is bemutatunk róla, amely alig néhány napon belül kezdődik.

Ha még nem hallottál róla reaktív programozás, Minden rendben. Ez egy gyorsan fejlődő tudományág, amely egyesíti az egyidejűséget az eseményvezérelt és az aszinkronnal. A reaktivitás minden webszolgáltatás és elosztott rendszer velejárója, és számos nagy teljesítményű, nagy fokú párhuzamossággal rendelkező rendszer magja. Röviden, a kurzus készítői azt javasolják, hogy a reaktív programozást tekintsék a funkcionális programozás természetes kiterjesztésének (magasabb rendű függvényekkel) párhuzamos rendszerekre, amelyek elosztott állapotúak, amelyeket az aktív alanyok által kicserélt aszinkron adatfolyamok koordinálnak és hangszerelnek, ill. szereplők.

Érthetőbb szavakkal ez a Reaktív Kiáltványban van leírva, az alábbiakban a főbb rendelkezéseket újramondom belőle, a teljes fordítást pedig a Habrén közöljük. Ahogy a Wikipédia mondja, a kifejezés reaktív programozás már régóta létezik és praktikus alkalmazások változó fokú egzotikum, de a Reactive Manifesto szerzőinek, a Typesafe Inc. kezdeményező csoportjának erőfeszítéseinek köszönhetően egészen a közelmúltban kapott új lendületet a fejlesztéshez és a terjesztéshez. A Typesafe a funkcionális programozói közösségben a kiváló Scala nyelv és a forradalmian új párhuzamos Akka platform szerzői által alapított cégként ismert. Most úgy pozícionálják cégüket, mint a világ első sugárhajtású platformjának megalkotóját, amelyet egy új generáció fejlesztésére terveztek. Platformjuk lehetővé teszi az összetett gyors fejlesztését felhasználói felületekés az absztrakció új szintjét biztosítja a párhuzamos számítástechnika és a többszálú feldolgozáson keresztül, csökkentve az ezekben rejlő kockázatokat a garantált kiszámítható skálázás révén. A gyakorlatba ülteti át a Reactive Manifesto elképzeléseit, és lehetővé teszi a fejlesztő számára a modern igényeknek megfelelő alkalmazások megértését és létrehozását.

Ezt a platformot és a reaktív programozást ismerheti meg, ha részt vesz a Reactive Principles Massive Open Online Course-on. Ez a kurzus Martin Odersky „Funkcionális programozás alapelvei a Scalában” című kurzusának folytatása, amelynek több mint 100 000 résztvevője volt, és a résztvevők a világon az egyik legmagasabb sikerességi arányt mutatták be a Massive Open Online Course esetében. A Scala nyelv megalkotójával közösen az új kurzust Eric Meyer, aki a .NET alatti reaktív programozás Rx keretrendszerét fejlesztette ki, és Roland Kuhn, aki jelenleg a Typesafe Akka fejlesztőcsapatát vezeti. A kurzus lefedi a reaktív programozás kulcsfontosságú elemeit, és bemutatja, hogyan alkalmazzák azokat a méretezhető és hibatűrő eseményvezérelt rendszerek tervezésére. A tananyag illusztrált rövid programokés egy sor feladatsor kíséri, amelyek mindegyike szoftverprojekt. Valamennyi feladat sikeres teljesítése esetén a résztvevők oklevelet kapnak (természetesen a részvétel és az igazolás ingyenes). A tanfolyam 7 hétig tart és ezen a hétfőn, november 4-én indul. A kurzus részletes vázlata és egy bemutatkozó videó is elérhető a kurzus oldalán: https://www.coursera.org/course/reactive.

Akit érdekel, vagy kétségei vannak, annak ajánlom a Reaktív Kiáltvány alapfogalmainak tömör összefoglalását. Szerzői jelentős változásokat észlelnek a pályázatok követelményeiben utóbbi évek. Ma az alkalmazások bármilyen környezetben üzembe helyezhetők mobil eszközök több ezer többmagos processzorral rendelkező felhőfürtökhöz. Ezek a környezetek új követelményeket támasztanak szoftverés technológiák. Az előző generációs architektúrák a felügyelt szerverekre és konténerekre összpontosítottak, további drága hardvereken, szabadalmaztatott megoldásokon és párhuzamos számítástechnika többszálon keresztül. Jelenleg egy új architektúra fejlesztése folyik, amely négy kulcsfontosságú tulajdonsággal rendelkezik, amelyek egyre inkább elterjednek mind a fogyasztói, mind a vállalati ipari környezetben. Az ilyen architektúrájú rendszerek: eseményvezérelt, skálázható, hibatűrő (Resilient) és gyors reagálásúak, pl. reagáló (Responsive). Ez zökkenőmentes, valós idejű felhasználói élményt biztosít, amelyet egy öngyógyító, méretezhető alkalmazáscsomag támogat, amely készen áll a többmagos és felhőkörnyezetekben történő telepítésre. A reaktív architektúrák mind a négy jellemzője a teljes technológiai veremre vonatkozik, ami megkülönbözteti őket a réteges architektúrák hivatkozásaitól. Tekintsük őket egy kicsit részletesebben.

Eseményvezérelt Az alkalmazások aszinkron komponens kommunikációt feltételeznek, és lazán csatolt felépítésüket valósítják meg: az üzenet küldőjének és fogadójának nem kell tudnia sem egymásról, sem az üzenet továbbításának módjáról, ami lehetővé teszi, hogy a kommunikáció tartalmára koncentrálhasson. Amellett, hogy a lazán csatolt komponensek jelentősen javítják a rendszer karbantarthatóságát, bővíthetőségét és evolúcióját, interakciójuk aszinkronitása és nem blokkoló jellege az erőforrások jelentős részét is felszabadíthatja, csökkentheti a válaszidőt és O több áteresztőképesség a hagyományos alkalmazásokhoz képest. Az eseményvezérelt természetnek köszönhető, hogy a reaktív architektúra többi jellemzője lehetséges.

Méretezhetőség a reaktív programozás keretében ez a rendszer reakciója a terhelés változására, pl. rugalmasság, amelyet a számítási csomópontok szükség szerinti hozzáadásának vagy felszabadításának képessége ér el. Az alacsony csatolás, az aszinkron üzenetküldés és a hely átláthatósága miatt a telepítési módszer és az alkalmazás topológia a telepítési idő döntésévé válik, és a terhelésre reagáló konfiguráció és az adaptív algoritmusok függvénye. És így, számítógép hálózat az alkalmazás részévé válik, kezdetben kifejezetten elosztott természetű.

hibatűrés A reaktív architektúra is a tervezés részévé válik, és ez jelentősen eltér a rendszer folyamatos rendelkezésre állását a szerverredundancián és a feladatátvételen keresztül biztosító hagyományos megközelítésektől. Egy ilyen rendszer rugalmasságát azáltal éri el, hogy képes megfelelően reagálni az egyes összetevők meghibásodására, elkülöníteni ezeket a hibákat azáltal, hogy kontextusukat az őket okozó üzenetek formájában tárolja, és továbbadja ezeket az üzeneteket egy másik komponensnek, amely döntést tud hozni arról, hogyan kezelni a hibát. Ez a megközelítés lehetővé teszi az alkalmazás üzleti logikájának tisztán tartását, elválasztva attól a hibakezelés logikáját, amely kifejezetten deklaratív formában van megfogalmazva a hibák regisztrálásához, elkülönítéséhez és a rendszer eszközeivel történő kezeléséhez. Az ilyen öngyógyító rendszerek felépítéséhez az összetevőket hierarchikusan rendezik, és a problémát olyan szintre emelik, amely meg tudja oldani.

És végül fogékonyság- ez a rendszer azon képessége, hogy a terheléstől és meghibásodásoktól függetlenül reagáljon a felhasználói bemenetekre, az ilyen alkalmazások bevonják a felhasználót interakcióba, érzést keltenek szoros kapcsolat rendszerrel és elegendő felszereléssel az aktuális feladatok elvégzéséhez. A válaszkészség nemcsak a valós idejű rendszerekben releváns, hanem az alkalmazások széles körében is szükséges. Ráadásul az a rendszer sem tekinthető hibatűrőnek, amely még meghibásodáskor sem tud gyorsan reagálni. A válaszkészség megfigyelhető modellek, eseményfolyamok és állapotjelző kliensek használatával érhető el. A megfigyelhető modellek eseményeket bocsátanak ki, amikor állapotuk megváltozik, és valós idejű interakciót biztosítanak a felhasználók és a rendszerek között, míg az eseményfolyamok biztosítják azt az absztrakciót, amelyre ez az interakció épül, nem blokkoló aszinkron transzformációk és kommunikáció révén.

Így a reaktív alkalmazások kiegyensúlyozott megközelítést képviselnek a modern szoftverfejlesztés számos problémájának megoldásában. Eseményvezérelt alapokra építve biztosítják a skálázhatóság és a hibatűrés garantálásához szükséges eszközöket, és támogatják a teljes értékű reszponzív felhasználói élményt. A szerzők mindezt elvárják több rendszerek betartják a reaktív kiáltvány elveit.

Ezen kívül a tanfolyami tervet fordítás nélkül adom. Csak arra az esetre, ha idáig elolvastad, és még mindig kíváncsi vagy.

1. hét: A funkcionális programozás alapelveinek áttekintése: helyettesítési modell, for-kifejezések és azok viszonya a monádokhoz. Bevezeti a for-kifejezések új megvalósítását: a véletlenérték generátorokat. Megmutatja, hogyan használható ez a véletlenszerű tesztelés során, és áttekintést ad a ScalaCheckről, egy eszközről, amely megvalósítja ezt az ötletet.

2. hét: Funkcionális programozás és változtatható állapot. Mi tesz egy objektumot változtathatóvá? Hogyan hat ez a helyettesítési modellre. Bővített példa: Digitális áramkör szimuláció

3. hét: határidős ügyletek. Bemutatja a futures-t, mint egy másik monádot, a for-kifejezésekkel konkrét szintaxisként. Megmutatja, hogyan lehet határidős ügyleteket összeállítani a szálak blokkolásának elkerülése érdekében. A szálak közötti hibakezelést tárgyalja.

4. hét: Reaktív adatfolyam feldolgozás. A határidők általánosítása reaktív számításokra folyamokon keresztül. stream operátorok.

5. hét:Színészek. Bemutatja a színészmodellt, a szereplőket a konzisztencia, az aszinkron üzenettovábbítás beágyazott egységeiként, tárgyalja az üzenetküldés különböző szemantikáját (legfeljebb egyszer, legalább egyszer, pontosan egyszer) és az esetleges konzisztenciát.

6. hét: felügyelet. Bemutatja a hibák reifikációját, a hierarchikus hibakezelést, a hiba kernel mintáját, az életciklus figyelését, tárgyalja a tranziens és perzisztens állapotokat.

7. hét: Beszélgetési minták. Megvitatja a szereplők közötti párbeszéd állapotának kezelését és az áramlásszabályozás mintáit, az üzenetek továbbítását a szereplők csoportjaihoz a rugalmasság vagy a terheléselosztás érdekében, a vétel nyugtázását a megbízható kézbesítés elérése érdekében.

Az OOP fejlesztés világa általában és a Java nyelv különösen aktív életet él. Megvannak a maga divatirányzatai, és ma elemezzük a szezon egyik fő trendjét - a ReactiveX keretrendszert. Ha még mindig távol áll ettől a hullámtól - ígérem, tetszeni fog! Egyértelműen jobb, mint a magas derekú farmer :).

Reaktív programozás

Amint az OOP nyelvek tömeges használatra érettek, a fejlesztők rájöttek, hogy a C-szerű nyelvek képességei néha mennyire hiányosak. Mivel a kódírás a funkcionális programozás stílusában súlyosan rontja az OOP kód minőségét, és ezáltal a projekt karbantarthatóságát, egy hibridet találtak ki - reaktív programozás.

A reaktív fejlesztési paradigma azon az elképzelésen alapul, hogy folyamatosan nyomon kell követni egy objektum állapotában bekövetkező változásokat. Ha ilyen változások történtek, akkor minden érdeklődő objektumnak már frissített adatokat kell kapnia, és csak velük kell dolgoznia, elfelejtve a régieket.

A reaktív programozási ötlet jó példája az Excel táblázat. Ha több cellát kapcsol össze egy képlettel, a számítás eredménye minden alkalommal megváltozik, amikor az ezekben a cellákban lévő adatok megváltoznak. A könyvelésnél az adatok ilyen dinamikus változása általános dolog, a programozóknál viszont inkább kivétel.

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

Ebben a példában az F1 és F2 függvények a C változó különböző értékeivel működnek. Gyakran előfordul, hogy mindkét függvénynek csak a legfrissebb adatokkal kell rendelkeznie - a reaktív programozás lehetővé teszi, hogy azonnal hívja az F1-et paramétereket a függvények logikájának megváltoztatása nélkül. Ez a kódstruktúra lehetővé teszi az alkalmazás számára, hogy azonnal reagáljon bármilyen változásra, ami gyorssá, rugalmassá és reagálóvá teszi.

ReactiveX

A reaktív programozási ötletek a semmiből való megvalósítása meglehetősen problémás lehet – vannak buktatók, és ez elég sok időt vesz igénybe. Ezért sok fejlesztő számára ez a paradigma csak elméleti anyag maradt a ReactiveX megjelenéséig.

A ReactiveX keretrendszer egy reaktív programozási eszköz, amely az összes népszerű OOP nyelvvel működik. Maguk a készítők többplatformos API-nak hívják az aszinkron fejlesztéshez, az Observer minta alapján.

Ha a "reaktív programozás" kifejezés egyfajta elméleti modell, akkor az Observer minta egy kész mechanizmus a program változásainak követésére. És elég gyakran kell követni őket: adatok betöltése és frissítése, eseményértesítések stb.

Az Observer minta körülbelül olyan régóta létezik, mint maga az OOP. Egy objektumot, amelynek állapota változhat, kiadónak nevezzük (a Megfigyelhető kifejezés népszerű fordítása). Az összes többi résztvevő, akit érdekelnek ezek a változások, előfizetők (megfigyelő, előfizető). Az értesítések fogadásához az előfizetők azonosítójuk kifejezett megadásával regisztrálnak a kiadónál. A kiadó időről időre értesítéseket generál, amelyeket a kiadó elküld a regisztrált előfizetők listájára.

Valójában a ReactiveX készítői nem találtak ki semmi forradalmiat, csak kényelmesen megvalósították a mintát. És bár sok OOP nyelv, és különösen a Java, rendelkezik a minta kész megvalósításával, ez a keretrendszer további "tuningolást" tartalmaz, amely az "Observert" nagyon hatékony eszközzé varázsolja.

RxAndroid

Az Android-világ ReactiveX könyvtárának portját rxAndroidnak hívják, és mint mindig, a Gradle-n keresztül csatlakozik.

Fordítsa le az "io.reactivex:rxandroid:1.1.0" fájlt

Az értesítéseket generáló kiadó itt a Megfigyelhető osztály használatával van megadva. Egy kiadónak több előfizetője is lehet, ezek megvalósításához az Előfizető osztályt használjuk. A megfigyelhető alapértelmezett viselkedése az, hogy egy vagy több üzenetet küld az előfizetőknek, majd kilép, vagy hibaüzenetet ad ki. Az üzenetek lehetnek változók és egész objektumok is.

Rx.Observable myObserv = rx.Observable.create(new rx.Observable.OnSubscribe