TeoreticQuiz

Symfony

Материал для подготовки к собеседованию (Middle / Senior). Термины на английском там, где это принято. Ориентир — современные версии Symfony 6/7 (актуальная стабильная — 8.x, текущая LTS — 7.4). Синтаксис — на атрибутах PHP 8 (в проекте так по умолчанию).

Где тема сложнее — объясняю проще и «на пальцах», потому что Symfony часто идёт тяжелее, чем 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:

  1. Контейнер зависимостей — фабрика всех объектов приложения.
  2. HttpKernel и события — превращение Request в Response, где в каждой точке можно вмешаться.
  3. 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) — в каждой точке можно вмешаться слушателем.

Упрощённо поток такой:

  1. public/index.php — точка входа: создаётся Request::createFromGlobals() и ядро, вызывается $kernel->handle($request).
  2. kernel.request — самое начало. Здесь работает роутер (определяет, какой контроллер вызвать), стартует сессия, отрабатывает система безопасности (firewall).
  3. kernel.controller — контроллер уже определён, но ещё не вызван. Можно его подменить/донастроить.
  4. kernel.controller_arguments + Argument Resolvers — Symfony собирает аргументы для метода контроллера (например, по типу Request $request или сущность по id).
  5. Вызывается контроллер, возвращает Response (или что угодно).
  6. kernel.view — срабатывает, только если контроллер вернул НЕ Response (например, массив/объект). Слушатель превращает это в Response (так работают, например, API-платформы).
  7. kernel.response — Response готов, можно его модифицировать (заголовки, куки).
  8. kernel.terminate — после отправки ответа клиенту (тяжёлые задачи «на потом»: отправка почты и т.п.).
  9. 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) в запросе (SQL FOR 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).