ViennaNET៖ សំណុំនៃបណ្ណាល័យសម្រាប់ផ្នែកខាងក្រោយ។ ផ្នែកទី 2

សហគមន៍អ្នកអភិវឌ្ឍន៍ Raiffeisenbank .NET បន្តពិនិត្យមើលខ្លឹមសាររបស់ ViennaNET ដោយសង្ខេប។ អំពីរបៀប និងមូលហេតុដែលយើងមកនេះ អ្នកអាចអានផ្នែកដំបូង.

នៅក្នុងអត្ថបទនេះ យើងនឹងឆ្លងកាត់បណ្ណាល័យដែលមិនទាន់ត្រូវបានពិចារណាសម្រាប់ធ្វើការជាមួយប្រតិបត្តិការចែកចាយ ជួរ និងមូលដ្ឋានទិន្នន័យ ដែលអាចត្រូវបានរកឃើញនៅក្នុងឃ្លាំង GitHub របស់យើង (ប្រភពគឺនៅទីនេះ) និង កញ្ចប់ Nuget នៅទីនេះ.

ViennaNET.Sagas

នៅពេលដែលគម្រោងប្តូរទៅ DDD និងស្ថាបត្យកម្មមីក្រូសេវា បន្ទាប់មកនៅពេលដែលតក្កវិជ្ជាអាជីវកម្មត្រូវបានចែកចាយនៅទូទាំងសេវាកម្មផ្សេងៗ បញ្ហាកើតឡើងទាក់ទងនឹងតម្រូវការក្នុងការអនុវត្តយន្តការប្រតិបត្តិការចែកចាយ ពីព្រោះសេណារីយ៉ូជាច្រើនជារឿយៗប៉ះពាល់ដល់ដែនជាច្រើនក្នុងពេលតែមួយ។ អ្នកអាចស្គាល់យន្តការបែបនេះឱ្យបានលម្អិតបន្ថែមទៀត ឧទាហរណ៍។ នៅក្នុងសៀវភៅ "Microservices Patterns" Chris Richardson.

នៅក្នុងគម្រោងរបស់យើង យើងបានអនុវត្តយន្តការដ៏សាមញ្ញមួយ ប៉ុន្តែមានប្រយោជន៍៖ រឿងព្រេងនិទាន ឬជាបិសាចផ្អែកលើវង់ភ្លេង។ ខ្លឹមសាររបស់វាមានដូចខាងក្រោម៖ មានសេណារីយ៉ូអាជីវកម្មជាក់លាក់មួយ ដែលចាំបាច់ត្រូវអនុវត្តប្រតិបត្តិការជាបន្តបន្ទាប់នៅក្នុងសេវាកម្មផ្សេងៗ ហើយប្រសិនបើបញ្ហាណាមួយកើតឡើងក្នុងជំហានណាមួយ នោះចាំបាច់ត្រូវហៅទៅនីតិវិធី rollback សម្រាប់ជំហានមុនទាំងអស់ ដែលជាកន្លែងដែលវាមាន។ បានផ្តល់។ ដូច្នេះហើយ នៅចុងបញ្ចប់នៃរឿងនិទាន ដោយមិនគិតពីភាពជោគជ័យ យើងទទួលបានទិន្នន័យស្របគ្នានៅក្នុងដែនទាំងអស់។

ការអនុវត្តរបស់យើងនៅតែធ្វើឡើងក្នុងទម្រង់ជាមូលដ្ឋានរបស់វា ហើយមិនជាប់ទាក់ទងនឹងការប្រើប្រាស់វិធីសាស្រ្តណាមួយនៃអន្តរកម្មជាមួយសេវាកម្មផ្សេងទៀត។ វាមិនពិបាកក្នុងការប្រើទេ៖ គ្រាន់តែបង្កើតជាកូនចៅនៃថ្នាក់អរូបីមូលដ្ឋាន SagaBase<T> ដែល T គឺជាថ្នាក់បរិបទរបស់អ្នក ដែលអ្នកអាចរក្សាទុកទិន្នន័យដំបូងដែលចាំបាច់សម្រាប់ saga ដើម្បីដំណើរការ ក៏ដូចជាលទ្ធផលកម្រិតមធ្យមមួយចំនួនផងដែរ។ បរិបទ​ឧទាហរណ៍​នឹង​ត្រូវ​ឆ្លង​កាត់​ទៅ​គ្រប់​ជំហាន​ក្នុង​ពេល​ប្រតិបត្តិ។ Saga ខ្លួនវាគឺជាថ្នាក់គ្មានរដ្ឋ ដូច្នេះវត្ថុអាចត្រូវបានដាក់ក្នុង DI ជា Singleton ដើម្បីទទួលបានភាពអាស្រ័យចាំបាច់។

ឧទាហរណ៍ការផ្សាយពាណិជ្ជកម្ម៖

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

ឧទាហរណ៍ការហៅទូរសព្ទ៖

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

ឧទាហរណ៍ពេញលេញនៃការអនុវត្តផ្សេងៗគ្នាអាចត្រូវបានមើល នៅទីនេះ និងនៅក្នុងការជួបប្រជុំគ្នាជាមួយ ការធ្វើតេស្ត.

ViennaNET.Orm.*

សំណុំនៃបណ្ណាល័យសម្រាប់ធ្វើការជាមួយមូលដ្ឋានទិន្នន័យផ្សេងៗតាមរយៈ Nhibernate ។ យើងប្រើវិធីសាស្រ្ត DB-First ដោយប្រើ Liquibase ដូច្នេះមានតែមុខងារសម្រាប់ធ្វើការជាមួយទិន្នន័យនៅក្នុងមូលដ្ឋានទិន្នន័យដែលត្រៀមរួចជាស្រេច។

ViennaNET.Orm.Seedwork и ViennaNET.Orm - សន្និបាតសំខាន់ៗដែលមានចំណុចប្រទាក់មូលដ្ឋាន និងការអនុវត្តរបស់ពួកគេរៀងៗខ្លួន។ សូមក្រឡេកមើលខ្លឹមសាររបស់ពួកគេឱ្យបានលំអិត។

ចំណុចប្រទាក់ IEntityFactoryService និងការអនុវត្តរបស់វា។ EntityFactoryService គឺជាចំណុចចាប់ផ្តើមដ៏សំខាន់សម្រាប់ធ្វើការជាមួយមូលដ្ឋានទិន្នន័យ ចាប់តាំងពីអង្គភាពការងារ ឃ្លាំងសម្រាប់ធ្វើការជាមួយអង្គភាពជាក់លាក់ ក៏ដូចជាប្រតិបត្តិករនៃពាក្យបញ្ជា និងសំណួរ SQL ផ្ទាល់ត្រូវបានបង្កើតនៅទីនេះ។ ពេលខ្លះវាងាយស្រួលក្នុងការកំណត់សមត្ថភាពនៃថ្នាក់សម្រាប់ធ្វើការជាមួយមូលដ្ឋានទិន្នន័យ ឧទាហរណ៍ ដើម្បីផ្តល់លទ្ធភាពត្រឹមតែអានទិន្នន័យប៉ុណ្ណោះ។ សម្រាប់ករណីបែបនេះ IEntityFactoryService មានបុព្វបុរស - ចំណុចប្រទាក់ IEntityRepositoryFactoryដែលប្រកាសតែវិធីសាស្ត្រសម្រាប់បង្កើតឃ្លាំងប៉ុណ្ណោះ។

ដើម្បីចូលប្រើមូលដ្ឋានទិន្នន័យដោយផ្ទាល់ យន្តការអ្នកផ្តល់សេវាត្រូវបានប្រើប្រាស់។ DBMS នីមួយៗដែលយើងប្រើក្នុងក្រុមរបស់យើងមានការអនុវត្តផ្ទាល់របស់វា៖ ViennaNET.Orm.MSSQL, ViennaNET.Orm.Oracle, ViennaNET.Orm.SQLite, ViennaNET.Orm.PostgreSql.

ក្នុងពេលជាមួយគ្នានេះ អ្នកផ្តល់សេវាជាច្រើនអាចត្រូវបានចុះឈ្មោះនៅក្នុងកម្មវិធីមួយក្នុងពេលតែមួយ ដែលអនុញ្ញាតឱ្យឧទាហរណ៍ ក្នុងក្របខ័ណ្ឌនៃសេវាកម្មមួយ ដោយមិនគិតថ្លៃសម្រាប់ការកែប្រែហេដ្ឋារចនាសម្ព័ន្ធ ដើម្បីអនុវត្តការធ្វើចំណាកស្រុកជាជំហានៗពី DBMS មួយទៅមួយទៀត។ យន្តការសម្រាប់ជ្រើសរើសការតភ្ជាប់ដែលត្រូវការ ហើយដូច្នេះអ្នកផ្តល់សេវាសម្រាប់ថ្នាក់អង្គភាពជាក់លាក់មួយ (សម្រាប់ការគូសផែនទីទៅតារាងមូលដ្ឋានទិន្នន័យត្រូវបានសរសេរ) ត្រូវបានអនុវត្តតាមរយៈការចុះឈ្មោះអង្គភាពនៅក្នុងថ្នាក់ BoundedContext (មានវិធីសាស្ត្រសម្រាប់ការចុះឈ្មោះអង្គភាពដែន) ឬអ្នកស្នងតំណែងរបស់វា។ ApplicationContext (មានវិធីសាស្រ្តសម្រាប់ការចុះឈ្មោះអង្គភាពកម្មវិធី សំណើផ្ទាល់ និងពាក្យបញ្ជា) ដែលឧបករណ៍សម្គាល់ការតភ្ជាប់ពីការកំណត់រចនាសម្ព័ន្ធត្រូវបានទទួលយកជាអាគុយម៉ង់៖

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

ឧទាហរណ៍បរិបទកម្មវិធី៖

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

ប្រសិនបើលេខសម្គាល់ការតភ្ជាប់មិនត្រូវបានបញ្ជាក់ នោះការតភ្ជាប់ដែលមានឈ្មោះ "លំនាំដើម" នឹងត្រូវបានប្រើ។

ការគូសផែនទីដោយផ្ទាល់នៃអង្គភាពទៅនឹងតារាងមូលដ្ឋានទិន្នន័យត្រូវបានអនុវត្តដោយប្រើឧបករណ៍ NHibernate ស្តង់ដារ។ អ្នកអាចប្រើការពិពណ៌នាទាំងតាមរយៈឯកសារ xml និងតាមរយៈថ្នាក់។ សម្រាប់ការសរសេរងាយស្រួលនៃឃ្លាំងដើមនៅក្នុងការធ្វើតេស្តឯកតា មានបណ្ណាល័យមួយ។ ViennaNET.TestUtils.Orm.

ឧទាហរណ៍ពេញលេញនៃការប្រើប្រាស់ ViennaNET.Orm.* អាចរកបាន នៅទីនេះ.

ViennaNET.ផ្ញើសារ។*

សំណុំនៃបណ្ណាល័យសម្រាប់ធ្វើការជាមួយជួរ។

ដើម្បីធ្វើការជាមួយជួរ វិធីសាស្រ្តដូចគ្នាត្រូវបានជ្រើសរើសដូចគ្នានឹង DBMSs ផ្សេងៗដែរ ពោលគឺវិធីសាស្រ្តបង្រួបបង្រួមអតិបរមាដែលអាចធ្វើទៅបានក្នុងលក្ខខណ្ឌនៃការធ្វើការជាមួយបណ្ណាល័យ ដោយមិនគិតពីកម្មវិធីគ្រប់គ្រងជួរដែលបានប្រើ។ បណ្ណាល័យ ViennaNET.Messaging ទទួលខុសត្រូវយ៉ាងជាក់លាក់ចំពោះការបង្រួបបង្រួមនេះ និង ViennaNET.Messaging.MQSeriesQueue, ViennaNET.Messaging.RabbitMQQueue и ViennaNET.Messaging.KafkaQueue មានការអនុវត្តអាដាប់ទ័រសម្រាប់ IBM MQ, RabbitMQ និង Kafka រៀងគ្នា។

នៅពេលធ្វើការជាមួយជួរមានដំណើរការពីរ: ទទួលសារនិងផ្ញើវា។

ពិចារណាទទួល។ មានជម្រើស 2 នៅទីនេះ៖ សម្រាប់ការស្តាប់ជាបន្តបន្ទាប់ និងសម្រាប់ការទទួលសារតែមួយ។ ដើម្បីស្តាប់ជួរជាបន្តបន្ទាប់ អ្នកត្រូវតែពណ៌នាអំពីថ្នាក់ដំណើរការដែលបានទទួលមរតកពី IMessageProcessorដែលនឹងទទួលខុសត្រូវក្នុងដំណើរការសារចូល។ បន្ទាប់មកវាត្រូវតែត្រូវបាន "ភ្ជាប់" ទៅជួរជាក់លាក់មួយ វាត្រូវបានធ្វើតាមរយៈការចុះឈ្មោះចូល IQueueReactorFactory បង្ហាញ​អត្តសញ្ញាណ​ជួរ​ពី​ការ​កំណត់​រចនាសម្ព័ន្ធ៖

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

ឧទាហរណ៍នៃការចាប់ផ្តើមស្តាប់៖

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

បន្ទាប់មក នៅពេលដែលសេវាកម្មចាប់ផ្តើម ហើយវិធីសាស្ត្រត្រូវបានហៅឱ្យចាប់ផ្តើមស្តាប់ សារទាំងអស់ពីជួរដែលបានបញ្ជាក់នឹងទៅកាន់ processor ដែលត្រូវគ្នា។

ដើម្បីទទួលបានសារតែមួយនៅក្នុងចំណុចប្រទាក់រោងចក្រ IMessagingComponentFactory មានវិធីសាស្រ្តមួយ។ CreateMessageReceiverដែលនឹងបង្កើតអ្នកទទួលដែលរង់ចាំសារពីជួរដែលបានបញ្ជាក់ទៅវា៖

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

ដើម្បីផ្ញើសារ អ្នកត្រូវប្រើដូចគ្នា។ IMessagingComponentFactory និងបង្កើតអ្នកផ្ញើសារ៖

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

មានជម្រើសបីដែលត្រៀមរួចជាស្រេចសម្រាប់ការដាក់សៀរៀល និងបង្ខូចសារ៖ គ្រាន់តែអត្ថបទ XML និង JSON ប៉ុន្តែបើចាំបាច់ អ្នកអាចបង្កើតការប្រតិបត្តិចំណុចប្រទាក់ផ្ទាល់ខ្លួនរបស់អ្នកយ៉ាងងាយស្រួល IMessageSerializer и IMessageDeserializer.

យើងបានព្យាយាមរក្សាសមត្ថភាពពិសេសរបស់អ្នកគ្រប់គ្រងជួរនីមួយៗ ឧ. ViennaNET.Messaging.MQSeriesQueue អនុញ្ញាតឱ្យអ្នកផ្ញើមិនត្រឹមតែអត្ថបទប៉ុណ្ណោះទេប៉ុន្តែថែមទាំងសារបៃផងដែរ។ ViennaNET.Messaging.RabbitMQQueue គាំទ្រ​ការ​តម្រង់​ផ្លូវ និង​ការ​តម្រង់​ជួរ​តាម​យន្តហោះ។ ឧបករណ៍រុំអាដាប់ធ័ររបស់យើងសម្រាប់ RabbitMQ ក៏អនុវត្តនូវភាពស្រដៀងគ្នាមួយចំនួននៃ RPC ផងដែរ៖ យើងផ្ញើសារហើយរង់ចាំការឆ្លើយតបពីជួរបណ្តោះអាសន្នពិសេស ដែលត្រូវបានបង្កើតឡើងសម្រាប់សារឆ្លើយតបតែមួយប៉ុណ្ណោះ។

នៅទីនេះ ឧទាហរណ៍នៃការប្រើជួរជាមួយ nuances ការតភ្ជាប់ជាមូលដ្ឋាន.

ViennaNET.CallContext

យើងប្រើជួរមិនត្រឹមតែសម្រាប់ការធ្វើសមាហរណកម្មរវាងប្រព័ន្ធផ្សេងៗប៉ុណ្ណោះទេ ប៉ុន្តែថែមទាំងសម្រាប់ការទំនាក់ទំនងរវាងមីក្រូសេវាកម្មនៃកម្មវិធីដូចគ្នា ឧទាហរណ៍ក្នុងរឿងខ្មោច។ នេះបាននាំឱ្យមានតម្រូវការក្នុងការបញ្ជូនរួមជាមួយសារដូចជាទិន្នន័យជំនួយដូចជាការចូលរបស់អ្នកប្រើ សំណើរកំណត់អត្តសញ្ញាណសម្រាប់ការចូលពីចុងដល់ចុង អាសយដ្ឋាន IP ប្រភព និងទិន្នន័យការអនុញ្ញាត។ ដើម្បីអនុវត្តការបញ្ជូនបន្តទិន្នន័យនេះ យើងបានបង្កើតបណ្ណាល័យមួយ។ ViennaNET.CallContextដែលអនុញ្ញាតឱ្យអ្នករក្សាទុកទិន្នន័យពីសំណើដែលចូលក្នុងសេវាកម្ម។ ក្នុងករណីនេះ របៀបដែលសំណើត្រូវបានធ្វើឡើងតាមរយៈជួរ ឬតាមរយៈ Http មិនមានបញ្ហានោះទេ។ បន្ទាប់មក មុនពេលផ្ញើសំណើ ឬសារចេញ ទិន្នន័យត្រូវបានយកចេញពីបរិបទ ហើយដាក់ក្នុងបឋមកថា។ ដូច្នេះ សេវាកម្មបន្ទាប់ទទួលបានទិន្នន័យជំនួយ និងគ្រប់គ្រងវាតាមរបៀបដូចគ្នា។

សូមអរគុណចំពោះការយកចិត្តទុកដាក់របស់អ្នក យើងទន្ទឹងរង់ចាំមតិយោបល់របស់អ្នក និងទាញសំណើ!

ប្រភព: www.habr.com