תבנית Abstract Factory
במאמר הקודם עסקנו ב־Factory Method. ראינו איך מחלקת בסיס יכולה לנהל תהליך, ולהשאיר למחלקות שיורשות ממנה את ההחלטה איזה אובייקט ליצור כחלק ממנו.
הפעם נעסוק בתבנית עם שם דומה, אבל עם מטרה קצת אחרת: Abstract Factory.
כאן אנחנו רוצים לבחור משפחה של אובייקטים קשורים. למשל, רכיבים שעובדים עם אותו ספק ענן, או רכיבי ממשק ששייכים לאותה מערכת עיצוב. הקוד שמשתמש בהם צריך להכיר את הפעולות שהם מציעים, בלי לבחור בעצמו את המימוש של כל רכיב.
המילה החשובה כאן היא משפחה. בלי הקשר הזה, קל מאוד לקבל מחלקה שמייצרת כל מיני אובייקטים ולקרוא לה Abstract Factory, גם כשהתבנית לא באמת נדרשת.
שני שירותים, בחירה אחת
ניקח מערכת שמפיקה דוחות. אחרי הפקת הדוח היא צריכה לשמור אותו באחסון קבצים ולשלוח הודעה לתור, כדי שרכיב אחר ימשיך לטפל בו.
המערכת שלנו מותקנת אצל כמה לקוחות. אצל חלקם התשתית נמצאת ב־Azure ואצל אחרים ב־AWS. לצורך הדוגמה, הדרישה היא ששני השירותים ישתמשו בספק שנבחר עבור אותה התקנה.
זו דרישה שלנו. אין מניעה עקרונית לשמור קובץ ב־Azure ולשלוח הודעה דרך AWS, אבל במערכת הזו אנחנו לא רוצים לאפשר בחירה נפרדת לכל שירות.
נתחיל משני ממשקים:
public interface IFileStorage
{
Task UploadAsync(string fileName, byte[] content);
}
public interface IMessageQueue
{
Task SendAsync(string message);
}
לקוד שמטפל בדוח לא אמור להיות אכפת אם הקובץ נשמר ב־Azure Blob Storage או ב־Amazon S3. מבחינתו, יש שירות שיודע לשמור קובץ ושירות שיודע לשלוח הודעה.
אפשר לממש אותם כך:
public sealed class AzureFileStorage : IFileStorage
{
public Task UploadAsync(string fileName, byte[] content)
{
Console.WriteLine($"Azure: uploading {fileName}");
return Task.CompletedTask;
}
}
public sealed class AzureMessageQueue : IMessageQueue
{
public Task SendAsync(string message)
{
Console.WriteLine($"Azure: sending {message}");
return Task.CompletedTask;
}
}
public sealed class AwsFileStorage : IFileStorage
{
public Task UploadAsync(string fileName, byte[] content)
{
Console.WriteLine($"AWS: uploading {fileName}");
return Task.CompletedTask;
}
}
public sealed class AwsMessageQueue : IMessageQueue
{
public Task SendAsync(string message)
{
Console.WriteLine($"AWS: sending {message}");
return Task.CompletedTask;
}
}
המימושים כאן מדפיסים למסך כדי שנוכל להתרכז במבנה. בקוד אמיתי הם היו משתמשים בספריות של ספקי הענן, עם הגדרות חיבור, הרשאות וטיפול בשגיאות.
עד כאן יש לנו שני סוגי שירותים ושני מימושים לכל סוג. שום דבר מיוחד.
אבל עכשיו צריך לחבר אותם.
המקום שבו אפשר להתבלבל
כל עוד אנחנו יוצרים את השירותים בנפרד, אפשר לכתוב גם את זה:
IFileStorage storage = new AzureFileStorage();
IMessageQueue queue = new AwsMessageQueue();
מבחינת הקומפיילר הכול תקין. שני האובייקטים מממשים את הממשקים הנכונים.
מבחינת הדרישה שלנו, נוצר שילוב שלא רצינו.
אפשר כמובן להקפיד בכל מקום על יצירת הזוג המתאים. אפשר גם להוסיף תנאי בכל מקום שבו יוצרים את השירותים. אבל אם בחירת ספק הענן היא החלטה אחת, יש היגיון לייצג אותה בקוד כהחלטה אחת.
בשביל זה נגדיר ממשק נוסף:
public interface ICloudServicesFactory
{
IFileStorage CreateFileStorage();
IMessageQueue CreateMessageQueue();
}
הממשק הזה הוא ה־Abstract Factory שלנו. הוא מגדיר אילו סוגי אובייקטים אפשר לקבל, בלי לציין את המחלקות שיממשו אותם.
למרות השם, אין חובה להשתמש במחלקה עם המילה abstract. בדוגמה שלנו ממשק מתאים בדיוק לתפקיד.
עכשיו כל ספק יקבל Factory משלו:
public sealed class AzureServicesFactory
: ICloudServicesFactory
{
public IFileStorage CreateFileStorage()
=> new AzureFileStorage();
public IMessageQueue CreateMessageQueue()
=> new AzureMessageQueue();
}
public sealed class AwsServicesFactory
: ICloudServicesFactory
{
public IFileStorage CreateFileStorage()
=> new AwsFileStorage();
public IMessageQueue CreateMessageQueue()
=> new AwsMessageQueue();
}
כך נראות שתי המשפחות:
| ה־Factory | אחסון קבצים | תור הודעות |
|---|---|---|
AzureServicesFactory | AzureFileStorage | AzureMessageQueue |
AwsServicesFactory | AwsFileStorage | AwsMessageQueue |
כל Factory מרכז את הידע על המימושים ששייכים למשפחה שלו. מי שמשתמש בו לא צריך להרכיב את הזוג בעצמו.
חשוב לדייק: עדיין אפשר לטעות ולכתוב בתוך AzureServicesFactory יצירה של AwsMessageQueue. הממשקים לא מונעים את זה. התבנית מרכזת את האחריות במקום אחד, שאפשר לבדוק, במקום לפזר אותה בין כל המשתמשים בשירותים.
הקוד שמטפל בדוח
עכשיו נכתוב את השירות שמשתמש בשני הרכיבים:
public sealed class ReportPublisher
{
private readonly IFileStorage _storage;
private readonly IMessageQueue _queue;
public ReportPublisher(ICloudServicesFactory factory)
{
_storage = factory.CreateFileStorage();
_queue = factory.CreateMessageQueue();
}
public async Task PublishAsync(
string fileName,
byte[] content)
{
await _storage.UploadAsync(fileName, content);
await _queue.SendAsync($"ReportReady:{fileName}");
}
}
המחלקה מקבלת Factory, מבקשת ממנו את השירותים ושומרת אותם לשימוש בהמשך. אין בתוכה אזכור של Azure או AWS.
כדי לעבוד עם Azure:
var publisher = new ReportPublisher(
new AzureServicesFactory());
await publisher.PublishAsync(
"monthly-report.csv",
new byte[] { 1, 2, 3 });
וכדי לעבוד עם AWS:
var publisher = new ReportPublisher(
new AwsServicesFactory());
await publisher.PublishAsync(
"monthly-report.csv",
new byte[] { 1, 2, 3 });
הפעולה נשארה אותה פעולה. החלפנו את האובייקט שאחראי לספק את משפחת המימושים.
כדאי לשים לב גם למה שלא פתרנו: אם העלאת הקובץ הצליחה ושליחת ההודעה נכשלה, יש לנו כשל חלקי. העובדה ששני הרכיבים הגיעו מאותו Factory, ואפילו עובדים אצל אותו ספק ענן, לא הופכת את שתי הפעולות לטרנזקציה אחת. זו בעיה נפרדת, שדורשת תכנון של ניסיונות חוזרים והתאוששות.
מישהו בכל זאת צריך לבחור
הקוד שלנו לא יכול להחליט לבד אצל איזה ספק הוא רץ. הבחירה עדיין קיימת, אבל אפשר לרכז אותה במקום שבו מרכיבים את המערכת:
ICloudServicesFactory factory = provider switch
{
"Azure" => new AzureServicesFactory(),
"AWS" => new AwsServicesFactory(),
_ => throw new ArgumentException(
$"Unsupported provider: {provider}")
};
var publisher = new ReportPublisher(factory);
המשתנה provider יכול להגיע מהגדרות האפליקציה.
לא העלמנו את ה־switch, וגם לא הייתה לנו סיבה להעלים אותו. העברנו את בחירת המשפחה למקום אחד. אחרי הבחירה, הקוד שמפרסם דוחות עובד מול הממשקים שלו.
אם נוסיף ספק שלישי, נכתוב את המימושים שלו ואת ה־Factory המתאים, ונוסיף אפשרות לבחירה. אין צורך לשנות את ReportPublisher, כל עוד הספק החדש מסוגל לעמוד באותם חוזים.
ההסתייגות הזו חשובה. שני שירותים שמציעים פעולה בשם SendAsync לא בהכרח מתנהגים באותו אופן מבחינת סדר הודעות, גודל הודעה או הבטחות מסירה. האחריות שלנו היא להגדיר חוזה שהמימושים באמת יכולים לקיים. ממשק משותף לא מוחק הבדלים בין מערכות.
ההבדל מ־Factory Method
קל לזכור את ההבחנה כ״אובייקט אחד מול כמה אובייקטים״, אבל זה לא כל הסיפור.
בתבנית Factory Method שראינו במאמר הקודם, מחלקת הבסיס ניהלה תהליך, ומתודת יצירה שניתנת לדריסה אפשרה למחלקות יורשות להחליט איזה מימוש ישתלב בו. נקודת ההרחבה הייתה בירושה.
כאן, ReportPublisher לא יורשת ממחלקה אחרת כדי לבחור שירותי ענן. היא מקבלת אובייקט נפרד שמספק לה משפחת שירותים. נקודת ההחלפה היא ה־Factory שמועבר אליה.
שתי התבניות גם יכולות להשתלב. אפשר לממש פעולות יצירה של Abstract Factory באמצעות Factory Methods. הן לא שתי אפשרויות שחייבים לבחור רק אחת מהן.
בדוגמה שלנו אין צורך בשילוב הזה. הממשק ושני המימושים שלו מספיקים.
ואולי מספיק להזריק את השירותים?
בהחלט.
אפשר לכתוב את הבנאי של ReportPublisher כך:
public ReportPublisher(
IFileStorage storage,
IMessageQueue queue)
{
_storage = storage;
_queue = queue;
}
ובזמן רישום התלויות לבחור יחד את שני המימושים המתאימים.
אם ספק הענן קבוע לכל חיי האפליקציה, והשירותים כבר נרשמים בצורה מסודרת ב־DI Container, זו עשויה להיות האפשרות הפשוטה יותר. עצם העובדה שיש לנו שני מימושים לכל ממשק לא מחייבת Factory נוסף.
התבנית נעשית שימושית יותר כשיש צורך מפורש לבקש משפחת אובייקטים, למשל כשאותו תהליך מטפל בלקוחות שמשתמשים בספקים שונים. במקרה כזה אפשר לבחור Factory בהתאם ללקוח, ולהעביר אותו לקוד שצריך לעבוד עם המשפחה שנבחרה.
גם אז צריך להחליט מי מנהל את חיי האובייקטים. בדוגמה כל קריאה למתודת יצירה מחזירה אובייקט חדש. במערכת אמיתית ייתכן שה־Factory ישתמש בלקוחות SDK משותפים או בתלויות שהוזרקו אליו. התבנית לא קובעת אם האובייקט יהיה חדש, משותף או דורש שחרור משאבים.
המחיר של משפחה קבועה
עד עכשיו היה נוח להוסיף ספק חדש. אבל מה יקרה אם נרצה להוסיף לכל ספק גם שירות לניהול סודות?
נצטרך להוסיף לממשק פעולה:
ISecretStore CreateSecretStore();
ומאותו רגע כל מימוש של ICloudServicesFactory יצטרך לספק אותה.
זה המחיר המרכזי של התבנית: קל יחסית להוסיף משפחה חדשה של מוצרים, אבל הוספת סוג מוצר חדש משפיעה על כל המשפחות הקיימות.
לכן כדאי לבדוק מה צפוי להשתנות במערכת. אם אנחנו מוסיפים עוד ספקים שמציעים את אותו אוסף שירותים, המבנה מתאים. אם בכל שבוע נוסף שירות מסוג אחר, או שלכל ספק יש אוסף יכולות שונה לחלוטין, ה־Factory המשותף עלול להפוך לממשק שמכריח מימושים להציע דברים שלא מתאימים להם.
במקרה כזה לא כדאי למהר למלא את המתודות ב־NotSupportedException. יכול להיות שהמשפחות שהגדרנו פשוט אינן אחידות כפי שחשבנו.
בדוגמה שלנו הדרישה הייתה לבחור אחסון ותור הודעות יחד. ה־Abstract Factory נתן לדרישה הזו מקום ברור בקוד. אם מחר נרצה לבחור אותם בנפרד, נצטרך לבחון מחדש גם את המבנה הזה.
זו הבדיקה שהייתי עושה לפני הוספת התבנית: האם יש כאן באמת קבוצת אובייקטים שצריך לבחור כמשפחה? אם כן, יש טעם לייצג את הקשר הזה. אם כל מה שצריך הוא להעביר שני שירותים לבנאי, אפשר בהחלט להסתפק בזה.