Ukuhlanganiswa kwesitayela se-BPM

Sawubona, UHabr!

Inkampani yethu igxile ekuthuthukisweni kwezixazululo zesoftware esezingeni le-ERP, lapho isabelo sebhubesi sithathwa yizinhlelo zokuthengiselana ezinenani elikhulu le-logic yebhizinisi kanye nokuhamba komsebenzi i-EDMS. Izinguqulo zesimanje zemikhiqizo yethu zisekelwe kubuchwepheshe be-JavaEE, kodwa futhi sizama ngenkuthalo ngamasevisi amancane. Enye yezindawo eziyinkinga kakhulu yezixazululo ezinjalo ukuhlanganiswa kwezinhlelo ezingaphansi ezihlukahlukene ezihlobene nezizinda eziseduze. Imisebenzi yokuhlanganisa ibilokhu isinikeza ikhanda elikhulu, kungakhathaliseki ukuthi yiziphi izitayela zezakhiwo, izitaki zobuchwepheshe nezinhlaka esizisebenzisayo, kodwa kamuva nje kube nenqubekelaphambili ekuxazululeni izinkinga ezinjalo.

Esihlokweni esilethwe ekunakekeleni kwakho, ngizokhuluma ngesipiliyoni kanye nocwaningo lwezakhiwo ze-NPO Krista endaweni eqokiwe. Sizophinde sicabangele isibonelo sesixazululo esilula senkinga yokuhlanganisa kusukela ekubukeni komthuthukisi wohlelo lokusebenza futhi sithole ukuthi yini efihliwe ngemuva kwalokhu kulula.

Umusho wokuzihlangula

Izixazululo zezakhiwo nezobuchwepheshe ezichazwe esihlokweni zinikezwa yimi ngokusekelwe ekuhlangenwe nakho komuntu siqu kumongo wemisebenzi ethile. Lezi zixazululo azisho ukuthi zisebenza emhlabeni wonke futhi zingase zingabi zinhle ngaphansi kwezinye izimo zokusetshenziswa.

Ngabe i-BPM ihlangene ngani nayo?

Ukuze siphendule lo mbuzo, sidinga ukuhlolisisa kancane imininingwane yezinkinga ezisetshenziswayo zezixazululo zethu. Ingxenye eyinhloko yengqondo yebhizinisi ohlelweni lwethu olujwayelekile lokuthengiselana ukufakwa kwedatha kusizindalwazi ngokusebenzisa ukuxhumana komsebenzisi, ukuqinisekiswa okwenziwa ngesandla nokuzenzakalelayo kwale datha, kuyidlulisa ngokunye ukuhamba komsebenzi, ukuyishicilela kolunye uhlelo/isizindalwazi sokuhlaziya/ingobo yomlando, okukhiqiza imibiko. Ngakho-ke, umsebenzi oyinhloko wesistimu kumakhasimende ukuzenzekelayo kwezinqubo zabo zangaphakathi zebhizinisi.

Ukuze kube lula, sisebenzisa igama elithi "idokhumenti" ekukhulumisaneni njengokunqanyulwa kwesethi yedatha, ehlanganiswe ukhiye ojwayelekile, lapho "kunganamathiselwa khona ukuhamba komsebenzi othile".
Kodwa kuthiwani nge-logic yokuhlanganisa? Phela, umsebenzi wokuhlanganisa ukhiqizwa ukwakhiwa kwesistimu, "esikiwe" ezingxenyeni HHAYI ngesicelo sekhasimende, kodwa ngaphansi kwethonya lezici ezihluke ngokuphelele:

• ngaphansi kwethonya lomthetho kaConway;
• ngenxa yokusetshenziswa kabusha kwezinhlelo ezingaphansi ezakhelwe eminye imikhiqizo ngaphambilini;
• njengoba kunqunywe umakhi, ngokusekelwe ezidingweni ezingasebenzi.

Kunesilingo esikhulu sokuhlukanisa ingqondo yokuhlanganisa kusukela kungqondongqondo yebhizinisi yokugeleza komsebenzi okuyinhloko ukuze kungangcolisi ingqondo yebhizinisi ngezinto zobuciko zokuhlanganiswa futhi kusindise umthuthukisi wohlelo lokusebenza ekungeneni ekujuleni okukhethekile kokuma kwendawo yesistimu. Le ndlela inezinzuzo eziningi, kodwa ukuzijwayeza kubonisa ukungasebenzi kwayo:

• ukuxazulula izinkinga zokuhlanganisa kuvame ukuslayida phansi ziye ezinkethweni ezilula ngendlela yamakholi avumelanayo ngenxa yamaphuzu okunweba anomkhawulo ekusetshenzisweni kokuhamba komsebenzi okuyinhloko (okuningi mayelana nokushiyeka kokuhlanganiswa okuvumelanayo ngezansi);
• ama-artifact okuhlanganiswa asangena kumqondo webhizinisi oyinhloko lapho kudingeka impendulo esuka kolunye uhlelo oluncane;
• umthuthukisi wohlelo lokusebenza akanaki ukuhlanganiswa futhi angakwazi ukukwephula kalula ngokushintsha ukuhamba komsebenzi;
• uhlelo luyeka ukuba lulonke kusukela ekubukeni komsebenzisi, "i-seams" phakathi kwezinhlelo ezingaphansi ziyabonakala, imisebenzi yabasebenzisi engafuneki iqala ukudluliselwa kwedatha isuka kusistimu encane iye kwenye.

Enye indlela ukucabangela ukusebenzisana kokuhlanganiswa njengengxenye ebalulekile yengqondo yebhizinisi ewumongo kanye nokuhamba komsebenzi. Ukugcina izidingo zekhono zabathuthukisi bohlelo lokusebenza zikhuphukela phezulu, ukudala ukusebenzisana okusha kokuhlanganiswa kufanele kwenziwe kalula futhi ngokwemvelo, ngezinketho ezincane zokukhetha isisombululo. Lokhu kunzima kakhulu kunalokho okubukekayo: ithuluzi kufanele libe namandla ngokwanele ukunikeza umsebenzisi izinhlobonhlobo ezidingekayo zokukhetha ukuze asetshenziswe futhi ngesikhathi esifanayo angavumeli ukudutshulwa onyaweni. Miningi imibuzo unjiniyela okufanele ayiphendule kumongo wemisebenzi yokuhlanganisa, kodwa leyo umthuthukisi wohlelo lokusebenza okungafanele acabange ngayo emsebenzini wakhe wansuku zonke: imingcele yokwenziwayo, ukungaguquguquki, i-athomu, ukuphepha, ukukala, ukulayisha kanye nokusatshalaliswa kwezinsiza, umzila, ukuhlela, ukusabalalisa nokushintsha izimo, njll. Kuyadingeka ukunikeza abathuthukisi bohlelo lokusebenza izifanekiso ezilula, lapho izimpendulo kuyo yonke imibuzo enjalo sezivele zifihliwe. Lawa maphethini kufanele avikeleke ngokwanele: ingqondo yebhizinisi ishintsha kaningi, okwandisa ingozi yokwethula amaphutha, izindleko zamaphutha kufanele zihlale zisezingeni eliphansi kakhulu.

Kodwa noma kunjalo, i-BPM ihlangene ngani nayo? Kunezinketho eziningi zokwenza ukuhamba komsebenzi ...
Ngempela, okunye ukuqaliswa kwezinqubo zebhizinisi kudume kakhulu ezixazululweni zethu - ngokusetha okumemezelayo komdwebo wenguquko yezwe kanye nokuxhuma izibambi nengqondo yebhizinisi ezinguqukweni. Ngesikhathi esifanayo, isimo esinquma isikhundla samanje se "idokhumenti" enkambisweni yebhizinisi siyimfanelo "yedokhumenti" ngokwayo.

Lena yindlela inqubo ebukeka ngayo ekuqaleni kwephrojekthi

Ukuthandwa kokuqaliswa okunjalo kungenxa yobulula obuhlobene nesivinini sokudala izinqubo zebhizinisi eziqondile. Kodwa-ke, njengoba izinhlelo zesoftware ziba nzima kakhulu, ingxenye ezenzakalelayo yenqubo yebhizinisi iyakhula futhi iba yinkimbinkimbi kakhulu. Kunesidingo sokubola, ukusetshenziswa kabusha kwezingxenye zezinqubo, kanye nezinqubo zokufokha ukuze igatsha ngalinye lenziwe ngokufana. Ngaphansi kwezimo ezinjalo, ithuluzi liba nzima, futhi umdwebo wenguquko yesifunda ulahlekelwa okuqukethwe kwawo kolwazi (ukusebenzelana kokuhlanganisa akubonakali kumdwebo nhlobo).

Yilokhu inqubo ebukeka ngayo ngemva kokuphindaphinda kaningana kokucacisa izidingo

Indlela yokuphuma kulesi simo kwaba ukuhlanganiswa kwenjini jBPM kweminye imikhiqizo enezinqubo zebhizinisi eziyinkimbinkimbi kakhulu. Esikhathini esifushane, lesi sixazululo sibe nempumelelo ethile: kube nokwenzeka ukusebenzisa izinqubo zebhizinisi eziyinkimbinkimbi ngenkathi kugcinwa umdwebo onolwazi futhi osesikhathini samanje ekubhalweni. I-BPMN2.

Ingxenye encane yenqubo yebhizinisi eyinkimbinkimbi

Ngokuhamba kwesikhathi, isixazululo asizange sifeze okulindelwe: ukuqina okuphezulu kwabasebenzi bokudala izinqubo zebhizinisi ngokusebenzisa amathuluzi abonakalayo akuzange kuvumele ukuzuza izinkomba zokukhiqiza ezamukelekayo, futhi ithuluzi ngokwalo laba elinye labangathandwa kakhulu phakathi konjiniyela. Kuphinde kwaba nezikhalo ngesakhiwo sangaphakathi senjini, okuholele ekutheni kubonakale “amapheshana” kanye “nezinduku” eziningi.

Isici esihle esiyinhloko sokusebenzisa i-jBPM kwakuwukufezeka kwezinzuzo kanye nokulimala kokuba nesakho isimo esiqhubekayo esimweni senqubo yebhizinisi. Siphinde sabona ukuthi kungenzeka ukusebenzisa indlela yenqubo ukuze kusetshenziswe izivumelwano eziyinkimbinkimbi zokuhlanganisa phakathi kwezinhlelo zokusebenza ezihlukene zisebenzisa ukusebenzisana okungavumelanisi ngokusebenzisa amasignali nemilayezo. Ukuba khona kombuso ophikelelayo kudlala indima ebalulekile kulokhu.

Ngokusekelwe kulokhu okungenhla, singaphetha ngokuthi: Indlela yenqubo ngesitayela se-BPM isivumela ukuthi sixazulule inhlobonhlobo yemisebenzi yokuzenzakalela izinqubo zebhizinisi eziyinkimbinkimbi nakakhulu, sihlanganise ngokuhambisana imisebenzi yokuhlanganisa kulezi zinqubo futhi sigcine ikhono lokubonisa ngokubonakalayo inqubo esetshenzisiwe ngenothi efanelekile.

Ukubi kwezingcingo ezivumelanisiwe njengephethini yokuhlanganisa

Ukuhlanganiswa okuvumelanayo kubhekisela ocingweni oluvimbayo olulula. Isistimu engaphansi eyodwa isebenza njengohlangothi lweseva futhi iveza i-API ngendlela efiswayo. Enye i-subsystem isebenza njengohlangothi lweklayenti futhi, ngesikhathi esifanele, ishaya ucingo ilindele umphumela. Ngokuya ngokwakhiwa kwesistimu, iklayenti nezinhlangothi zeseva zingasingathwa ngohlelo lokusebenza nenqubo efanayo, noma kwezinye ezihlukene. Esimeni sesibili, udinga ukusebenzisa ukuqaliswa okuthile kwe-RPC futhi unikeze ngokumasha amapharamitha kanye nomphumela wocingo.

Iphethini enjalo yokuhlanganisa inesethi enkulu ngokwanele yezithiyo, kodwa isetshenziswa kabanzi ekusebenzeni ngenxa yobulula bayo. Ijubane lokuqalisa liyakhanga futhi likwenza ukuthi ulisebenzise ngokuphindaphindiwe ngaphansi kwezimo "zokushisa" izinsuku zokugcina, ubhala isisombululo esikweletini sobuchwepheshe. Kodwa futhi kwenzeka ukuthi abathuthukisi abangenalwazi bayisebenzise ngokungazi, bengayiboni imiphumela emibi.

Ngokungeziwe ekwenyukeni okusobala kakhulu ekuxhumekeni kwezinhlelo ezingaphansi, kunezinkinga ezingacacile ngokuthengiselana "kokusabalalisa" kanye "nokwelula". Ngempela, uma ingqondo yebhizinisi yenza noma yiziphi izinguquko, khona-ke ukuthengiselana kudingekile, futhi ukuthengiselana, ngokulandelayo, kukhiya izinsiza ezithile zohlelo lokusebenza ezithintwa yilezi zinguquko. Okusho ukuthi, kuze kube yilapho isistimu engaphansi ilinda impendulo esuka kwenye, ngeke ikwazi ukuqedela okwenziwayo kanye nokukhiya kokukhulula. Lokhu kwandisa kakhulu ingozi yemiphumela ehlukahlukene:

• ukuphendula kwesistimu kulahleka, abasebenzisi balinda isikhathi eside ukuze bathole izimpendulo zezicelo;
• iseva ngokuvamile iyeka ukuphendula izicelo zomsebenzisi ngenxa yochungechunge oluchichimayo: imicu eminingi “ima” kukhiye wensiza esetshenziswa umsebenzi;
• i-deadlocks iqala ukuvela: amathuba okuba khona kwawo ancike kakhulu esikhathini sokuthengiselana, inani le-logic yebhizinisi kanye nezingidi ezihilelekile ekuthengiseni;
• amaphutha okuphelelwa yisikhathi kokwenziwe avela;
• iseva "iyawa" ku-OutOfMemory uma umsebenzi udinga ukucutshungulwa nokushintshwa kwedatha enkulu, futhi ukuba khona kokuhlanganiswa okuvumelanayo kwenza kube nzima kakhulu ukuhlukanisa ukucubungula kube yimisebenzi "elula".

Ngokombono wezakhiwo, ukusetshenziswa kwezingcingo ezivinjiwe ngesikhathi sokuhlanganiswa kuholela ekulahlekelweni kokulawulwa kwekhwalithi yezinhlelo ezingaphansi ngazinye: akunakwenzeka ukuqinisekisa ukuhloswa kwekhwalithi yesistimu engaphansi eyodwa ngokuhlukana nemigomo yekhwalithi yolunye uhlelo oluncane. Uma ama-subsystems athuthukiswa amaqembu ahlukene, lokhu kuyinkinga enkulu.

Izinto ziba mnandi nakakhulu uma izinhlelo ezingaphansi ezihlanganiswayo zikuzinhlelo zokusebenza ezihlukene futhi izinguquko ezivumelanisiwe zidinga ukwenziwa nhlangothi zombili. Uzenza kanjani lezi zinguquko zibe umsebenzi?

Uma izinguquko zenziwa ekuthengiseni okuhlukene, khona-ke ukuphathwa okuhlukile okuqinile kanye nesinxephezelo kuzodingeka kuhlinzekwe, futhi lokhu kuqeda ngokuphelele inzuzo eyinhloko yokuhlanganiswa okuvumelanayo - ukulula.

Ukuthengiselana okusatshalalisiwe nakho kuyafika engqondweni, kodwa asikusebenzisi ezisombululweni zethu: kunzima ukuqinisekisa ukwethembeka.

"Saga" njengesixazululo senkinga yokuthengiselana

Ngokuthandwa okukhulayo kwama-microservices, kunesidingo esikhulayo salokhu Iphethini yeSaga.

Le phethini ixazulula ngokuphelele izinkinga ezingenhla zokuthengiselana okude, futhi yandisa amathuba okuphatha isimo sesistimu ukusuka ohlangothini lwengqondo yebhizinisi: isinxephezelo ngemuva kokuthenga okungaphumelelanga kungenzeka singahlehliseli uhlelo esimweni salo sokuqala, kodwa sinikeze enye indlela. umzila wokucubungula idatha. Iphinde ikuvumela ukuthi ungaphindi izinyathelo zokucubungula idatha eziqedwe ngempumelelo uma uzama ukuletha inqubo esiphethweni "esihle".

Kuyathakazelisa ukuthi ezinhlelweni ze-monolithic, le phethini ibalulekile futhi uma kuziwa ekuhlanganisweni kwamasistimu angaphansi ahlanganiswe ngokuxekethile futhi kuba nemithelela engemihle ebangelwa ukuthengiselana okude kanye nokukhiya kwensiza okuhambisanayo.

Mayelana nezinqubo zethu zebhizinisi ngesitayela se-BPM, kuvele kulula kakhulu ukusebenzisa iSagas: izinyathelo zomuntu ngamunye zeSagas zingasethwa njengemisebenzi ngaphakathi kwenqubo yebhizinisi, futhi isimo esiqhubekayo senqubo yebhizinisi sinquma, phakathi ezinye izinto, isimo sangaphakathi seSagas. Okusho ukuthi, asidingi noma iyiphi indlela yokuxhumana eyengeziwe. Okudingayo umthengisi womlayezo osekelwa iziqinisekiso "okungenani kanye" njengezokuthutha.

Kodwa isixazululo esinjalo sinalo "intengo" yalo:

• umqondo webhizinisi uba nzima kakhulu: udinga ukuthola isinxephezelo;
• kuyodingeka ukushiya ukungaguquguquki okugcwele, okungase kuzwele ikakhulukazi izinhlelo ze-monolithic;
• i-architecture iba inkimbinkimbi kancane, kunesidingo esengeziwe somthengisi womlayezo;
• Amathuluzi engeziwe okuqapha nawokuphatha azodingeka (yize ngokujwayelekile lokhu kuhle kakhulu: izinga lensizakalo yohlelo lizokhula).

Kuzinhlelo ze-monolithic, ukulungiswa kokusebenzisa i-"Sags" akubonakali kangako. Ngama-microservices kanye namanye ama-SOA, lapho, cishe, sekuvele kukhona umthengisi, futhi ukungaguquguquki okugcwele kwanikelwa ekuqaleni kwephrojekthi, izinzuzo zokusebenzisa leli phethini zingadlula kakhulu izinkinga, ikakhulukazi uma kukhona i-API elula ibhizinisi logic level.

Ukufakwa kwe-logic yebhizinisi kuma-microservices

Lapho siqala ukuhlola ama-microservices, kwaphakama umbuzo ozwakalayo: kuphi ukubeka umqondo webhizinisi lesizinda maqondana nesevisi enikeza ukuphikelela kwedatha yesizinda?

Uma ubheka ukwakheka kwe-BPMS ehlukahlukene, kungase kubonakale kunengqondo ukuhlukanisa ingqondo yebhizinisi nokuphikelela: dala ungqimba lweplatifomu kanye nama-microservices azimele esizinda akha imvelo nesiqukathi sokwenza umqondo webhizinisi lesizinda, futhi uhlele ukuphikelela kwedatha yesizinda njengento ehlukile. ungqimba lwama-microservices alula kakhulu futhi angasindi. Izinqubo zebhizinisi kulokhu zihlela izinsizakalo zesendlalelo sokuphikelela.

Le ndlela ine-plus enkulu kakhulu: ungakwazi ukwandisa ukusebenza kwesikhulumi ngendlela othanda ngayo, futhi kuphela ungqimba oluhambisanayo lwe-microservices yesikhulumi "elizokhuluphala" kulokhu. Izinqubo zebhizinisi ezivela kunoma yisiphi isizinda zithola ngokushesha ithuba lokusebenzisa ukusebenza okusha kweplatifomu ngokushesha nje lapho ibuyekezwa.

Ucwaningo olunemininingwane eminingi lwembula ukushiyeka okukhulu kwale ndlela:

• isevisi yesikhulumi esebenzisa ingqondo yebhizinisi yezizinda eziningi ngesikhathi esisodwa ithwala ubungozi obukhulu njengephuzu elilodwa lokwehluleka. Izinguquko ezivamile kungqondongqondo yebhizinisi zandisa ubungozi bezimbungulu eziholela ekuhlulekeni kohlelo lonke;
• Izinkinga zokusebenza: ingqondo yebhizinisi isebenza nedatha yayo ngokusebenzisa isixhumi esibonakalayo esincane nesinensayo:
  • idatha izophinda ihlelwe futhi iphonswe kusitaki senethiwekhi;
  • isevisi yesizinda ngokuvamile izobuyisela idatha eningi kunalokho okudingwa ingqondo yebhizinisi ukuze icutshungulwe, ngenxa yokunganele kombuzo wokukwazi ukwenza ipharamitha ezingeni le-API yangaphandle yesevisi;
  • izingcezu ezimbalwa ezizimele zomqondo webhizinisi zingaphinda zicele idatha efanayo ukuze icutshungulwe (unganciphisa le nkinga ngokwengeza ubhontshisi weseshini ogcina idatha, kodwa lokhu kwenza inkimbinkimbi yezakhiwo futhi kudale izinkinga zokusha kwedatha kanye nokungasebenzi kwenqolobane);
• izinkinga zokwenziwayo:
  • izinqubo zebhizinisi ezinesimo esiqhubekayo ezigcinwe isevisi yesikhulumi azihambisani nedatha yesizinda, futhi azikho izindlela ezilula zokuxazulula le nkinga;
  • ukuhambisa ukukhiya kwedatha yesizinda ngaphandle kokuthengiselana: uma i-logic yebhizinisi lesizinda idinga ukwenza izinguquko, ngemva kokuhlola kuqala ukulunga kwedatha yangempela, kuyadingeka ukukhipha ukuthi kungenzeka kube noshintsho lokuncintisana kudatha ecutshunguliwe. Ukuvinjwa kwangaphandle kwedatha kungasiza ekuxazululeni inkinga, kodwa isisombululo esinjalo sithwala izingozi ezengeziwe futhi sinciphisa ukwethembeka okuphelele kwesistimu;
• ezinye izinkinga lapho ubuyekeza: kwezinye izimo, udinga ukubuyekeza isevisi yokuphikelela kanye nengqondo yebhizinisi ngokuhambisanayo noma ngokulandelana okuqinile.

Ekugcineni, kwadingeka ngibuyele ezintweni eziyisisekelo: hlanganisa idatha yesizinda kanye nomqondo webhizinisi lesizinda ku-microservice eyodwa. Le ndlela yenza lula umbono we-microservice njengengxenye ebalulekile ohlelweni futhi ayinikezi izinkinga ezingenhla. Lokhu futhi akumahhala:

• Ukumiswa kwe-API kuyadingeka ekusebenzisaneni nokucabanga kwebhizinisi (ikakhulukazi, ukuhlinzeka ngemisebenzi yomsebenzisi njengengxenye yezinqubo zebhizinisi) kanye nezinsizakalo zeplathifomu ye-API; ukunaka okucophelelayo kuzinguquko ze-API, ukuhambisana phambili nangemuva kuyadingeka;
• kuyadingeka ukwengeza imitapo yolwazi eyengeziwe yesikhathi sokusebenza ukuze kuqinisekiswe ukusebenza komqondo webhizinisi njengengxenye yaleyo sevisi encane, futhi lokhu kunikeza izimfuneko ezintsha zaleyo mitapo yolwazi: ukukhanya kanye nobuncane bokuncika okuguquguqukayo;
• Abathuthukisi bengqondo yebhizinisi badinga ukulandelela izinguqulo zelabhulali: uma i-microservice ingaqedwa isikhathi eside, cishe izoqukatha inguqulo yakudala yemitapo yolwazi. Lokhu kungaba isithiyo esingalindelekile sokwengeza isici esisha futhi kungase kudinge ingqondo yebhizinisi endala yesevisi enjalo ukuthi ithuthelwe ezinguqulweni ezintsha zamalabhulali uma kube nezinguquko ezingahambisani phakathi kwezinguqulo.

Ungqimba lwezinsizakalo zenkundla lukhona futhi kusakhiwo esinjalo, kodwa lesi sendlalelo asisakhi isiqukathi sokwenza umqondo webhizinisi lesizinda, kodwa kuphela indawo yaso, esihlinzeka ngemisebenzi "yenkundla" eyisizayo. Isendlalelo esinjalo asidingeki nje kuphela ukuze kugcinwe ukukhanya kwesizinda se-microservices, kodwa futhi nokuhlanganisa ukuphathwa.

Isibonelo, imisebenzi yabasebenzisi ezinqubweni zebhizinisi ikhiqiza imisebenzi. Kodwa-ke, lapho usebenza ngemisebenzi, umsebenzisi kufanele abone imisebenzi evela kuzo zonke izizinda kuhlu olujwayelekile, okusho ukuthi kufanele kube nensizakalo yeplathifomu yokubhaliswa komsebenzi efanele, esulwe kumqondo webhizinisi lesizinda. Ukugcina i-encapsulation ye-logic yebhizinisi kulo mongo kuyinkinga impela, futhi lokhu kungokunye ukuyekethisa kwalesi sakhiwo.

Ukuhlanganiswa kwezinqubo zebhizinisi ngeso lomthuthukisi wohlelo lokusebenza

Njengoba sekushiwo ngenhla, umthuthukisi wohlelo lokusebenza kumele akhishwe ezicini zobuchwepheshe nezobunjiniyela zokuqaliswa kokusebenzelana kwezinhlelo zokusebenza ezimbalwa ukuze akwazi ukubala ekukhiqizeni okuhle kwentuthuko.

Ake sizame ukuxazulula inkinga enzima yokuhlanganisa, esungulwe ngokukhethekile esihlokweni. Lona kuzoba umsebenzi "wegeyimu" ohlanganisa izinhlelo zokusebenza ezintathu, lapho ngayinye yazo ichaza igama elithile lesizinda: "app1", "app2", "app3".

Ngaphakathi kohlelo ngalunye, kwethulwa izinqubo zebhizinisi eziqala "ukudlala ibhola" ngebhasi lokuhlanganisa. Imilayezo ebizwa ngokuthi "Ibhola" izosebenza njengebhola.

QAPHELA:

• umdlali wokuqala umqalisi. Umema abanye abadlali emdlalweni, aqale umdlalo futhi angawuqeda noma nini;
• abanye abadlali bamemezela ukuhlanganyela kwabo emdlalweni, "bajwayelane" omunye nomunye kanye nomdlali wokuqala;
• ngemuva kokuthola ibhola, umdlali ukhetha omunye umdlali obambe iqhaza bese emdlulisela ibhola. Inani eliphelele lamaphasi libaliwe;
• Umdlali ngamunye "unamandla", ancipha ngokudlula ngakunye kwebhola kulowo mdlali. Lapho amandla ephela, umdlali uyakhishwa emdlalweni, ememezela ukuthi uzothatha umhlalaphansi;
• uma umdlali eshiywe yedwa, ngokushesha umemezela ukuhamba kwakhe;
• lapho bonke abadlali bekhishiwe, umdlali wokuqala umemezela ukuphela komdlalo. Uma eshiye umdlalo ngaphambili, kusasele ukulandela umdlalo ukuze awuqedele.

Ukuxazulula le nkinga, ngizosebenzisa i-DSL yethu ngezinqubo zebhizinisi, ezikuvumela ukuthi uchaze i-logic e-Kotlin ngokuhlangene, ngobuncane be-boilerplate.

Kuhlelo lokusebenza1, inqubo yebhizinisi yomdlali wokuqala (futhi ungumqalisi womdlalo) izosebenza:

ikilasi InitialPlayer

import ru.krista.bpm.ProcessInstance
import ru.krista.bpm.runtime.ProcessImpl
import ru.krista.bpm.runtime.constraint.UniqueConstraints
import ru.krista.bpm.runtime.dsl.processModel
import ru.krista.bpm.runtime.dsl.taskOperation
import ru.krista.bpm.runtime.instance.MessageSendInstance

data class PlayerInfo(val name: String, val domain: String, val id: String)

class PlayersList : ArrayList<PlayerInfo>()

// Это класс экземпляра процесса: инкапсулирует его внутреннее состояние
class InitialPlayer : ProcessImpl<InitialPlayer>(initialPlayerModel) {
    var playerName: String by persistent("Player1")
    var energy: Int by persistent(30)
    var players: PlayersList by persistent(PlayersList())
    var shotCounter: Int = 0
}

// Это декларация модели процесса: создается один раз, используется всеми
// экземплярами процесса соответствующего класса
val initialPlayerModel = processModel<InitialPlayer>(name = "InitialPlayer",
                                                     version = 1) {

    // По правилам, первый игрок является инициатором игры и должен быть единственным
    uniqueConstraint = UniqueConstraints.singleton

    // Объявляем активности, из которых состоит бизнес-процесс
    val sendNewGameSignal = signal<String>("NewGame")
    val sendStopGameSignal = signal<String>("StopGame")
    val startTask = humanTask("Start") {
        taskOperation {
            processCondition { players.size > 0 }
            confirmation { "Подключилось ${players.size} игроков. Начинаем?" }
        }
    }
    val stopTask = humanTask("Stop") {
        taskOperation {}
    }
    val waitPlayerJoin = signalWait<String>("PlayerJoin") { signal ->
        players.add(PlayerInfo(
                signal.data!!,
                signal.sender.domain,
                signal.sender.processInstanceId))
        println("... join player ${signal.data} ...")
    }
    val waitPlayerOut = signalWait<String>("PlayerOut") { signal ->
        players.remove(PlayerInfo(
                signal.data!!,
                signal.sender.domain,
                signal.sender.processInstanceId))
        println("... player ${signal.data} is out ...")
    }
    val sendPlayerOut = signal<String>("PlayerOut") {
        signalData = { playerName }
    }
    val sendHandshake = messageSend<String>("Handshake") {
        messageData = { playerName }
        activation = {
            receiverDomain = process.players.last().domain
            receiverProcessInstanceId = process.players.last().id
        }
    }
    val throwStartBall = messageSend<Int>("Ball") {
        messageData = { 1 }
        activation = { selectNextPlayer() }
    }
    val throwBall = messageSend<Int>("Ball") {
        messageData = { shotCounter + 1 }
        activation = { selectNextPlayer() }
        onEntry { energy -= 1 }
    }
    val waitBall = messageWaitData<Int>("Ball") {
        shotCounter = it
    }

    // Теперь конструируем граф процесса из объявленных активностей
    startFrom(sendNewGameSignal)
            .fork("mainFork") {
                next(startTask)
                next(waitPlayerJoin).next(sendHandshake).next(waitPlayerJoin)
                next(waitPlayerOut)
                        .branch("checkPlayers") {
                            ifTrue { players.isEmpty() }
                                    .next(sendStopGameSignal)
                                    .terminate()
                            ifElse().next(waitPlayerOut)
                        }
            }
    startTask.fork("afterStart") {
        next(throwStartBall)
                .branch("mainLoop") {
                    ifTrue { energy < 5 }.next(sendPlayerOut).next(waitBall)
                    ifElse().next(waitBall).next(throwBall).loop()
                }
        next(stopTask).next(sendStopGameSignal)
    }

    // Навешаем на активности дополнительные обработчики для логирования
    sendNewGameSignal.onExit { println("Let's play!") }
    sendStopGameSignal.onExit { println("Stop!") }
    sendPlayerOut.onExit { println("$playerName: I'm out!") }
}

private fun MessageSendInstance<InitialPlayer, Int>.selectNextPlayer() {
    val player = process.players.random()
    receiverDomain = player.domain
    receiverProcessInstanceId = player.id
    println("Step ${process.shotCounter + 1}: " +
            "${process.playerName} >>> ${player.name}")
}

Ngokungeziwe ekusebenzeni okunengqondo kwebhizinisi, ikhodi engenhla ingakhiqiza imodeli yento yenqubo yebhizinisi engabonwa njengomdwebo. Asikasebenzisi isibonisi, ngakho-ke kudingeke ukuthi sichithe isikhathi sidweba (lapha ngenze lula ukuphawula kwe-BPMN mayelana nokusetshenziswa kwamasango ukuze kuthuthukiswe ukufana komdwebo ngekhodi engenhla):

i-app2 izofaka inqubo yebhizinisi yomunye umdlali:

ikilasi RandomPlayer

import ru.krista.bpm.ProcessInstance
import ru.krista.bpm.runtime.ProcessImpl
import ru.krista.bpm.runtime.dsl.processModel
import ru.krista.bpm.runtime.instance.MessageSendInstance

data class PlayerInfo(val name: String, val domain: String, val id: String)

class PlayersList: ArrayList<PlayerInfo>()

class RandomPlayer : ProcessImpl<RandomPlayer>(randomPlayerModel) {

    var playerName: String by input(persistent = true, 
                                    defaultValue = "RandomPlayer")
    var energy: Int by input(persistent = true, defaultValue = 30)
    var players: PlayersList by persistent(PlayersList())
    var allPlayersOut: Boolean by persistent(false)
    var shotCounter: Int = 0

    val selfPlayer: PlayerInfo
        get() = PlayerInfo(playerName, env.eventDispatcher.domainName, id)
}

val randomPlayerModel = processModel<RandomPlayer>(name = "RandomPlayer", 
                                                   version = 1) {

    val waitNewGameSignal = signalWait<String>("NewGame")
    val waitStopGameSignal = signalWait<String>("StopGame")
    val sendPlayerJoin = signal<String>("PlayerJoin") {
        signalData = { playerName }
    }
    val sendPlayerOut = signal<String>("PlayerOut") {
        signalData = { playerName }
    }
    val waitPlayerJoin = signalWaitCustom<String>("PlayerJoin") {
        eventCondition = { signal ->
            signal.sender.processInstanceId != process.id 
                && !process.players.any { signal.sender.processInstanceId == it.id}
        }
        handler = { signal ->
            players.add(PlayerInfo(
                    signal.data!!,
                    signal.sender.domain,
                    signal.sender.processInstanceId))
        }
    }
    val waitPlayerOut = signalWait<String>("PlayerOut") { signal ->
        players.remove(PlayerInfo(
                signal.data!!,
                signal.sender.domain,
                signal.sender.processInstanceId))
        allPlayersOut = players.isEmpty()
    }
    val sendHandshake = messageSend<String>("Handshake") {
        messageData = { playerName }
        activation = {
            receiverDomain = process.players.last().domain
            receiverProcessInstanceId = process.players.last().id
        }
    }
    val receiveHandshake = messageWait<String>("Handshake") { message ->
        if (!players.any { message.sender.processInstanceId == it.id}) {
            players.add(PlayerInfo(
                    message.data!!, 
                    message.sender.domain, 
                    message.sender.processInstanceId))
        }
    }
    val throwBall = messageSend<Int>("Ball") {
        messageData = { shotCounter + 1 }
        activation = { selectNextPlayer() }
        onEntry { energy -= 1 }
    }
    val waitBall = messageWaitData<Int>("Ball") {
        shotCounter = it
    }

    startFrom(waitNewGameSignal)
            .fork("mainFork") {
                next(sendPlayerJoin)
                        .branch("mainLoop") {
                            ifTrue { energy < 5 || allPlayersOut }
                                    .next(sendPlayerOut)
                                    .next(waitBall)
                            ifElse()
                                    .next(waitBall)
                                    .next(throwBall)
                                    .loop()
                        }
                next(waitPlayerJoin).next(sendHandshake).next(waitPlayerJoin)
                next(waitPlayerOut).next(waitPlayerOut)
                next(receiveHandshake).next(receiveHandshake)
                next(waitStopGameSignal).terminate()
            }

    sendPlayerJoin.onExit { println("$playerName: I'm here!") }
    sendPlayerOut.onExit { println("$playerName: I'm out!") }
}

private fun MessageSendInstance<RandomPlayer, Int>.selectNextPlayer() {
    val player = if (process.players.isNotEmpty()) 
        process.players.random() 
    else 
        process.selfPlayer
    receiverDomain = player.domain
    receiverProcessInstanceId = player.id
    println("Step ${process.shotCounter + 1}: " +
            "${process.playerName} >>> ${player.name}")
}

Umdwebo:

Kuhlelo lokusebenza lwe-app3, sizokwenza umdlali abe nokuziphatha okuhluke kancane: esikhundleni sokukhetha ngokungahleliwe umdlali olandelayo, uzokwenza ngokuvumelana ne-algorithm ye-round-robin:

ikilasi RoundRobinPlayer

import ru.krista.bpm.ProcessInstance
import ru.krista.bpm.runtime.ProcessImpl
import ru.krista.bpm.runtime.dsl.processModel
import ru.krista.bpm.runtime.instance.MessageSendInstance

data class PlayerInfo(val name: String, val domain: String, val id: String)

class PlayersList: ArrayList<PlayerInfo>()

class RoundRobinPlayer : ProcessImpl<RoundRobinPlayer>(roundRobinPlayerModel) {

    var playerName: String by input(persistent = true, 
                                    defaultValue = "RoundRobinPlayer")
    var energy: Int by input(persistent = true, defaultValue = 30)
    var players: PlayersList by persistent(PlayersList())
    var nextPlayerIndex: Int by persistent(-1)
    var allPlayersOut: Boolean by persistent(false)
    var shotCounter: Int = 0

    val selfPlayer: PlayerInfo
        get() = PlayerInfo(playerName, env.eventDispatcher.domainName, id)
}

val roundRobinPlayerModel = processModel<RoundRobinPlayer>(
        name = "RoundRobinPlayer", 
        version = 1) {

    val waitNewGameSignal = signalWait<String>("NewGame")
    val waitStopGameSignal = signalWait<String>("StopGame")
    val sendPlayerJoin = signal<String>("PlayerJoin") {
        signalData = { playerName }
    }
    val sendPlayerOut = signal<String>("PlayerOut") {
        signalData = { playerName }
    }
    val waitPlayerJoin = signalWaitCustom<String>("PlayerJoin") {
        eventCondition = { signal ->
            signal.sender.processInstanceId != process.id 
                && !process.players.any { signal.sender.processInstanceId == it.id}
        }
        handler = { signal ->
            players.add(PlayerInfo(
                    signal.data!!, 
                    signal.sender.domain, 
                    signal.sender.processInstanceId))
        }
    }
    val waitPlayerOut = signalWait<String>("PlayerOut") { signal ->
        players.remove(PlayerInfo(
                signal.data!!, 
                signal.sender.domain, 
                signal.sender.processInstanceId))
        allPlayersOut = players.isEmpty()
    }
    val sendHandshake = messageSend<String>("Handshake") {
        messageData = { playerName }
        activation = {
            receiverDomain = process.players.last().domain
            receiverProcessInstanceId = process.players.last().id
        }
    }
    val receiveHandshake = messageWait<String>("Handshake") { message ->
        if (!players.any { message.sender.processInstanceId == it.id}) {
            players.add(PlayerInfo(
                    message.data!!, 
                    message.sender.domain, 
                    message.sender.processInstanceId))
        }
    }
    val throwBall = messageSend<Int>("Ball") {
        messageData = { shotCounter + 1 }
        activation = { selectNextPlayer() }
        onEntry { energy -= 1 }
    }
    val waitBall = messageWaitData<Int>("Ball") {
        shotCounter = it
    }

    startFrom(waitNewGameSignal)
            .fork("mainFork") {
                next(sendPlayerJoin)
                        .branch("mainLoop") {
                            ifTrue { energy < 5 || allPlayersOut }
                                    .next(sendPlayerOut)
                                    .next(waitBall)
                            ifElse()
                                    .next(waitBall)
                                    .next(throwBall)
                                    .loop()
                        }
                next(waitPlayerJoin).next(sendHandshake).next(waitPlayerJoin)
                next(waitPlayerOut).next(waitPlayerOut)
                next(receiveHandshake).next(receiveHandshake)
                next(waitStopGameSignal).terminate()
            }

    sendPlayerJoin.onExit { println("$playerName: I'm here!") }
    sendPlayerOut.onExit { println("$playerName: I'm out!") }
}

private fun MessageSendInstance<RoundRobinPlayer, Int>.selectNextPlayer() {
    var idx = process.nextPlayerIndex + 1
    if (idx >= process.players.size) {
        idx = 0
    }
    process.nextPlayerIndex = idx
    val player = if (process.players.isNotEmpty()) 
        process.players[idx] 
    else 
        process.selfPlayer
    receiverDomain = player.domain
    receiverProcessInstanceId = player.id
    println("Step ${process.shotCounter + 1}: " +
            "${process.playerName} >>> ${player.name}")
}

Uma kungenjalo, ukuziphatha komdlali akufani nokwangaphambilini, ngakho umdwebo awushintshi.

Manje sidinga ukuhlolwa ukuze sikwenze konke. Ngizonikeza kuphela ikhodi yokuhlola ngokwayo, ukuze ngingahlanganisi isihloko nge-boilerplate (eqinisweni, ngisebenzise indawo yokuhlola edalwe ngaphambili ukuze ngihlole ukuhlanganiswa kwezinye izinqubo zebhizinisi):

testGame()

@Test
public void testGame() throws InterruptedException {
    String pl2 = startProcess(app2, "RandomPlayer", playerParams("Player2", 20));
    String pl3 = startProcess(app2, "RandomPlayer", playerParams("Player3", 40));
    String pl4 = startProcess(app3, "RoundRobinPlayer", playerParams("Player4", 25));
    String pl5 = startProcess(app3, "RoundRobinPlayer", playerParams("Player5", 35));
    String pl1 = startProcess(app1, "InitialPlayer");
    // Теперь нужно немного подождать, пока игроки "познакомятся" друг с другом.
    // Ждать через sleep - плохое решение, зато самое простое. 
    // Не делайте так в серьезных тестах!
    Thread.sleep(1000);
    // Запускаем игру, закрывая пользовательскую активность
    assertTrue(closeTask(app1, pl1, "Start"));
    app1.getWaiting().waitProcessFinished(pl1);
    app2.getWaiting().waitProcessFinished(pl2);
    app2.getWaiting().waitProcessFinished(pl3);
    app3.getWaiting().waitProcessFinished(pl4);
    app3.getWaiting().waitProcessFinished(pl5);
}

private Map<String, Object> playerParams(String name, int energy) {
    Map<String, Object> params = new HashMap<>();
    params.put("playerName", name);
    params.put("energy", energy);
    return params;
}

Qalisa ukuhlolwa, bheka ilogu:

console okukhiphayo

Взята блокировка ключа lock://app1/process/InitialPlayer
Let's play!
Снята блокировка ключа lock://app1/process/InitialPlayer
Player2: I'm here!
Player3: I'm here!
Player4: I'm here!
Player5: I'm here!
... join player Player2 ...
... join player Player4 ...
... join player Player3 ...
... join player Player5 ...
Step 1: Player1 >>> Player3
Step 2: Player3 >>> Player5
Step 3: Player5 >>> Player3
Step 4: Player3 >>> Player4
Step 5: Player4 >>> Player3
Step 6: Player3 >>> Player4
Step 7: Player4 >>> Player5
Step 8: Player5 >>> Player2
Step 9: Player2 >>> Player5
Step 10: Player5 >>> Player4
Step 11: Player4 >>> Player2
Step 12: Player2 >>> Player4
Step 13: Player4 >>> Player1
Step 14: Player1 >>> Player4
Step 15: Player4 >>> Player3
Step 16: Player3 >>> Player1
Step 17: Player1 >>> Player2
Step 18: Player2 >>> Player3
Step 19: Player3 >>> Player1
Step 20: Player1 >>> Player5
Step 21: Player5 >>> Player1
Step 22: Player1 >>> Player2
Step 23: Player2 >>> Player4
Step 24: Player4 >>> Player5
Step 25: Player5 >>> Player3
Step 26: Player3 >>> Player4
Step 27: Player4 >>> Player2
Step 28: Player2 >>> Player5
Step 29: Player5 >>> Player2
Step 30: Player2 >>> Player1
Step 31: Player1 >>> Player3
Step 32: Player3 >>> Player4
Step 33: Player4 >>> Player1
Step 34: Player1 >>> Player3
Step 35: Player3 >>> Player4
Step 36: Player4 >>> Player3
Step 37: Player3 >>> Player2
Step 38: Player2 >>> Player5
Step 39: Player5 >>> Player4
Step 40: Player4 >>> Player5
Step 41: Player5 >>> Player1
Step 42: Player1 >>> Player5
Step 43: Player5 >>> Player3
Step 44: Player3 >>> Player5
Step 45: Player5 >>> Player2
Step 46: Player2 >>> Player3
Step 47: Player3 >>> Player2
Step 48: Player2 >>> Player5
Step 49: Player5 >>> Player4
Step 50: Player4 >>> Player2
Step 51: Player2 >>> Player5
Step 52: Player5 >>> Player1
Step 53: Player1 >>> Player5
Step 54: Player5 >>> Player3
Step 55: Player3 >>> Player5
Step 56: Player5 >>> Player2
Step 57: Player2 >>> Player1
Step 58: Player1 >>> Player4
Step 59: Player4 >>> Player1
Step 60: Player1 >>> Player4
Step 61: Player4 >>> Player3
Step 62: Player3 >>> Player2
Step 63: Player2 >>> Player5
Step 64: Player5 >>> Player4
Step 65: Player4 >>> Player5
Step 66: Player5 >>> Player1
Step 67: Player1 >>> Player5
Step 68: Player5 >>> Player3
Step 69: Player3 >>> Player4
Step 70: Player4 >>> Player2
Step 71: Player2 >>> Player5
Step 72: Player5 >>> Player2
Step 73: Player2 >>> Player1
Step 74: Player1 >>> Player4
Step 75: Player4 >>> Player1
Step 76: Player1 >>> Player2
Step 77: Player2 >>> Player5
Step 78: Player5 >>> Player4
Step 79: Player4 >>> Player3
Step 80: Player3 >>> Player1
Step 81: Player1 >>> Player5
Step 82: Player5 >>> Player1
Step 83: Player1 >>> Player4
Step 84: Player4 >>> Player5
Step 85: Player5 >>> Player3
Step 86: Player3 >>> Player5
Step 87: Player5 >>> Player2
Step 88: Player2 >>> Player3
Player2: I'm out!
Step 89: Player3 >>> Player4
... player Player2 is out ...
Step 90: Player4 >>> Player1
Step 91: Player1 >>> Player3
Step 92: Player3 >>> Player1
Step 93: Player1 >>> Player4
Step 94: Player4 >>> Player3
Step 95: Player3 >>> Player5
Step 96: Player5 >>> Player1
Step 97: Player1 >>> Player5
Step 98: Player5 >>> Player3
Step 99: Player3 >>> Player5
Step 100: Player5 >>> Player4
Step 101: Player4 >>> Player5
Player4: I'm out!
... player Player4 is out ...
Step 102: Player5 >>> Player1
Step 103: Player1 >>> Player3
Step 104: Player3 >>> Player1
Step 105: Player1 >>> Player3
Step 106: Player3 >>> Player5
Step 107: Player5 >>> Player3
Step 108: Player3 >>> Player1
Step 109: Player1 >>> Player3
Step 110: Player3 >>> Player5
Step 111: Player5 >>> Player1
Step 112: Player1 >>> Player3
Step 113: Player3 >>> Player5
Step 114: Player5 >>> Player3
Step 115: Player3 >>> Player1
Step 116: Player1 >>> Player3
Step 117: Player3 >>> Player5
Step 118: Player5 >>> Player1
Step 119: Player1 >>> Player3
Step 120: Player3 >>> Player5
Step 121: Player5 >>> Player3
Player5: I'm out!
... player Player5 is out ...
Step 122: Player3 >>> Player5
Step 123: Player5 >>> Player1
Player5: I'm out!
Step 124: Player1 >>> Player3
... player Player5 is out ...
Step 125: Player3 >>> Player1
Step 126: Player1 >>> Player3
Player1: I'm out!
... player Player1 is out ...
Step 127: Player3 >>> Player3
Player3: I'm out!
Step 128: Player3 >>> Player3
... player Player3 is out ...
Player3: I'm out!
Stop!
Step 129: Player3 >>> Player3
Player3: I'm out!

Kungafinyelelwa iziphetho ezimbalwa ezibalulekile kukho konke lokhu:

• uma amathuluzi adingekayo etholakala, abathuthukisi bohlelo lokusebenza bangakha ukusebenzisana kokuhlanganiswa phakathi kwezinhlelo zokusebenza ngaphandle kokuhlukana nokucabanga kwebhizinisi;
• ubunkimbinkimbi (ubunzima) bomsebenzi wokuhlanganisa odinga amakhono obunjiniyela bungafihlwa ngaphakathi kohlaka uma lubekwe ekuqaleni ekwakhiweni kohlaka. Ubunzima bomsebenzi (ubunzima) abukwazi ukufihlwa, ngakho-ke isisombululo somsebenzi onzima kukhodi sizobukeka ngokufanele;
• lapho uthuthukisa ingqondo yokuhlanganisa, kuyadingeka ukucabangela ukuvumelana ekugcineni kanye nokuntuleka komugqa wokushintsha kwesimo sabo bonke abahlanganyeli bokuhlanganiswa. Lokhu kusiphoqa ukuthi senza inkimbinkimbi ukuze siyenze ingazweli ohlelweni okwenzeka ngalo izehlakalo zangaphandle. Esibonelweni sethu, umdlali uphoqeleka ukuthi abambe iqhaza emdlalweni ngemuva kokuthi ememezele ukuphuma kwakhe emdlalweni: abanye abadlali bazoqhubeka nokudlulisela ibhola kuye kuze kube yilapho ulwazi mayelana nokuphuma kwakhe lufika futhi lucutshungulwa yibo bonke ababambiqhaza. Le logic ayilandeli emithethweni yomdlalo futhi iyisixazululo sokuyekethisa ngaphakathi kohlaka lwezakhiwo ezikhethiwe.

Okulandelayo, ake sikhulume ngobuqili obuhlukahlukene besixazululo sethu, ukuyekethisa kanye namanye amaphuzu.

Yonke imilayezo kulayini owodwa

Zonke izinhlelo zokusebenza ezihlanganisiwe zisebenza nebhasi elilodwa lokuhlanganisa, elethulwa njengomthengisi wangaphandle, i-BPMQueue eyodwa yemilayezo kanye nesihloko se-BPTopic esisodwa samasignali (imicimbi). Ukudlulisa yonke imilayezo ngomugqa owodwa kukodwa nje kuwukuyekethisa. Ezingeni elinengqondo lebhizinisi, manje usungakwazi ukwethula izinhlobo eziningi zemilayezo ngendlela ofuna ngayo ngaphandle kokwenza izinguquko kusakhiwo sesistimu. Lokhu ukwenza lula okubalulekile, kodwa kuthwala ubungozi obuthile, obekuthi, esimweni semisebenzi yethu evamile, obubonakala bungabaluleki kangako kithi.

Nokho, kunobuqili obukodwa lapha: uhlelo lokusebenza ngalunye luhlunga imilayezo "yalo" kusukela kulayini osemnyango, ngegama lesizinda salo. Futhi, isizinda singacaciswa kumasignali, uma udinga ukukhawulela "ububanzi" besignali kuhlelo lokusebenza olulodwa. Lokhu kufanele kukhuphule umkhawulokudonsa webhasi, kodwa ingqondo yebhizinisi kufanele manje isebenze ngamagama esizinda: okuphoqelekile ekuthumeleni imilayezo, efiselekayo kumasignali.

Ukuqinisekisa ukwethembeka kwebhasi lokuhlanganisa

Ukuthembeka kwakhiwe ngezinto ezimbalwa:

• Umthengisi womlayezo okhethiwe uyingxenye ebalulekile yezakhiwo kanye nephuzu elilodwa lokwehluleka: kufanele abekezelele ngokwanele amaphutha. Kufanele usebenzise ukusetshenziswa okuhlolwe isikhathi kuphela ngokusekelwa okuhle nomphakathi omkhulu;
• kuyadingeka ukuqinisekisa ukutholakala okuphezulu komthengisi womlayezo, okumele uhlukaniswe ngokomzimba nezinhlelo zokusebenza ezihlanganisiwe (ukutholakala okuphezulu kwezicelo ezinomqondo webhizinisi osetshenzisiwe kunzima kakhulu futhi kuyabiza ukuhlinzeka);
• umthengisi unesibopho sokuhlinzeka ngeziqinisekiso zokulethwa "okungenani kanye". Lokhu kuyisidingo esiyisibopho sokusebenza okuthembekile kwebhasi lokuhlanganisa. Asikho isidingo seziqinisekiso zezinga "kanye ngqo": izinqubo zebhizinisi ngokuvamile azinandaba nokufika okuphindaphindiwe kwemilayezo noma imicimbi, futhi emisebenzini ekhethekile lapho lokhu kubalulekile, kulula ukwengeza amasheke angeziwe kumqondo webhizinisi kunokusebenzisa njalo. kunalokho "kuyabiza" " iziqinisekiso;
• ukuthumela imilayezo namasignali kufanele kuhileleke ekwenziweni okufanayo ngoshintsho esimweni sezinqubo zebhizinisi kanye nedatha yesizinda. Inketho ekhethwayo kungaba ukusebenzisa iphethini Ibhokisi lokuphumayo lokwenziwayo, kodwa izodinga ithebula elengeziwe kusizindalwazi kanye ne-relay. Ezinhlelweni ze-JEE, lokhu kungenziwa lula ngokusebenzisa umphathi wendawo we-JTA, kodwa ukuxhumana nomthengisi okhethiwe kufanele kukwazi ukusebenza ngemodi. XA;
• abaphathi bemilayezo engenayo nemicimbi kumele nabo basebenze nomsebenzi wokushintsha isimo senqubo yebhizinisi: uma lowo msebenzi uhlehliswa, khona-ke ukwamukelwa komlayezo nakho kufanele kukhanselwe;
• imilayezo engalethwanga ngenxa yamaphutha kufanele igcinwe esitolo esihlukile I-DLQ (Umugqa Wezincwadi Ezifile). Ukwenza lokhu, sidale i-microservice yesikhulumi ehlukile egcina imilayezo enjalo endaweni yayo yokugcina, iyikhombe ngezibaluli (yokuqoqa ngokushesha nokusesha), futhi iveze i-API ukuze ibukwe, ithumele kabusha ekhelini okuyiwa kulo, futhi isuse imilayezo. Abaphathi besistimu bangasebenza nale sevisi ngokusebenzisa isixhumi esibonakalayo sewebhu;
• kuzilungiselelo zomthengisi, udinga ukulungisa inani lokuzama kabusha kokulethwa kanye nokubambezeleka phakathi kokulethwa ukuze unciphise amathuba okuthi imilayezo ingene ku-DLQ (cishe akunakwenzeka ukubala amapharamitha alungile, kodwa ungenza ngamandla futhi uwalungise ngesikhathi ukusebenza);
• isitolo se-DLQ kufanele sigadwe ngokuqhubekayo, futhi isistimu yokuqapha kufanele yazise abaphathi besistimu ukuze bakwazi ukuphendula ngokushesha ngangokunokwenzeka lapho imilayezo engalethiwe ivela. Lokhu kuzonciphisa "indawo yomonakalo" yokwehluleka noma iphutha lengqondo yebhizinisi;
• ibhasi lokuhlanganisa kumele lingabi nandaba nokungabikho kwesikhashana kwezicelo: okubhaliselwe kwesihloko kumele kuhlale isikhathi eside, futhi igama lesizinda lesicelo kumele lihluke ukuze omunye umuntu angazami ukucubungula umlayezo walo emgqeni ngesikhathi sokungabikho kwesicelo.

Ukuqinisekisa ukuphepha kwentambo yengqondo yebhizinisi

Isenzakalo esifanayo senqubo yebhizinisi singathola imilayezo nemicimbi eminingana ngesikhathi esisodwa, ukucutshungulwa okuzoqala ngokuhambisana. Ngesikhathi esifanayo, kumthuthukisi wohlelo lokusebenza, yonke into kufanele ibe lula futhi iphephe.

Inqubo yebhizinisi enengqondo icubungula umcimbi wangaphandle ngamunye othinta le nqubo yebhizinisi ngazinye. Le micimbi ingaba:

• ukwethula isibonelo senqubo yebhizinisi;
• isenzo somsebenzisi esihlobene nomsebenzi ongaphakathi kwenqubo yebhizinisi;
• ukwamukela umlayezo noma isignali lapho inqubo yebhizinisi ibhaliswe khona;
• ukuphelelwa yisikhathi kwesibali sikhathi esibekwe yisibonelo senqubo yebhizinisi;
• lawula isenzo nge-API (isb. ukunqamula inqubo).

Umcimbi ngamunye onjalo ungashintsha isimo senqubo yebhizinisi: eminye imisebenzi ingaphela futhi eminye iqale, amanani ezakhiwo eziphikelelayo angashintsha. Ukuvala noma yimuphi umsebenzi kungase kuphumele ekuvulweni komsebenzi owodwa noma ngaphezulu kwalena elandelayo. Lezo, nazo, zingayeka ukulinda eminye imicimbi, noma, uma zingadingi idatha eyengeziwe, zingaqedela kumsebenzi ofanayo. Ngaphambi kokuvala ukuthengiselana, isimo esisha senqubo yebhizinisi sigcinwa kusizindalwazi, lapho sizolinda khona umcimbi wangaphandle olandelayo.

Idatha yenqubo yebhizinisi eqhubekayo egcinwe kusizindalwazi esihlobene iyindawo elula kakhulu yokucubungula ukuvumelanisa lapho usebenzisa KHETHA UKUZE UBUYEKEZWE. Uma ukuthengiselana okukodwa kukwazile ukuthola isimo senqubo yebhizinisi kusuka ku-database ukuyishintsha, akukho okunye ukuthengiselana okufanayo okuzokwazi ukuthola isimo esifanayo kolunye ushintsho, futhi ngemva kokuqedwa kokuthengiselana kokuqala, okwesibili kuqinisekisiwe ukuthola isimo esivele sishintshile.

Sisebenzisa izingidi ezingenathemba ohlangothini lwe-DBMS, sifeza zonke izidingo ezidingekayo I-ACID, futhi ugcine ikhono lokukala uhlelo lokusebenza ngengqondo yebhizinisi ngokwandisa inani lezimo ezisebenzayo.

Kodwa-ke, izikhiya ezingenathemba zisisongela ngokuvimba, okusho ukuthi KHETHA UKUZE UBUYEKEZWE kusafanele kukhawulwe esikhathini esithile esiphusile uma kwenzeka kuba nezingqinamba kwezinye izimo ezimbi kakhulu kungqondongqondo yebhizinisi.

Enye inkinga ukuvumelanisa kokuqala kwenqubo yebhizinisi. Yize singekho isibonelo senqubo yebhizinisi, asikho isimo kusizindalwazi, ngakho-ke indlela echaziwe ngeke isebenze. Uma ufuna ukuqinisekisa ukuhluka kwesenzakalo senqubo yebhizinisi kusikophu esithile, uzodinga uhlobo oluthile lwento yokuvumelanisa ehlotshaniswa nekilasi lenqubo kanye nobubanzi obuhambisanayo. Ukuze sixazulule le nkinga, sisebenzisa indlela ehlukile yokukhiya esivumela ukuthi sithathe isikhiya esisetshenziswa ngokunganaki esicaciswe ukhiye ngefomethi ye-URI ngesevisi yangaphandle.

Ezibonelweni zethu, inqubo yebhizinisi ye-InitialPlayer iqukethe isimemezelo

uniqueConstraint = UniqueConstraints.singleton

Ngakho-ke, ilogi iqukethe imilayezo mayelana nokuthatha nokukhulula ukukhiya kokhiye ohambelanayo. Ayikho imilayezo enjalo yezinye izinqubo zebhizinisi: i- uniqueConstraint ayisethiwe.

Izinkinga zenqubo yebhizinisi ngesimo esiqhubekayo

Ngezinye izikhathi ukuba nesimo esiphikelelayo akusizi nje kuphela, kodwa futhi kuvimbela ngempela ukuthuthukiswa.
Izinkinga ziqala lapho udinga ukwenza izinguquko kumqondo webhizinisi kanye / noma imodeli yenqubo yebhizinisi. Alukho ushintsho olunjalo olutholakala luhambisana nesimo esidala sezinqubo zebhizinisi. Uma kunezimo eziningi "ezibukhoma" kusizindalwazi, ukwenza izinguquko ezingahambelani kungase kubangele izinkinga eziningi, esivame ukuhlangana nazo lapho sisebenzisa i-jBPM.

Ngokuya ngokujula koshintsho, ungenza ngezindlela ezimbili:

1. dala uhlobo olusha lwenqubo yebhizinisi ukuze ungenzi izinguquko ezingahambisani nendala, futhi ulisebenzise esikhundleni sokudala lapho uqala izimo ezintsha. Izimo ezindala zizoqhubeka nokusebenza "ngendlela yakudala";
2. thuthela isimo esiqhubekayo sezinqubo zebhizinisi lapho ubuyekeza ingqondo yebhizinisi.

Indlela yokuqala ilula, kodwa inemikhawulo nemibi, isibonelo:

• ukuphindaphinda kwe-logic yebhizinisi kumamodeli wenqubo yebhizinisi eminingi, ukwanda komthamo we-logic yebhizinisi;
• ngokuvamile kudingeka uguquko olusheshayo oluya kumqondo webhizinisi elisha (cishe njalo ngokwemisebenzi yokuhlanganisa);
• umthuthukisi akazi ukuthi kunini lapho kungenzeka khona ukususa amamodeli aphelelwe yisikhathi.

Empeleni, sisebenzisa zombili izindlela, kodwa senze izinqumo eziningi zokwenza ukuphila kwethu kube lula:

• kusizindalwazi, isimo esiqhubekayo senqubo yebhizinisi sigcinwa ngendlela efundeka kalula nesingacubungulwa kalula: ngochungechunge lwefomethi ye-JSON. Lokhu kukuvumela ukuthi wenze ukuthutha kokubili ngaphakathi kohlelo lokusebenza nangaphandle. Ezimweni ezimbi kakhulu, ungakwazi futhi ukuyilungisa ngezibambo (ikakhulukazi ewusizo ekuthuthukisweni ngesikhathi sokulungisa iphutha);
• i-logic yebhizinisi yokuhlanganisa ayisebenzisi amagama ezinqubo zebhizinisi, ukuze nganoma yisiphi isikhathi kungenzeka ukuthi esikhundleni sokuqaliswa kwezinqubo ezibambe iqhaza kufakwe entsha, enegama elisha (isibonelo, "InitialPlayerV2"). Ukubophezela kwenzeka ngamagama emiyalezo namasignali;
• imodeli yenqubo inenombolo yenguqulo, esiyikhulisayo uma senza izinguquko ezingahambisani nale modeli, futhi le nombolo igcinwa kanye nesimo sesibonelo senqubo;
• isimo esiqhubekayo senqubo sifundwa kusukela kusisekelo kuqala ukuya kumodeli yento elula inqubo yokuthutha engasebenza nayo uma inombolo yenguqulo yemodeli ishintshile;
• inqubo yokuthutha ibekwe eduze komqondo webhizinisi futhi ibizwa ngokuthi "ivila" esimweni ngasinye senqubo yebhizinisi ngesikhathi sokubuyiselwa kwalo kusizindalwazi;
• uma udinga ukuthutha isimo sazo zonke izimo zenqubo ngokushesha nangokuvumelanayo, kusetshenziswa izixazululo zokuthutha zesizindalwazi sakudala, kodwa kufanele usebenze ne-JSON lapho.

Ingabe ngidinga olunye uhlaka lwezinqubo zebhizinisi?

Izisombululo ezichazwe esihlokweni zisivumele ukuthi senze izimpilo zethu zibe lula kakhulu, sandise ububanzi bezinkinga ezixazululwe ezingeni lokuthuthukiswa kohlelo lokusebenza, futhi senze umqondo wokuhlukanisa umqondo webhizinisi ube ngama-microservices uthandeke kakhulu. Kulokhu, umsebenzi omningi owenziwe, uhlaka "olulula" kakhulu lwezinqubo zebhizinisi lwenziwe, kanye nezingxenye zesevisi zokuxazulula izinkinga ezikhonjiwe kumongo wemisebenzi eminingi esetshenzisiwe. Sinesifiso sokwabelana ngale miphumela, ukuletha ukuthuthukiswa kwezingxenye ezifanayo ekufinyeleleni okuvulekile ngaphansi kwelayisensi yamahhala. Lokhu kuzodinga umzamo nesikhathi. Ukuqonda isidingo sezixazululo ezinjalo kungaba isikhuthazo esengeziwe kithi. Esihlokweni esihlongozwayo, ukunakwa okuncane kakhulu kukhokhwa emandleni ohlaka ngokwalo, kodwa ezinye zazo zibonakala ezibonelweni eziveziwe. Uma nokho sishicilela uhlaka lwethu, indatshana ehlukile izonikelwa kulo. Okwamanje, sizojabula uma ushiya impendulo encane ngokuphendula umbuzo:

Abasebenzisi ababhalisiwe kuphela abangabamba iqhaza kuhlolovo. Ngena ngemvume, wamukelekile.

Ingabe ngidinga olunye uhlaka lwezinqubo zebhizinisi?

• 18,8%Yebo, kudala ngifuna into efana nalena.

• 12,5%kuyathakazelisa ukufunda okwengeziwe mayelana nokusebenzisa kwakho, kungase kube usizo2

• 6,2%sisebenzisa olunye lwezinhlaka ezikhona, kodwa sicabanga ngokulushintsha1

• 18,8%sisebenzisa olunye lwezinhlaka ezikhona, konke kuvumelana3

• 18,8%ukubhekana ngaphandle kohlaka3

• 25,0%bhala eyakho4

Bangu-16 abasebenzisi abavotile. Abasebenzisi abangu-7 bagobile.

Source: www.habr.com