יישום תבנית המפעל הפשטנית לתמיכה בפיתוח תוכנה רב-פלטפורמות הנדסה

מבוא לתבניות עיצוב בריאת בהנדסה

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

הבעיה העיקרית בתוכנות הנדסה רב כוכבית היא שכל פלטפורמה עשויה לדרוש גרסאות שונות של UI widgets, גישה למערכת קבצים, מודלים מתיישים, או ספריות מספריות. פשוט לכתוב לוגיקה מותנית לאורך בסיס הקוד (למשל, FLT:0) מובילה ל-ספאגטי כי הוא קשה להרחיב, לבדוק, ולפענוח.

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

הבנת תבנית המפעל

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

(הופנה מהדף מודל החרושת, אשר עוסק בסוג מוצר יחיד.המפעל המינהלי מטפל בסוגי מוצר מרובים המיועדים לעבוד יחד.לדוגמה, ביישום הנדסי חוצה כוכבי, ייתכן שיהיה צורך ב-FLT:0 ButtonigtureFLT:1, FLT:2TextFielddofdFLT 3, ו-LT4Diadulating (מתאים ל-Fal) כל אחד, כלומר, כלומר, כל אחד, אם הוא חלק מ-F2, כלומר, הוא אחד, הוא קבוע, הוא אחד, הוא אחד, הוא אחד, הוא אחד, כולל את כל אחד, הוא אחד, כולל את כל אחד, כולל את כל אחד מהם, הוא אחד, בין היתר, בין היתר, בין היתר, בין היתר, בין אם הוא חלק מ-FLT2, בין היתר, בין היתר, בין היתר, בין היתר, בין היתר, בין אם הוא אומר:2.

התבנית מופצה בספר "Gang of Four" הקלאסי "FLT:0" תבניות עיצוב: יסודות של תוכנה מבוססת אובייקטים הניתנים להגדרה מחדש של 1 (Gang of Four) "מקודמת" (Gang of Four) הוא שימושי במיוחד בתחומי הנדסה שבהם משפחת מוצר עשויה לכלול לא רק אלמנטים של UI, אלא גם ממשק API ספציפי לממשק תקשורת, ניהול זיכרון, או סימולציות.

משתתפים מרכזיים בתבנית

• (ב) ,0) ,בסטרקטפלט: 1 (ב) , הכרזה על מערכת של שיטות יצירה, אחת לכל סוג של מוצר במשפחה.
• (FLT:0)ConcreteFactory:FLT:1) מיישם את שיטות הבריאה עבור פלטפורמה מסוימת.כל מפעל קונקרטי מייצר מוצרים עקביים לדרישות הפלטפורמה.
• (FLT:0) ייצור של Abstract: FLT:1 Declares ממשק עבור אובייקט מוצר.כל המוצרים קונקרטיים הנגזרים מממשק זה חייבים לדבוק באותה חוזה.
• (ב) ,0) ייצור המוצר: FLT:1 יישום ממשק המוצר הפשטי עבור פלטפורמה מסוימת.
• (FLT:0)Client:BuildFLT:1) משתמש רק ממשקי המוצר ה-PracreFactory וה-Preple Product Interfaces.It Never Direct Immediaiates קונקרטיים; במקום זאת הוא מקבל אותם דרך המפעל.

מדוע תוכנות הנדסה רב-Platform דורשות את תבנית המפעל

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

(לדוגמא, כלי סימולציה הנדסי שצריך להפוך מודלים 3D ב- Windows, זה עשוי למנף DirectX; על macOS, מתכת; על לינוקס, Vulkan או OpenGL. A Video מוכר כרטיס וידאו יכול גם להשתנות.על ידי יישום תבנית המפעל הפשט, הסימולציה מבקשת ישויות הליבה של FLT:0RendererFLT:1 ו-FLT:2Comeputeputine החדש של ה-FLT.

דוגמה נוספת היא קובץ I/O. Engineering פרויקטים לעתים קרובות כרוכים בנתוני נתונים גדולים (קבצי CAD, סימולציות, יומני) הדרך להתמודד עם נתיבי קבצים, הרשאות, ו ⁇ שונה בין OSes. מפעל מופשט יכול לספק מוצר FPLT:0File System AccessFLT:1 אשר מערערערער את ההבדלים הללו, ומאפשר להנדסת מיקוד לעיבוד נתונים במקום טיפול.

על פי ניתוח של 2020 על ידי המאמר של FLT:0 [InfoQ על מפעל אבסטרי FLT:1, צוותים אשר מאמצים את דוח זה הפחית באגים שילוב ומהיר יותר על גבי לוחות של פלטפורמות חדשות.התבנית גם מעודדת הפרדה נקייה בין "מה" (ממשקי המוצר) ואת "איך" (היישום קונקרטי), שהוא קריטי בצוותי הנדסה גדולים שבו מומחים עובדים במקביל.

שלב-בי-שלב יישום של תבנית המפעלים הפשטנית

כדי להמחיש את התבנית, אנו נרחיב את הדוגמה מהמאמר המקורי למבנה שלם עבור תוכנת הנדסה רב כוכבית. נניח שאנו בונים יישום המבצע ניתוח יסוד סופי (FEA) וחייב לרוץ על Windows, macOS ולינוקס. התוכנה זקוקה לשלוש משפחות מוצר: פתרון (מנוע מספרי), פוסט-מעבד (ויזואליזציה), ותוצאות (התאמה), ותוצאות בלתי תואמים ל-HDVF5 משימות שונות, וכו '.

1.1 ממשקי מוצר

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

// AbstractProduct for Solver
interface ISolver {
 Result solve(Problem problem);
}

// AbstractProduct for PostProcessor
interface IPostProcessor {
 void visualize(Result result);
 void exportReport(Result result);
}

// AbstractProduct for DataExporter
interface IDataExporter {
 void exportToHDF5(Result result, Path path);
 void exportToCSV(Result result, Path path);
}

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

ההרחבה Define abstract Factory

לאחר מכן, אנו מכריזים על המפעל המופשט שיצור כל אחד מבני משפחת מוצר.

interface IPlatformFactory {
 ISolver createSolver();
 IPostProcessor createPostProcessor();
 IDataExporter createDataExporter();
}

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

יישום קריטריונים לכל פלטפורמה

כעת אנו יוצרים מפעל קונקרטי לכל מערכת הפעלה של מטרה.כל מפעל מחזיר מוצרים המותאם במיוחד ל-OS.

(FLT:0)WindowsFactory: 1FLT) משתמש ב- Intel MKL עבור פותר (המועיל ל- Windows), גרפיקה WPF עבור עיבוד לאחר, ויצוא מותאם אישית המנצל את ממשקי API של קבצים נורמטיביים של Windows.

class WindowsFactory : IPlatformFactory {
 ISolver createSolver() { return new MklSolverWin(); }
 IPostProcessor createPostProcessor() { return new WpfPostProcessor(); }
 IDataExporter createDataExporter() { return new WinDataExporter(); }
}

(ב) ,0) מ"מקרא-פלט: 1FLT" משתמש במסגרת של פתרון, ויזואליזייזר מבוסס מתכת, וייצוא מודעות של POSIX-Aware.

class MacFactory : IPlatformFactory {
 ISolver createSolver() { return new AccelerateSolverMac(); }
 IPostProcessor createPostProcessor() { return new MetalPostProcessor(); }
 IDataExporter createDataExporter() { return new MacDataExporter(); }
}

(FLT:0)לינוקסFactory: 1FLT) משתמש ב- OpenBLAS עבור Solr, Vulkan post-מעבדטור, ו- HDF5 יצואן באמצעות ספריות מערכת.

class LinuxFactory : IPlatformFactory {
 ISolver createSolver() { return new OpenBlasSolverLinux(); }
 IPostProcessor createPostProcessor() { return new VulkanPostProcessor(); }
 IDataExporter createDataExporter() { return new Hdf5ExporterLinux(); }
}

הערה: שיעורי המוצר קונקרטיים (למשל, FLT:13) ליישם את ממשקי המוצר המופשטים.הם מכילים את כל הלוגיקה הספציפית של הפלטפורמה.

קוד לקוח: שימוש במפעל

הלקוח (למשל, מודול ניהול FEA) מקבל התייחסות ל-FLT:14 בסטארט-אפ.זה קורא שיטות המפעל כדי לקבל מקרים של מוצרים, לא קורא במפורש FLT:15 על מחלקה קונקרטית.

class FeaManager {
 private IPlatformFactory factory;

 public FeaManager(IPlatformFactory factory) {
 this.factory = factory;
 }

 public void runAnalysis(Problem problem) {
 ISolver solver = factory.createSolver();
 Result result = solver.solve(problem);

 IPostProcessor postProc = factory.createPostProcessor();
 postProc.visualize(result);

 IDataExporter exporter = factory.createDataExporter();
 exporter.exportToCSV(result, Paths.get("output.csv"));
 }
}

יצירתו של ה-FLT:17 (למשל, FLT 18) נעשית פעם, בדרך כלל בנקודת הכניסה של היישום או מיכל הזרקת התלות.

אינטגרציה עם פיזור תלות

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

// Using a DI container (e.g., Spring or Unity)
container.Register<IPlatformFactory, WindowsFactory>();
// Then any class requiring IPlatformFactory gets it injected automatically.

היתרונות של תבנית המפעל האבסטרקטי בהנדסת Multi-Platform

• Platform Independence: FLT:1 לוגיקה הנדסית הליבה (פתרון, הדמיה, יצוא) לעולם לא מתייחס לשיעורים ספציפיים פלטפורמה.זה מאפשר את אותו בסיס קוד להיות מואסף ולרוץ על כל פלטפורמה נתמך על ידי החלפת המפעל קונקרטי בנקודה אחת.
• (FLT:0)Ease of Extensions: הוספת תמיכה בפלטפורמה חדשה (למשל, מערכת משובצת מבוססת ARM) כוללת יצירת מפעל קונקרטי חדש ושיעורי מוצר חדשים.לא קיים קוד הלקוח צריך להשתנות באופן דרמטי.
• (FLT:0) עקביות והתאמה: ההרחבה 1 (FLT:1) התבנית מבטיחה כי כל המוצרים שנוצרו על ידי מפעל יחיד הם עקביים הדדית.לדוגמה, המפתר של מפעל Windows ישתמש במודל ניהול זיכרון זהה ליצוא הנתונים של Windows.זה מונע אינטגרציה עדינה אשר לעתים קרובות מתרחשת בעת ערבוב ספריות ספציפיות פלטפורמה.
• (FLT:0) estability:FLT:1 על ידי בהתאם לממשקים מופשטים, כל רכיב ניתן לבדוק בבידוד.לדוגמה, את המפת ניתן לבדוק ללא מעבד אמיתי באמצעות לעג מקרים של מוצר.זה חשוב במיוחד בתוכנות הנדסיות שבו תיקון מספרי הוא קריטי.
• צוותים של פלטפורמה 1FLT יכולים לעבוד באופן עצמאי על יישום המפעל קונקרטי שלהם, כל עוד הם לדבוק ממשקי המוצר.זה מאפשר פרויקט לספק פלטפורמות מרובות בו זמנית ללא חסימת שילוב.
• (FLT:0) אופטימיזציה של Windows:FLT:1 כל מפעל פלטפורמה יכול לבחור את הספריות היעילות ביותר עבור הסביבה זו.לדוגמה, Windows Solr עשוי להשתמש בספריית Math Kernel של אינטל (MKL) עבור האצה CPU, בעוד macOS פותר משתמש מסגרת Accelerate של אפל, ולינוקס משתמש ב- OpenBLAS.המפעלים המופשטים מסתירים את האפשרויות הללו, ומאפשר ללקוח תמיד לקבל את הביצועים הטובים ביותר ללא קוד.

class MockFactory : IPlatformFactory {
 ISolver createSolver() { return new MockSolver(that returns fixed result); }
 IPostProcessor createPostProcessor() { return new MockPostProcessor(records calls); }
 IDataExporter createDataExporter() { return new MockDataExporter(records calls); }
}