К содержимому
Войти

PHP Road Map

🧱 SOLID на примерах PHP

SOLID — пять правил о том, как раскладывать код по классам, чтобы новая фича не ломала три старых. На собеседовании PHP-разработчика их спрашивают почти всегда, и ответ «S значит single responsibility, O значит open-closed» интервьюера не устраивает: он ждёт пример из твоего кода, где принцип нарушен и что из этого вышло. В срезе вакансий на hh за неделю 2026-W46 SOLID прямо упомянут в 6% вакансий мидла и 10% сеньора

🧠 Как это устроено

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

БукваПринципЧто ломается без негоТипичный симптом в PHP
SSingle ResponsibilityПравка одного требования задевает чужой кодКонтроллер на 300 строк
OOpen/ClosedКаждый новый вариант — правка старого классаmatch по типу платежа в пяти местах
LLiskov SubstitutionНаследник ломает код, который работал с родителемsave(), который бросает исключение
IInterface SegregationКлиент зависит от методов, которые не вызываетИнтерфейс репозитория на 12 методов
DDependency InversionБизнес-логику не отделить от инфраструктурыnew SmtpMailer() в конструкторе

Принципы связаны между собой. Нарушение LSP часто лечится через ISP, OCP без DIP не работает, а SRP задаёт границы, внутри которых работают остальные четыре. Дальше каждый принцип разобран на коде из обычного проекта на Laravel или Symfony

🛠️ Пять принципов на одном проекте

S — одна причина для изменений

Роберт Мартин формулирует SRP не как «класс делает одну вещь», а как «у модуля одна причина меняться». Причины приходят от людей: маркетинг меняет скидки, бухгалтерия меняет формат счёта, DevOps переносит почтовый сервер. Если правки от разных людей попадают в один класс, они мешают друг другу

Толстый контроллер собирает все причины сразу:

final class OrderController
{
    public function store(Request $request): JsonResponse
    {
        $data = $request->validate(['items' => 'required|array']);

        $total = 0;
        foreach ($data['items'] as $item) {
            $total += $item['price'] * $item['qty'];
        }
        if ($request->user()->isVip()) {
            $total = (int) round($total * 0.9);
        }

        $order = Order::create(['user_id' => $request->user()->id, 'total' => $total]);
        Mail::to($request->user())->send(new OrderCreated($order));

        return response()->json($order, 201);
    }
}

Здесь четыре причины меняться: правила валидации, расчёт скидки, схема таблицы, шаблон письма. Чтобы протестировать скидку VIP, приходится поднимать HTTP-запрос, базу и почту. А когда тот же заказ начнут создавать из консольной команды или очереди, расчёт скопируют, и через месяц две копии разойдутся

После разделения контроллер только переводит HTTP на язык приложения:

final class OrderController
{
    public function __construct(private PlaceOrder $placeOrder) {}

    public function store(StoreOrderRequest $request): JsonResponse
    {
        $order = ($this->placeOrder)($request->user(), $request->items());

        return response()->json($order, 201);
    }
}

Валидация ушла в StoreOrderRequest, расчёт цены — в отдельный калькулятор, письмо отправляет слушатель события OrderPlaced. PlaceOrder вызывается одинаково из контроллера, команды и задачи в очереди. Где живёт бизнес-логика и что такое сервисный слой — на странице про слои приложения

O — новое добавляют, старое не трогают

Открыт для расширения, закрыт для изменения: новый вариант поведения появляется новым классом, а не новой веткой в старом. Классическое нарушение — сервис оплаты:

final class PaymentService
{
    public function pay(Order $order, string $method): void
    {
        match ($method) {
            'card' => $this->cardGateway->charge($order->total, $order->cardToken),
            'sbp' => $this->sbp->createQr($order->id, $order->total),
            'invoice' => $this->mailer->sendInvoice($order),
            default => throw new InvalidArgumentException("Unknown method $method"),
        };
    }
}

Один match сам по себе не беда. Беда начинается, когда такой же match по $method появляется в расчёте комиссии, возврате и тексте чека. Добавить рассрочку — значит найти все четыре места и не забыть ни одно. Решение — интерфейс и по классу на способ оплаты:

interface PaymentMethod
{
    public function supports(string $method): bool;
    public function pay(Order $order): void;
}

final class PaymentService
{
    /** @param iterable<PaymentMethod> $methods */
    public function __construct(private iterable $methods) {}

    public function pay(Order $order, string $method): void
    {
        foreach ($this->methods as $m) {
            if ($m->supports($method)) {
                $m->pay($order);
                return;
            }
        }
        throw new InvalidArgumentException("Unknown method $method");
    }
}

Рассрочка теперь — новый класс InstallmentPayment, а PaymentService и его тесты не меняются. Список реализаций собирает контейнер по тегу: в Laravel это tag() и tagged() или атрибут #[Tag], в Symfony — теги сервисов, подробнее на страницах модулей Laravel и Symfony. Сам приём называется «стратегия», он разобран на странице про паттерны

L — наследник не удивляет

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

Квадрат и прямоугольник. Математически квадрат — частный случай прямоугольника, но как объект он ведёт себя иначе. Проверено на PHP 8.4:

class Rectangle
{
    public function __construct(protected int $width, protected int $height) {}

    public function setWidth(int $w): void { $this->width = $w; }
    public function setHeight(int $h): void { $this->height = $h; }
    public function area(): int { return $this->width * $this->height; }
}

class Square extends Rectangle
{
    public function setWidth(int $w): void { $this->width = $this->height = $w; }
    public function setHeight(int $h): void { $this->width = $this->height = $h; }
}

function stretch(Rectangle $r): int
{
    $r->setWidth(5);
    $r->setHeight(4);
    return $r->area(); // автор функции ждёт 20
}

echo stretch(new Rectangle(1, 1)), "\n"; // 20
echo stretch(new Square(1, 1)), "\n";    // 16

Типы совпали, PHP не возразил, а результат неверный. Пример из жизни ближе — репозиторий, который умеет только читать:

final class CachedUserRepository implements UserRepository
{
    public function find(int $id): ?User { /* читает из Redis */ }

    public function save(User $user): void
    {
        throw new LogicException('Read-only repository');
    }
}

Любой код, который получил UserRepository и вызвал save(), падает с Uncaught LogicException уже в рантайме. Интерфейс обещал запись, реализация обещание нарушила. Лечится это не try/catch вокруг save(), а честным интерфейсом: читающий репозиторий реализует только чтение, об этом следующий принцип

LSP и система типов PHP

Часть LSP PHP проверяет сам. С PHP 7.4 сигнатуры наследника подчиняются двум правилам:

  • ковариантность возврата: наследник может вернуть более узкий тип. Родитель обещал Animal, наследник отдаёт Dog — это разрешено, потому что Dog тоже Animal
  • контравариантность параметров: наследник может принять более широкий тип. Родитель принимал Dog, наследник принимает любой Animal — разрешено, старые вызовы продолжают работать

Наоборот нельзя. Проверено на PHP 8.4:

interface Animal {}
class Dog implements Animal {}

interface Feeder { public function feed(Animal $a): void; }

class DogFeeder implements Feeder
{
    public function feed(Dog $d): void {} // сузили параметр
}
// Fatal error: Declaration of DogFeeder::feed(Dog $d): void
// must be compatible with Feeder::feed(Animal $a): void

Ошибка возникает при объявлении класса, до первой выполненной строки скрипта. Так же PHP падает, если наследник расширил тип возврата (Animal вместо Dog) или добавил обязательный параметр. Новый параметр со значением по умолчанию допустим, int|string вместо int тоже. Типы свойств инвариантны: наследник не может их менять, исключение с 8.4 — абстрактные свойства только с get (тогда можно сузить) или только с set (тогда можно расширить)

Исключения PHP не проверяет. В отличие от Java, они не входят в сигнатуру метода, @throws в PHPDoc читает только статический анализатор. Поэтому CachedUserRepository выше проходит проверку типов, хотя ломает контракт. То же с предусловиями: родитель принимал любую сумму, а наследник бросает исключение на сумме больше 100 000 — компилятор промолчит, поймают только тесты и ревью

I — интерфейс под клиента

Клиент не должен зависеть от методов, которые не использует. Жирный интерфейс обычно растёт из репозитория:

interface UserRepository
{
    public function find(int $id): ?User;
    public function findByEmail(string $email): ?User;
    public function paginate(int $page, int $perPage): array;
    public function save(User $user): void;
    public function delete(User $user): void;
    public function exportToCsv(string $path): void;
    public function searchFullText(string $query): array;
}

Ночной отчёт вызывает только paginate, а тестовый двойник для него должен реализовать все семь методов. Поиск переехал в Elasticsearch — и его реализация обязана уметь save и delete, иначе получится тот самый LogicException из примера про LSP

Интерфейсы режут по тому, кто их вызывает: UserReader с find и findByEmail, UserWriter с save и delete, UserSearch отдельно. Один класс на Doctrine может реализовать все три, а кэширующий — только UserReader. Экспорт в CSV в репозиторий вообще не входит, это отдельный сервис

D — зависимость от абстракции

Модули верхнего уровня не зависят от модулей нижнего уровня, оба зависят от абстракций. Верхний уровень — бизнес-правила: выставить счёт, начислить бонус. Нижний — SMTP, PDF-библиотека, конкретная база. Нарушение выглядит так:

final class InvoiceService
{
    private SmtpMailer $mailer;

    public function __construct()
    {
        $this->mailer = new SmtpMailer('smtp.example.com', 587);
    }
}

InvoiceService знает адрес почтового сервера, в тесте отправит настоящее письмо, а переезд на почтовый API потребует правки бизнес-кода. После инверсии сервис получает интерфейс:

interface InvoiceMailer
{
    public function send(Invoice $invoice, Email $to): void;
}

final class InvoiceService
{
    public function __construct(private InvoiceMailer $mailer) {}
}

Ключевое в DIP — кто владеет интерфейсом. InvoiceMailer лежит рядом с InvoiceService и описан его словами: счёт и адрес, без SMTP-портов. Реализация SmtpInvoiceMailer живёт в инфраструктуре и зависит от этого интерфейса. Стрелка зависимости развернулась: инфраструктура подстраивается под бизнес, а не наоборот

Как объект попадает в конструктор (через контейнер, autowiring или руками в фабрике), решает уже Dependency Injection. Этот механизм разобран на странице про DI и контейнер

🧭 Когда принцип вредит

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

  • Интерфейс с одной реализацией навсегда. UserServiceInterface и единственный UserService, которого никто не подменяет, — лишний файл и лишний прыжок в IDE. Интерфейс окупается на границе с внешним миром (почта, платёжный шлюз, API партнёра), когда реализаций несколько или когда нужен двойник в тестах
  • OCP заранее. Стратегия на два способа оплаты, которые не менялись три года, хуже честного match. Рабочее правило — абстракция появляется на третьем варианте, когда уже видно, что именно меняется
  • SRP до атомов. Пятнадцать классов по одному методу, которые всегда меняются вместе, — это одна ответственность, размазанная по папке. Причина меняться у них общая, значит и класс должен быть один
  • YAGNI. «Вдруг поменяем базу» — частый аргумент за репозиторий над Eloquent. Базу меняют редко, а слой поверх ORM пишут и поддерживают каждый день. Абстракция под гипотетическое требование обычно угадывает его неправильно

Фреймворки тоже нарушают принципы сознательно: модель Eloquent и хранит данные, и сама ходит в базу, зато CRUD пишется за минуты. Где этот компромисс перестаёт окупаться, разобрано на странице про слои приложения

🗺️ GRASP коротко

GRASP — девять принципов распределения обязанностей между классами из книги Крейга Лармана «Applying UML and Patterns». SOLID говорит, каким должен быть класс, GRASP — какому классу отдать новую обязанность. На собеседовании хватает четырёх:

ПринципВопрос, на который отвечаетПример в PHP
Information ExpertКому дать задачу? Тому, у кого есть данные для неё$order->total() считает сам заказ по своим строкам, а не сервис, который вытаскивает из него массив
ControllerКто первым принимает системное событие?PlaceOrder — объект сценария. HTTP-контроллер, команда и задача очереди только передают ему вызов
Low CouplingКак уменьшить зависимости?InvoiceService знает интерфейс InvoiceMailer, а не SMTP-клиент
High CohesionКак держать класс сфокусированным?В PriceCalculator только расчёт цены, без отправки писем и логов в файл

Controller из GRASP и контроллер из MVC — разные вещи. GRASP называет так объект, который представляет сценарий («оформить заказ») и делегирует работу. В PHP-проекте эту роль обычно играет сервис приложения, а контроллер фреймворка остаётся тонким адаптером к HTTP

Остальные пять перекликаются с SOLID:

  • Polymorphism: вместо match по типу каждый вариант становится своим классом
  • Protected Variations: место, которое будет меняться, закрывают стабильным интерфейсом, почти OCP
  • Pure Fabrication: класс, которого нет в предметной области, но он разгружает доменные объекты, как репозиторий
  • Indirection: посредник между двумя классами, например интерфейс или адаптер
  • Creator: объект создаёт тот, кто его содержит или использует

⚠️ Где ошибаются

  • Пересказывают аббревиатуру без примера. «SRP — класс отвечает за одну вещь» звучит как заученное. Интервьюер сразу спросит, что такое «одна вещь». Рассказывай через причину меняться и конкретный класс, который ты разделял
  • Путают DIP и DI. DIP говорит, кто от кого зависит и кто владеет интерфейсом. DI — способ передать зависимость снаружи. Можно внедрять через конструктор конкретный SmtpMailer: это DI без DIP
  • Считают, что LSP — про сигнатуры. PHP проверит типы, но не поведение. Square, который меняет обе стороны, и save() с исключением проходят проверку типов и ломают код в рантайме
  • Лечат LSP проверкой типа. if ($repo instanceof CachedUserRepository) перед save() — признак того, что иерархия неверная. Каждый такой instanceof нарушает и LSP, и OCP: новый наследник требует новой проверки

🎯 Вопросы с собеседований

Расскажи SOLID на примере из своего кода

Сильный ответ — одна история, а не пять определений. Например: был контроллер оформления заказа на 300 строк, где считалась скидка и отправлялось письмо, и правка скидки для маркетинга задела письма — это SRP. Расчёт вынесли в калькулятор, письмо в слушатель события, сценарий в PlaceOrder. Способы оплаты разложили по классам с общим интерфейсом, чтобы новый способ добавлялся без правки сервиса, — это OCP. Почтовый клиент сервис получает через интерфейс, который описан словами бизнеса, — это DIP. Дальше стоит сказать, где принцип не применял сознательно и почему

Что такое GRASP?

Девять принципов Крейга Лармана о том, какому классу отдать обязанность. Information Expert — тому, у кого есть нужные данные: сумму заказа считает заказ. Controller — объект сценария, который принимает системное событие и делегирует работу; это не MVC-контроллер, в PHP его роль играет сервис приложения. Low Coupling и High Cohesion — меньше зависимостей между классами и больше связи внутри класса. Остальные пять (Creator, Polymorphism, Pure Fabrication, Indirection и Protected Variations) во многом пересекаются с SOLID

Чем DIP отличается от DI?

DIP — принцип проектирования: бизнес-код и инфраструктура зависят от абстракции, а абстракцией владеет бизнес-код. DI — техника: объект получает зависимости снаружи, через конструктор или сеттер, а не создаёт их через new. DI обычно используют, чтобы выполнить DIP, но одно без другого возможно: внедрить через конструктор конкретный SmtpMailer — это DI без инверсии. Контейнер — лишь инструмент, который автоматизирует DI

Как LSP связан с типами возврата и исключениями в PHP?

С PHP 7.4 наследник может сузить тип возврата (ковариантность) и расширить тип параметра (контравариантность), а обратное даёт Fatal error: Declaration of ... must be compatible with ... прямо при объявлении класса. Это механическая часть LSP: старые вызовы не ломаются по типам. Исключения в сигнатуру не входят, PHP их не проверяет, и наследник, бросающий LogicException там, где родитель работал, нарушает LSP незаметно для компилятора. Такие нарушения ловят тесты на контракт, которые прогоняют одинаково для всех реализаций интерфейса

Когда следовать SOLID не нужно?

Когда абстракция не решает существующую проблему. Интерфейс с одной реализацией без подмены в тестах, стратегия на два стабильных варианта, слой репозиториев над Eloquent «на случай смены базы» добавляют код и прыжки по файлам. Я ввожу абстракцию, когда появился второй-третий вариант или граница с внешней системой, где нужен двойник в тестах. Короткий скрипт или прототип можно писать без оглядки на SOLID, если он не станет основой продукта

📚 Что почитать