ViennaNET: קבוצה של ספריות עבור הקצה האחורי. חלק 2

קהילת המפתחים של Raiffeisenbank .NET ממשיכה לסקור בקצרה את התוכן של ViennaNET. על איך ולמה הגענו לזה, אתה יכול לקרוא את החלק הראשון.

במאמר זה, נעבור על ספריות שטרם נחשבו לעבודה עם עסקאות מבוזרות, תורים ומסדי נתונים, אשר ניתן למצוא במאגר GitHub שלנו (מקורות נמצאים כאן), ו חבילות נוגט כאן.

ViennaNET.Sagas

כאשר פרויקט עובר לארכיטקטורת DDD ו-microservice, אז כאשר ההיגיון העסקי מופץ על פני שירותים שונים, מתעוררת בעיה הקשורה לצורך ביישום מנגנון עסקה מבוזר, מכיוון שלרוב תרחישים רבים משפיעים על מספר תחומים בו-זמנית. אתה יכול להכיר מנגנונים כאלה ביתר פירוט, למשל, בספר "Microservices Patterns", כריס ריצ'רדסון.

בפרויקטים שלנו, הטמענו מנגנון פשוט אך שימושי: סאגה, או יותר נכון סאגה מבוססת תזמור. המהות שלה היא כדלקמן: יש תרחיש עסקי מסוים שבו יש צורך לבצע פעולות ברצף בשירותים שונים, ואם מתעוררות בעיות כלשהן בכל שלב, יש צורך לקרוא להליך החזרה לאחור עבור כל השלבים הקודמים, שבו הוא נמצא מסופק. כך, בסוף הסאגה, ללא קשר להצלחה, אנו מקבלים נתונים עקביים בכל התחומים.

היישום שלנו עדיין נעשה בצורתו הבסיסית ואינו קשור לשימוש בכל שיטות של אינטראקציה עם שירותים אחרים. זה לא קשה לשימוש: פשוט צור צאצא של מחלקת האבסטרקט הבסיסית SagaBase<T>, כאשר T היא מחלקת ההקשר שלך שבה אתה יכול לאחסן את הנתונים הראשוניים הדרושים כדי שהסאגה תעבוד, כמו גם כמה תוצאות ביניים. מופע ההקשר יועבר לכל השלבים במהלך הביצוע. Saga עצמו הוא מחלקה חסרת מדינה, כך שניתן למקם את המופע ב-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-First באמצעות Liquibase, כך שיש רק פונקציונליות לעבודה עם נתונים במסד נתונים מוכן.

ViennaNET.Orm.Seedwork и ViennaNET.Orm – מכלולים עיקריים המכילים ממשקים בסיסיים והטמעות שלהם, בהתאמה. בואו נסתכל על התוכן שלהם ביתר פירוט.

ממשק IEntityFactoryService ויישומה EntityFactoryService הם נקודת המוצא העיקרית לעבודה עם מסד הנתונים, שכן כאן נוצרים יחידת העבודה, מאגרים לעבודה עם ישויות ספציפיות, כמו גם מבצעים של פקודות ושאילתות SQL ישירות. לפעמים נוח להגביל את היכולות של מחלקה לעבודה עם מסד נתונים, למשל, לספק את היכולת לקרוא רק נתונים. למקרים כאלה IEntityFactoryService יש ממשק קדמון IEntityRepositoryFactory, שמצהיר רק על שיטה ליצירת מאגרים.

כדי לגשת ישירות למסד הנתונים, נעשה שימוש במנגנון הספק. לכל DBMS שאנו משתמשים בצוותים שלנו יש יישום משלו: ViennaNET.Orm.MSSQL, ViennaNET.Orm.Oracle, ViennaNET.Orm.SQLite, ViennaNET.Orm.PostgreSql.

במקביל, ניתן לרשום מספר ספקים באפליקציה אחת במקביל, מה שמאפשר למשל במסגרת שירות אחד, ללא כל עלויות לשינוי התשתית, לבצע הגירה שלב אחר שלב מ- DBMS אחד למשנהו. המנגנון לבחירת החיבור הנדרש, ולפיכך, הספק למחלקת ישות ספציפית (שעבורה נכתב מיפוי לטבלאות מסד נתונים) מיושם באמצעות רישום הישות במחלקה BoundedContext (מכיל שיטה לרישום ישויות תחום) או היורש שלה 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.*

סט ספריות לעבודה עם תורים.

לעבודה עם תורים, נבחרה אותה גישה כמו עם DBMSs שונים, כלומר הגישה המאוחדת המקסימלית האפשרית מבחינת עבודה עם הספרייה, ללא קשר למנהל התורים בו נעשה שימוש. סִפְרִיָה ViennaNET.Messaging אחראי בדיוק לאיחוד הזה, ו ViennaNET.Messaging.MQSeriesQueue, ViennaNET.Messaging.RabbitMQQueue и ViennaNET.Messaging.KafkaQueue מכילים יישומי מתאם עבור IBM MQ, RabbitMQ וקפקא, בהתאמה.

בעבודה עם תורים יש שני תהליכים: קבלת הודעה ושליחה.

שקול לקבל. יש כאן 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