ViennaNET: set o lyfrgelloedd ar gyfer y pen ôl. Rhan 2

Mae cymuned ddatblygwyr Raiffeisenbank .NET yn parhau i adolygu cynnwys ViennaNET yn fyr. Ynglŷn â sut a pham y daethom at hyn, gallwch ddarllen y rhan gyntaf.

Yn yr erthygl hon, byddwn yn mynd trwy lyfrgelloedd sydd eto i'w hystyried ar gyfer gweithio gyda thrafodion dosbarthedig, ciwiau a chronfeydd data, sydd i'w gweld yn ein cadwrfa GitHub (ffynonellau sydd yma), a Pecynnau Nuget yma.

FiennaNET.Sagas

Pan fydd prosiect yn newid i bensaernïaeth DDD a microservice, yna pan fydd rhesymeg busnes yn cael ei ddosbarthu ar draws gwahanol wasanaethau, mae problem yn codi sy'n ymwneud â'r angen i weithredu mecanwaith trafodion dosbarthedig, oherwydd mae llawer o senarios yn aml yn effeithio ar sawl parth ar unwaith. Gallwch ddod yn gyfarwydd â mecanweithiau o'r fath yn fwy manwl, er enghraifft, yn y llyfr "Microservices Patterns", Chris Richardson.

Yn ein prosiectau, rydym wedi rhoi mecanwaith syml ond defnyddiol ar waith: saga, neu yn hytrach saga seiliedig ar offeryniaeth. Mae ei hanfod fel a ganlyn: mae yna senario busnes penodol lle mae angen cyflawni gweithrediadau mewn gwahanol wasanaethau yn olynol, ac os bydd unrhyw broblemau'n codi ar unrhyw gam, mae angen galw'r weithdrefn dychwelyd ar gyfer pob cam blaenorol, lle mae darparu. Felly, ar ddiwedd y saga, waeth beth fo'u llwyddiant, rydym yn derbyn data cyson ym mhob parth.

Mae ein gweithrediad yn dal i gael ei wneud yn ei ffurf sylfaenol ac nid yw'n gysylltiedig â'r defnydd o unrhyw ddulliau o ryngweithio â gwasanaethau eraill. Nid yw'n anodd ei ddefnyddio: gwnewch ddisgynnydd o'r dosbarth haniaethol sylfaenol SagaBase<T>, lle T yw eich dosbarth cyd-destun lle gallwch storio'r data cychwynnol sy'n angenrheidiol i'r saga weithio, yn ogystal â rhai canlyniadau canolradd. Bydd yr enghraifft cyd-destun yn cael ei drosglwyddo i bob cam yn ystod y gweithredu. Mae Saga ei hun yn ddosbarth heb wladwriaeth, felly gellir gosod yr enghraifft yn DI fel Singleton i gael y dibyniaethau angenrheidiol.

Hysbyseb enghreifftiol:

public class ExampleSaga : SagaBase<ExampleContext>
{
  public ExampleSaga()
  {
    Step("Step 1")
      .WithAction(c => ...)
      .WithCompensation(c => ...);
	
    AsyncStep("Step 2")
      .WithAction(async c => ...);
  }
}

Galwad enghreifftiol:

var saga = new ExampleSaga();
var context = new ExampleContext();
await saga.Execute(context);

Gellir gweld enghreifftiau llawn o wahanol weithrediadau yma ac mewn cynulliad â profion.

ViennaNET.Orm.*

Set o lyfrgelloedd ar gyfer gweithio gyda chronfeydd data amrywiol trwy Nhibernate. Rydym yn defnyddio dull DB-First gan ddefnyddio Liquibase, felly dim ond swyddogaeth sydd ar gyfer gweithio gyda data mewn cronfa ddata parod.

ViennaNET.Orm.Seedwork и ViennaNET.Orm - prif gynulliadau sy'n cynnwys rhyngwynebau sylfaenol a'u gweithrediadau, yn y drefn honno. Gadewch i ni edrych ar eu cynnwys yn fwy manwl.

rhyngwyneb IEntityFactoryService a'i weithrediad EntityFactoryService yw'r prif fan cychwyn ar gyfer gweithio gyda'r gronfa ddata, gan fod yr Uned Waith, ystorfeydd ar gyfer gweithio gydag endidau penodol, yn ogystal ag ysgutorion gorchmynion ac ymholiadau SQL uniongyrchol yn cael eu creu yma. Weithiau mae'n gyfleus cyfyngu ar allu dosbarth ar gyfer gweithio gyda chronfa ddata, er enghraifft, i ddarparu'r gallu i ddarllen data yn unig. Ar gyfer achosion o'r fath IEntityFactoryService mae yna hynafiad - rhyngwyneb IEntityRepositoryFactory, sydd ond yn datgan dull ar gyfer creu ystorfeydd.

I gael mynediad uniongyrchol i'r gronfa ddata, defnyddir mecanwaith y darparwr. Mae gan bob DBMS a ddefnyddiwn yn ein timau ei weithrediad ei hun: ViennaNET.Orm.MSSQL, ViennaNET.Orm.Oracle, ViennaNET.Orm.SQLite, ViennaNET.Orm.PostgreSql.

Ar yr un pryd, gellir cofrestru sawl darparwr mewn un cais ar yr un pryd, sy'n caniatáu, er enghraifft, o fewn fframwaith un gwasanaeth, heb unrhyw gostau ar gyfer addasu'r seilwaith, i gyflawni mudo cam wrth gam o un DBMS i'r llall. Mae'r mecanwaith ar gyfer dewis y cysylltiad gofynnol ac, felly, y darparwr ar gyfer dosbarth endid penodol (y mae mapio i dablau cronfa ddata wedi'i ysgrifennu ar ei gyfer) yn cael ei weithredu trwy gofrestru'r endid yn y dosbarth BoundedContext (yn cynnwys dull ar gyfer cofrestru endidau parth) neu ei olynydd ApplicationContext (yn cynnwys dulliau ar gyfer cofrestru endidau cais , ceisiadau uniongyrchol a gorchmynion), lle mae'r dynodwr cysylltiad o'r ffurfwedd yn cael ei dderbyn fel dadl:

"db": [
  {
    "nick": "mssql_connection",
    "dbServerType": "MSSQL",
    "ConnectionString": "...",
    "useCallContext": true
  },
  {
    "nick": "oracle_connection",
    "dbServerType": "Oracle",
    "ConnectionString": "..."
  }
],

Cyd-destun Cais Enghreifftiol:

internal sealed class DbContext : ApplicationContext
{
  public DbContext()
  {
    AddEntity<SomeEntity>("mssql_connection");
    AddEntity<MigratedSomeEntity>("oracle_connection");
    AddEntity<AnotherEntity>("oracle_connection");
  }
}

Os nad yw'r ID cysylltiad wedi'i nodi, yna bydd y cysylltiad o'r enw “diofyn” yn cael ei ddefnyddio.

Gweithredir mapio endidau yn uniongyrchol i dablau cronfa ddata gan ddefnyddio offer safonol NHibernate. Gallwch ddefnyddio'r disgrifiad trwy ffeiliau xml a thrwy ddosbarthiadau. Ar gyfer ysgrifennu storfeydd bonion yn gyfleus mewn profion Uned, mae llyfrgell ViennaNET.TestUtils.Orm.

Ceir enghreifftiau llawn o ddefnyddio ViennaNET.Orm.* yma.

ViennaNET.Negeseuon.*

Set o lyfrgelloedd ar gyfer gweithio gyda chiwiau.

Er mwyn gweithio gyda chiwiau, dewiswyd yr un dull â gwahanol DBMSs, sef y dull unedig mwyaf posibl o ran gweithio gyda'r llyfrgell, ni waeth pa reolwr ciw a ddefnyddir. Llyfrgell ViennaNET.Messaging yn union gyfrifol am yr uno hwn, a ViennaNET.Messaging.MQSeriesQueue, ViennaNET.Messaging.RabbitMQQueue и ViennaNET.Messaging.KafkaQueue cynnwys gweithrediadau addasydd ar gyfer IBM MQ, RabbitMQ a Kafka, yn y drefn honno.

Wrth weithio gyda chiwiau, mae dwy broses: derbyn neges a'i hanfon.

Ystyriwch dderbyn. Mae 2 opsiwn yma: ar gyfer gwrando parhaus ac ar gyfer derbyn un neges. I wrando'n gyson ar y ciw, yn gyntaf rhaid i chi ddisgrifio'r dosbarth prosesydd a etifeddwyd ohono IMessageProcessor, a fydd yn gyfrifol am brosesu'r neges sy'n dod i mewn. Nesaf, rhaid iddo fod yn “gysylltiedig” â chiw penodol; gwneir hyn trwy gofrestru i mewn IQueueReactorFactory gan nodi'r dynodwr ciw o'r ffurfweddiad:

"messaging": {
    "ApplicationName": "MyApplication"
},
"rabbitmq": {
    "queues": [
      {
        "id": "myQueue",
        "queuename": "lalala",
        ...
      }
    ]
},

Enghraifft o ddechrau gwrando:

_queueReactorFactory.Register<MyMessageProcessor>("myQueue");
var queueReactor = queueReactorFactory.CreateQueueReactor("myQueue");
queueReactor.StartProcessing();

Yna, pan fydd y gwasanaeth yn dechrau a gelwir y dull i ddechrau gwrando, bydd yr holl negeseuon o'r ciw penodedig yn mynd i'r prosesydd cyfatebol.

I dderbyn un neges mewn rhyngwyneb ffatri IMessagingComponentFactory mae dull CreateMessageReceivera fydd yn creu derbynnydd yn aros am neges o'r ciw a nodir iddo:

using (var receiver = _messagingComponentFactory.CreateMessageReceiver<TestMessage>("myQueue"))
{
    var message = receiver.Receive();
}

I anfon neges mae angen i chi ddefnyddio'r un peth IMessagingComponentFactory a chreu anfonwr neges:

using (var sender = _messagingComponentFactory.CreateMessageSender<MyMessage>("myQueue"))
{
    sender.SendMessage(new MyMessage { Value = ...});
}

Mae tri opsiwn parod ar gyfer cyfresoli a dad-gyfresi neges: dim ond testun, XML a JSON, ond os oes angen, gallwch chi wneud eich gweithrediadau rhyngwyneb eich hun yn hawdd IMessageSerializer и IMessageDeserializer.

Rydym wedi ceisio cadw galluoedd unigryw pob rheolwr ciw, e.e. ViennaNET.Messaging.MQSeriesQueue yn eich galluogi i anfon nid yn unig negeseuon testun, ond hefyd negeseuon beit, a ViennaNET.Messaging.RabbitMQQueue cefnogi llwybro a chiwio ar-y-hedfan. Mae ein peiriant lapio addasydd ar gyfer RabbitMQ hefyd yn gweithredu rhywfaint o semblance o RPC: rydym yn anfon neges ac yn aros am ymateb gan giw dros dro arbennig, sy'n cael ei greu ar gyfer un neges ymateb yn unig.

Yma enghraifft o ddefnyddio ciwiau gyda naws cysylltu sylfaenol.

ViennaNET.CallContext

Rydym yn defnyddio ciwiau nid yn unig ar gyfer integreiddio rhwng systemau gwahanol, ond hefyd ar gyfer cyfathrebu rhwng microwasanaethau o'r un cymhwysiad, er enghraifft, o fewn saga. Arweiniodd hyn at yr angen i drosglwyddo ynghyd â'r neges ddata ategol fel y mewngofnodi defnyddiwr, dynodwr cais ar gyfer logio o un pen i'r llall, cyfeiriad IP ffynhonnell a data awdurdodi. Er mwyn gweithredu'r broses o anfon y data hwn ymlaen, rydym wedi datblygu llyfrgell ViennaNET.CallContext, sy'n eich galluogi i storio data o gais sy'n mynd i mewn i'r gwasanaeth. Yn yr achos hwn, nid oes ots sut y gwnaed y cais, trwy giw neu drwy Http. Yna, cyn anfon y cais neu'r neges sy'n mynd allan, mae data'n cael ei gymryd o'r cyd-destun a'i roi yn y penawdau. Felly, mae'r gwasanaeth nesaf yn derbyn y data ategol ac yn ei reoli yn yr un modd.

Diolch am eich sylw, edrychwn ymlaen at eich sylwadau a'ch ceisiadau tynnu!

Ffynhonnell: hab.com