← Ко всем статьям
Позиционированиеmiddleархитектура

Почему IT Smetanin не для новичков: что получит middle в проде

Администратор18 ноября 2026 г.1 мин чтения23 просмотров

Открываю вчерашний PR. В контроллере — проверка статуса заказа, проверка прав пользователя и запись в базу. Всё в одном методе.

Код работает. Тест на основной сценарий проходит. Но я оставляю комментарий не к строке, а к самому решению:

Кто отвечает за то, что заказу разрешено перейти именно в этот статус?

Автор исправляет метод. Но вопрос остаётся: если завтра тот же переход понадобится мобильному приложению, админке или фоновой задаче, где разработчик найдёт правило? В контроллере? Скопирует проверку? Напишет ещё одну?

Это не лень. Часто разработчик просто решает текущую задачу и не видит, сколько других сценариев зависят от того же правила.

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

Одна проверка — несколько точек входа

У заказа есть статус. Допустимые переходы зависят от его текущего состояния: нельзя отправить неоплаченный заказ, нельзя отменить завершённый.

Пока заказом управляет один экран, проверку легко оставить рядом с обработчиком запроса. Но у живого продукта обычно больше одного входа.

Сайт ─────┐
Мобильное ├──> проверки статуса ──> База
Админка ──┤
Фон ──────┘

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

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

Тогда я и задал себе вопрос: если правило изменится, сколько мест придётся исправить?

Правило разошлось.

Контроллер отвечает за запрос, а не за жизненный цикл заказа

Контроллеру есть чем заниматься: принять HTTP-запрос, проверить формат входных данных, вызвать сценарий и вернуть ответ. Ему не обязательно знать все условия, при которых заказ меняет статус.

На ревью я разделяю две вещи, которые часто смешивают:

  • Права пользователя: имеет ли этот человек право выполнить действие?
  • Правило предметной области: допустим ли такой переход для самого заказа?

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

Например, проверка перехода может выглядеть так:

php
if (! $order->canBeCancelled()) {
    throw new InvalidOrderTransition();
}

Сам фрагмент ничего не решает, если canBeCancelled() проверяет только удобный для текущего экрана сценарий. Метод должен учитывать состояние заказа, а не то, откуда пришёл запрос.

Я не предлагаю создавать сервис, интерфейс и фабрику для каждого условия. Иногда дополнительный слой усложнит небольшой модуль сильнее, чем поможет. Архитектура — не соревнование по количеству классов.

Перед выделением отдельной ответственности я смотрю на три обстоятельства:

  • правило используют несколько независимых сценариев;
  • условия часто меняются;
  • ошибка или расхождение между проверками дорого обходится продукту.

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

Не паттерн определяет границу. Её определяют связи и цена изменения.

Отмена заказа — это не только проверка статуса

Допустим, в задаче написано: «Добавить отмену заказа». Разработчик проверяет статус, добавляет кнопку и сохраняет новое значение. Основной сценарий работает.

Но в проде у этой операции есть продолжение.

Что произойдёт, если пользователь дважды нажмёт «Отменить»? Что вернёт API при повторном запросе? Может ли в это же время фоновая задача перевести заказ в другой статус? Что случится, если два запроса одновременно прочитают старое состояние?

Последний случай легко пропустить в обычном тесте.

Представим, что заказ оплачен. Почти одновременно приходят два запроса: один отменяет заказ, другой начинает его отправку. Оба процесса читают статус «Оплачен» и проверяют переход по одному и тому же исходному состоянию. Если система не защищает изменение от гонки, результат может зависеть от порядка записи.

Здесь уже недостаточно вынести canBeCancelled() в отдельный метод. Нужно решить, как система защищает переход:

  • выполняет проверку и изменение в одной транзакции;
  • блокирует запись на время операции, если это оправдано;
  • проверяет версию или исходное состояние при сохранении;
  • определяет, что делать со вторым запросом, если первый уже изменил заказ.

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

Есть ещё один контракт — ответ API. Повторная отмена может быть идемпотентной операцией, а может возвращать ошибку о недопустимом переходе. Оба варианта возможны, но клиент должен получать предсказуемый результат. Иначе мобильное приложение, сайт и админка начнут по-разному обрабатывать одну ситуацию.

Вот почему middle должен видеть не только условие в if, но и весь сценарий: от входного запроса до результата, который увидит пользователь.

Как обсуждать решение на ревью без вкусовщины

В команде может быть несколько сильных разработчиков, но каждый по-своему понимает, где должна находиться ответственность.

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

Само по себе ни одно из этих предложений не доказывает, что решение подходит задаче.

Я возвращаю обсуждение к последствиям:

  • Какое ограничение системы мы защищаем?
  • Что изменится, если появится новый сценарий?
  • Как проверить поведение без HTTP-запроса?
  • Что произойдёт при повторном или параллельном запросе?
  • Какой вариант будет проще изменить, когда появится новое требование?

Так команда обсуждает не любимые инструменты, а поведение системы. Иногда после такого разговора становится понятно, что нужен отдельный сценарий приложения. Иногда достаточно метода модели. Бывает и так, что предложенный раздутый класс ничего не упрощает — его лучше не создавать.

Общий язык не отменяет разногласий. Он позволяет проверить аргументы.

От принципов к работе с модулем

В IT Smetanin мы выстраиваем обучение от принципов к более крупным архитектурным решениям:

SOLID ──> Паттерны ──> Антипаттерны ──> MCDDP

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

MCDDP расширяет взгляд до модуля целиком: его данных, связей, сценариев и взаимодействия с остальной системой.

Я не хочу, чтобы после SOLID разработчик просто начал создавать больше интерфейсов и маленьких классов. Это легко превратить в новый ритуал: формально всё разделили, а менять систему стало труднее.

Паттерн тоже не должен становиться ответом до того, как сформулирована проблема. Сначала нужно понять, что меняется, кто зависит от этого изменения и какие ограничения система обязана сохранить. Только потом выбирать инструмент.

Практика: не переписывать весь репозиторий

Возьмите один модуль, с которым уже работаете. Например, заказы.

Не нужно сразу переносить все классы, вводить новые слои и менять структуру проекта. Выберите одно изменение, которое действительно предстоит сделать, и проследите его последствия.

Уровень Что проверить
Класс Не смешивает ли он несколько причин для изменения
Зависимости Не знает ли один компонент слишком много о других
Сценарий Обрабатывает ли он повторные и недопустимые действия
Модуль Понятно ли, какие правила он защищает и какие сценарии их используют
Границы системы Не нарушает ли изменение контракт с другими частями приложения

После этого сформулируйте решение словами: что вы меняете, почему ответственность находится именно здесь и какие риски закрываете.

Если после изменений стало больше классов — это ещё не результат. Если вы можете объяснить устройство модуля, показать ограничения и проверить поведение на важных сценариях, у решения есть инженерное обоснование.

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

С чего начать

Откройте сегодня один модуль, который часто меняется. Выберите одно правило и за 15–20 минут проследите, какие сценарии от него зависят, что может нарушить его работу и где придётся менять код при следующем требовании.

Пока ничего не переписывайте. Сначала найдите место, где решение перестаёт быть очевидным. Именно там стоит разбираться с ответственностью, зависимостями и компромиссами.

Сначала ясная граница. Потом рефакторинг.

Проектная работа

Нужна помощь с архитектурой?

Расскажите о задаче — предложу реалистичный план по срокам и стеку.

Поделиться

MAX

Похожие статьи