Содержание статьи
- 1. Открытые ошибки — накопленный технический долг
- 2. UnitOfWork — класс, который знает слишком много
- 3. Политика Pull Requests: когда осторожность превращается в препятствие
- 4. Производительность: цена универсальной архитектуры
- 5. Слишком высокая связность компонентов
- 6. Second-Level Cache: сложная подсистема с высокой ценой ошибки
- 7. Поддержка множества СУБД — универсальность, за которую платят все
- 8. Главная проблема — отсутствие готовности к фундаментальным изменениям
- 9. Почему Doctrine — не Symfony, Composer или FrankenPHP
- 10. Doctrine популярна не потому, что идеальна, а потому, что её трудно заменить
- 11. Что действительно необходимо изменить
- Заключение. Популярность — не архитектурное достижение
- Материалы для проверки
Doctrine ORM — один из фундаментальных компонентов современной PHP-экосистемы. На ней построены тысячи приложений, она глубоко интегрирована с Symfony, хорошо документирована и обладает огромной накопленной экспертизой.
Но популярность программного обеспечения не равнозначна его техническому совершенству.
Doctrine ORM сегодня — пример библиотеки, в которой исторические архитектурные решения, сложность поддержки и консервативная модель развития постепенно превратились в ограничения для дальнейшего прогресса.
И самая большая проблема даже не в производительности, огромном UnitOfWork или накопленных ошибках.
1. Открытые ошибки — накопленный технический долг
В репозитории Doctrine ORM есть открытые issues, отмеченные как ошибки. Их точное число зависит от даты проверки и используемых фильтров GitHub, поэтому фиксированную цифру здесь не приводим.
Само по себе количество открытых ошибок не доказывает низкого качества библиотеки. У зрелого проекта с большой аудиторией неизбежно появляются многочисленные отчёты о дефектах.
Гораздо важнее другие вопросы:
- Сколько ошибок остаются открытыми годами?
- Сколько из них затрагивают корректность persistence и hydration?
- Сколько ошибок воспроизводятся, но не получают исправлений?
- Как часто исправление блокируется опасениями нарушить историческое поведение?
- Сколько проблем фактически становятся частью неофициального контракта библиотеки?
ORM — не обычный вспомогательный пакет. Это инфраструктура, отвечающая за сохранность и согласованность данных.
Ошибка в сериализаторе может привести к некорректному ответу API. Ошибка в ORM способна привести к незаметно пропущенному UPDATE, неправильному удалению связанной сущности или нарушению состояния Identity Map.
Поэтому качество ORM следует оценивать не только по количеству тестов и релизов, но и по способности проекта систематически устранять известные дефекты.
Динамический список отчётов доступен в трекере Doctrine ORM. Открытая issue ещё не равна подтверждённому дефекту; длительность обсуждения сама по себе не устанавливает причину задержки исправления.
2. UnitOfWork — класс, который знает слишком много
UnitOfWork — центральный механизм Doctrine ORM.
Он отвечает за отслеживание изменений сущностей, Identity Map, вычисление changesets, каскадные операции, порядок записи данных, управление коллекциями, lifecycle events и взаимодействие с persisters.
Проблема не в том, что этот компонент сложный. Unit of Work по определению является сложным алгоритмом.
Проблема в том, что значительная часть этой сложности исторически сосредоточена внутри одного класса, насчитывающего тысячи строк.
В результате UnitOfWork одновременно выступает:
- координатором транзакций;
- хранилищем состояния;
- механизмом dirty checking;
- планировщиком операций;
- обработчиком графа ассоциаций;
- участником hydration;
- диспетчером событий;
- посредником между persisters и EntityManager.
Такое объединение обязанностей создаёт высокую стоимость любого изменения.
Оптимизация сравнения скалярных полей может затронуть ассоциации. Изменение порядка INSERT способно повлиять на lifecycle events. Исправление lazy loading требует понимания внутренних структур состояния.
В итоге даже локальное улучшение превращается в задачу, требующую изучения значительной части ORM.
Современная архитектура могла бы разделять эти обязанности между специализированными компонентами, сохраняя UnitOfWork координатором.
При этом речь не о механическом разбиении класса на десятки файлов. Перенос методов без изменения зависимостей ничего не решает.
Проверить концентрацию обязанностей можно в исходном UnitOfWork версии 3.7.1. Поведение Identity Map и вычисления изменений описано в документации внутренних механизмов Doctrine. Схема ниже показывает области ответственности, а не точный граф вызовов конкретного релиза.
3. Политика Pull Requests: когда осторожность превращается в препятствие
Doctrine поддерживается ограниченным количеством людей, и осторожность сопровождающих проект понятна.
Любое изменение ORM потенциально затрагивает тысячи приложений. Maintainers обязаны учитывать обратную совместимость, нестандартные mappings, пользовательские расширения и поведение, на которое уже полагаются разработчики.
Но у такого подхода есть обратная сторона.
Когда для сравнительно небольшого архитектурного улучшения требуется длительное обсуждение, когда новые внутренние абстракции воспринимаются прежде всего как риск, а изменения откладываются из-за необходимости сохранить исторические особенности реализации, развитие замедляется.
Возникает парадокс:
Это замкнутый круг.
Особенно болезненно он проявляется в работе с внешними contributors. Разработчик может потратить дни на изучение внутренних механизмов, подготовить тесты, бенчмарки и реализацию, но так и не получить понятного решения относительно предложенного подхода.
Здесь важно различать обоснованный отказ и отсутствие предсказуемого процесса принятия решений.
Не каждый PR должен быть принят. Однако проекту нужны ясные архитектурные ориентиры, понятные критерии оценки performance PR и своевременная обратная связь.
Иначе сообщество постепенно перестаёт предлагать серьёзные изменения, ограничиваясь небольшими исправлениями.
4. Производительность: цена универсальной архитектуры
Doctrine ORM часто критикуют за производительность. Но проблема не сводится к тому, что ORM медленнее прямого SQL.
Это ожидаемо: ORM создаёт объекты, отслеживает их состояние, управляет связями и предоставляет абстракции поверх базы данных.
Вопрос заключается в другом:
Рассмотрим типичный цикл:
- DBAL получает строки результата.
- ORM преобразует значения.
- Hydrator создаёт или находит сущности.
- Identity Map обеспечивает идентичность объектов.
- Формируются snapshots.
- При
flush()выполняется dirty checking. - Вычисляются changesets.
- Формируются и выполняются SQL-операции.
Каждый этап имеет собственную стоимость.
При работе с десятками сущностей она может быть незаметной. При обработке десятков или сотен тысяч объектов накладные расходы становятся существенными.
Dirty checking
При deferred implicit change tracking ORM должна проверить управляемые сущности на изменения.
Даже если приложение ничего не изменило, системе приходится обходить объекты и сравнивать их состояние со snapshots.
Стоимость такого обхода растёт вместе с количеством сущностей и полей.
Особенно важно оптимизировать наиболее распространённый сценарий — когда большинство сущностей не изменилось.
Это относится к политике DEFERRED_IMPLICIT. В официальной документации также описана DEFERRED_EXPLICIT: проверяются явно отмеченные сущности и соответствующие каскады. Read-only сущности исключаются из вычисления изменений. Эти механизмы уменьшают объём работы, но требуют учитывать их семантику в приложении.
Hydration
Hydration также создаёт значительные накладные расходы: reflection, преобразование типов, проверка Identity Map, обработка ассоциаций, snapshots и lazy loading.
При этом оптимизация отдельных участков не всегда приводит к заметному ускорению полного запроса.
Ускорение hydration на 30% не означает ускорение приложения на 30%, если большую часть времени занимает SQL или сеть.
Поэтому серьёзная работа над производительностью требует измерять не только микробенчмарки, но и полные сценарии ORM.
Проблема не в PHP
PHP 8.4 и 8.5 предоставляют достаточно эффективный runtime для построения высокопроизводительных систем.
Проблемы алгоритмической сложности, лишних обходов, избыточных промежуточных массивов и повторного чтения metadata невозможно решить одним обновлением версии PHP.
Для этого нужно менять сами алгоритмы.
Именно здесь архитектурная инерция Doctrine становится препятствием.
5. Слишком высокая связность компонентов
Высокая связность — одна из наиболее фундаментальных проблем больших ORM.
UnitOfWork, EntityManager, persisters, hydrators, metadata, proxy/lazy-object infrastructure и обработчики ассоциаций зависят друг от друга не только через публичные контракты, но и через предположения о внутреннем состоянии.
Например, изменение механизма hydration может потребовать корректировок в регистрации managed entities, формировании snapshots и последующем dirty checking.
Изменение lazy loading может повлиять на Identity Map и порядок инициализации ассоциаций.
Исправление orphan removal способно затронуть вычисление changesets и последовательность операций при flush.
Это означает, что компоненты нельзя уверенно развивать независимо.
Высокая связность приводит к трём последствиям.
Первое — высокая стоимость изменений. Даже небольшая оптимизация требует глубокого понимания соседних механизмов.
Второе — сложность тестирования. Изолированный unit test не всегда способен воспроизвести реальное взаимодействие компонентов.
Третье — риск регрессий. Исправление одного сценария может нарушить другой, формально не связанный с исходной задачей.
Для зрелой инфраструктурной библиотеки это особенно опасно.
Архитектура должна не просто работать сегодня. Она должна позволять безопасно изменять реализацию завтра.
6. Second-Level Cache: сложная подсистема с высокой ценой ошибки
Second-Level Cache — одна из наиболее сложных частей Doctrine ORM.
Её задача — повторно использовать данные между запросами и экземплярами EntityManager, сокращая обращения к базе данных.
Однако кэширование ORM принципиально сложнее обычного key-value cache.
Необходимо согласовывать:
- состояние объектов и кэша;
- изменения сущностей и ассоциаций;
- транзакционные границы;
- invalidation;
- concurrent updates;
- ошибки cache provider;
- частично успешные операции;
- ситуацию, когда COMMIT в БД состоялся, а обновление кэша завершилось ошибкой.
Последний сценарий особенно важен.
Представим, что транзакция успешно зафиксирована в PostgreSQL, но последующая операция invalidation в Redis завершилась исключением.
Данные в базе уже изменены, а кэш потенциально содержит устаревшее состояние.
Повторить транзакцию автоматически нельзя: в описанном сценарии результат COMMIT уже известен. Отдельной проверки требуют аварии соединения непосредственно во время COMMIT, когда исход может оказаться неопределённым.
Поэтому корректная реализация должна учитывать не только успешный путь, но и все аварийные границы.
Сама сложность этих сценариев не доказывает, что каждый релиз Doctrine L2 cache нестабилен. Для такого утверждения необходимы воспроизводимые дефекты и конкретные версии.
Но она показывает, почему L2 cache требует самостоятельного аудита, интеграционных тестов с реальным Redis и проверки отказов после COMMIT.
Если кэш создаёт риск неконсистентного состояния, его экономия на SQL-запросах теряет смысл.
Документация Second-Level Cache описывает подсистему и стратегии кеширования. Ниже — сценарий проверки границы БД и кеша, а не утверждение о воспроизводимом дефекте всех поддерживаемых версий.
7. Поддержка множества СУБД — универсальность, за которую платят все
Doctrine исторически ориентируется на работу с различными реляционными базами данных.
В этом есть очевидное преимущество: разработчик получает переносимую модель данных и может использовать знакомые ORM-инструменты независимо от конкретной СУБД.
Но универсальность имеет стоимость.
PostgreSQL, MySQL, MariaDB, SQLite, SQL Server и другие платформы отличаются:
- стратегиями генерации идентификаторов;
- синтаксисом SQL;
- механизмами блокировок;
- типами данных;
- поведением транзакций;
- возможностями
RETURNING,UPSERTи пакетных операций; - поддержкой JSON и специфических индексов;
- ограничениями DDL.
Чем больше платформ поддерживается, тем сложнее внедрять оптимизации, использующие возможности конкретной базы.
Каждое изменение необходимо рассматривать с точки зрения переносимости.
При этом переносимость не всегда является реальным требованием бизнеса.
Большинство production-приложений не переключаются между PostgreSQL и MySQL по желанию пользователя. СУБД выбирается при проектировании архитектуры и затем используется годами.
Получается, что приложение, работающее исключительно с PostgreSQL, косвенно оплачивает архитектурную сложность поддержки платформ, которые никогда не будет использовать.
Это не означает, что Doctrine должна отказаться от мультиплатформенности.
Но возникает принципиальный вопрос:
Для специализированной ORM с фокусом на PostgreSQL возможны другие компромиссы: более простой SQL generation, узкие оптимизированные пути и меньшая матрица совместимости.
Универсальная ORM и специализированная ORM решают разные задачи. Ни одна из этих моделей не обязана быть единственно правильной.
8. Главная проблема — отсутствие готовности к фундаментальным изменениям
Все перечисленные проблемы имеют общий корень.
Doctrine — зрелая, широко используемая библиотека с большим количеством исторических контрактов.
Чем популярнее она становится, тем дороже любое несовместимое изменение.
Чем дороже изменение, тем сильнее желание сохранить существующую реализацию.
А чем дольше сохраняется существующая реализация, тем больше технического долга приходится учитывать при следующем изменении.
Так возникает архитектурная инерция.
Консерватизм полезен, когда защищает пользователей от необдуманных решений.
Но он становится проблемой, когда сохранение существующего кода начинает восприниматься как более важная цель, чем устранение его фундаментальных недостатков.
При этом утверждать, что никто из maintainers не хочет ничего менять, было бы несправедливо: Doctrine развивалась, выпускала новые major-версии и проводила значительные изменения.
Проблема скорее в другом: темп и масштаб архитектурных изменений могут не соответствовать накопленной сложности проекта.
Для инфраструктурной библиотеки недостаточно просто сохранять работоспособность.
Необходимо постоянно уменьшать стоимость будущих изменений.
Иначе каждое следующее поколение разработчиков получает ещё более сложную систему.
9. Почему Doctrine — не Symfony, Composer или FrankenPHP
В PHP-экосистеме существуют проекты, демонстрирующие, что зрелость и активное развитие могут сосуществовать.
Symfony развивает архитектуру компонентной платформы, поддерживает предсказуемую политику версионирования и регулярно внедряет новые возможности.
Composer решает сложные инфраструктурные задачи управления зависимостями и продолжает развиваться как ключевой инструмент экосистемы.
FrankenPHP показывает, что даже привычную инфраструктуру выполнения PHP-приложений можно переосмыслить, предложив новые архитектурные решения.
Разумеется, эти проекты нельзя сравнивать напрямую по количеству issues, PR или частоте релизов. У них разные задачи, команды, ресурсы и требования к совместимости.
Но они демонстрируют важный принцип:
Doctrine сегодня во многом удерживает своё положение благодаря зрелости, распространённости, интеграциям и стоимости миграции.
Это реальные преимущества.
Однако они не равнозначны отсутствию технических проблем.
10. Doctrine популярна не потому, что идеальна, а потому, что её трудно заменить
Для PHP-разработчика, использующего Symfony, Doctrine часто становится выбором по умолчанию.
Она предлагает:
- зрелую модель EntityManager и UnitOfWork;
- интеграцию с Symfony;
- migrations и развитую экосистему;
- поддержку сложных associations;
- большой объём документации;
- доступность специалистов;
- накопленный опыт эксплуатации.
Создать альтернативу, которая сразу повторит весь этот набор возможностей, чрезвычайно сложно.
Но именно здесь возникает проблема рыночной инерции.
Когда библиотека занимает доминирующее положение, пользователи могут продолжать выбирать её не потому, что она лучше всех решает текущую задачу, а потому, что переход на другую технологию слишком дорог.
Это не означает полного отсутствия альтернатив. В PHP существуют другие ORM и подходы к persistence, включая Eloquent, Cycle ORM и решения на основе DBAL.
Однако они не всегда являются прямой заменой Doctrine ORM по семантике, API, интеграциям и поведению.
Поэтому популярность Doctrine следует оценивать осторожно.
Количество установок показывает распространённость технологии, но не измеряет удовлетворённость её архитектурой.
11. Что действительно необходимо изменить
Doctrine не нужна очередная волна переименований классов или косметического переноса методов.
Нужны изменения на уровне инженерных принципов.
Во-первых, основные алгоритмы ORM должны быть изолированы и иметь измеримые характеристики производительности.
Во-вторых, UnitOfWork должен преимущественно координировать операции, а не самостоятельно реализовывать все механизмы работы с состоянием.
В-третьих, performance regressions должны контролироваться автоматическими бенчмарками наряду с функциональными тестами.
В-четвёртых, L2 cache должен иметь чётко определённые гарантии корректности при транзакционных и сетевых сбоях.
В-пятых, политика рассмотрения архитектурных PR должна быть достаточно прозрачной, чтобы внешние разработчики понимали, какие изменения проект готов принимать.
И наконец, проекту необходима долгосрочная архитектурная стратегия, в которой уменьшение сложности является самостоятельной целью.
Без этого даже качественные локальные исправления будут лишь поддерживать существующую систему, не устраняя причины накопления технического долга.
Заключение. Популярность — не архитектурное достижение
Doctrine ORM сыграла огромную роль в развитии PHP.
Она дала экосистеме зрелый persistence layer, сделала сложные объектные модели доступными широкому кругу разработчиков и стала фундаментом множества успешных проектов.
Но уважение к историческим достижениям не должно исключать техническую критику.
Огромный UnitOfWork, высокая связность, стоимость dirty checking и hydration, сложность L2 cache, ограничения мультиплатформенной архитектуры и консервативный процесс принятия изменений — это не случайный набор независимых недостатков.
Это признаки системы, в которой стоимость эволюции стала слишком высокой.
Самое опасное для зрелого open-source проекта — не наличие технического долга.
Стабильность означает предсказуемое поведение, корректность данных, тестируемость и управляемость изменений.
Она не означает сохранение существующей реализации любой ценой.
Doctrine остаётся важнейшей ORM в PHP-экосистеме. Но её популярность не должна освобождать проект от необходимости пересматривать архитектуру, улучшать производительность и снижать техническую сложность.
Материалы для проверки
Источники проверены . Ссылка на исходный код закреплена за версией 3.7.1; страницы документации current и результаты поиска GitHub меняются со временем. Архитектурные оценки и требования к развитию проекта — позиция автора. Число открытых ошибок и статистика сроков рассмотрения PR в статье не используются как доказательство качества библиотеки.
- Doctrine Internals: Identity Map и обнаружение изменений
- Политики отслеживания изменений
- Second-Level Cache
- UnitOfWork.php: исходный код конкретной версии
- Правила участия в развитии Doctrine
Автор участвует в PHP Open Source и развивает ModernORM. Публичные проекты и принятые изменения ModernERP.
Продолжение: что мы убрали и реализовали в ModernORM: примеры для PHP 8.4 и PostgreSQL.