SOLID: Първите 5 принципа на обектно ориентиран софтуерен дизайн, част: 1 Принцип на единна отговорност

Въведение в SOLID и защо е полезно.

SOLID е акроним за първите пет принципа на обектно-ориентиран дизайн (OOD) от Робърт С. Мартин (известен също като Чичо Боб ).

Тези принципи прилагат добри практики, които дават възможност за разработване на софтуер със съображения за поддръжка и разширяване с разрастването на проекта. Приемането на тези практики може също да допринесе за избягване на лош код, препроектиране на кода и гъвкава (agile) или адаптивна разработка на софтуер.

SOLID означава:

• S – Принцип на единична отговорност (Single-responsibility principle)
     – Никога не трябва да има повече от една причина за промяна на класа.
• O – Отворено-затворен принцип (Open–closed principle)
     – Софтуерните обекти… трябва да бъдат отворени за разширение, но затворени за модификация.
• L – Принцип на заместване на Лисков (Liskov substitution principle)
     – Функциите, които използват указатели или препратки към базови класове, трябва да могат да използват обекти от производни класове, без да знаят това.
• I – Принцип на разделяне на интерфейса (Interface segregation principle)
     – Много специфични за клиента интерфейси са по-добри от един интерфейс с общо предназначение.
• D – Принцип на инверсия на зависимост (Dependency inversion principle)
     – Зависи от абстракции, [не] конкреции.

В този урок ще бъдете запознати с принцип S – принцип на единичната отговорност, за да разберете как SOLID може да ви помогне да направите по-добър разработчик.

Принцип на единна отговорност

Например, помислете за приложение, което взема колекция от форми – кръгове и квадрати – и изчислява сумата от площта на всички форми в колекцията.

Първо, създайте класовете на фигурите и накарайте конструкторите да настроят необходимите параметри.

За квадрати ще трябва да знаете length страната:

class Square
{
    public $length;

    public function construct($length)
    {
        $this->length = $length;
    }
}

За кръгове ще трябва да знаете radius:

class Circle
{
    public $radius;

    public function construct($radius)
    {
        $this->radius = $radius;
    }
}

След това създайте AreaCalculator класа и след това напишете логиката, за да сумирате областите на всички предоставени форми. Площта на квадрат се изчислява по дължината на квадрат. Площта на окръжността се изчислява като PI по радиус на квадрат.

class AreaCalculator
{
    protected $shapes;

    public function __construct($shapes = [])
    {
        $this->shapes = $shapes;
    }

    public function sum()
    {
        foreach ($this->shapes as $shape) {
            if (is_a($shape, 'Square')) {
                $area[] = pow($shape->length, 2);
            } elseif (is_a($shape, 'Circle')) {
                $area[] = pi() * pow($shape->radius, 2);
            }
        }

        return array_sum($area);
    }

    public function output()
    {
        return implode('', [
          '',
              'Sum of the areas of provided shapes: ',
              $this->sum(),
          '',
      ]);
    }
}

За да използвате AreaCalculator класа, ще трябва да инстанциирате класа и да предадете масив от форми и да покажете изхода в долната част на страницата.

Ето пример с колекция от три фигури:

• кръг с радиус 2
• квадрат с дължина 5
• втори квадрат с дължина 6

$shapes = [
  new Circle(2),
  new Square(5),
  new Square(6),
];

$areas = new AreaCalculator($shapes);

echo $areas->output();

Проблемът с метода за извеждане е, че AreaCalculator управлява логиката за извеждане на данните.

Помислете за сценарий, при който изходът трябва да бъде преобразуван в друг формат като JSON.

Цялата логика ще бъде обработена от AreaCalculator класа. Това би нарушило принципа на единна отговорност.
AreaCalculator класа трябва да се занимава само със сумата от областите на предвидените форми. Не трябва да се интересува дали потребителят иска JSON или HTML.

За да се справи с това SumCalculatorOutputter , можете да създадете отделен клас и да използвате този нов клас за обработка на логиката, от която се нуждаете, за да изведете данните на потребителя:

class SumCalculatorOutputter
{
    protected $calculator;

    public function __constructor(AreaCalculator $calculator)
    {
        $this->calculator = $calculator;
    }

    public function JSON()
    {
        $data = [
          'sum' => $this->calculator->sum(),
      ];

        return json_encode($data);
    }

    public function HTML()
    {
        return implode('', [
          '',
              'Sum of the areas of provided shapes: ',
              $this->calculator->sum(),
          '',
      ]);
    }
}

SumCalculatorOutputter класа ще работи по следния начин:

$shapes = [
  new Circle(2),
  new Square(5),
  new Square(6),
];

$areas = new AreaCalculator($shapes);
$output = new SumCalculatorOutputter($areas);

echo $output->JSON();
echo $output->HTML();

Сега логиката, от която се нуждаете да изведете данните на потребителя, се обработва от SumCalculatorOutputter класа.

Това отговаря на принципа на единна отговорност.
Източник: https://www.digitalocean.com

Част 1 – SOLID: Първите 5 принципа на обектно ориентиран софтуерен дизайн, част: 1 Принцип на единна отговорност

Част 2 – SOLID: Първите 5 принципа на обектно ориентиран софтуерен дизайн, част: 2 Принцип отворено-затворен

Част 3 – SOLID: Първите 5 принципа на обектно ориентиран софтуерен дизайн, част: 3 Принцип на заместване на Лисков

Част 4 – SOLID: Първите 5 принципа на обектно ориентиран софтуерен дизайн, част: 4 Принцип за разделяне на интерфейсите – ISP

Част 5 – SOLID: Първите 5 принципа на обектно ориентиран софтуерен дизайн, част: 5 Принцип на обръщане на зависимостите – DIP

Ако желаете да свалите примери с правилен и грешен подход вижте тук: СВАЛИ