வியன்னாநெட்: பின்தளத்திற்கான நூலகங்களின் தொகுப்பு. பகுதி 2

Raiffeisenbank .NET டெவலப்பர் சமூகம் வியன்னாநெட்டின் உள்ளடக்கங்களை சுருக்கமாக மதிப்பாய்வு செய்து வருகிறது. எப்படி, ஏன் இதற்கு வந்தோம் என்பது பற்றி, முதல் பகுதியை நீங்கள் படிக்கலாம்.

இந்தக் கட்டுரையில், விநியோகிக்கப்பட்ட பரிவர்த்தனைகள், வரிசைகள் மற்றும் தரவுத்தளங்களுடன் பணிபுரிவதற்காக, இன்னும் கருத்தில் கொள்ளப்படாத நூலகங்களுக்குச் செல்வோம், அதை எங்கள் கிட்ஹப் களஞ்சியத்தில் காணலாம் (ஆதாரங்கள் இங்கே உள்ளன), மற்றும் நுகெட் தொகுப்புகள் இங்கே.

வியன்னாநெட்.சாகாஸ்

ஒரு திட்டம் டிடிடி மற்றும் மைக்ரோ சர்வீஸ் கட்டமைப்பிற்கு மாறும்போது, ​​பல்வேறு சேவைகளில் வணிக தர்க்கம் விநியோகிக்கப்படும்போது, ​​விநியோகிக்கப்பட்ட பரிவர்த்தனை பொறிமுறையை செயல்படுத்த வேண்டியதன் அவசியத்துடன் தொடர்புடைய சிக்கல் எழுகிறது, ஏனெனில் பல காட்சிகள் ஒரே நேரத்தில் பல டொமைன்களைப் பாதிக்கின்றன. அத்தகைய வழிமுறைகளை நீங்கள் இன்னும் விரிவாக அறிந்து கொள்ளலாம், எடுத்துக்காட்டாக, "மைக்ரோ சர்வீசஸ் பேட்டர்ன்ஸ்" புத்தகத்தில், கிறிஸ் ரிச்சர்ட்சன்.

எங்கள் திட்டங்களில், எளிமையான ஆனால் பயனுள்ள பொறிமுறையை நாங்கள் செயல்படுத்தியுள்ளோம்: ஒரு சாகா அல்லது ஆர்கெஸ்ட்ரேஷன் அடிப்படையிலான சாகா. அதன் சாராம்சம் பின்வருமாறு: வெவ்வேறு சேவைகளில் தொடர்ச்சியாக செயல்பாடுகளைச் செய்ய வேண்டிய ஒரு குறிப்பிட்ட வணிக சூழ்நிலை உள்ளது, மேலும் ஏதேனும் சிக்கல்கள் ஏதேனும் ஏற்பட்டால், முந்தைய எல்லா படிகளுக்கும் திரும்பப்பெறும் செயல்முறையை அழைக்க வேண்டியது அவசியம். வழங்கப்படும். எனவே, சரித்திரத்தின் முடிவில், வெற்றியைப் பொருட்படுத்தாமல், எல்லா களங்களிலும் நிலையான தரவைப் பெறுகிறோம்.

எங்கள் செயல்படுத்தல் இன்னும் அதன் அடிப்படை வடிவத்தில் செய்யப்படுகிறது மற்றும் பிற சேவைகளுடன் தொடர்பு கொள்ளும் எந்த முறைகளையும் பயன்படுத்தவில்லை. இதைப் பயன்படுத்துவது கடினம் அல்ல: அடிப்படை சுருக்க வகுப்பான 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);

பல்வேறு செயலாக்கங்களின் முழு எடுத்துக்காட்டுகளையும் பார்க்கலாம் இங்கே மற்றும் சட்டசபையில் சோதனைகள்.

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 கோப்புகள் மூலமாகவும் வகுப்புகள் மூலமாகவும் விளக்கத்தைப் பயன்படுத்தலாம். அலகு சோதனைகளில் ஸ்டப் களஞ்சியங்களை எளிதாக எழுத, ஒரு நூலகம் உள்ளது ViennaNET.TestUtils.Orm.

ViennaNET.Orm.* ஐப் பயன்படுத்துவதற்கான முழு எடுத்துக்காட்டுகளைக் காணலாம் இங்கே.

ViennaNET.Messaging.*

வரிசைகளுடன் வேலை செய்வதற்கான நூலகங்களின் தொகுப்பு.

வரிசைகளுடன் பணிபுரிய, பல்வேறு டிபிஎம்எஸ்களைப் போலவே அதே அணுகுமுறை தேர்ந்தெடுக்கப்பட்டது, அதாவது, வரிசை மேலாளரைப் பொருட்படுத்தாமல், நூலகத்துடன் பணிபுரியும் வகையில் அதிகபட்ச சாத்தியமான ஒருங்கிணைந்த அணுகுமுறை. நூலகம் 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

வெவ்வேறு அமைப்புகளுக்கு இடையே ஒருங்கிணைக்க மட்டும் வரிசைகளைப் பயன்படுத்துகிறோம், ஆனால் அதே பயன்பாட்டின் மைக்ரோ சர்வீஸ்களுக்கு இடையேயான தகவல்தொடர்புக்கு, எடுத்துக்காட்டாக, ஒரு சகாவுக்குள். பயனர் உள்நுழைவு, எண்ட்-டு-எண்ட் லாக்கிங்கிற்கான கோரிக்கை அடையாளங்காட்டி, மூல ஐபி முகவரி மற்றும் அங்கீகாரத் தரவு போன்ற துணை தரவுகளை செய்தியுடன் அனுப்ப வேண்டிய அவசியத்திற்கு இது வழிவகுத்தது. இந்தத் தரவை முன்னனுப்புவதைச் செயல்படுத்த, நாங்கள் ஒரு நூலகத்தை உருவாக்கினோம் ViennaNET.CallContext, இது சேவையில் நுழையும் கோரிக்கையிலிருந்து தரவைச் சேமிக்க உங்களை அனுமதிக்கிறது. இந்த வழக்கில், வரிசை அல்லது Http வழியாக கோரிக்கை எவ்வாறு செய்யப்பட்டது என்பது முக்கியமல்ல. பின்னர், வெளிச்செல்லும் கோரிக்கை அல்லது செய்தியை அனுப்புவதற்கு முன், தரவு சூழலில் இருந்து எடுக்கப்பட்டு தலைப்புகளில் வைக்கப்படும். இவ்வாறு, அடுத்த சேவையானது துணைத் தரவைப் பெறுகிறது மற்றும் அதை அதே வழியில் நிர்வகிக்கிறது.

உங்கள் கவனத்திற்கு நன்றி, உங்கள் கருத்துகளையும் இழுக்கும் கோரிக்கைகளையும் எதிர்பார்க்கிறோம்!

ஆதாரம்: www.habr.com