Elastīga koda rakstīšana, izmantojot SOLID

No tulka: publicēts jums Severina Peresa raksts par SOLID principu izmantošanu programmēšanā. Rakstā sniegtā informācija būs noderīga gan iesācējiem, gan pieredzējušiem programmētājiem.

Ja jūs interesē attīstība, jūs, visticamāk, esat dzirdējuši par SOLID principiem. Tie ļauj programmētājam rakstīt tīru, labi strukturētu un viegli uzturējamu kodu. Ir vērts atzīmēt, ka programmēšanā ir vairākas pieejas, kā pareizi veikt konkrētu darbu. Dažādiem speciālistiem ir dažādas idejas un izpratne par “pareizo ceļu”, tas viss ir atkarīgs no katra cilvēka pieredzes. Taču SOLID sludinātās idejas pieņem gandrīz visi IT kopienas pārstāvji. Tie kļuva par sākumpunktu daudzu labu attīstības pārvaldības prakšu rašanās un attīstībai.

Sapratīsim, kas ir SOLID principi un kā tie mums palīdz.

Skillbox iesaka: Praktiskais kurss "Mobile Developer PRO".

Atgādinām: visiem "Habr" lasītājiem - atlaide 10 000 rubļu, reģistrējoties jebkurā Skillbox kursā, izmantojot "Habr" reklāmas kodu.

Kas ir SOLID?

Šis termins ir saīsinājums, katrs termina burts ir noteikta principa nosaukuma sākums:

• Svienotais atbildības princips. Modulim var būt viens un tikai viens izmaiņu iemesls.
• Jūsu darbs IR Klientu apkalpošana Opildspalva/slēgtais princips (atvērtā/slēgtā princips). Klasēm un citiem elementiem jābūt atvērtiem paplašināšanai, bet slēgtiem modificēšanai.
•  Jūsu darbs IR Klientu apkalpošana Liskov aizstāšanas princips (Liskova aizstāšanas princips). Funkcijām, kas izmanto bāzes tipu, ir jāspēj izmantot pamata tipa apakštipus, to nezinot.
• Jūsu darbs IR Klientu apkalpošana IInterfeisa segregācijas princips  (saskarnes atdalīšanas princips). Programmatūras entītijām nevajadzētu būt atkarīgām no metodēm, kuras tās neizmanto.
• Jūsu darbs IR Klientu apkalpošana Datkarības inversijas princips (atkarības inversijas princips). Augstākā līmeņa moduļiem nevajadzētu būt atkarīgiem no zemāka līmeņa moduļiem.

Vienas atbildības princips

 
Vienotās atbildības princips (Single Responsibility Principle — SRP) nosaka, ka katrai programmas klasei vai modulim ir jāatbild tikai par vienu šīs programmas funkcionalitātes daļu. Turklāt šīs atbildības elementi ir jāpiešķir savai klasei, nevis jāizkaisa pa nesaistītām klasēm. SRP izstrādātājs un galvenais evaņģēlists Roberts S. Mārtins apraksta atbildību kā pārmaiņu iemeslu. Sākotnēji viņš ierosināja šo terminu kā vienu no sava darba "Objektorientētā dizaina principi" elementiem. Koncepcija ietver lielu daļu savienojamības modeļa, ko iepriekš definēja Toms Demarko.

Koncepcijā bija iekļauti arī vairāki Deivida Parnasa formulēti jēdzieni. Divas galvenās ir iekapsulēšana un informācijas slēpšana. Parnas apgalvoja, ka sistēmas sadalīšanu atsevišķos moduļos nevajadzētu balstīt uz blokshēmu vai izpildes plūsmu analīzi. Jebkurā no moduļiem ir jābūt konkrētam risinājumam, kas klientiem sniedz minimālu informāciju.

Starp citu, Martins sniedza interesantu piemēru ar uzņēmuma augstākajiem vadītājiem (COO, CTO, CFO), no kuriem katrs izmanto specifisku biznesa programmatūru dažādiem mērķiem. Rezultātā jebkurš no tiem var ieviest izmaiņas programmatūrā, neietekmējot citu vadītāju intereses.

Dievišķs objekts

Kā vienmēr, labākais veids, kā apgūt SRP, ir redzēt to darbībā. Apskatīsim programmas sadaļu, kurā NAV ievērots vienotas atbildības princips. Šis ir Rubīna kods, kas apraksta kosmosa stacijas uzvedību un atribūtus.

Pārskatiet piemēru un mēģiniet noteikt tālāk norādīto.
To objektu pienākumi, kuri ir deklarēti SpaceStation klasē.
Tie, kurus varētu interesēt kosmosa stacijas darbība.

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

Patiesībā mūsu kosmosa stacija nedarbojas (es nedomāju, ka tuvākajā laikā saņemšu zvanu no NASA), taču šeit ir ko analizēt.

Tādējādi SpaceStation klasei ir vairāki dažādi pienākumi (vai uzdevumi). Tos visus var iedalīt tipos:

• sensori;
• izejmateriāli (palīgmateriāli);
• degviela;
• paātrinātāji.

Lai arī nevienam no stacijas darbiniekiem nav iedalīta klase, mēs varam viegli iedomāties, kurš par ko ir atbildīgs. Visticamāk, zinātnieks kontrolē sensorus, loģistikas pienākums ir nodrošināt resursus, inženieris ir atbildīgs par degvielas piegādēm, bet pilots kontrolē pastiprinātājus.

Vai mēs varam teikt, ka šī programma nav saderīga ar SRP? Jā, protams. Bet SpaceStation klase ir tipisks "dieva objekts", kas zina visu un dara visu. Šis ir galvenais objektorientētās programmēšanas pretmodelis. Iesācējam šādus objektus ir ārkārtīgi grūti uzturēt. Pagaidām programma ir ļoti vienkārša, jā, taču iedomājieties, kas notiks, ja pievienosim jaunas funkcijas. Varbūt mūsu kosmosa stacijai būs nepieciešama medicīnas stacija vai sanāksmju telpa. Un jo vairāk būs funkciju, jo vairāk SpaceStation pieaugs. Tā kā šī iekārta būs savienota ar citām, visa kompleksa apkalpošana kļūs vēl grūtāka. Rezultātā varam traucēt, piemēram, akseleratoru darbību. Ja pētnieks pieprasa izmaiņas sensoros, tas var ļoti labi ietekmēt stacijas sakaru sistēmas.

SRP principa pārkāpšana var dot īstermiņa taktisku uzvaru, taču galu galā mēs “zaudēsim karu”, un turpmāk šādu briesmoni uzturēt būs ļoti grūti. Vislabāk ir sadalīt programmu atsevišķās koda sadaļās, no kurām katra ir atbildīga par konkrētas darbības veikšanu. To saprotot, mainīsim SpaceStation klasi.

Sadalīsim atbildību

Iepriekš mēs definējām četrus operāciju veidus, kurus kontrolē SpaceStation klase. Mēs tos paturēsim prātā, veicot pārstrukturēšanu. Atjauninātais kods labāk atbilst 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

Ir daudz izmaiņu, programma tagad noteikti izskatās labāk. Tagad mūsu SpaceStation klase ir kļuvusi vairāk par konteineru, kurā tiek uzsāktas darbības ar atkarīgām daļām, tostarp sensoru komplektu, patērējamo materiālu padeves sistēmu, degvielas tvertni un pastiprinātājiem.

Jebkuram no mainīgajiem tagad ir atbilstoša klase: Sensors; SupplyHold; Degvielas tvertne; Dzinēji.

Šajā koda versijā ir vairākas svarīgas izmaiņas. Lieta ir tāda, ka atsevišķas funkcijas ir ne tikai iekapsulētas savās klasēs, tās ir organizētas tā, lai tās kļūtu paredzamas un konsekventas. Mēs grupējam elementus ar līdzīgu funkcionalitāti, lai ievērotu saskaņotības principu. Tagad, ja mums ir jāmaina sistēmas darbības veids, pārejot no hash struktūras uz masīvu, vienkārši izmantojiet SupplyHold klasi; mums nav jāpieskaras citiem moduļiem. Tādā veidā, ja loģistikas virsnieks kaut ko mainīs savā sekcijā, pārējā stacija paliks neskarta. Šajā gadījumā SpaceStation klase pat neuzzinās par izmaiņām.

Mūsu virsnieki, kas strādā kosmosa stacijā, droši vien ir priecīgi par izmaiņām, jo ​​viņi var pieprasīt sev nepieciešamās. Ņemiet vērā, ka kodam ir tādas metodes kā report_supplies un report_fuel, kas ietvertas klasēs SupplyHold un FuelTank. Kas notiktu, ja Zeme lūgtu mainīt veidu, kā tā ziņo? Abas klases, SupplyHold un FuelTank, būs jāmaina. Ko darīt, ja jāmaina degvielas un palīgmateriālu piegādes veids? Visticamāk, jums atkal būs jāmaina visas tās pašas klases. Un tas jau ir SRP principa pārkāpums. Labosim šo.

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.

Šajā jaunākajā programmas versijā pienākumi ir sadalīti divās jaunās klasēs — FuelReporter un SupplyReporter. Viņi abi ir Reportieru klases bērni. Turklāt SpaceStation klasei pievienojām instanču mainīgos, lai vajadzības gadījumā varētu inicializēt vajadzīgo apakšklasi. Tagad, ja Zeme nolems mainīt kaut ko citu, tad mēs veiksim izmaiņas apakšklasēs, nevis galvenajā klasē.

Protams, dažas no mūsu klasēm joprojām ir atkarīgas viena no otras. Tādējādi objekts SupplyReporter ir atkarīgs no SupplyHold, un FuelReporter ir atkarīgs no FuelTank. Protams, pastiprinātāji ir jāpievieno degvielas tvertnei. Bet šeit jau viss izskatās loģiski, un izmaiņu veikšana nebūs īpaši sarežģīta – viena objekta koda rediģēšana citu īpaši neietekmēs.

Tādējādi esam izveidojuši modulāru kodu, kurā ir precīzi definēti katra objekta/klases pienākumi. Darbs ar šādu kodu nav problēma, tā uzturēšana būs vienkāršs uzdevums. Mēs esam pārveidojuši visu "dievišķo objektu" par SRP.

Skillbox iesaka:

• Divu gadu praktiskais kurss "Es esmu PRO tīmekļa izstrādātājs".
• Tiešsaistes kurss "C# izstrādātājs no 0".
• Praktiskā gada kurss "PHP izstrādātājs no 0 līdz PRO".

Avots: www.habr.com