כתיבת קוד גמיש באמצעות SOLID

מהמתרגם: פורסם עבורך מאמר מאת Severin Perez על שימוש בעקרונות SOLID בתכנות. המידע מהמאמר יהיה שימושי הן למתכנתים מתחילים והן למתכנתים מנוסים.

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

בואו נבין מה הם עקרונות SOLID וכיצד הם עוזרים לנו.

Skillbox ממליצה: קורס מעשי "Mobile Developer PRO".

אנו מזכירים: לכל קוראי Habr - הנחה של 10 רובל בעת הרשמה לכל קורס Skillbox באמצעות קוד ההטבה של Habr.

מה זה SOLID?

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

• Sעיקרון אחריות אחד. למודול יכולה להיות סיבה אחת ויחידה לשינוי.
• השמיים Oעט/עיקרון סגור (עקרון פתוח/סגור). שיעורים ואלמנטים אחרים צריכים להיות פתוחים להארכה, אך סגורים לשינויים.
•  השמיים Lעקרון ההחלפה של iskov (עקרון החלפת ליסקוב). פונקציות המשתמשות בסוג בסיס צריכות להיות מסוגלות להשתמש בתתי סוגים של סוג הבסיס מבלי לדעת זאת.
• השמיים Iעקרון הפרדת ממשק  (עקרון הפרדת ממשק). ישויות תוכנה לא אמורות להיות תלויות בשיטות שאינן משתמשות בהן.
• השמיים Dעקרון היפוך תלויות (עקרון היפוך תלות). מודולים ברמות גבוהות יותר לא צריכים להיות תלויים במודולים ברמות נמוכות יותר.

עיקרון אחריות יחידה

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

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

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

חפץ אלוהי

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

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

class SpaceStation
  def initialize
    @supplies = {}
    @fuel = 0
  end
 
  def run_sensors
    puts "----- Sensor Action -----"
    puts "Running sensors!"
  end
 
  def load_supplies(type, quantity)
    puts "----- Supply Action -----"
    puts "Loading #{quantity} units of #{type} in the supply hold."
    
    if @supplies[type]
      @supplies[type] += quantity
    else
      @supplies[type] = quantity
    end
  end
 
  def use_supplies(type, quantity)
    puts "----- Supply Action -----"
    if @supplies[type] != nil && @supplies[type] > quantity
      puts "Using #{quantity} of #{type} from the supply hold."
      @supplies[type] -= quantity
    else
      puts "Supply Error: Insufficient #{type} in the supply hold."
    end
  end
 
  def report_supplies
    puts "----- Supply Report -----"
    if @supplies.keys.length > 0
      @supplies.each do |type, quantity|
        puts "#{type} avalilable: #{quantity} units"
      end
    else
      puts "Supply hold is empty."
    end
  end
 
  def load_fuel(quantity)
    puts "----- Fuel Action -----"
    puts "Loading #{quantity} units of fuel in the tank."
    @fuel += quantity
  end
 
  def report_fuel
    puts "----- Fuel Report -----"
    puts "#{@fuel} units of fuel available."
  end
 
  def activate_thrusters
    puts "----- Thruster Action -----"
    if @fuel >= 10
      puts "Thrusting action successful."
      @fuel -= 10
    else
      puts "Thruster Error: Insufficient fuel available."
    end
  end
end

למעשה, תחנת החלל שלנו לא מתפקדת (אני לא חושב שאקבל שיחה מנאס"א בקרוב), אבל יש כאן מה לנתח.

לפיכך, למחלקת SpaceStation יש כמה תחומי אחריות (או משימות). ניתן לחלק את כולם לסוגים:

• חיישנים;
• אספקה ​​(חומרים מתכלים);
• דלק;
• מאיצים.

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

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

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

בואו נחלק אחריות

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

class SpaceStation
  attr_reader :sensors, :supply_hold, :fuel_tank, :thrusters
 
  def initialize
    @supply_hold = SupplyHold.new
    @sensors = Sensors.new
    @fuel_tank = FuelTank.new
    @thrusters = Thrusters.new(@fuel_tank)
  end
end
 
class Sensors
  def run_sensors
    puts "----- Sensor Action -----"
    puts "Running sensors!"
  end
end
 
class SupplyHold
  attr_accessor :supplies
 
  def initialize
    @supplies = {}
  end
 
  def load_supplies(type, quantity)
    puts "----- Supply Action -----"
    puts "Loading #{quantity} units of #{type} in the supply hold."
    
    if @supplies[type]
      @supplies[type] += quantity
    else
      @supplies[type] = quantity
    end
  end
 
  def use_supplies(type, quantity)
    puts "----- Supply Action -----"
    if @supplies[type] != nil && @supplies[type] > quantity
      puts "Using #{quantity} of #{type} from the supply hold."
      @supplies[type] -= quantity
    else
      puts "Supply Error: Insufficient #{type} in the supply hold."
    end
  end
 
  def report_supplies
    puts "----- Supply Report -----"
    if @supplies.keys.length > 0
      @supplies.each do |type, quantity|
        puts "#{type} avalilable: #{quantity} units"
      end
    else
      puts "Supply hold is empty."
    end
  end
end
 
class FuelTank
  attr_accessor :fuel
 
  def initialize
    @fuel = 0
  end
 
  def get_fuel_levels
    @fuel
  end
 
  def load_fuel(quantity)
    puts "----- Fuel Action -----"
    puts "Loading #{quantity} units of fuel in the tank."
    @fuel += quantity
  end
 
  def use_fuel(quantity)
    puts "----- Fuel Action -----"
    puts "Using #{quantity} units of fuel from the tank."
    @fuel -= quantity
  end
 
  def report_fuel
    puts "----- Fuel Report -----"
    puts "#{@fuel} units of fuel available."
  end
end
 
class Thrusters
  def initialize(fuel_tank)
    @linked_fuel_tank = fuel_tank
  end
 
  def activate_thrusters
    puts "----- Thruster Action -----"
    if @linked_fuel_tank.get_fuel_levels >= 10
      puts "Thrusting action successful."
      @linked_fuel_tank.use_fuel(10)
    else
      puts "Thruster Error: Insufficient fuel available."
    end
  end
end

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

עבור כל אחד מהמשתנים יש כעת מחלקה מתאימה: חיישנים; SupplyHold; מיכל דלק; דחפים.

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

הקצינים שלנו שעובדים בתחנת החלל כנראה שמחים על השינויים כי הם יכולים לבקש את אלה שהם צריכים. שימו לב שלקוד יש שיטות כגון report_supplies ו-report_fuel הכלולות במחלקות SupplyHold ו-FuelTank. מה יקרה אם כדור הארץ יבקש לשנות את אופן הדיווח שלו? יהיה צורך לשנות את שני המחלקות, SupplyHold ו-FuelTank. מה אם אתה צריך לשנות את אופן אספקת הדלק והחומרים המתכלים? סביר להניח שתצטרך לשנות שוב את כל אותם מחלקות. וזו כבר הפרה של עקרון SRP. בוא נתקן את זה.

class SpaceStation
  attr_reader :sensors, :supply_hold, :supply_reporter,
              :fuel_tank, :fuel_reporter, :thrusters
 
  def initialize
    @sensors = Sensors.new
    @supply_hold = SupplyHold.new
    @supply_reporter = SupplyReporter.new(@supply_hold)
    @fuel_tank = FuelTank.new
    @fuel_reporter = FuelReporter.new(@fuel_tank)
    @thrusters = Thrusters.new(@fuel_tank)
  end
end
 
class Sensors
  def run_sensors
    puts "----- Sensor Action -----"
    puts "Running sensors!"
  end
end
 
class SupplyHold
  attr_accessor :supplies
  attr_reader :reporter
 
  def initialize
    @supplies = {}
  end
 
  def get_supplies
    @supplies
  end
 
  def load_supplies(type, quantity)
    puts "----- Supply Action -----"
    puts "Loading #{quantity} units of #{type} in the supply hold."
    
    if @supplies[type]
      @supplies[type] += quantity
    else
      @supplies[type] = quantity
    end
  end
 
  def use_supplies(type, quantity)
    puts "----- Supply Action -----"
    if @supplies[type] != nil && @supplies[type] > quantity
      puts "Using #{quantity} of #{type} from the supply hold."
      @supplies[type] -= quantity
    else
      puts "Supply Error: Insufficient #{type} in the supply hold."
    end
  end
end
 
class FuelTank
  attr_accessor :fuel
  attr_reader :reporter
 
  def initialize
    @fuel = 0
  end
 
  def get_fuel_levels
    @fuel
  end
 
  def load_fuel(quantity)
    puts "----- Fuel Action -----"
    puts "Loading #{quantity} units of fuel in the tank."
    @fuel += quantity
  end
 
  def use_fuel(quantity)
    puts "----- Fuel Action -----"
    puts "Using #{quantity} units of fuel from the tank."
    @fuel -= quantity
  end
end
 
class Thrusters
  FUEL_PER_THRUST = 10
 
  def initialize(fuel_tank)
    @linked_fuel_tank = fuel_tank
  end
 
  def activate_thrusters
    puts "----- Thruster Action -----"
    
    if @linked_fuel_tank.get_fuel_levels >= FUEL_PER_THRUST
      puts "Thrusting action successful."
      @linked_fuel_tank.use_fuel(FUEL_PER_THRUST)
    else
      puts "Thruster Error: Insufficient fuel available."
    end
  end
end
 
class Reporter
  def initialize(item, type)
    @linked_item = item
    @type = type
  end
 
  def report
    puts "----- #{@type.capitalize} Report -----"
  end
end
 
class FuelReporter < Reporter
  def initialize(item)
    super(item, "fuel")
  end
 
  def report
    super
    puts "#{@linked_item.get_fuel_levels} units of fuel available."
  end
end
 
class SupplyReporter < Reporter
  def initialize(item)
    super(item, "supply")
  end
 
  def report
    super
    if @linked_item.get_supplies.keys.length > 0
      @linked_item.get_supplies.each do |type, quantity|
        puts "#{type} avalilable: #{quantity} units"
      end
    else
      puts "Supply hold is empty."
    end
  end
end
 
iss = SpaceStation.new
 
iss.sensors.run_sensors
  # ----- Sensor Action -----
  # Running sensors!
 
iss.supply_hold.use_supplies("parts", 2)
  # ----- Supply Action -----
  # Supply Error: Insufficient parts in the supply hold.
iss.supply_hold.load_supplies("parts", 10)
  # ----- Supply Action -----
  # Loading 10 units of parts in the supply hold.
iss.supply_hold.use_supplies("parts", 2)
  # ----- Supply Action -----
  # Using 2 of parts from the supply hold.
iss.supply_reporter.report
  # ----- Supply Report -----
  # parts avalilable: 8 units
 
iss.thrusters.activate_thrusters
  # ----- Thruster Action -----
  # Thruster Error: Insufficient fuel available.
iss.fuel_tank.load_fuel(100)
  # ----- Fuel Action -----
  # Loading 100 units of fuel in the tank.
iss.thrusters.activate_thrusters
  # ----- Thruster Action -----
  # Thrusting action successful.
  # ----- Fuel Action -----
  # Using 10 units of fuel from the tank.
iss.fuel_reporter.report
  # ----- Fuel Report -----
# 90 units of fuel available.

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

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

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

Skillbox ממליצה:

• קורס מעשי שנתיים "אני מפתח אתרים PRO".
• קורס מקוון "מפתח C# מ-0".
• קורס מעשי בן שנה "מפתח PHP מ-0 ל-PRO".

מקור: www.habr.com