വിയന്നനെറ്റ്: ബാക്കെൻഡിനായുള്ള ഒരു കൂട്ടം ലൈബ്രറികൾ. ഭാഗം 2

Raiffeisenbank .NET ഡെവലപ്പർ കമ്മ്യൂണിറ്റി വിയന്നനെറ്റിന്റെ ഉള്ളടക്കങ്ങൾ ഹ്രസ്വമായി അവലോകനം ചെയ്യുന്നത് തുടരുന്നു. എങ്ങനെ, എന്തുകൊണ്ട് ഞങ്ങൾ ഇതിലേക്ക് വന്നു എന്നതിനെക്കുറിച്ച്, നിങ്ങൾക്ക് ആദ്യ ഭാഗം വായിക്കാം.

ഈ ലേഖനത്തിൽ, വിതരണം ചെയ്ത ഇടപാടുകൾ, ക്യൂകൾ, ഡാറ്റാബേസുകൾ എന്നിവയുമായി പ്രവർത്തിക്കുന്നതിന് ഇതുവരെ പരിഗണിക്കപ്പെടാത്ത ലൈബ്രറികളിലൂടെ ഞങ്ങൾ പോകും, ​​അത് ഞങ്ങളുടെ GitHub ശേഖരത്തിൽ (ഉറവിടങ്ങൾ ഇവിടെയുണ്ട്), ഒപ്പം ന്യൂജെറ്റ് പാക്കേജുകൾ ഇവിടെയുണ്ട്.

വിയന്നനെറ്റ്.സാഗസ്

ഒരു പ്രോജക്റ്റ് ഡിഡിഡിയിലേക്കും മൈക്രോസർവീസ് ആർക്കിടെക്ചറിലേക്കും മാറുമ്പോൾ, ബിസിനസ്സ് ലോജിക് വിവിധ സേവനങ്ങളിൽ വിതരണം ചെയ്യുമ്പോൾ, വിതരണം ചെയ്ത ഇടപാട് സംവിധാനം നടപ്പിലാക്കേണ്ടതിന്റെ ആവശ്യകതയുമായി ബന്ധപ്പെട്ട ഒരു പ്രശ്നം ഉണ്ടാകുന്നു, കാരണം പല സാഹചര്യങ്ങളും ഒരേസമയം നിരവധി ഡൊമെയ്‌നുകളെ ബാധിക്കും. അത്തരം സംവിധാനങ്ങളെക്കുറിച്ച് കൂടുതൽ വിശദമായി നിങ്ങൾക്ക് പരിചയപ്പെടാം, ഉദാഹരണത്തിന്, "മൈക്രോസർവീസസ് പാറ്റേൺസ്" എന്ന പുസ്തകത്തിൽ, ക്രിസ് റിച്ചാർഡ്സൺ.

ഞങ്ങളുടെ പ്രോജക്റ്റുകളിൽ, ഞങ്ങൾ ലളിതവും എന്നാൽ ഉപയോഗപ്രദവുമായ ഒരു സംവിധാനം നടപ്പിലാക്കിയിട്ടുണ്ട്: ഒരു സാഗ, അല്ലെങ്കിൽ ഒരു ഓർക്കസ്ട്രേഷൻ അടിസ്ഥാനമാക്കിയുള്ള സാഗ. അതിന്റെ സാരാംശം ഇപ്രകാരമാണ്: വ്യത്യസ്ത സേവനങ്ങളിൽ തുടർച്ചയായി പ്രവർത്തനങ്ങൾ നടത്തേണ്ട ഒരു പ്രത്യേക ബിസിനസ്സ് സാഹചര്യമുണ്ട്, ഏതെങ്കിലും ഘട്ടത്തിൽ എന്തെങ്കിലും പ്രശ്നങ്ങൾ ഉണ്ടായാൽ, മുമ്പത്തെ എല്ലാ ഘട്ടങ്ങളിലും റോൾബാക്ക് നടപടിക്രമം വിളിക്കേണ്ടത് ആവശ്യമാണ്. നൽകിയത്. അങ്ങനെ, സാഗയുടെ അവസാനം, വിജയം പരിഗണിക്കാതെ, എല്ലാ ഡൊമെയ്‌നുകളിലും ഞങ്ങൾക്ക് സ്ഥിരമായ ഡാറ്റ ലഭിക്കും.

ഞങ്ങളുടെ നടപ്പാക്കൽ ഇപ്പോഴും അതിന്റെ അടിസ്ഥാന രൂപത്തിലാണ് നിർമ്മിച്ചിരിക്കുന്നത്, മറ്റ് സേവനങ്ങളുമായുള്ള ആശയവിനിമയ രീതികളുടെ ഉപയോഗവുമായി ബന്ധപ്പെടുത്തിയിട്ടില്ല. ഇത് ഉപയോഗിക്കുന്നത് ബുദ്ധിമുട്ടുള്ള കാര്യമല്ല: അടിസ്ഥാന അബ്സ്ട്രാക്റ്റ് ക്ലാസായ SagaBase<T> ന്റെ ഒരു പിൻഗാമിയാക്കുക, ഇവിടെ T എന്നത് നിങ്ങളുടെ സന്ദർഭ ക്ലാസ്സാണ്, അതിൽ നിങ്ങൾക്ക് സാഗ പ്രവർത്തിക്കാൻ ആവശ്യമായ പ്രാരംഭ ഡാറ്റയും ചില ഇന്റർമീഡിയറ്റ് ഫലങ്ങളും സംഭരിക്കാൻ കഴിയും. നിർവ്വഹണ സമയത്ത് എല്ലാ ഘട്ടങ്ങളിലേക്കും സന്ദർഭ ഉദാഹരണം കൈമാറും. സാഗ തന്നെ ഒരു സ്‌റ്റേറ്റ്‌ലെസ് ക്ലാസാണ്, അതിനാൽ ആവശ്യമായ ഡിപൻഡൻസികൾ ലഭിക്കുന്നതിന് ഉദാഹരണം DI-യിൽ ഒരു സിംഗിൾടണായി സ്ഥാപിക്കാവുന്നതാണ്.

ഉദാഹരണ പരസ്യം:

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);

വിവിധ നിർവ്വഹണങ്ങളുടെ പൂർണ്ണ ഉദാഹരണങ്ങൾ കാണാൻ കഴിയും ഇവിടെ കൂടെ അസംബ്ലിയിലും പരിശോധനകൾ.

ViannaNET.Orm.*

Nhibernate വഴി വിവിധ ഡാറ്റാബേസുകളിൽ പ്രവർത്തിക്കുന്നതിനുള്ള ഒരു കൂട്ടം ലൈബ്രറികൾ. ഞങ്ങൾ ലിക്വിബേസ് ഉപയോഗിച്ച് ഡിബി-ഫസ്റ്റ് സമീപനം ഉപയോഗിക്കുന്നു, അതിനാൽ ഒരു റെഡിമെയ്ഡ് ഡാറ്റാബേസിൽ ഡാറ്റയ്‌ക്കൊപ്പം പ്രവർത്തിക്കാനുള്ള പ്രവർത്തനക്ഷമത മാത്രമേയുള്ളൂ.

ViennaNET.Orm.Seedwork и ViennaNET.Orm - യഥാക്രമം അടിസ്ഥാന ഇന്റർഫേസുകളും അവയുടെ നിർവ്വഹണങ്ങളും അടങ്ങുന്ന പ്രധാന അസംബ്ലികൾ. അവയുടെ ഉള്ളടക്കം കൂടുതൽ വിശദമായി നോക്കാം.

ഇന്റർഫേസ് IEntityFactoryService അതിന്റെ നടപ്പാക്കലും EntityFactoryService ഡാറ്റാബേസുമായി പ്രവർത്തിക്കുന്നതിനുള്ള പ്രധാന ആരംഭ പോയിന്റാണ്, കാരണം യൂണിറ്റ് ഓഫ് വർക്ക്, നിർദ്ദിഷ്ട എന്റിറ്റികളുമായി പ്രവർത്തിക്കുന്നതിനുള്ള ശേഖരണങ്ങൾ, അതുപോലെ തന്നെ കമാൻഡുകളുടെ എക്സിക്യൂട്ടീവുകളും നേരിട്ടുള്ള SQL അന്വേഷണങ്ങളും ഇവിടെ സൃഷ്ടിക്കപ്പെടുന്നു. ഒരു ഡാറ്റാബേസുമായി പ്രവർത്തിക്കുന്നതിന് ഒരു ക്ലാസിന്റെ കഴിവുകൾ പരിമിതപ്പെടുത്തുന്നത് ചിലപ്പോൾ സൗകര്യപ്രദമാണ്, ഉദാഹരണത്തിന്, ഡാറ്റ വായിക്കാനുള്ള കഴിവ് നൽകുന്നതിന്. അത്തരം സന്ദർഭങ്ങളിൽ IEntityFactoryService ഒരു പൂർവ്വികൻ - ഇന്റർഫേസ് ഉണ്ട് IEntityRepositoryFactory, ഇത് റിപ്പോസിറ്ററികൾ സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു രീതി മാത്രം പ്രഖ്യാപിക്കുന്നു.

ഡാറ്റാബേസ് നേരിട്ട് ആക്സസ് ചെയ്യുന്നതിന്, പ്രൊവൈഡർ മെക്കാനിസം ഉപയോഗിക്കുന്നു. ഞങ്ങളുടെ ടീമുകളിൽ ഞങ്ങൾ ഉപയോഗിക്കുന്ന ഓരോ DBMS-നും അതിന്റേതായ നടപ്പിലാക്കൽ ഉണ്ട്: ViennaNET.Orm.MSSQL, ViennaNET.Orm.Oracle, ViennaNET.Orm.SQLite, ViennaNET.Orm.PostgreSql.

അതേ സമയം, ഒരേ സമയം നിരവധി ദാതാക്കളെ ഒരു ആപ്ലിക്കേഷനിൽ രജിസ്റ്റർ ചെയ്യാൻ കഴിയും, ഉദാഹരണത്തിന്, ഒരു സേവനത്തിന്റെ ചട്ടക്കൂടിനുള്ളിൽ, ഇൻഫ്രാസ്ട്രക്ചർ പരിഷ്ക്കരിക്കുന്നതിന് യാതൊരു ചെലവും കൂടാതെ, ഒരു ഘട്ടം ഘട്ടമായുള്ള മൈഗ്രേഷൻ നടത്താൻ ഇത് അനുവദിക്കുന്നു. ഒരു DBMS മറ്റൊന്നിലേക്ക്. ആവശ്യമായ കണക്ഷൻ തിരഞ്ഞെടുക്കുന്നതിനുള്ള സംവിധാനം, അതിനാൽ, ഒരു നിർദ്ദിഷ്ട എന്റിറ്റി ക്ലാസിനായുള്ള ദാതാവ് (ഡാറ്റാബേസ് ടേബിളുകളിലേക്കുള്ള മാപ്പിംഗ് എഴുതിയത്) എന്റിറ്റിയെ ബൗണ്ടഡ് കോൺടെക്‌സ് ക്ലാസിൽ (ഡൊമെയ്ൻ എന്റിറ്റികൾ രജിസ്റ്റർ ചെയ്യുന്നതിനുള്ള ഒരു രീതി അടങ്ങിയിരിക്കുന്നു) അല്ലെങ്കിൽ അതിന്റെ പിൻഗാമിയിൽ രജിസ്റ്റർ ചെയ്യുന്നതിലൂടെ നടപ്പിലാക്കുന്നു. 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.* ഉപയോഗിക്കുന്നതിന്റെ പൂർണ്ണ ഉദാഹരണങ്ങൾ കണ്ടെത്താനാകും ഇവിടെ.

ViannaNET.മെസേജിംഗ്.*

ക്യൂവിൽ പ്രവർത്തിക്കാനുള്ള ഒരു കൂട്ടം ലൈബ്രറികൾ.

ക്യൂകളിൽ പ്രവർത്തിക്കാൻ, വിവിധ ഡിബിഎംഎസുകൾക്കുള്ള അതേ സമീപനം തിരഞ്ഞെടുത്തു, അതായത്, ക്യൂ മാനേജർ ഉപയോഗിച്ചത് പരിഗണിക്കാതെ, ലൈബ്രറിയുമായി പ്രവർത്തിക്കുമ്പോൾ സാധ്യമായ പരമാവധി ഏകീകൃത സമീപനം. പുസ്തകശാല 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();

തുടർന്ന്, സേവനം ആരംഭിക്കുകയും കേൾക്കാൻ ആരംഭിക്കുന്നതിനുള്ള രീതി വിളിക്കുകയും ചെയ്യുമ്പോൾ, നിർദ്ദിഷ്ട ക്യൂവിൽ നിന്നുള്ള എല്ലാ സന്ദേശങ്ങളും അനുബന്ധ പ്രോസസ്സറിലേക്ക് പോകും.

ഒരു ഫാക്ടറി ഇന്റർഫേസിൽ ഒരൊറ്റ സന്ദേശം ലഭിക്കുന്നതിന് 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-യുടെ ചില സമാനതകൾ നടപ്പിലാക്കുന്നു: ഞങ്ങൾ ഒരു സന്ദേശം അയയ്‌ക്കുകയും ഒരു പ്രത്യേക താൽക്കാലിക ക്യൂവിൽ നിന്നുള്ള പ്രതികരണത്തിനായി കാത്തിരിക്കുകയും ചെയ്യുന്നു, അത് ഒരു പ്രതികരണ സന്ദേശത്തിനായി മാത്രം സൃഷ്‌ടിക്കപ്പെട്ടതാണ്.

ഇവിടെ അടിസ്ഥാന കണക്ഷൻ സൂക്ഷ്മതകളുള്ള ക്യൂകൾ ഉപയോഗിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം.

ViannaNET.CallContext

വ്യത്യസ്ത സിസ്റ്റങ്ങൾ തമ്മിലുള്ള സംയോജനത്തിന് മാത്രമല്ല, ഒരേ ആപ്ലിക്കേഷന്റെ മൈക്രോസർവീസുകൾ തമ്മിലുള്ള ആശയവിനിമയത്തിനും ഞങ്ങൾ ക്യൂകൾ ഉപയോഗിക്കുന്നു, ഉദാഹരണത്തിന്, ഒരു സാഗയ്ക്കുള്ളിൽ. ഉപയോക്തൃ ലോഗിൻ, എൻഡ്-ടു-എൻഡ് ലോഗിംഗിനുള്ള അഭ്യർത്ഥന ഐഡന്റിഫയർ, ഉറവിട ഐപി വിലാസം, അംഗീകാര ഡാറ്റ എന്നിവ പോലുള്ള സഹായ ഡാറ്റ സന്ദേശത്തോടൊപ്പം കൈമാറേണ്ടതിന്റെ ആവശ്യകതയിലേക്ക് ഇത് നയിച്ചു. ഈ ഡാറ്റ കൈമാറൽ നടപ്പിലാക്കുന്നതിനായി, ഞങ്ങൾ ഒരു ലൈബ്രറി വികസിപ്പിച്ചെടുത്തു ViennaNET.CallContext, സേവനത്തിൽ പ്രവേശിക്കുന്ന ഒരു അഭ്യർത്ഥനയിൽ നിന്ന് ഡാറ്റ സംഭരിക്കുന്നതിന് ഇത് നിങ്ങളെ അനുവദിക്കുന്നു. ഈ സാഹചര്യത്തിൽ, ഒരു ക്യൂ വഴിയോ Http വഴിയോ എങ്ങനെയാണ് അഭ്യർത്ഥന നടത്തിയത് എന്നത് പ്രശ്നമല്ല. തുടർന്ന്, ഔട്ട്‌ഗോയിംഗ് അഭ്യർത്ഥനയോ സന്ദേശമോ അയയ്‌ക്കുന്നതിന് മുമ്പ്, സന്ദർഭത്തിൽ നിന്ന് ഡാറ്റ എടുത്ത് തലക്കെട്ടുകളിൽ സ്ഥാപിക്കുന്നു. അങ്ങനെ, അടുത്ത സേവനം സഹായ ഡാറ്റ സ്വീകരിക്കുകയും അതേ രീതിയിൽ കൈകാര്യം ചെയ്യുകയും ചെയ്യുന്നു.

നിങ്ങളുടെ ശ്രദ്ധയ്ക്ക് നന്ദി, നിങ്ങളുടെ അഭിപ്രായങ്ങൾക്കും അഭ്യർത്ഥനകൾക്കും ഞങ്ങൾ പ്രതീക്ഷിക്കുന്നു!

അവലംബം: www.habr.com