વિયેનાનેટ: બેકએન્ડ માટે પુસ્તકાલયોનો સમૂહ. ભાગ 2

Raiffeisenbank .NET ડેવલપર સમુદાય વિયેનાનેટની સામગ્રીની સંક્ષિપ્તમાં સમીક્ષા કરવાનું ચાલુ રાખે છે. અમે આ કેવી રીતે અને શા માટે આવ્યા તે વિશે, તમે પ્રથમ ભાગ વાંચી શકો છો.

આ લેખમાં, અમે વિતરિત વ્યવહારો, કતાર અને ડેટાબેસેસ સાથે કામ કરવા માટે હજુ સુધી ધ્યાનમાં લેવાતી લાઇબ્રેરીઓમાંથી પસાર થઈશું, જે અમારા GitHub રિપોઝીટરીમાં મળી શકે છે (સ્ત્રોતો અહીં છે), અને Nuget પેકેજો અહીં.

વિયેનાનેટ.સાગાસ

જ્યારે કોઈ પ્રોજેક્ટ DDD અને માઇક્રોસર્વિસ આર્કિટેક્ચર પર સ્વિચ કરે છે, ત્યારે જ્યારે બિઝનેસ લોજિકને વિવિધ સેવાઓમાં વિતરિત કરવામાં આવે છે, ત્યારે વિતરિત ટ્રાન્ઝેક્શન મિકેનિઝમને અમલમાં મૂકવાની જરૂરિયાત સાથે સંબંધિત સમસ્યા ઊભી થાય છે, કારણ કે ઘણી પરિસ્થિતિઓ ઘણી વખત એક સાથે અનેક ડોમેન્સને અસર કરે છે. તમે વધુ વિગતવાર આવા મિકેનિઝમ્સથી પરિચિત થઈ શકો છો, ઉદાહરણ તરીકે, "માઈક્રો સર્વિસીસ પેટર્ન" પુસ્તકમાં, ક્રિસ રિચાર્ડસન.

અમારા પ્રોજેક્ટ્સમાં, અમે એક સરળ પણ ઉપયોગી મિકેનિઝમ અમલમાં મૂક્યું છે: એક ગાથા, અથવા તેના બદલે ઓર્કેસ્ટ્રેશન-આધારિત ગાથા. તેનો સાર નીચે મુજબ છે: ત્યાં એક ચોક્કસ વ્યવસાય દૃશ્ય છે જેમાં વિવિધ સેવાઓમાં ક્રમિક રીતે કામગીરી કરવી જરૂરી છે, અને જો કોઈપણ પગલા પર કોઈ સમસ્યા ઊભી થાય, તો અગાઉના તમામ પગલાઓ માટે રોલબેક પ્રક્રિયાને કૉલ કરવો જરૂરી છે, જ્યાં તે છે. પૂરી પાડવામાં આવેલ છે. આમ, ગાથાના અંતે, સફળતાને અનુલક્ષીને, અમે તમામ ડોમેન્સમાં સુસંગત ડેટા પ્રાપ્ત કરીએ છીએ.

અમારું અમલીકરણ હજી પણ તેના મૂળભૂત સ્વરૂપમાં કરવામાં આવ્યું છે અને અન્ય સેવાઓ સાથે ક્રિયાપ્રતિક્રિયાની કોઈપણ પદ્ધતિઓના ઉપયોગ સાથે જોડાયેલું નથી. તેનો ઉપયોગ કરવો મુશ્કેલ નથી: ફક્ત બેઝ એબ્સ્ટ્રેક્ટ ક્લાસ 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 દ્વારા વિવિધ ડેટાબેઝ સાથે કામ કરવા માટે પુસ્તકાલયોનો સમૂહ. અમે લિક્વિબેઝનો ઉપયોગ કરીને DB-પ્રથમ અભિગમનો ઉપયોગ કરીએ છીએ, તેથી તૈયાર ડેટાબેઝમાં ડેટા સાથે કામ કરવા માટે માત્ર કાર્યક્ષમતા છે.

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

જો કનેક્શન ID સ્પષ્ટ કરેલ નથી, તો પછી "ડિફોલ્ટ" નામના જોડાણનો ઉપયોગ કરવામાં આવશે.

ડેટાબેઝ કોષ્ટકો પર એન્ટિટીનું ડાયરેક્ટ મેપિંગ પ્રમાણભૂત NHibernate ટૂલ્સનો ઉપયોગ કરીને લાગુ કરવામાં આવે છે. તમે xml ફાઇલો અને વર્ગો દ્વારા વર્ણનનો ઉપયોગ કરી શકો છો. એકમ કસોટીઓમાં સ્ટબ રીપોઝીટરીઝના અનુકૂળ લેખન માટે, એક પુસ્તકાલય છે ViennaNET.TestUtils.Orm.

ViennaNET.Orm.* નો ઉપયોગ કરવાના સંપૂર્ણ ઉદાહરણો મળી શકે છે અહીં.

ViennaNET.Messaging.*

કતાર સાથે કામ કરવા માટે પુસ્તકાલયોનો સમૂહ.

કતાર સાથે કામ કરવા માટે, વિવિધ 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();

પછી, જ્યારે સેવા શરૂ થાય છે અને સાંભળવાનું શરૂ કરવા માટે પદ્ધતિને બોલાવવામાં આવે છે, ત્યારે ઉલ્લેખિત કતારમાંથી તમામ સંદેશાઓ અનુરૂપ પ્રોસેસર પર જશે.

ફેક્ટરી ઇન્ટરફેસમાં એક સંદેશ પ્રાપ્ત કરવા માટે 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