ವಿಯೆನ್ನಾನೆಟ್: ಬ್ಯಾಕೆಂಡ್‌ಗಾಗಿ ಲೈಬ್ರರಿಗಳ ಒಂದು ಸೆಟ್. ಭಾಗ 2

Raiffeisenbank .NET ಡೆವಲಪರ್ ಸಮುದಾಯವು ViennaNET ನ ವಿಷಯಗಳನ್ನು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಪರಿಶೀಲಿಸುವುದನ್ನು ಮುಂದುವರೆಸಿದೆ. ನಾವು ಇದಕ್ಕೆ ಹೇಗೆ ಮತ್ತು ಏಕೆ ಬಂದೆವು ಎಂಬುದರ ಕುರಿತು, ನೀವು ಮೊದಲ ಭಾಗವನ್ನು ಓದಬಹುದು.

ಈ ಲೇಖನದಲ್ಲಿ, ವಿತರಿಸಿದ ವಹಿವಾಟುಗಳು, ಸರತಿ ಸಾಲುಗಳು ಮತ್ತು ಡೇಟಾಬೇಸ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ನಾವು ಇನ್ನೂ ಪರಿಗಣಿಸಬೇಕಾದ ಗ್ರಂಥಾಲಯಗಳ ಮೂಲಕ ಹೋಗುತ್ತೇವೆ, ಅದನ್ನು ನಮ್ಮ 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);

ವಿಭಿನ್ನ ಅನುಷ್ಠಾನಗಳ ಸಂಪೂರ್ಣ ಉದಾಹರಣೆಗಳನ್ನು ವೀಕ್ಷಿಸಬಹುದು ಇಲ್ಲಿ ಮತ್ತು ಅಸೆಂಬ್ಲಿಯಲ್ಲಿ ಪರೀಕ್ಷೆಗಳು.

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.*

ಸಾಲುಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಗ್ರಂಥಾಲಯಗಳ ಒಂದು ಸೆಟ್.

ಕ್ಯೂಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು, ವಿವಿಧ 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