הבנת תצורה של Interface Segregation in Modern Software Architecture

פרויקטים גדולים של תוכנה דורשים משמעת ארכיטקטונית קפדנית.כפי שבסיסי הקוד גדלים, תלותיים מתרבים, ושינויים שפעם לקח דקות יכולים לעגל לתוך ימים של בדיקות רגרסציה.ה- Interface Segregation Principle (ISP), אחד מחמשת עקרונות SOLID של עיצוב מוכוון אובייקט, מטפל ישירות המורכבות הזו על ידי ניהול כמה אנו מגדירים חוזים בין רכיבים.

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

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

מקור ISP

רוברט מרטין הציג את ISP במאמרו משנת 1996 "The Interface Segregation Principle", לאחר מכן הסדיר אותו ב-SOLID acronym.הוא השתמש בדוגמה של מדפסת רב-תפקודית שאילצה את הלקוחות להיות תלויים בשיטות הדפסה, מכווץ, ופקס אפילו כאשר הם צריכים הדפסה.

כיצד ה- Interface Segregation Differs from Another SOLID Principles

ISP הוא לעתים קרובות מבולבל עם אחריות יחידה Principle (SRP) כי שניהם מעודדים מודולים ממוקדים. עם זאת, SRP מתייחס באחריות של מחלקה או מודול (FLT:0 ציבוריות איכות הכללה ve 1), בעוד ISP מתייחס חוזים אלה מודולים לחשוף (FLT:2interface granulartion 3) מחלקה עשויה להיות אחריות אחת אך ורק חשיפה גדולה עבור לקוחות מרובים ISP.

יתרונות קריטיים של ISP בפרויקטים גדולים

צמצום ההשפעות של Coupling ו- Ripple Effects

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

שיפור יכולת הקריאה וזיהוי צוות

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

רגישות טובה יותר וטיפוח

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

גמישות מוגברת לשינויים עתידיים

פרויקטים בקנה מידה גדול עוברים לעתים קרובות מספקים גדולים או הגירה (למשל, מעבר ממונוליט לשירותים, שינוי מסדי נתונים, אימוץ ארכיטקטורות מונעות אירוע) ממשקים מתואמים מאפשרים להחליף יישומים לממשק מבלי להשפיע על חלקים אחרים של המערכת.לדוגמה, החלפת מערכת ההודעות האלקטרונית (אשר מיישמת FLT:6) אינה דורשת שינויים כדי להזמין ממשק עיבוד (FLT 7).

יישום Interface Segregation: A Practical Guide

שלב 1: זיהוי תפקידים של לקוחות

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

  • (ב) ,0) ראו UIRFLT 1 (הדגשה על שורת ה-UIFLT) – צריך לקרוא משימות ולעדכן את מצב המשימה.
  • (ב) ,0) "הרש"ל" (ב) צריך ליצור, למחוק ולמשימות ארכיון.
  • (ב) ,0) העברת מידע על השלמת המשימה.
  • (ב) ,0) ,לאה של שירות ההשראה (לאה) צריך לשלוח התראות כאשר משימות יוחלפו.

(ב) "באשר" (ב) "ב"ה) יש לתכנן ממשקים שמתאימים לכל תפקיד: (ב"ד: 10) ,FLT:11, FLT:11, ו-"FLT:12" (ב)

שלב 2: שמור על טבלאות קטנות אך עקביות

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

שלב 3: השתמש בקומפוזיציה Overheritance

לקוחות הזקוקים ליכולות מרובות יכולים להלחין ממשקים.לדוגמה, ניהול משתמשים UI עשוי לדרוש (FLT:16 ו-FLT:17 במקום יורשים משומן FLT 18, זה תלוי בשני ממשקים צרים.הרכב זה טבעי בשפות עם מספר רב של ממשקים (Java, C#) או עם סוג של (GoScript) בדינמיקה, כמו Python, באפשרותך להשתמש בהגדרה מפורשת (DIp) או שימוש ב- 544).

שלב 4: רצון טוב

בבסיס קוד מורשת גדול, כתיבת כל הממשקים בבת אחת היא מסוכנת ושיבוש.גישה בטוחה יותר היא ה-FLT:0strangler figeurFLT:1 עבור ממשקים:

  1. לזהות את ממשק השומן הבעייתי ביותר (האחד עם התלויים ביותר).
  2. Define ממשק צר חדש המכסה את תפקיד הלקוח.
  3. לשנות את הלקוח כדי להיות תלוי בממשק החדש.
  4. צור מתאם שמושך את היישום הישן בממשק החדש.
  5. חזור על כל תפקיד הלקוח עד שהממשק המקורי אינו בשימוש, ולאחר מכן למחוק אותו.

חיזוק זה מקטין את הסיכון ומספק אימות מוקדם כי ממשקים חדשים פועלים כראוי.

שלב 5: אימות עם בדיקות אוטומטיות

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

דוגמאות אמיתיות ל-ISP בפרויקטים גדולים

דוגמה: הודעות Broker Interfaces

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

דוגמה 2: החזרת שערי API

פרויקטים גדולים רבים משתמשים בשער API הכולל מספר שירותי החזרת.אם השער חושף גרף יחיד GraphQL או REST משאבים הכוללים שדות עבור משתמשים ציבוריים ומנהלים פנימיים, הוא מכריח את כל הלקוחות להבין שדות שהם לא יכולים להשתמש בהם. במקום זאת, השער יכול לבודד את הschema שלו על ידי תפקיד: ממשק FLT:23 עם שדות מוגבלים, LT:24 עם ממשק מלא, ו-CRFUD זה גם כן, על ידי מערכת אבטחה.

דוגמה: Plugin Architectures

(הופנה מהדף IDEs, מערכות ניהול תוכן ומנועי משחקים תומכים בתוספים. ממשק שומן שמחייב כל תוסף ליישום שיטות לשכפול, הפעלת אירועים, התמדה נתונים, ותצורה של UI מפרה את ISP. למערכות מוצלחות מגדירות ממשקים עתירי-העת בסדר: FLT:26, FLT:27, טיפול, טיפול בנתוני המשך, וכו 'תאמת רק את מה שהם צריכים:2Foztrated להשתמש בתכונות של ה-FLT-FLTable:

מלכודות נפוצות וכיצד להימנע מהם

Over-Segation

יצירת ממשקים זעירים רבים מדי יכול להוביל ל"זיהום פנים", מה שחייב את הצרכנים להיות תלויים בממשקים מרובים עבור פעולות פשוטות.לדוגמה, הפרדה FLT:29, FLT:30, ו-FLT:31 לתוך ממשקים נפרדים הוא מוגזם אם פעולות אלה תמיד בשימוש יחד.המפתח הוא לבודד בהתבסס על תפקידים של לקוחות, לא עקרות שיטה אם כל שיטה שלו הופך להיות יעיל, תאבד את הממשק של הממשק של הממשק.

המונחים:

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

אמנות נמינג לא עקביות

בבסיס קוד גדול עם ממשקים רבים, שמות בלתי עקביים מבלבלים את היזמים.הקמת אמנה: למשל, כל הממשקים שקראו את הנתונים מסיום עם "Reader" (ראהים:FLT:32, FLT:33), כל מה שכותב בסופו של דבר עם "Writer" (FLT:34), וכל זה משלב את שניהם שימוש במרכיבים.

התעלמות מהשפעת על הזרקת התלות

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

צמצום ההשפעה של ISP

כדי להצדיק השקעה בהפרדה בין ממשק, אתה יכול לעקוב אחר מדדים כגון:

  • (FLT:0) afferent Coupupling (Ca): ההרחבה 1) מספר המעמדות מחוץ למרכיב שתלוי בו. High Ca על ממשק השומן מצביע על כך שלקוחות רבים מושפעים משינויים.
  • (ב) מספר השיעורים, אם לקוח תלוי רק בממשקים צרים, Ce יורדת, שיפור הלכידה.
  • (ה)היות (I): ⁇ 1 I= Ce / (Ca + Ce) חוסר יציבות גבוה פירושו מרכיב קשה לשנות.
  • (FLT:0) שינוי ניתוח השפעה: FLT:1 מעקב כמה מודולים צריך להיות שונה כאשר דרישה משנה ממשק אחד.

(ב) כלי [15] (בעבור .NET) או (FLT:2narQubeveFLT 3) יכול ליצור מדדים אלה ולזהות ממשקים גדולים המפרים את ISP.

מיפוי למערכות Distributed Systems: REST, GraphQL ו- gRPC

REST APIs

שירותים RESTful לעתים קרובות לחשוף נקודות קצה כי קובצי משאבים קשורים רבים.A יחיד (FLT:37), נקודת קצה עשוי לתמוך GET, POST, PUT, DELETE, בתוספת פרמטרים של שאילתה עבור סינון, מיון ודמיון.זה יכול להפר את ISP אם כמה לקוחות רק צריך לקרוא פרופילים משתמשים בעוד אחרים צריכים ליצור או למחוק אותם.

GraphQL

(ב) גרף (ב) מספק נתונים טעונים, כך שלקוחות מבקשים רק את התחומים הדרושים להם.עם זאת, הschema עדיין יכול להפר את ISP אם היא קבוצות שאינן קשורות למוטציות שורש יחיד או לשאילתה.לדוגמה, סוג של LT:41 הכולל גם את ההנחיות FLT:42 ו-FLT:43 כוחות החזית כדי להיות תלות בשני התחומים.

gRPC

(ה) הגדרות שירות GRPC יכולות להפוך בקלות לקבצים של שומן עם עשרות RPCs.לאחר ISP, עליך לפצל שירותים על ידי תפקיד הלקוח.במקום אחדFLT:48, להגדיר את FLT:49, FLT:50, ו- (FLT:50, ו-FLT:51 זה גם מאפשר מדיניות אבטחה שונה לתפקיד.

ISP ו- Team Organization

פרויקטים גדולים לעתים קרובות יש עשרות קבוצות, כל אחד מהם כולל חלקים שונים של מערכת ההפרדה של Interface מאפשר תפוצה:0 (contract-First DevelopmentofFLT:1): צוותים מגדירים ממשקים צרים עבור החלקים שהם חושפים, וצוותים אחרים תלויים אך ורק על חוזים אלה.זה מקטין את התקשורת על פני כי שינויים ביישום הפנימי של צוות אינם משפיעים על אחרים כל עוד החוזים נשארים יציבים, אם יש צורך אנלוגי כדי ליצור גרסה חדשה ללא צורך זה יכול לגרום לממשק קיים ללא רצף של צוותים.

בפועל, פרויקטים רבים בקוד פתוח ובסיסי קוד ארגוניים מאמצים את ISP באופן בלתי נמנע באמצעות חבילה.לדוגמה, FLT:0Angular FrameworksFLT:1 חושף מספר חבילות קטנות (FLT:52, FLT:53, FLT:53, FLT:54) במקום ספרייה מונוליטית אחת.

מסקנה

עקרון ה- Interface Segregation הוא לא רק מושג אקדמי; זה כלי מעשי לניהול המורכבות בפרויקטים תוכנה בקנה מידה גדול.על ידי תכנון ממשקים ממוקדים, תכונות, רכיבים מחוסנים, לשפר את יכולת הבדיקה, ולהפוך את המערכת שלך להכרחי לשנות.אם אתה עובד עם שפות מוכוונות אובייקט, מיקרו-שירותי API, או שערי API, החלת ISP מפחיתה את החיכוך שנוצר על ידי צוותים של ימינו, התחלות של קבוצות שומן.