Symfony
Материал для подготовки к собеседованию (Middle / Senior). Термины на английском там, где это принято. Ориентир — современные версии Symfony 6/7 (актуальная стабильная — 8.x, текущая LTS — 7.4). Синтаксис — на атрибутах PHP 8 (в проекте так по умолчанию).
Где тема сложнее — объясняю проще и «на пальцах», потому что Symfony часто идёт тяжелее, чем Laravel.
Содержание
- Что такое Symfony простыми словами
- Структура проекта и Symfony Flex
- Жизненный цикл запроса и HttpKernel
- HttpFoundation: Request и Response
- Сессии и flash-сообщения
- Dependency Injection и контейнер сервисов
- Продвинутый DI: фабрики, декораторы, локаторы, tagged
- Bundles (бандлы)
- Конфигурация, параметры и env
- Маршрутизация
- Контроллеры и Argument Resolvers
- Doctrine ORM: основы и EntityManager
- Doctrine: состояния сущности и Unit of Work
- Doctrine: репозитории, DQL, QueryBuilder
- Doctrine: связи
- Doctrine: N+1, fetch-режимы, оптимизация
- Doctrine: транзакции и блокировки
- Doctrine: события и lifecycle callbacks
- Doctrine: миграции, фикстуры, продвинутый маппинг
- Doctrine: пагинация
- Формы
- Валидация
- Сериализация
- Безопасность
- Кастомный Authenticator и события безопасности
- JWT-аутентификация
- Messenger — очереди и шины сообщений
- CQRS на Messenger
- События и EventDispatcher
- Console — консольные команды
- Twig — шаблоны
- Mailer — почта
- HTTP Client
- Кэширование
- Rate Limiter, Lock, Workflow, Scheduler
- Профайлер, логи и отладка
- Тестирование
- Производительность и деплой
- Архитектура и паттерны
- Symfony vs Laravel
- Вероятные вопросы
Что такое Symfony простыми словами
Symfony — это набор независимых PHP-компонентов (HttpFoundation, Routing, DependencyInjection, Console, EventDispatcher и др.) и фреймворк, который собирает их вместе. Многие другие проекты (в том числе Laravel) используют компоненты Symfony под капотом.
Главная идея Symfony: всё есть сервис, и всё собирается через контейнер зависимостей. Ты почти не создаёшь объекты вручную через new — их создаёт и «связывает» контейнер, а тебе он их подаёт (это и есть Dependency Injection).
Отличие от Laravel «на пальцах»: Laravel даёт много «магии» и готовых решений из коробки (фасады, Eloquent, хелперы) — быстро писать. Symfony более строгий и явный: больше конфигурации, но меньше «магии», код предсказуемее и лучше масштабируется на больших проектах. Doctrine (ORM в Symfony) работает по паттерну Data Mapper, а не Active Record, как Eloquent (об этом ниже).
Три «кита», без которых не понять Symfony:
- Контейнер зависимостей — фабрика всех объектов приложения.
- HttpKernel и события — превращение
RequestвResponse, где в каждой точке можно вмешаться. - Doctrine (Data Mapper) — работа с БД через объекты и EntityManager.
Структура проекта и Symfony Flex
Основные каталоги современного Symfony-проекта:
config/ конфигурация (packages/, routes.yaml, services.yaml)
src/ твой код (Controller/, Entity/, Repository/, Service/…)
templates/ шаблоны Twig
public/ index.php — точка входа, статика
var/ кэш (var/cache) и логи (var/log)
migrations/ миграции Doctrine
tests/ тесты
bin/console консольная утилита
vendor/ зависимости Composer
.env переменные окружения
Symfony Flex — плагин Composer, который автоматизирует установку пакетов. Когда ставишь пакет, Flex через «рецепты» (recipes) сам создаёт нужные конфиги, добавляет bundle в config/bundles.php, прописывает переменные в .env. То есть меньше ручной настройки.
Пакеты часто ставят по «алиасам» рецептов:
composer require orm # doctrine
composer require --dev maker # генератор кода
composer require symfony/messenger
Точка входа public/index.php минимальна:
use App\Kernel;
require_once dirname(__DIR__).'/vendor/autoload_runtime.php';
return function (array $context) {
return new Kernel($context['APP_ENV'], (bool) $context['APP_DEBUG']);
};
Жизненный цикл запроса и HttpKernel
Сердце Symfony — компонент HttpKernel. Он превращает объект Request в объект Response. Весь путь построен на событиях (kernel events) — в каждой точке можно вмешаться слушателем.
Упрощённо поток такой:
public/index.php— точка входа: создаётсяRequest::createFromGlobals()и ядро, вызывается$kernel->handle($request).kernel.request— самое начало. Здесь работает роутер (определяет, какой контроллер вызвать), стартует сессия, отрабатывает система безопасности (firewall).kernel.controller— контроллер уже определён, но ещё не вызван. Можно его подменить/донастроить.kernel.controller_arguments+ Argument Resolvers — Symfony собирает аргументы для метода контроллера (например, по типуRequest $requestили сущность по id).- Вызывается контроллер, возвращает
Response(или что угодно). kernel.view— срабатывает, только если контроллер вернул НЕResponse(например, массив/объект). Слушатель превращает это вResponse(так работают, например, API-платформы).kernel.response—Responseготов, можно его модифицировать (заголовки, куки).kernel.terminate— после отправки ответа клиенту (тяжёлые задачи «на потом»: отправка почты и т.п.).kernel.exception— если где-то выброшено исключение, ядро ловит его и даёт слушателям превратить в понятныйResponse(страница ошибки / JSON).
Ключевая мысль для собеседования: в Symfony почти всё расширяется через подписку на kernel-события, а не через переопределение классов. Схема потока:
Request
→ kernel.request (роутинг, firewall, сессия)
→ kernel.controller (какой контроллер вызвать)
→ kernel.controller_arguments (аргументы метода)
→ [Контроллер]
→ kernel.view (если вернулся не Response)
→ kernel.response (правка ответа)
Response → клиенту
→ kernel.terminate (постобработка)
при исключении в любой точке → kernel.exception
HttpFoundation: Request и Response
Компонент HttpFoundation — объектная обёртка над HTTP (вместо суперглобальных $_GET, $_POST, $_SERVER).
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpFoundation\JsonResponse;
public function handle(Request $request): Response
{
$q = $request->query->get('q'); // GET-параметр
$name = $request->request->get('name'); // POST-параметр (form)
$token = $request->headers->get('Authorization');
$data = $request->getPayload(); // тело запроса (json/form)
$file = $request->files->get('avatar');
$ip = $request->getClientIp();
return new JsonResponse(['ok' => true], Response::HTTP_OK);
}
Объект Request состоит из «сумок» (ParameterBag): query, request, attributes (параметры маршрута), cookies, files, server, headers. Response инкапсулирует статус, заголовки и тело; есть спец-классы: JsonResponse, RedirectResponse, BinaryFileResponse, StreamedResponse.
Сессии и flash-сообщения
Сессия в Symfony — сервис, доступный через Request или тип SessionInterface.
$session = $request->getSession();
$session->set('cart_id', 42);
$id = $session->get('cart_id');
// Flash — одноразовое сообщение (живёт до следующего запроса)
$this->addFlash('success', 'Товар добавлен в корзину');
Во Twig flash читают так:
{% for message in app.flashes('success') %}
<div class="alert">{{ message }}</div>
{% endfor %}
Хранилище сессий настраивается (файлы, Redis через session.handler), что важно для нескольких серверов.
Dependency Injection и контейнер сервисов
Это самая важная тема Symfony. Разберём просто.
Сервис — любой объект, который что-то делает (например, MailSender, PriceCalculator). Контейнер — большой «реестр» сервисов: он умеет создавать их и отдавать по запросу.
Dependency Injection (DI) — вместо того чтобы внутри класса писать new Mailer(), ты просто указываешь зависимость в конструкторе, а контейнер сам её подставит:
class OrderService
{
// Контейнер сам создаст и передаст сюда MailerInterface и LoggerInterface
public function __construct(
private MailerInterface $mailer,
private LoggerInterface $logger,
) {}
}
Как контейнер понимает, что подставить? Через autowiring — он смотрит на тип аргумента (MailerInterface) и находит подходящий сервис. Плюс autoconfigure — автоматически «навешивает» на сервисы теги по их интерфейсам (например, класс с интерфейсом подписчика событий сам зарегистрируется как подписчик).
Базовая настройка (config/services.yaml) обычно уже делает всё это автоматически для всего каталога src/:
services:
_defaults:
autowire: true # автоматически внедрять зависимости по типам
autoconfigure: true # автоматически регистрировать теги
App\:
resource: '../src/' # все классы из src/ становятся сервисами
Если несколько реализаций одного интерфейса — autowiring не знает, какую взять. Тогда используют именованные привязки, #[Autowire] или #[AsAlias]:
public function __construct(
#[Autowire(service: 'app.stripe_gateway')]
private PaymentGatewayInterface $gateway,
) {}
Или через bind в конфиге (для всех сервисов сразу):
services:
_defaults:
bind:
$projectDir: '%kernel.project_dir%'
Psr\Log\LoggerInterface $auditLogger: '@monolog.logger.audit'
Параметры vs сервисы. Параметр — просто значение (строка, число, массив из конфига). Внедрить параметр можно так:
public function __construct(
#[Autowire('%kernel.project_dir%')]
private string $projectDir,
#[Autowire('%env(APP_SECRET)%')]
private string $secret,
#[Autowire('%app.items_per_page%')]
private int $perPage,
) {}
Область видимости сервисов. По умолчанию сервисы — shared (синглтон в рамках контейнера): один экземпляр на весь запрос. Можно сделать несовместный (shared: false) — новый экземпляр при каждом запросе из контейнера.
Compiler Passes (для Senior) — «продвинутый» способ вмешаться в контейнер на этапе его сборки (компиляции): например, найти все сервисы с определённым тегом и передать их в другой сервис. Так работают многие расширения Symfony. Контейнер в проде компилируется в PHP-файл — поэтому он быстрый и «замороженный».
Продвинутый DI: фабрики, декораторы, локаторы, tagged
Фабрика — когда объект нельзя просто «создать через конструктор», а нужно получить из другого сервиса/метода:
services:
App\Service\NewsletterManager:
factory: ['@App\Service\NewsletterManagerFactory', 'create']
arguments: ['%env(MAILER_DSN)%']
Декоратор — обернуть существующий сервис своим, сохранив оригинал внутри (паттерн «Декоратор»). Часто для добавления логирования/кэша без правки исходного класса:
#[AsDecorator(decorates: MailerInterface::class)]
class LoggingMailer implements MailerInterface
{
public function __construct(
#[AutowireDecorated] private MailerInterface $inner,
private LoggerInterface $logger,
) {}
public function send(RawMessage $message, ?Envelope $envelope = null): void
{
$this->logger->info('Sending email');
$this->inner->send($message, $envelope); // вызываем оригинал
}
}
Tagged iterator / locator — собрать все сервисы с общим тегом (или интерфейсом) в коллекцию. Классический пример — набор «стратегий» (обработчиков экспорта, платёжных провайдеров):
interface ExporterInterface { public function format(): string; }
class RegistryOfExporters
{
/** @param iterable<ExporterInterface> $exporters */
public function __construct(
#[AutowireIterable(tag: 'app.exporter')] // или #[TaggedIterator]
private iterable $exporters,
) {}
}
С autoconfigure можно навесить тег на все реализации интерфейса автоматически:
services:
_instanceof:
App\Export\ExporterInterface:
tags: ['app.exporter']
Service Locator — «ленивый» контейнер, из которого достают сервисы по ключу только когда нужно (#[AutowireLocator]). Полезно, чтобы не создавать все зависимости сразу.
Lazy services — сервис создаётся не сразу, а при первом реальном обращении (#[Autoconfigure(lazy: true)]) — экономит ресурсы на тяжёлых объектах.
Bundles (бандлы)
Bundle — это плагин/модуль Symfony: переиспользуемый набор функционала (сервисы, конфиги, роуты). Например, DoctrineBundle, SecurityBundle, MakerBundle.
Подключённые бандлы перечислены в config/bundles.php:
return [
Symfony\Bundle\FrameworkBundle\FrameworkBundle::class => ['all' => true],
Doctrine\Bundle\DoctrineBundle\DoctrineBundle::class => ['all' => true],
Symfony\Bundle\SecurityBundle\SecurityBundle::class => ['all' => true],
];
Раньше свой код тоже оформляли как бандлы. Сейчас рекомендация — не создавать бандл для кода самого приложения (просто держать код в src/); бандлы делают в основном для переиспользуемых библиотек, которые ставятся в несколько проектов.
Свой бандл, который отдаёт настраиваемую конфигурацию, обычно содержит класс Extension (загружает сервисы бандла) и класс Configuration (описывает и валидирует дерево настроек). Для собеседования достаточно понимать: bundle = переиспользуемый модуль со своими сервисами и конфигом.
Конфигурация, параметры и env
Конфигурация лежит в config/ в формате YAML (по умолчанию), но можно PHP или XML.
config/packages/*.yaml— настройки бандлов (doctrine, security, framework и т.д.), часто по окружениям (config/packages/prod/).config/services.yaml— регистрация и настройка сервисов.- Параметры — значения под ключом
parameters:.
parameters:
app.items_per_page: 20
services:
App\Service\Catalog:
arguments:
$perPage: '%app.items_per_page%'
$dsn: '%env(DATABASE_URL)%'
Переменные окружения (.env). Секреты и то, что меняется между окружениями. В коде их читают через синтаксис %env(VAR)%. .env коммитят как значения по умолчанию для dev, а реальные секреты держат в .env.local (не в git) или в Symfony Secrets (зашифрованное хранилище — secrets:set).
Процессоры env-переменных — приведение и обработка значений на лету:
parameters:
app.allowed_ips: '%env(csv:ALLOWED_IPS)%' # строка → массив
app.debug: '%env(bool:APP_DEBUG)%' # строка → bool
app.db_port: '%env(int:DB_PORT)%'
app.secret: '%env(file:SECRET_FILE)%' # прочитать из файла
Окружения (environments): dev, prod, test. Управляется переменной APP_ENV. В dev включены профайлер и подробные ошибки; в prod — агрессивное кэширование контейнера и конфигурации (нужно прогревать кэш: cache:warmup).
Маршрутизация
Маршруты чаще всего задают атрибутами прямо над методом контроллера:
use Symfony\Component\Routing\Attribute\Route;
class ProductController extends AbstractController
{
#[Route('/products/{id}', name: 'product_show', methods: ['GET'], requirements: ['id' => '\d+'])]
public function show(int $id): Response
{
// ...
}
}
name— имя маршрута (по нему генерируют URL).requirements— ограничения на параметры (регуляркой).methods— HTTP-методы.defaults— значения по умолчанию.- Можно навесить
#[Route('/admin', name: 'admin_')]на класс — станет префиксом пути и имени для всех методов.
Генерация URL (в контроллере и Twig):
$url = $this->generateUrl('product_show', ['id' => 5]); // /products/5
$abs = $this->generateUrl('product_show', ['id' => 5], UrlGeneratorInterface::ABSOLUTE_URL);
<a href="{{ path('product_show', {id: 5}) }}">Товар</a>
<a href="{{ url('product_show', {id: 5}) }}">Абсолютная ссылка</a>
Полезное: приоритеты (priority), локализованные маршруты (разные пути для разных языков), поддомены (host), проверка маршрутов — php bin/console debug:router.
Контроллеры и Argument Resolvers
Контроллер — обычный класс, чаще наследует AbstractController (даёт хелперы render(), json(), redirectToRoute(), createNotFoundException(), addFlash(), denyAccessUnlessGranted() и т.д.).
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
class ProductController extends AbstractController
{
#[Route('/products/{id}', name: 'product_show')]
public function show(Product $product): Response // сущность найдена автоматически по {id}
{
return $this->render('product/show.html.twig', [
'product' => $product,
]);
}
}
Контроллер можно сделать «одиночным действием» (__invoke) — один класс = одно действие (удобно для сложной логики):
#[Route('/checkout', name: 'checkout')]
class CheckoutController extends AbstractController
{
public function __invoke(Request $request): Response { /* ... */ }
}
Argument Resolvers — механизм, который наполняет аргументы метода:
Request $request— текущий запрос.- тип-сущность (
Product $product) — автоматически загрузит из БД по параметру маршрута (аналог Route Model Binding в Laravel). Можно уточнить критерий через#[MapEntity]. #[MapRequestPayload]— десериализует тело запроса (JSON) в DTO с автоматической валидацией.#[MapQueryParameter]— берёт значение из query-строки.#[MapQueryString]— собрать всю query-строку в DTO.#[CurrentUser]— текущий аутентифицированный пользователь.
public function create(
#[MapRequestPayload] CreateProductDto $dto,
#[CurrentUser] User $user,
#[MapQueryParameter] int $page = 1,
): Response {
// тело JSON уже разобрано в DTO и провалидировано
}
Можно писать свой Argument Resolver (реализовав ValueResolverInterface) — например, чтобы автоматически подставлять какой-то объект контекста.
Doctrine ORM: основы и EntityManager
Doctrine — ORM в Symfony. Главное отличие от Eloquent (Laravel): Doctrine — это Data Mapper, а не Active Record.
Простыми словами:
- В Laravel модель сама себя сохраняет:
$user->save()(Active Record — «объект знает про БД»). - В Doctrine сущность (Entity) — это просто объект с данными, он ничего не знает про БД. За сохранение отвечает отдельный объект — EntityManager. Ты как бы говоришь: «менеджер, запомни этот объект и потом сохрани всё разом».
Сущность (Entity)
use Doctrine\ORM\Mapping as ORM;
#[ORM\Entity(repositoryClass: ProductRepository::class)]
#[ORM\Table(name: 'products')]
#[ORM\Index(columns: ['name'], name: 'idx_name')]
class Product
{
#[ORM\Id]
#[ORM\GeneratedValue]
#[ORM\Column]
private ?int $id = null;
#[ORM\Column(length: 255)]
private string $name;
#[ORM\Column(type: 'decimal', precision: 10, scale: 2)]
private string $price;
#[ORM\Column(type: 'datetime_immutable')]
private \DateTimeImmutable $createdAt;
public function getId(): ?int { return $this->id; }
public function getName(): string { return $this->name; }
public function setName(string $name): static { $this->name = $name; return $this; }
// остальные геттеры/сеттеры...
}
EntityManager: сохранение, обновление, удаление
use Doctrine\ORM\EntityManagerInterface;
class ProductService
{
public function __construct(private EntityManagerInterface $em) {}
public function create(): void
{
$product = new Product();
$product->setName('Laptop');
$this->em->persist($product); // «возьми объект под контроль»
$this->em->flush(); // «выполни все накопленные изменения одним разом»
}
public function update(Product $product): void
{
// Обновление — просто меняем объект и делаем flush (persist не нужен!)
$product->setName('Gaming Laptop');
$this->em->flush();
}
public function delete(Product $product): void
{
$this->em->remove($product);
$this->em->flush();
}
}
Важная мысль: flush() вызывают один раз в конце (не после каждого изменения). Он открывает транзакцию, применяет все накопленные изменения и коммитит.
Doctrine: состояния сущности и Unit of Work
Unit of Work — внутренний механизм Doctrine (объясняю просто): менеджер запоминает все объекты «под контролем» и при flush() вычисляет, что именно изменилось (change set), и делает минимально нужные SQL-запросы одной пачкой в транзакции.
Каждая сущность в каждый момент имеет одно из состояний:
| Состояние | Что значит |
|---|---|
| new (transient) | только что создан через new, Doctrine про него не знает |
| managed | под контролем EntityManager (после persist или загрузки из БД) — изменения отслеживаются |
| detached | был managed, но менеджер «забыл» о нём (clear/detach) — изменения не отслеживаются |
| removed | помечен на удаление (remove), удалится при flush |
$product = new Product(); // new
$em->persist($product); // managed
$em->flush(); // сохранён, остаётся managed
$em->detach($product); // detached (или $em->clear() — забыть всё)
$em->remove($product); // removed
Полезно понимать: если сущность не managed, изменения в ней при flush() не сохранятся. Метод $em->clear() часто используют в больших batch-обработках, чтобы освобождать память.
Doctrine: репозитории, DQL, QueryBuilder
Репозиторий — класс для запросов к конкретной сущности:
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\Persistence\ManagerRegistry;
/**
* @extends ServiceEntityRepository<Product>
*/
class ProductRepository extends ServiceEntityRepository
{
public function __construct(ManagerRegistry $registry)
{
parent::__construct($registry, Product::class);
}
// QueryBuilder — программное построение запроса
public function findExpensive(float $min): array
{
return $this->createQueryBuilder('p')
->andWhere('p.price > :min')
->setParameter('min', $min)
->orderBy('p.price', 'DESC')
->setMaxResults(20)
->getQuery()
->getResult();
}
// DQL — язык запросов по объектам
public function findByNameDql(string $name): array
{
return $this->getEntityManager()
->createQuery('SELECT p FROM App\Entity\Product p WHERE p.name LIKE :n')
->setParameter('n', "%$name%")
->getResult();
}
// Нативный SQL — для сложной аналитики
public function rawStats(): array
{
$sql = 'SELECT category_id, COUNT(*) AS cnt FROM products GROUP BY category_id';
return $this->getEntityManager()->getConnection()->executeQuery($sql)->fetchAllAssociative();
}
}
Готовые методы: find($id), findOneBy([...]), findAll(), findBy([...], ['name' => 'ASC'], $limit, $offset), count([...]).
- DQL (Doctrine Query Language) — язык запросов, похожий на SQL, но оперирует объектами и их полями, а не таблицами и колонками.
- QueryBuilder — программное построение DQL-запроса.
- DBAL — низкоуровневый слой (нативный SQL,
Connection), когда ORM избыточен.
Режимы гидрации (что вернёт запрос): getResult() — объекты-сущности; getArrayResult() — массивы (быстрее, только чтение); getScalarResult() — плоские скаляры; getSingleScalarResult() — одно значение (например, COUNT).
Пагинация — через Doctrine\ORM\Tools\Pagination\Paginator (умеет считать total и корректно работать с JOIN), либо пакет KnpPaginatorBundle.
Doctrine: связи
// Много товаров у одной категории — ManyToOne со стороны Product (owning side, тут хранится FK)
#[ORM\ManyToOne(inversedBy: 'products')]
#[ORM\JoinColumn(nullable: false)]
private ?Category $category = null;
// Обратная сторона — OneToMany в Category (inverse side)
#[ORM\OneToMany(mappedBy: 'category', targetEntity: Product::class)]
private Collection $products;
public function __construct()
{
$this->products = new ArrayCollection();
}
Типы связей: OneToOne, OneToMany/ManyToOne, ManyToMany.
Важные понятия:
- Owning side — сторона, где физически хранится внешний ключ (или таблица связи для ManyToMany). Только изменения на owning side сохраняются.
- Inverse side (
mappedBy) — обратная сторона, для удобного доступа. - Каскады (
cascade: ['persist', 'remove']) — операции переносятся на связанные сущности. - orphanRemoval: true — если убрать дочернюю сущность из коллекции, она удалится из БД.
ManyToMany:
#[ORM\ManyToMany(targetEntity: Tag::class, inversedBy: 'products')]
#[ORM\JoinTable(name: 'product_tag')]
private Collection $tags;
Если у связующей таблицы должны быть свои поля (как pivot-модель в Laravel) — делают отдельную сущность с двумя ManyToOne.
Doctrine: N+1, fetch-режимы, оптимизация
Как и в Laravel, связи по умолчанию загружаются лениво (LAZY) — при первом обращении. При обходе коллекции это даёт N+1 запросов.
Проблема:
$products = $productRepository->findAll();
foreach ($products as $product) {
echo $product->getCategory()->getName(); // +1 запрос на КАЖДЫЙ товар
}
Решение — загрузить связь заранее одним запросом через JOIN + addSelect:
$this->createQueryBuilder('p')
->addSelect('c') // выбрать и категорию тоже (иначе будет lazy)
->join('p.category', 'c')
->getQuery()
->getResult();
Fetch-режимы связи:
LAZY(по умолчанию) — грузится при обращении.EAGER— грузится сразу вместе с сущностью (осторожно — может тянуть лишнее).EXTRA_LAZY— для больших коллекций: позволяетcount(),contains(), срезы без загрузки всей коллекции в память.
Другие приёмы оптимизации: гидрация в массивы (getArrayResult) для read-only списков; setMaxResults/setFirstResult; батч-обработка с iterate/toIterable и $em->clear(); профайлер показывает число запросов (ловить N+1).
Doctrine: транзакции и блокировки
Явная транзакция через обёртку (авто-commit при успехе, rollback при исключении):
$em->wrapInTransaction(function (EntityManagerInterface $em) {
$order = new Order();
$em->persist($order);
// ... другие операции
});
Ручное управление:
$em->getConnection()->beginTransaction();
try {
// ...
$em->flush();
$em->getConnection()->commit();
} catch (\Throwable $e) {
$em->getConnection()->rollBack();
throw $e;
}
Блокировки:
- Пессимистичная —
$em->lock($entity, LockMode::PESSIMISTIC_WRITE)или->setLockMode(LockMode::PESSIMISTIC_WRITE)в запросе (SQLFOR UPDATE). - Оптимистичная — колонка версии с атрибутом
#[ORM\Version]: Doctrine сам проверит, что запись не изменилась другим процессом, иначе броситOptimisticLockException.
#[ORM\Version]
#[ORM\Column(type: 'integer')]
private int $version;
Doctrine: события и lifecycle callbacks
Doctrine умеет реагировать на события жизненного цикла сущностей: prePersist, postPersist, preUpdate, postUpdate, preRemove, postRemove, postLoad.
Lifecycle callback — метод прямо в сущности:
#[ORM\Entity]
#[ORM\HasLifecycleCallbacks]
class Product
{
#[ORM\PrePersist]
public function setCreatedAtValue(): void
{
$this->createdAt = new \DateTimeImmutable();
}
}
EntityListener / Doctrine subscriber — вынести логику в отдельный класс (чище, если логика зависит от сервисов). Современный способ — атрибут #[AsEntityListener]:
#[AsEntityListener(event: Events::prePersist, entity: Product::class)]
class ProductPrePersistListener
{
public function prePersist(Product $product, PrePersistEventArgs $args): void
{
// ...
}
}
Нюанс (как и в Laravel): события Doctrine НЕ срабатывают на массовых DQL-запросах (UPDATE ... WHERE), только на операциях через EntityManager с объектами.
Doctrine: миграции, фикстуры, продвинутый маппинг
Миграции (DoctrineMigrationsBundle): Doctrine сравнивает сущности с текущей схемой БД и генерирует SQL.
php bin/console make:migration # сгенерировать по изменениям
php bin/console doctrine:migrations:migrate # применить
php bin/console doctrine:migrations:migrate prev # откат на шаг назад
Фикстуры (DoctrineFixturesBundle) — наполнение БД тестовыми/справочными данными:
class ProductFixtures extends Fixture
{
public function load(ObjectManager $manager): void
{
for ($i = 0; $i < 20; $i++) {
$p = new Product();
$p->setName("Product $i");
$manager->persist($p);
}
$manager->flush();
}
}
Запуск: php bin/console doctrine:fixtures:load. Генерацию фейковых данных обычно делают с zenstruck/foundry (аналог фабрик Laravel).
Продвинутый маппинг (для Senior):
- Embeddables (
#[ORM\Embedded]) — value object внутри сущности (например,Addressвстроен вUser, но в одной таблице). - Наследование — стратегии
SINGLE_TABLE(все наследники в одной таблице с колонкой-дискриминатором) иJOINED(отдельные таблицы). - Кастомные типы — свой тип колонки (например, для enum или специфичного значения).
- Custom DQL functions — свои функции в DQL.
Doctrine: пагинация
Наивный setFirstResult()/setMaxResults() возвращает срез, но не считает общее число записей и некорректно работает с JOIN «один-ко-многим» (одна сущность-владелец может размножиться на несколько строк из-за join → срез собьётся).
Правильный инструмент — Doctrine\ORM\Tools\Pagination\Paginator: он умеет посчитать total и корректно постранично выбирать даже с fetch-join коллекций (делает это в несколько запросов под капотом).
use Doctrine\ORM\Tools\Pagination\Paginator;
public function paginate(int $page = 1, int $perPage = 20): array
{
$query = $this->createQueryBuilder('p')
->leftJoin('p.comments', 'c')->addSelect('c') // fetch-join коллекции
->orderBy('p.createdAt', 'DESC')
->setFirstResult(($page - 1) * $perPage)
->setMaxResults($perPage)
->getQuery();
$paginator = new Paginator($query, fetchJoinCollection: true);
return [
'items' => iterator_to_array($paginator), // сущности текущей страницы
'total' => count($paginator), // всего записей (COUNT)
'pages' => (int) ceil(count($paginator) / $perPage),
];
}
Флаг fetchJoinCollection: true включается, когда в запросе есть fetch-join коллекции (addSelect по to-many-связи). Альтернатива с удобным UI/хелперами — KnpPaginatorBundle (пагинация одной строкой + готовые шаблоны ссылок для Twig). Для очень больших таблиц/бесконечного скролла лучше keyset-пагинация (WHERE id < :lastId ORDER BY id DESC LIMIT n) — стабильнее и без дорогого OFFSET.
Формы
Компонент Form строит и обрабатывает HTML-формы, привязывая их к объектам (сущности или DTO).
class ProductType extends AbstractType
{
public function buildForm(FormBuilderInterface $builder, array $options): void
{
$builder
->add('name', TextType::class, ['label' => 'Название'])
->add('price', MoneyType::class, ['currency' => 'RUB'])
->add('category', EntityType::class, [
'class' => Category::class,
'choice_label' => 'name',
])
->add('tags', CollectionType::class, [
'entry_type' => TagType::class,
'allow_add' => true,
'allow_delete' => true,
])
->add('save', SubmitType::class);
}
public function configureOptions(OptionsResolver $resolver): void
{
$resolver->setDefaults([
'data_class' => Product::class,
'csrf_protection' => true, // защита CSRF включена по умолчанию
]);
}
}
Обработка в контроллере:
$form = $this->createForm(ProductType::class, $product);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
$em->persist($product);
$em->flush();
$this->addFlash('success', 'Сохранено');
return $this->redirectToRoute('product_list');
}
return $this->render('product/new.html.twig', ['form' => $form]);
handleRequest сам разбирает данные из запроса и заполняет объект.
Form Events — вмешаться в жизненный цикл формы (PRE_SET_DATA, PRE_SUBMIT, POST_SUBMIT) — например, динамически менять поля в зависимости от данных.
Data Transformers — преобразование между «моделью» и «представлением» (например, объект Tag ↔ строка в input). Полезно для нестандартных полей.
В API-проектах формы часто не используют, а берут Serializer + Validator (или API Platform) напрямую. Рендер формы во Twig: {{ form(form) }} или по частям {{ form_row(form.name) }}.
Валидация
Правила задают атрибутами прямо на свойствах (или в YAML). Проверяет сервис ValidatorInterface.
use Symfony\Component\Validator\Constraints as Assert;
class RegisterDto
{
#[Assert\NotBlank]
#[Assert\Email]
public string $email;
#[Assert\NotBlank]
#[Assert\Length(min: 8, minMessage: 'Минимум {{ limit }} символов')]
public string $password;
#[Assert\Valid] // провалидировать вложенный объект
public AddressDto $address;
#[Assert\Count(min: 1)]
#[Assert\All([new Assert\Type('string')])] // проверка каждого элемента массива
public array $roles = [];
}
$errors = $validator->validate($dto);
if (count($errors) > 0) {
foreach ($errors as $error) {
echo $error->getPropertyPath() . ': ' . $error->getMessage();
}
}
Группы валидации — применять разные правила в разных сценариях (groups), и последовательности (GroupSequence) — проверять группы по очереди (следующая не запускается, если предыдущая упала).
Кастомный constraint — свой класс-ограничение + класс-валидатор:
#[\Attribute]
class ContainsSpam extends Constraint
{
public string $message = 'Текст содержит запрещённые слова.';
}
class ContainsSpamValidator extends ConstraintValidator
{
public function validate(mixed $value, Constraint $constraint): void
{
if (str_contains((string) $value, 'spam')) {
$this->context->buildViolation($constraint->message)->addViolation();
}
}
}
При использовании #[MapRequestPayload] валидация DTO происходит автоматически (при ошибке — 422).
Сериализация
Компонент Serializer превращает объекты в JSON/XML и обратно (важно для API).
- Normalize — объект → массив; encode — массив → строку (JSON). И наоборот: decode + denormalize.
- Группы сериализации (
#[Groups(['read'])]) — отдавать в разных сценариях разные наборы полей.
use Symfony\Component\Serializer\Attribute\Groups;
class Product
{
#[Groups(['read', 'write'])]
public string $name;
#[Groups(['read'])] // только в ответе, не при записи
public \DateTimeImmutable $createdAt;
}
$json = $serializer->serialize($product, 'json', ['groups' => ['read']]);
$dto = $serializer->deserialize($request->getContent(), CreateProductDto::class, 'json');
// Контекст: игнорировать null, ограничить глубину, обработать циклы
$json = $serializer->serialize($product, 'json', [
AbstractObjectNormalizer::SKIP_NULL_VALUES => true,
AbstractObjectNormalizer::CIRCULAR_REFERENCE_LIMIT => 1,
]);
Кастомный нормалайзер (реализует NormalizerInterface) — своя логика превращения конкретного типа в массив (например, форматировать даты по-своему).
Для полноценных REST/GraphQL API поверх Symfony часто ставят API Platform — он использует Serializer и Validator и генерирует API из сущностей (эндпоинты, документацию OpenAPI, пагинацию, фильтры).
Безопасность
Настраивается в config/packages/security.yaml. Ключевые понятия простыми словами:
- Firewall (файрвол) — «охранник на входе» для части сайта (например, весь
^/или отдельно^/api). Определяет, как пользователи аутентифицируются в этой зоне. - Authentication (аутентификация) — «кто ты». Современная система — authenticators (
form_login,json_login,access_token, свой кастомный). - Authorization (авторизация) — «что тебе можно». Через роли,
access_controlи Voters. - User Provider — откуда брать пользователей (обычно из БД через Doctrine:
entity). - Password Hasher — хеширование паролей (
auto— обычно bcrypt/argon2id).
security:
password_hashers:
Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface:
algorithm: auto
providers:
app_user_provider:
entity: { class: App\Entity\User, property: email }
firewalls:
dev:
pattern: ^/(_(profiler|wdt)|css|images|js)/
security: false
main:
lazy: true
provider: app_user_provider
form_login:
login_path: app_login
check_path: app_login
logout:
path: app_logout
remember_me:
secret: '%kernel.secret%'
lifetime: 604800
access_control:
- { path: ^/admin, roles: ROLE_ADMIN }
- { path: ^/profile, roles: ROLE_USER }
role_hierarchy:
ROLE_ADMIN: ROLE_USER
ROLE_SUPER_ADMIN: [ROLE_ADMIN, ROLE_ALLOWED_TO_SWITCH]
Роли — строки вида ROLE_USER, ROLE_ADMIN. Иерархия ролей означает, что ROLE_ADMIN включает ROLE_USER.
Хеширование пароля вручную (например, при регистрации):
public function __construct(private UserPasswordHasherInterface $hasher) {}
$user->setPassword($this->hasher->hashPassword($user, $plainPassword));
Voters (голосователи) — самый гибкий способ авторизации: класс, который решает, можно ли конкретному пользователю сделать действие над конкретным объектом (аналог Policies в Laravel).
class PostVoter extends Voter
{
public const EDIT = 'POST_EDIT';
protected function supports(string $attribute, mixed $subject): bool
{
return $attribute === self::EDIT && $subject instanceof Post;
}
protected function voteOnAttribute(string $attribute, mixed $subject, TokenInterface $token): bool
{
$user = $token->getUser();
if (!$user instanceof User) {
return false;
}
return $subject->getAuthor() === $user; // автор может редактировать
}
}
// В контроллере
$this->denyAccessUnlessGranted(PostVoter::EDIT, $post);
// или проверка без исключения
if ($this->isGranted(PostVoter::EDIT, $post)) { /* ... */ }
Стратегии решения (когда несколько voters): affirmative (хватает одного «за» — по умолчанию), unanimous (все должны быть «за»), consensus (большинство).
CSRF — для форм встроена защита CSRF-токеном (в Form-компоненте автоматически; в Twig — csrf_token()). Аутентификация по токенам (API) от CSRF не зависит.
User Checker — дополнительная проверка пользователя при логине (например, забанен ли аккаунт).
Кастомный Authenticator и события безопасности
Когда встроенных способов входа мало (например, вход по API-токену в заголовке), пишут свой authenticator:
use Symfony\Component\Security\Http\Authenticator\AbstractAuthenticator;
use Symfony\Component\Security\Http\Authenticator\Passport\Passport;
use Symfony\Component\Security\Http\Authenticator\Passport\SelfValidatingPassport;
use Symfony\Component\Security\Http\Authenticator\Passport\Badge\UserBadge;
class ApiTokenAuthenticator extends AbstractAuthenticator
{
public function __construct(private UserRepository $users) {}
// Должен ли этот authenticator обрабатывать запрос?
public function supports(Request $request): ?bool
{
return $request->headers->has('X-API-TOKEN');
}
public function authenticate(Request $request): Passport
{
$token = $request->headers->get('X-API-TOKEN');
return new SelfValidatingPassport(
new UserBadge($token, function (string $token) {
$user = $this->users->findOneByApiToken($token);
if (!$user) {
throw new UserNotFoundException();
}
return $user;
})
);
}
public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $firewallName): ?Response
{
return null; // продолжить обработку запроса
}
public function onAuthenticationFailure(Request $request, AuthenticationException $exception): ?Response
{
return new JsonResponse(['error' => 'Auth failed'], Response::HTTP_UNAUTHORIZED);
}
}
Понятие Passport — «пропуск», который несёт информацию о пользователе (UserBadge) и «значки» (badges): проверка пароля, CSRF, remember-me. Для JWT в реальных проектах чаще берут готовый LexikJWTAuthenticationBundle.
События безопасности — можно подписаться на LoginSuccessEvent, LoginFailureEvent, LogoutEvent (например, логировать входы, сбрасывать что-то при выходе). Login throttling (ограничение попыток входа) включается в конфиге firewall — защита от brute force.
JWT-аутентификация
Для stateless API (SPA, мобильные) часто используют JWT (JSON Web Token) вместо серверных сессий. Токен — самодостаточная подписанная строка, клиент шлёт её в заголовке Authorization: Bearer <token>; сервер не хранит состояние сессии.
Строение JWT — три части через точку: header (алгоритм) . payload (claims: id пользователя, роли, срок exp) . signature (подпись). Payload только base64 (не шифрование!) — секреты в токен не кладут; целостность гарантирует подпись (сервер проверяет её своим ключом).
В Symfony стандарт — бандл LexikJWTAuthenticationBundle (+ асимметричные ключи):
# config/packages/security.yaml
security:
firewalls:
login:
pattern: ^/api/login
stateless: true
json_login:
check_path: /api/login_check
success_handler: lexik_jwt_authentication.handler.authentication_success
failure_handler: lexik_jwt_authentication.handler.authentication_failure
api:
pattern: ^/api
stateless: true # без сессий
jwt: ~ # проверка Bearer-токена на каждый запрос
access_control:
- { path: ^/api/login, roles: PUBLIC_ACCESS }
- { path: ^/api, roles: IS_AUTHENTICATED_FULLY }
Поток: клиент шлёт логин/пароль на /api/login_check → сервер проверяет и возвращает JWT → клиент кладёт токен в Authorization: Bearer ... на каждый защищённый запрос → firewall jwt проверяет подпись и срок, восстанавливает пользователя (stateless, без сессии).
Нюансы: короткий срок жизни access-токена + refresh token (отдельный бандл) для обновления без повторного логина; отозвать выданный JWT «на лету» нельзя (он валиден до exp) — при необходимости ведут blacklist/меняют ключ; роли берут из payload. JWT — это про аутентификацию, авторизация всё так же через роли/voters.
Messenger — очереди и шины сообщений
Messenger — компонент для работы с сообщениями и очередями (аналог очередей в Laravel, но более гибкий, по паттерну «шина сообщений»).
Простыми словами:
- Message (сообщение) — обычный объект с данными (например,
SendEmailMessage). - Handler (обработчик) — класс, который умеет обрабатывать этот тип сообщения.
- Message Bus (шина) — ты «кидаешь» сообщение в шину (
dispatch), а она находит нужный обработчик. - Transport (транспорт) — где сообщения живут: синхронно (
sync), либо асинхронно в очереди (Doctrine-таблица, Redis, RabbitMQ через AMQP). - Stamps (марки) — метаданные на конверте сообщения (задержка, приоритет, идентификатор и т.д.).
// Сообщение — просто DTO
final class SendWelcomeEmail
{
public function __construct(public readonly int $userId) {}
}
// Обработчик
#[AsMessageHandler]
class SendWelcomeEmailHandler
{
public function __construct(private MailerInterface $mailer) {}
public function __invoke(SendWelcomeEmail $message): void
{
// отправить письмо пользователю $message->userId
}
}
Отправка в шину:
public function __construct(private MessageBusInterface $bus) {}
$this->bus->dispatch(new SendWelcomeEmail($user->getId()));
// С задержкой 5 секунд
$this->bus->dispatch(new SendWelcomeEmail($id), [new DelayStamp(5000)]);
Конфигурация транспортов (config/packages/messenger.yaml):
framework:
messenger:
transports:
async: '%env(MESSENGER_TRANSPORT_DSN)%' # например, Doctrine/Redis/AMQP
failed: 'doctrine://default?queue_name=failed'
routing:
App\Message\SendWelcomeEmail: async # это сообщение — в асинхронную очередь
failure_transport: failed
Запуск фонового воркера (обычно под supervisor / systemd):
php bin/console messenger:consume async -vv
php bin/console messenger:failed:show # посмотреть упавшие
php bin/console messenger:failed:retry # повторить
Middleware шины — слои вокруг обработки сообщения (например, doctrine_transaction оборачивает обработку в транзакцию, логирование, валидация). Есть retry-стратегии (сколько раз повторять при ошибке и с какой задержкой) и failure transport для упавших сообщений.
CQRS на Messenger
Messenger позволяет завести несколько шин — это удобно для паттерна CQRS (разделение команд и запросов). Объясняю просто:
- Command (команда) — «сделай что-то» (создать заказ). Меняет состояние, обычно ничего не возвращает.
- Query (запрос) — «дай данные» (получить список заказов). Ничего не меняет, возвращает результат.
- Event (событие) — «что-то произошло» (заказ создан). Может иметь несколько обработчиков.
framework:
messenger:
buses:
command.bus:
middleware: ['validation', 'doctrine_transaction']
query.bus:
default_middleware: allow_no_handlers
event.bus:
default_middleware: allow_no_handlers
Плюс: чёткое разделение ответственности, легче тестировать и масштабировать (например, запросы читать с реплики). Для простого CRUD это избыточно — применять по необходимости.
События и EventDispatcher
Компонент EventDispatcher реализует паттерн «Наблюдатель». Есть события ядра (kernel.*) и свои доменные события.
- Event Listener — метод, подписанный на событие (регистрируется атрибутом или тегом).
- Event Subscriber — класс, который сам объявляет, на какие события подписан (метод
getSubscribedEvents).
Listener через атрибут:
class RequestListener
{
#[AsEventListener(event: KernelEvents::REQUEST, priority: 10)]
public function onKernelRequest(RequestEvent $event): void
{
// ...
}
}
Subscriber:
class LocaleSubscriber implements EventSubscriberInterface
{
public static function getSubscribedEvents(): array
{
return [
KernelEvents::REQUEST => ['onKernelRequest', 20], // [метод, приоритет]
KernelEvents::EXCEPTION => 'onException',
];
}
public function onKernelRequest(RequestEvent $event): void { /* ... */ }
public function onException(ExceptionEvent $event): void { /* ... */ }
}
Свои доменные события:
final class OrderPlacedEvent
{
public function __construct(public readonly Order $order) {}
}
// Диспатч
$this->eventDispatcher->dispatch(new OrderPlacedEvent($order));
Нюансы: приоритеты (кто раньше сработает), stopPropagation() (остановить дальнейших слушателей). Разница listener vs subscriber: listener настраивается снаружи (в атрибуте/конфиге), subscriber сам «знает», на что подписан (список в коде класса). Для доменных событий с фоновой обработкой часто используют Messenger (event bus) вместо синхронного EventDispatcher.
Console — консольные команды
Компонент Console — свои CLI-команды (bin/console).
#[AsCommand(name: 'app:send-report', description: 'Отправить ежедневный отчёт')]
class SendReportCommand extends Command
{
public function __construct(private ReportService $reports)
{
parent::__construct();
}
protected function configure(): void
{
$this
->addArgument('email', InputArgument::REQUIRED, 'Кому отправить')
->addOption('force', 'f', InputOption::VALUE_NONE, 'Игнорировать кэш');
}
protected function execute(InputInterface $input, OutputInterface $output): int
{
$io = new SymfonyStyle($input, $output);
$email = $input->getArgument('email');
$io->title('Генерация отчёта');
$io->progressStart(100);
// ... работа с $io->progressAdvance();
$io->progressFinish();
$io->success("Отчёт отправлен на $email");
return Command::SUCCESS; // или FAILURE / INVALID
}
}
Запуск: php bin/console app:send-report user@mail.com --force. SymfonyStyle даёт удобный вывод (заголовки, таблицы, прогресс-бары, вопросы). Полезные встроенные: cache:clear, debug:container, debug:router, debug:autowiring, make:* (MakerBundle), doctrine:*.
Twig — шаблоны
Twig — шаблонизатор Symfony.
{# templates/product/show.html.twig #}
{% extends 'base.html.twig' %}
{% block title %}{{ product.name }}{% endblock %}
{% block body %}
<h1>{{ product.name }}</h1> {# {{ }} экранирует вывод — защита от XSS #}
<p>{{ product.price|number_format(2, '.', ' ') }} ₽</p>
{% for item in items %}
<li>{{ item.title }}</li>
{% else %}
<li>Ничего нет</li>
{% endfor %}
{% if is_granted('ROLE_ADMIN') %}
<a href="{{ path('product_edit', {id: product.id}) }}">Редактировать</a>
{% endif %}
{% endblock %}
Основное: наследование (extends/block), инклюды (include), фильтры (|upper, |date, |number_format), функции (path(), asset(), is_granted()), автоэкранирование вывода, макросы (переиспользуемые кусочки разметки).
Кастомное расширение Twig — свои фильтры/функции:
class AppExtension extends AbstractExtension
{
public function getFilters(): array
{
return [new TwigFilter('price', [$this, 'formatPrice'])];
}
public function formatPrice(float $value): string
{
return number_format($value, 2, '.', ' ') . ' ₽';
}
}
Twig Components (современный подход) — компонентный UI с классом-логикой и шаблоном (похоже на компоненты Blade/Vue). Логику в шаблоны не тащат — только отображение.
Mailer — почта
Компонент Mailer отправляет письма. Транспорт задаётся через MAILER_DSN (SMTP, или сервисы вроде Mailgun/SES).
use Symfony\Component\Mailer\MailerInterface;
use Symfony\Component\Mime\Email;
public function __construct(private MailerInterface $mailer) {}
$email = (new Email())
->from('noreply@shop.dev')
->to($user->getEmail())
->subject('Заказ оформлен')
->text('Спасибо за заказ!')
->html('<p>Спасибо за заказ!</p>');
$this->mailer->send($email);
Для писем с шаблоном Twig — TemplatedEmail (->htmlTemplate('emails/order.html.twig')->context([...])). Если Mailer настроен с транспортом Messenger, отправка идёт асинхронно через очередь (не тормозит запрос). Есть удобные Notifier для SMS/Slack/push.
HTTP Client
Компонент HttpClient — делать запросы к внешним API (замена cURL/Guzzle).
use Symfony\Contracts\HttpClient\HttpClientInterface;
public function __construct(private HttpClientInterface $client) {}
$response = $this->client->request('GET', 'https://api.example.com/users', [
'headers' => ['Authorization' => 'Bearer '.$token],
'query' => ['page' => 1],
]);
$status = $response->getStatusCode();
$data = $response->toArray(); // распарсить JSON в массив
Особенности: ленивость (запрос реально уходит при чтении ответа), потоковость, конкурентные запросы (несколько запросов параллельно), «scoped» клиенты с базовым URL и настройками под конкретный API.
Кэширование
- Cache Component (PSR-6 / PSR-16) — кэш данных в коде. Адаптеры: filesystem, Redis, Memcached, APCu.
use Symfony\Contracts\Cache\CacheInterface;
use Symfony\Contracts\Cache\ItemInterface;
public function __construct(private CacheInterface $cache) {}
$value = $this->cache->get('stats_'.$id, function (ItemInterface $item) use ($id) {
$item->expiresAfter(3600);
$item->tag(['stats']); // тег для групповой инвалидации
return $this->computeStats($id); // выполнится только при промахе кэша
});
// Инвалидация
$this->cache->delete('stats_'.$id);
- PSR-6 vs PSR-16: PSR-6 — «пул + item» (гибко, с метаданными, тегами); PSR-16 (SimpleCache) — простой
get/set/delete. - Теги (
TagAwareCache) — инвалидировать группу ключей разом. - HTTP-кэш — заголовки
Cache-Control,ETag, встроенный reverse-proxy Symfony (HttpCache) или Varnish. - Кэш контейнера и конфигурации — на проде Symfony компилирует контейнер и конфиги в PHP-файлы в
var/cache(после деплоя делаютcache:clear/cache:warmup).
Rate Limiter, Lock, Workflow, Scheduler
Rate Limiter — ограничение частоты (защита от brute force, лимиты API). Стратегии: token_bucket, sliding_window, fixed_window.
framework:
rate_limiter:
login:
policy: 'sliding_window'
limit: 5
interval: '1 minute'
public function __construct(private RateLimiterFactory $loginLimiter) {}
$limiter = $this->loginLimiter->create($request->getClientIp());
if (false === $limiter->consume(1)->isAccepted()) {
throw new TooManyRequestsHttpException(); // HTTP 429
}
Lock — распределённые блокировки (чтобы одну задачу не выполняли два процесса одновременно):
public function __construct(private LockFactory $lockFactory) {}
$lock = $this->lockFactory->createLock('report-generation');
if ($lock->acquire()) {
try { /* ... */ } finally { $lock->release(); }
}
Workflow — конечный автомат (state machine) для сущностей со сложным жизненным циклом (заказ: new → paid → shipped → delivered). Описываешь состояния (places) и переходы (transitions), а компонент следит, чтобы нельзя было перейти «не туда».
if ($workflow->can($order, 'pay')) {
$workflow->apply($order, 'pay'); // применит переход и вызовет события
}
Scheduler — планировщик задач в коде (современная альтернатива cron для повторяющихся сообщений Messenger): описываешь расписание (RecurringMessage::every('1 day', ...)), а воркер messenger:consume scheduler_... его выполняет.
Профайлер, логи и отладка
- Web Profiler / Debug Toolbar (в
dev) — панель внизу страницы: сколько запросов к БД (ловить N+1!), какие сервисы, время, память, события, письма, security-токен. php bin/console debug:container— список сервисов;debug:router— маршруты;debug:autowiring— что можно внедрить по типу;debug:event-dispatcher— слушатели событий.- Логи — компонент Monolog (
var/log/), каналы (channels) и обработчики (handlers) настраиваются по окружениям (в prod — только warning+, в dev — всё). dump()/dd()(VarDumper) — удобный вывод переменных (в браузере и в тулбаре).
Тестирование
- PHPUnit — основной инструмент.
KernelTestCase— тесты с доступом к контейнеру (можно достать реальные сервисы, EntityManager) — интеграционные тесты.WebTestCase— функциональные тесты: эмулируют HTTP-запросы к приложению без реального сервера.
class ProductControllerTest extends WebTestCase
{
public function testShow(): void
{
$client = static::createClient();
$client->request('GET', '/products/1');
$this->assertResponseIsSuccessful();
$this->assertResponseStatusCodeSame(200);
$this->assertSelectorTextContains('h1', 'Laptop');
}
public function testServiceFromContainer(): void
{
self::bootKernel();
$service = static::getContainer()->get(ProductService::class);
$this->assertNotNull($service);
}
}
Полезное: клиент умеет ходить по ссылкам и отправлять формы ($client->submitForm(...)), работа с БД в тестах (окружение test, транзакции/пересоздание схемы), фикстуры, $client->loginUser($user) для тестов от имени пользователя. Юнит-тесты сервисов — обычный PHPUnit с моками зависимостей.
Производительность и деплой
- OPcache обязателен; на проде — preloading (
config/preload.php) держит классы в памяти между запросами. - Прогрев кэша при деплое:
composer install --no-dev --optimize-autoloader, затемcache:clear+cache:warmup(контейнер и конфиги компилируются в PHP). - APCu — для кэша метаданных Doctrine и системного кэша.
- Ловля N+1 через профайлер; индексы БД; гидрация в массивы для read-only.
- Runtime: обычный PHP-FPM, либо резидентные раннеры — FrankenPHP / RoadRunner / Swoole (держат приложение в памяти, как Octane в Laravel) — большой прирост, но нужна аккуратность с состоянием сервисов между запросами.
- Тяжёлые задачи — в Messenger (асинхронно), почта — асинхронно через транспорт.
Архитектура и паттерны
- Тонкие контроллеры — бизнес-логику выносят в сервисы (классы в
src/Serviceили доменные слои), контроллер только принимает запрос и отдаёт ответ. - DTO — типизированный перенос данных (вход API через
#[MapRequestPayload], выход через Serializer/группы). - Value Objects + Embeddables — для значений домена.
- CQRS на Messenger (командная/запросная/событийная шины) — для сложных доменов.
- Слоистая / гексагональная архитектура, DDD — Symfony хорошо ложится на это благодаря явному DI и отсутствию «магии».
- Встроенные паттерны: DI/IoC (контейнер), Observer (EventDispatcher), Decorator (декораторы сервисов), Strategy (tagged services), Data Mapper (Doctrine).
Symfony vs Laravel
| Аспект | Symfony | Laravel |
|---|---|---|
| Философия | явность, гибкость, строгость | скорость разработки, «магия», DX |
| ORM | Doctrine (Data Mapper) | Eloquent (Active Record) |
| Сохранение | persist() + flush() через EntityManager |
$model->save() |
| DI | контейнер, autowiring, компилируется | контейнер, autowiring |
| Расширяемость | kernel-события, compiler passes, декораторы | сервис-провайдеры, фасады |
| Конфигурация | YAML/PHP/атрибуты, явная | минимум, из коробки |
| Очереди | Messenger (шина сообщений, несколько шин) | Queues / Horizon |
| Шаблоны | Twig | Blade |
| Авторизация | Voters, access_control |
Policies, Gates |
| Порог входа | выше | ниже |
| Где силён | крупные/долгоживущие проекты, строгая архитектура | быстрый старт, MVP, продуктовая разработка |
Важно: Laravel использует ряд компонентов Symfony под капотом (HttpFoundation, Routing, Console и др.) — это разные подходы, а не «конкуренты на уничтожение».
Вероятные вопросы
Чем Doctrine отличается от Eloquent? Doctrine — Data Mapper: сущность не знает про БД, за сохранение отвечает EntityManager (persist+flush). Eloquent — Active Record: модель сама себя сохраняет (save). Doctrine строже и лучше для сложных доменов, Eloquent проще и быстрее в разработке.
Что такое persist() и flush()? persist — сказать менеджеру «возьми объект под контроль»; flush — выполнить все накопленные изменения одним разом в транзакции. Для обновления существующего (managed) объекта persist не нужен — достаточно изменить объект и вызвать flush.
Какие состояния бывают у сущности? new (Doctrine не знает), managed (под контролем, изменения отслеживаются), detached (менеджер забыл о нём), removed (помечен на удаление). Изменения сохраняются только для managed-сущностей.
Что такое Unit of Work? Внутренний механизм Doctrine: отслеживает изменения объектов и при flush вычисляет минимальный набор SQL-запросов, выполняя их пачкой в транзакции.
Что такое autowiring и autoconfigure? Autowiring — контейнер подставляет зависимости по типу аргумента конструктора. Autoconfigure — автоматически навешивает теги по интерфейсам (подписчики, команды и т.п.).
Как внедрить конкретную реализацию, если интерфейс реализуют несколько классов? Через #[Autowire(service: ...)], алиасы/bind в services.yaml или #[AsAlias].
Что такое декоратор сервиса? Обёртка над существующим сервисом с тем же интерфейсом, добавляющая поведение (лог, кэш), сохраняя оригинал внутри. Настраивается #[AsDecorator].
Что такое tagged services и зачем? Собрать все сервисы с общим тегом/интерфейсом в коллекцию (набор стратегий/обработчиков) и внедрить как iterable — расширяемость без правки кода.
Что такое compiler pass? Способ вмешаться в контейнер на этапе компиляции (например, собрать сервисы с тегом в агрегатор). Продвинутый механизм расширения.
Что такое kernel-события и зачем они? События на этапах обработки запроса (kernel.request, controller, view, response, exception, terminate). Через подписку на них расширяют поведение, не переопределяя классы.
Firewall, authentication, authorization — в чём разница? Firewall — зона защиты и способ входа; authentication — «кто ты» (authenticators); authorization — «что тебе можно» (роли, access_control, voters).
Что такое Voter? Класс, решающий, можно ли пользователю сделать действие над объектом (гибкая авторизация, аналог Policy). Проверка — denyAccessUnlessGranted()/isGranted().
Что такое Passport в системе безопасности? «Пропуск» с информацией о пользователе (UserBadge) и «значками» (проверка пароля, CSRF, remember-me), который возвращает authenticator.
Как решать N+1 в Doctrine? Загружать связь заранее через JOIN + addSelect в QueryBuilder/DQL; для больших коллекций — EXTRA_LAZY; ловить N+1 в профайлере.
LAZY, EAGER, EXTRA_LAZY — что это? Режимы загрузки связей: LAZY — при обращении; EAGER — сразу вместе с сущностью; EXTRA_LAZY — для больших коллекций (count/contains/срезы без полной загрузки).
Что такое Messenger? Компонент для сообщений и очередей: сообщение → шина (dispatch) → обработчик; транспорт синхронный или асинхронный (Redis, AMQP, Doctrine). Воркер — messenger:consume. Поддерживает несколько шин (CQRS), retry и failure transport.
Как реализовать CQRS в Symfony? Через несколько шин Messenger (command/query/event) со своими middleware — разделение изменения состояния и чтения данных.
DQL vs SQL? DQL оперирует объектами и их полями (сущностями), а не таблицами/колонками. Для сложных случаев — нативный SQL через DBAL.
Listener vs Subscriber? Listener настраивается снаружи (атрибут/конфиг); Subscriber сам объявляет подписки в getSubscribedEvents. Функционально похожи; приоритеты и stopPropagation управляют порядком/остановкой.
Как обрабатываются исключения? Событие kernel.exception: слушатели превращают исключение в понятный Response (страница ошибки/JSON). В dev — подробная страница, в prod — общая.
Зачем cache:clear/cache:warmup на проде? На проде контейнер и конфигурация компилируются в PHP-файлы в var/cache; после деплоя кэш нужно пересобрать.
Где хранить секреты? Реальные секреты — в .env.local (вне git) или в Symfony Secrets (зашифрованное хранилище). В .env — значения по умолчанию для dev.
Что такое Symfony Flex? Плагин Composer, который через «рецепты» автоматически настраивает пакеты (конфиги, регистрация bundle, .env) при установке.
Чем embeddable отличается от связи? Embeddable — value object, встроенный в ту же таблицу сущности (нет отдельной таблицы и внешнего ключа), в отличие от связи между сущностями.
Оптимистичная vs пессимистичная блокировка в Doctrine? Оптимистичная — через #[ORM\Version] (проверка версии при сохранении, иначе OptimisticLockException); пессимистичная — LockMode::PESSIMISTIC_WRITE (SQL FOR UPDATE).