Принцип открытости/закрытости в PHP
Принцип открытости/закрытости (Open/Closed Principle, OCP) формулируется жестко: программные сущности должны быть открыты для расширения, но закрыты для модификации. На практике это значит, что добавление нового поведения не должно требовать переписывания уже работающего кода. В PHP 8.3–8.5 добиться этого помогают строгая типизация, интерфейсы, полиморфизм и композиция.
Зачем нужен OCP
Когда под каждое новое требование приходится вносить правки в существующие методы, растёт регрессия: чем больше точек изменения, тем выше риск задеть побочные сценарии. Правильно спроектированный модуль переиспользует готовую логику через контракты, а не через условные разветвления.
Код ниже показывает проблему. Отрисовка зависит от конкретных классов, и появление нового элемента вынуждает трогать метод render():
<?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
declare(strict_types=1);
namespace App\Renderer\Contract;
interface HtmlElementInterface
{
public function render(): string;
}Общий код выносится в абстрактный класс. Это не новый элемент системы, а общий фундамент:
<?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
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
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
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
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-проверками внутри сервиса
Даже после появления интерфейса разработчики иногда продолжают ветвить по типу внутри логики:
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. Но сам по себе строгий режим не компенсирует плохую архитектуру.