ViennaNET: පසුපෙළ සඳහා පුස්තකාල කට්ටලයක්. 2 කොටස

Raiffeisenbank .NET සංවර්ධක ප්‍රජාව ViennaNET හි අන්තර්ගතය කෙටියෙන් සමාලෝචනය කරයි. අපි මෙයට පැමිණියේ කෙසේද සහ ඇයි යන්න ගැන, ඔබට පළමු කොටස කියවිය හැකිය.

මෙම ලිපියෙන්, අපගේ GitHub ගබඩාවේ (GitHub ගබඩාවේ) සොයා ගත හැකි බෙදා හරින ලද ගනුදෙනු, පෝලිම් සහ දත්ත සමුදායන් සමඟ වැඩ කිරීම සඳහා අපි තවමත් සලකා බලා නැති පුස්තකාල හරහා යන්නෙමු.මූලාශ්‍ර මෙහි ඇත), සහ Nuget පැකේජ මෙතනින්.

ViennaNET.Sagas

ව්‍යාපෘතියක් DDD සහ microservice architecture වෙත මාරු වූ විට, ව්‍යාපාරික තර්කනය විවිධ සේවාවන් හරහා බෙදා හරින විට, බෙදා හරින ලද ගනුදෙනු යාන්ත්‍රණයක් ක්‍රියාත්මක කිරීමේ අවශ්‍යතාවය සම්බන්ධ ගැටළුවක් පැන නගී, මන්ද බොහෝ අවස්ථා බොහෝ විට වසම් කිහිපයකට එකවර බලපාන බැවිනි. ඔබට එවැනි යාන්ත්‍රණයන් වඩාත් විස්තරාත්මකව දැන හඳුනා ගත හැකිය, උදාහරණයක් ලෙස, "Microservices Patterns" පොතේ, Chris Richardson.

අපගේ ව්‍යාපෘති වලදී, අපි සරල නමුත් ප්‍රයෝජනවත් යාන්ත්‍රණයක් ක්‍රියාවට නංවා ඇත: සාගා හෝ ඒ වෙනුවට වාද්‍ය වෘන්දය පදනම් කරගත් සාගා. එහි සාරය පහත පරිදි වේ: විවිධ සේවාවන්හි මෙහෙයුම් අනුක්‍රමිකව සිදු කිරීමට අවශ්‍ය නිශ්චිත ව්‍යාපාරික දර්ශනයක් ඇති අතර, කිසියම් පියවරකදී කිසියම් ගැටළුවක් ඇති වුවහොත්, පෙර පැවති සියලුම පියවර සඳහා ආපසු හැරීමේ ක්‍රියා පටිපාටිය ඇමතීමට අවශ්‍ය වේ. සපයා ඇත. මේ අනුව, සාගා අවසානයේ, සාර්ථකත්වය නොතකා, අපට සියලු වසම්වල ස්ථාවර දත්ත ලැබේ.

අපගේ ක්‍රියාත්මක කිරීම තවමත් එහි මූලික ස්වරූපයෙන් සිදු කර ඇති අතර වෙනත් සේවාවන් සමඟ අන්තර්ක්‍රියා කිරීමේ කිසිදු ක්‍රමයක් භාවිතා කිරීම හා බැඳී නොමැත. එය භාවිතා කිරීම අපහසු නැත: 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 හරහා විවිධ දත්ත සමුදායන් සමඟ වැඩ කිරීම සඳහා පුස්තකාල කට්ටලයක්. අපි Liquibase භාවිතයෙන් DB-First ප්‍රවේශය භාවිතා කරමු, එබැවින් සූදානම් කළ දත්ත ගබඩාවක දත්ත සමඟ වැඩ කිරීම සඳහා පමණක් ක්‍රියාකාරීත්වය ඇත.

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 ගොනු හරහා සහ පන්ති හරහා විස්තරය භාවිතා කළ හැකිය. ඒකක පරීක්ෂණවල stub repositories පහසු ලිවීම සඳහා පුස්තකාලයක් ඇත ViennaNET.TestUtils.Orm.

ViennaNET.Orm.* භාවිතා කිරීම පිළිබඳ සම්පූර්ණ උදාහරණ සොයා ගත හැක මෙහි.

ViennaNET.Messaging.*

පෝලිම් සමඟ වැඩ කිරීම සඳහා පුස්තකාල කට්ටලයක්.

පෝලිම් සමඟ වැඩ කිරීම සඳහා, විවිධ DBMS සමඟ එකම ප්‍රවේශය තෝරා ගන්නා ලදී, එනම්, භාවිතා කරන ලද පෝලිම් කළමනාකරු නොසලකා පුස්තකාලය සමඟ වැඩ කිරීමේදී හැකි උපරිම ඒකාබද්ධ ප්‍රවේශය. පුස්තකාලය 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 හි යම් සමානකමක් ද ක්‍රියාත්මක කරයි: අපි පණිවිඩයක් යවා විශේෂ තාවකාලික පෝලිමකින් ප්‍රතිචාරයක් එනතෙක් බලා සිටිමු, එය එක් ප්‍රතිචාර පණිවිඩයක් සඳහා පමණක් නිර්මාණය කර ඇත.

මෙහි මූලික සම්බන්ධතා සූක්ෂ්මතා සහිත පෝලිම් භාවිතා කිරීමේ උදාහරණයක්.

ViennaNET.CallContext

අපි විවිධ පද්ධති අතර ඒකාබද්ධ කිරීම සඳහා පමණක් නොව, එකම යෙදුමේ ක්ෂුද්‍ර සේවා අතර සන්නිවේදනය සඳහා පෝලිම් භාවිතා කරමු, උදාහරණයක් ලෙස, සාගා තුළ. පරිශීලක පිවිසුම, අන්තයේ සිට ලොග් වීම සඳහා ඉල්ලීම් හැඳුනුම්කාරකය, මූලාශ්‍ර IP ලිපිනය සහ අවසර දත්ත වැනි සහායක දත්ත පණිවිඩය සමඟ සම්ප්‍රේෂණය කිරීමේ අවශ්‍යතාවයට මෙය හේතු විය. මෙම දත්ත ඉදිරියට යැවීම ක්‍රියාවට නැංවීම සඳහා, අපි පුස්තකාලයක් සංවර්ධනය කළෙමු ViennaNET.CallContext, සේවාවට ඇතුළු වන ඉල්ලීමකින් දත්ත ගබඩා කිරීමට ඔබට ඉඩ සලසයි. මෙම අවස්ථාවෙහිදී, පෝලිමක් හරහා හෝ Http හරහා ඉල්ලීම සිදු කළේ කෙසේද යන්න ගැටළුවක් නොවේ. ඉන්පසුව, පිටතට යන ඉල්ලීම හෝ පණිවිඩය යැවීමට පෙර, දත්ත සන්දර්භයෙන් ලබාගෙන ශීර්ෂයන් තුළ තබා ඇත. මේ අනුව, ඊළඟ සේවාව සහායක දත්ත ලබා ගන්නා අතර එය එකම ආකාරයකින් කළමනාකරණය කරයි.

ඔබගේ අවධානයට ස්තූතියි, අපි ඔබගේ අදහස් සහ අදින්න ඉල්ලීම් බලාපොරොත්තු වන්නෙමු!

මූලාශ්රය: www.habr.com