PHPTime

Принцип открытости/закрытости в PHP

Принцип открытости/закрытости (Open/Closed Principle, OCP) формулируется жестко: программные сущности должны быть открыты для расширения, но закрыты для модификации. На практике это значит, что добавление нового поведения не должно требовать переписывания уже работающего кода. В PHP 8.3–8.5 добиться этого помогают строгая типизация, интерфейсы, полиморфизм и композиция.

Зачем нужен OCP

Когда под каждое новое требование приходится вносить правки в существующие методы, растёт регрессия: чем больше точек изменения, тем выше риск задеть побочные сценарии. Правильно спроектированный модуль переиспользует готовую логику через контракты, а не через условные разветвления.

Код ниже показывает проблему. Отрисовка зависит от конкретных классов, и появление нового элемента вынуждает трогать метод render():

PHP
<?php

declare(strict_types=1);

namespace App\Renderer;

use InvalidArgumentException;

final class HtmlDiv
{
    public function __construct(
        private string $text,
        private ?string $id = null,
        private ?string $class = null
    ) {
        if ($text === '') {
            throw new InvalidArgumentException('Текст элемента не может быть пустым');
        }
    }

    public function renderDiv(): string
    {
        return sprintf(
            '<div%s%s>%s</div>',
            $this->id !== null ? ' id="' . $this->id . '"' : '',
            $this->class !== null ? ' class="' . $this->class . '"' : '',
            $this->text
        );
    }
}

final class HtmlParagraph
{
    public function __construct(
        private string $text,
        private ?string $id = null,
        private ?string $class = null
    ) {
        if ($text === '') {
            throw new InvalidArgumentException('Текст элемента не может быть пустым');
        }
    }

    public function renderParagraph(): string
    {
        return sprintf(
            '<p%s%s>%s</p>',
            $this->id !== null ? ' id="' . $this->id . '"' : '',
            $this->class !== null ? ' class="' . $this->class . '"' : '',
            $this->text
        );
    }
}

final class HtmlRenderer
{
    /** @param array<int, HtmlDiv|HtmlParagraph> $elements */
    public function __construct(private array $elements = [])
    {
    }

    public function addElement(HtmlDiv|HtmlParagraph $element): self
    {
        $this->elements[] = $element;
        return $this;
    }

    public function render(): string
    {
        $html = '';
        foreach ($this->elements as $element) {
            if ($element instanceof HtmlDiv) {
                $html .= $element->renderDiv();
            } elseif ($element instanceof HtmlParagraph) {
                $html .= $element->renderParagraph();
            }
        }
        return $html;
    }
}

Тип-объединение HtmlDiv|HtmlParagraph не спасает: интерфейс класса HtmlRenderer прибит к двум конкретным реализациям. Новый элемент — правки в сигнатуре, конфликт с принципом.

Интерфейс как точка открытости

Первый шаг к решению — вынести контракт, который описывает поведение без конкретики. Вместо надстройки с бесконечными if рендерер принимает любую реализацию:

PHP
<?php

declare(strict_types=1);

namespace App\Renderer\Contract;

interface HtmlElementInterface
{
    public function render(): string;
}

Общий код выносится в абстрактный класс. Это не новый элемент системы, а общий фундамент:

PHP
<?php

declare(strict_types=1);

namespace App\Renderer\Element;

use App\Renderer\Contract\HtmlElementInterface;
use InvalidArgumentException;

abstract class AbstractHtmlElement implements HtmlElementInterface
{
    public function __construct(
        protected string $text,
        protected ?string $id = null,
        protected ?string $class = null
    ) {
        if ($text === '') {
            throw new InvalidArgumentException('Текст элемента не может быть пустым');
        }
        if ($id !== null) {
            $this->validateAttribute($id);
        }
        if ($class !== null) {
            $this->validateAttribute($class);
        }
    }

    private function validateAttribute(string $value): void
    {
        if (preg_match('/^[a-z0-9_-]+$/', $value) !== 1) {
            throw new InvalidArgumentException('Некорректное значение атрибута');
        }
    }

    protected function attributes(): string
    {
        $html = '';
        if ($this->id !== null) {
            $html .= ' id="' . $this->id . '"';
        }
        if ($this->class !== null) {
            $html .= ' class="' . $this->class . '"';
        }
        return $html;
    }
}

Важно видеть разницу: базовый класс не является тем «ядром», которое нельзя трогать. Он содержит только общее, а конкретика живёт в финальных классах:

PHP
<?php

declare(strict_types=1);

namespace App\Renderer\Element;

final class HtmlDiv extends AbstractHtmlElement
{
    public function render(): string
    {
        return sprintf('<div%s>%s</div>', $this->attributes(), $this->text);
    }
}

final class HtmlParagraph extends AbstractHtmlElement
{
    public function render(): string
    {
        return sprintf('<p%s>%s</p>', $this->attributes(), $this->text);
    }
}

Теперь рендерер зависит от интерфейса, а не от существующих реализаций. Расширение достижимо добавлением нового класса, старый код остаётся на месте:

PHP
<?php

declare(strict_types=1);

namespace App\Renderer;

use App\Renderer\Contract\HtmlElementInterface;

final class HtmlRenderer
{
    /** @param array<int, HtmlElementInterface> $elements */
    public function __construct(private array $elements = [])
    {
    }

    public function addElement(HtmlElementInterface $element): self
    {
        $this->elements[] = $element;
        return $this;
    }

    public function render(): string
    {
        $html = '';
        foreach ($this->elements as $element) {
            $html .= $element->render();
        }
        return $html;
    }
}

В новых проектах для однотипных коллекций оправдан вариант с iterable или дженериками через docblock. Суть остаётся той же: зависимость от контракта, не от конкретики.

Наследование хуже композиции

Наследование выглядит как простой способ расширения, но закладывает хрупкую связь между базовым и дочерним классом. Изменение AbstractHtmlElement отражается на всей иерархии. Композиция оставляет базовый код изолированным, новая логика подключается снаружи.

Классический сценарий для композиции — стратегии. Допустим, есть заказ, и для разных клиентов действуют разные правила расчёта скидки. Наследование быстро породит разветвлённое дерево, а композиция делает поведение заменяемым:

PHP
<?php

declare(strict_types=1);

namespace App\Discount;

use App\Order;

interface DiscountStrategy
{
    public function calculate(Order $order): float;
}

final readonly class PersonalDiscount implements DiscountStrategy
{
    public function __construct(private float $percent)
    {
    }

    public function calculate(Order $order): float
    {
        return $order->total() * ($this->percent / 100);
    }
}

final readonly class PromoCodeDiscount implements DiscountStrategy
{
    public function __construct(private float $amount)
    {
    }

    public function calculate(Order $order): float
    {
        if ($this->amount >= $order->total()) {
            return $order->total();
        }
        return $this->amount;
    }
}

final class PriceCalculator
{
    public function __construct(private DiscountStrategy $discountStrategy)
    {
    }

    public function total(Order $order): float
    {
        $discount = $this->discountStrategy->calculate($order);
        return max(0.0, $order->total() - $discount);
    }
}

Новый тип скидки добавляется без модификации PriceCalculator. Менять конфигурацию поведения можно даже на рантайме через setter, не трогая бизнес-логику.

Классы-фабрики и enum

Если выбор стратегии должен быть явным, полезно использовать enum в связке с фабрикой. PHP 8.4 и 8.5 поддерживают богатые enum с методами, но не стоит зашивать поведение в значение — enum остаётся маркером, фабрика ответственна за создание объекта:

PHP
<?php

declare(strict_types=1);

namespace App\Payment;

use InvalidArgumentException;

enum PaymentMethod: string
{
    case Card = 'card';
    case Sbp = 'sbp';
    case Invoice = 'invoice';
}

interface PaymentGateway
{
    public function pay(float $amount): void;
}

final readonly class CardGateway implements PaymentGateway
{
    public function pay(float $amount): void
    {
        // Эквайринг
    }
}

final readonly class SbpGateway implements PaymentGateway
{
    public function pay(float $amount): void
    {
        // Платёж через СБП
    }
}

final class PaymentGatewayFactory
{
    public function make(PaymentMethod $method): PaymentGateway
    {
        return match ($method) {
            PaymentMethod::Card => new CardGateway(),
            PaymentMethod::Sbp => new SbpGateway(),
            PaymentMethod::Invoice => throw new InvalidArgumentException('Счёт не требует онлайн-шлюза'),
        };
    }
}

Фабрика остаётся единой точкой создания, но появление нового шлюза не затрагивает код, который использует интерфейс PaymentGateway. В более сложных приложениях фабрику можно заменить контейнером, который резолвит реализацию по конфигурации.

Границы закрытости: когда OCP избыточен

Абсолютная «закрытость навсегда» в реальном коде не встречается. Если вы делаете внутренний модуль, который будет использовать один потребитель, строить абстракции на каждый чих избыточно. Показатель необходимости OCP — появление условных конструкций, повторяющихся проверок instanceof, длинных switch или match с бизнес-логикой, которая просится в отдельные классы.

Также неверно делать открытыми нестабильные части ядра. Если интерфейс меняется каждый спринт, замораживание контракта приведёт к обратному эффекту: обходы и костыли вокруг неудобного API. Закрытым должно быть то, что уже застабилизировалось.

Ошибка с type-проверками внутри сервиса

Даже после появления интерфейса разработчики иногда продолжают ветвить по типу внутри логики:

PHP
if ($element instanceof HtmlDiv) {
    $element->render();
} elseif ($element instanceof HtmlParagraph) {
    $element->render();
} elseif ($element instanceof HtmlImage) {
    $element->render();
}

Каждая ветка вызывает один и тот же метод. Это сигнал, что иерархия навязана искусственно. Работайте через HtmlElementInterface, а специфика остаётся внутри самой реализации.

Типизация и строгий режим

declare(strict_types=1) дисциплинирует API: контракт, описанный в сигнатурах, не размывается неявным приведением типов. Это не панацея, но в связке с интерфейсами резко снижает количество ошибок из-за «почти подходящего» аргумента. Для пограничных модулей полезна возможность PHP 8.4 использовать асимметричную видимость свойств: данные чаще доступны только на чтение, а изменение — через методы.

Чек-лист

  • Выносите контракт в интерфейс, если модуль потребляет более одной реализации поведения.
  • Заменяйте instanceof, switch и цепочки elseif полиморфизмом.
  • Предпочитайте композицию наследованию для изменяемого поведения.
  • Изолируйте фабрики и конфигурацию от бизнес-логики.
  • Используйте readonly-классы и строгие типы для устойчивого API.
  • Не спешите абстрагировать код, который стабилен и имеет одного потребителя.
  • Вводите интерфейсы по мере появления второй реализации, а не «на будущее».

Частые вопросы

Чем наследование хуже композиции при расширении кода?

Наследование связывает дочерний класс с внутренней логикой базового: изменения родительского типа могут затронуть всю иерархию. Композиция заменяет поведение снаружи через интерфейс, не требуя изменения существующего класса.

Когда OCP нарушается чаще всего?

Когда в методе появляются проверки instanceof, switch по типу объекта или регулярные if с вызовом похожих методов. Это признак, что вместо общего контракта используются конкретные классы.

Всегда ли нужно выносить интерфейс перед расширением?

Нет. Если реализация существует в единственном экземпляре и сценарий стабилен, интерфейс добавляет лишнюю абстракцию. Контракт полезен, когда появляется вторая реализация или потребители из разных слоёв приложения.

Помогает ли строгая типизация соблюдению OCP?

Косвенно. declare(strict_types=1) и точные сигнатуры фиксируют контракт, снижают неоднозначность и упрощают защиту от случайного изменения API. Но сам по себе строгий режим не компенсирует плохую архитектуру.

Справка по теме

Ещё в разделе «Возможности PHP»

Релиз PHP 7: что изменилось и как перейти на PHP 8

Что изменилось в PHP 7: производительность, скалярные типы, типы возврата, операторы ?? и <=>. План перехода с PHP 7.x на PHP 8.3–8.5 с проверкой совместимости.

7 мин

Возможности PHP 5.6 и их развитие в PHP 8.x

Разбираем ключевые возможности PHP 5.6: variadic-функции, оператор **, импорт функций и константные выражения. Как это работает в PHP 8.3–8.5.

6 мин

Почему некоторые PHP-разработчики предпочитают статические API

Разбираем, почему статические методы до сих пор популярны в PHP, чем они удобны и опасны, и как фасады Laravel совмещают статику с DI.

6 мин

Трейты в PHP и behaviors в Yii 2: что выбрать для модели

Сравниваем трейты PHP и behaviors Yii 2 на примерах PHP 8.3–8.5: абстрактные методы, свойства, конфликты имён, события модели и критерии выбора.

6 мин