Cykl życia żądania w Symfony: HttpKernel i zdarzenia kernela
17 listopada, 2026 | 7 minuty czytania
Każde żądanie HTTP w aplikacji Symfony przechodzi tę samą drogę: front controller uruchamia kernel, komponent HttpKernel zamienia obiekt Request w obiekt Response, a w kluczowych momentach wysyła zdarzenia kernela (kernel events). Do tych zdarzeń podpinają się routing, Security, Profiler i Twój własny kod. Kto rozumie ten cykl, wie, gdzie umieścić logikę, dlaczego listener nie działa i skąd biorą się różnice między środowiskiem dev a produkcją.
Artykuł zweryfikowany dla Symfony 8.1 i 7.4 LTS. Jest częścią przewodnika Symfony: kompletny przewodnik po frameworku PHP.
Cykl życia żądania w pigułce
| Element | Rola |
|---|---|
| Punkt wejścia | public/index.php (front controller) |
| Uruchomienie aplikacji | komponent Runtime (vendor/autoload_runtime.php) |
| Obsługa żądania | HttpKernel::handle() |
| Obiekty wejścia i wyjścia | Request i Response z komponentu HttpFoundation |
| Zdarzenia | 8 zdarzeń kernela, stałe w klasie KernelEvents |
| Wybór kontrolera | ControllerResolver na podstawie atrybutu _controller ustawionego przez routing |
| Argumenty kontrolera | ArgumentResolver i resolvery wartości (value resolvers) |
| Podgląd w praktyce | php bin/console debug:event-dispatcher i panel Events w Profilerze |
Droga żądania od index.php do odpowiedzi

Cykl życia żądania w Symfony: 8 zdarzeń kernela, wczesna odpowiedź i obsługa wyjątków
Główna ścieżka biegnie z góry na dół, ale są od niej dwa skróty. Listener kernel.request może od razu ustawić odpowiedź, np. przekierowanie na logowanie, i wtedy kontroler w ogóle się nie wykonuje. Wyjątek zgłoszony na dowolnym etapie trafia do kernel.exception, a gotowa strona błędu przechodzi jeszcze przez kernel.response.
Front controller, komponent Runtime i Kernel
Serwer WWW (nginx, Apache, Caddy) kieruje każde żądanie do jednego pliku: public/index.php. To jedyny punkt wejścia aplikacji, dlatego nazywa się go front controllerem. We współczesnym Symfony ten plik jest bardzo krótki:
// public/index.php
use App\Kernel;
require_once dirname(__DIR__).’/vendor/autoload_runtime.php’;
return function (array $context): Kernel {
return new Kernel($context[’APP_ENV’], (bool) $context[’APP_DEBUG’]);
};
Front controller niczego sam nie uruchamia. Zwraca funkcję, która tworzy obiekt Kernel, a resztą zajmuje się komponent Runtime, wprowadzony w Symfony 5.3:
- Plik autoload_runtime.php, generowany przez wtyczkę Composera, tworzy obiekt Runtime. Domyślnie jest to SymfonyRuntime, odpowiedni dla PHP-FPM z nginx lub Apache.
- Runtime rozwiązuje argumenty funkcji, tutaj tablicę $context ze zmiennymi środowiskowymi i wartościami z pliku .env.
- Funkcja zwraca aplikację, czyli Kernel z ustawionym środowiskiem (APP_ENV) i trybem debugowania (APP_DEBUG).
- Runner uruchamia aplikację. Dla aplikacji HTTP sprowadza się to do utworzenia obiektu Request z danych PHP, wywołania $kernel->handle(), wysłania odpowiedzi i wywołania $kernel->terminate().
Takie rozdzielenie ma praktyczny sens: ta sama aplikacja może działać pod PHP-FPM, w trybie worker FrankenPHP, w RoadRunnerze czy na AWS Lambda bez zmian w kodzie, wystarczy inny Runtime. Kod umieszczony poza zwracaną funkcją wykonuje się przy dołączaniu pliku, więc nie powinien mieć efektów ubocznych.
Co robi Kernel przy pierwszym żądaniu
Klasa App\Kernel dziedziczy po Symfony\Component\HttpKernel\Kernel i korzysta z MicroKernelTrait. Przy pierwszym wywołaniu handle() kernel się „uruchamia” (boot): ładuje bundle, wczytuje skompilowany kontener usług z katalogu var/cache/ i rejestruje listenery. W środowisku produkcyjnym kontener jest kompilowany raz, przy rozgrzewaniu cache, więc kolejne żądania tylko go wczytują. Następnie kernel przekazuje żądanie usłudze http_kernel, czyli obiektowi HttpKernel, który prowadzi właściwy cykl.
Zdarzenia kernela krok po kroku
HttpKernel nie zawiera logiki routingu, bezpieczeństwa ani renderowania. Jego zadaniem jest wywołanie zdarzeń w ustalonej kolejności i uruchomienie kontrolera. Całą resztę robią listenery podpięte do tych zdarzeń przez komponent EventDispatcher. Dzięki temu każdy etap można rozszerzyć bez zmiany kodu frameworka.
| Kolejność | Zdarzenie | Klasa zdarzenia | Do czego służy | Przykładowe listenery Symfony |
|---|---|---|---|---|
| 1 | kernel.request | RequestEvent | Uzupełnienie żądania danymi albo zwrócenie odpowiedzi od razu | RouterListener, LocaleListener, firewall Security |
| 2 | kernel.controller | ControllerEvent | Przygotowanie lub podmiana kontrolera przed wywołaniem | obsługa atrybutu #[Cache], listenery Profilera |
| 3 | kernel.controller_arguments | ControllerArgumentsEvent | Odczyt i zmiana argumentów przekazywanych do kontrolera | listenery atrybutów kontrolera |
| 4 | kernel.view | ViewEvent | Zamiana wyniku kontrolera, który nie jest obiektem Response, w odpowiedź | obsługa atrybutu #[Template] |
| 5 | kernel.response | ResponseEvent | Modyfikacja odpowiedzi: nagłówki, ciasteczka, treść | pasek debugowania, zapis sesji i użytkownika |
| 6 | kernel.finish_request | FinishRequestEvent | Przywrócenie stanu globalnego po zakończeniu żądania, ważne przy sub-requestach | przywrócenie lokalizacji tłumaczeń z żądania nadrzędnego |
| 7 | kernel.terminate | TerminateEvent | Prace po wysłaniu odpowiedzi do klienta | np. wysyłka e-maili z kolejki w pamięci |
| dowolny etap | kernel.exception | ExceptionEvent | Zamiana wyjątku w odpowiedź z błędem | ErrorListener, ExceptionListener Security |
Nazwy zdarzeń są dostępne jako stałe w klasie KernelEvents, np. KernelEvents::REQUEST. Każde zdarzenie dziedziczy po KernelEvent, które udostępnia m.in. getRequest() i isMainRequest().
W obrębie jednego zdarzenia o kolejności decyduje priorytet listenera: wyższy działa wcześniej. Na przykład RouterListener działa na kernel.request z priorytetem 32, a LocaleListener z priorytetem 16, więc lokalizacja może korzystać z parametrów trasy. Aktualną listę listenerów i ich priorytetów w Twojej aplikacji pokaże polecenie:
php bin/console debug:event-dispatcher kernel.request
Nowości w Symfony 8.1: zdarzenia atrybutów kontrolera
Od Symfony 8.1 kernel wysyła też zdarzenia dla atrybutów PHP umieszczonych na kontrolerze, w formacie {zdarzenie}.{KlasaAtrybutu}, np. kernel.controller_arguments.Symfony\Component\HttpKernel\Attribute\Cache. Działa to dla wszystkich zdarzeń kernela z wyjątkiem kernel.request i kernel.terminate. Własny atrybut, np. #[RequiresFeature(’beta’)], można więc obsłużyć listenerem nasłuchującym dokładnie na ten atrybut, bez ręcznego przeglądania refleksji kontrolera. Zdarzenia od kernel.controller_arguments w górę udostępniają także metadane kontrolera (controllerMetadata).
Routing, kontroler i argumenty
kernel.request: routing, lokalizacja, bezpieczeństwo
Pierwsze zdarzenie przygotowuje żądanie. RouterListener dopasowuje adres URL do trasy i zapisuje wynik w atrybutach żądania ($request->attributes): nazwę trasy (_route), kontroler (_controller) i parametry z adresu, np. {slug}. Jeśli żadna trasa nie pasuje, listener zgłasza wyjątek, który kończy się odpowiedzią 404.
Po routingu działa m.in. firewall komponentu Security. Może on sam ustawić odpowiedź, np. przekierowanie na stronę logowania. Wtedy dzieje się coś ważnego: propagacja zdarzenia zostaje zatrzymana, kontroler nie jest wywoływany, a cykl przeskakuje od razu do kernel.response. Ten sam mechanizm możesz wykorzystać we własnym listenerze, np. do obsługi trybu konserwacji.
Wybór kontrolera
ControllerResolver czyta atrybut _controller i zamienia go w wywoływalny obiekt PHP. W aplikacji z FrameworkBundle kontrolery są usługami w kontenerze, więc dostają zależności przez konstruktor i autowiring. Zaraz potem kernel wysyła kernel.controller, w którym listener może przygotować dane dla kontrolera albo podmienić go na inny callable metodą setController().
Rozwiązywanie argumentów
ArgumentResolver analizuje sygnaturę metody kontrolera przez refleksję i dla każdego argumentu pyta kolejne resolvery wartości (ValueResolverInterface), czy potrafią go dostarczyć. Dzięki temu w kontrolerze wystarczy zadeklarować, czego potrzebujesz:
| Argument w kontrolerze | Skąd bierze się wartość |
|---|---|
| string $slug | parametr trasy o tej samej nazwie |
| Request $request | bieżące żądanie |
| #[MapRequestPayload] CreateOrderDto $dto | treść żądania (JSON lub formularz) zdeserializowana do obiektu i zwalidowana |
| #[MapQueryString] SearchQuery $query | parametry z adresu URL zmapowane na obiekt |
| #[MapQueryParameter] int $page = 1 | pojedynczy parametr z adresu URL z walidacją typu |
| #[CurrentUser] User $user | zalogowany użytkownik z komponentu Security |
| Product $product (encja Doctrine) | encja pobrana z bazy na podstawie parametru trasy, przez EntityValueResolver |
| enum typu BackedEnum, Uuid, DateTimeImmutable | parametr trasy przekonwertowany na odpowiedni typ |
Po rozwiązaniu argumentów kernel wysyła kernel.controller_arguments. To ostatni moment, aby odczytać lub zmienić argumenty metodami getArguments() i setArguments().
Własny resolver wartości to dobry sposób na powtarzalne przypadki, np. wstrzykiwanie bieżącego klienta w aplikacji wielodostępnej (multi-tenant). Kontroler deklaruje wtedy Tenant $tenant, a logika ustalania klienta jest w jednym miejscu.
Wywołanie kontrolera
Kontroler zwykle zwraca obiekt Response. Jeśli zwróci coś innego, np. tablicę lub obiekt DTO, kernel wysyła kernel.view, w którym listener musi zamienić ten wynik w odpowiedź. Tak działa atrybut #[Template], który renderuje szablon Twig z tablicy zwróconej przez kontroler. Jeśli żaden listener nie ustawi odpowiedzi, Symfony zgłasza wyjątek.
Odpowiedź, zakończenie i obsługa wyjątków
kernel.response: ostatnie poprawki odpowiedzi
Niezależnie od tego, skąd pochodzi odpowiedź (z listenera kernel.request, z kontrolera czy z kernel.view), przed wysłaniem przechodzi przez kernel.response. To właściwe miejsce na globalne nagłówki, np. Content-Security-Policy czy X-Request-Id, ciasteczka i nagłówki cache. Z tego zdarzenia korzysta pasek debugowania, który w środowisku dev wstrzykuje swój kod przed </body>, oraz komponent Security, który zapisuje zalogowanego użytkownika w sesji.
kernel.finish_request: sprzątanie po żądaniu
To zdarzenie następuje po kernel.response i służy do przywrócenia stanu globalnego aplikacji. Ma znaczenie głównie przy sub-requestach: gdy zakończy się żądanie podrzędne, np. tłumacz wraca do lokalizacji żądania nadrzędnego.
kernel.terminate: praca po wysłaniu odpowiedzi
Po wysłaniu odpowiedzi Runtime wywołuje $kernel->terminate(), a kernel wysyła kernel.terminate. Pod PHP-FPM i FrankenPHP Symfony najpierw kończy połączenie z klientem (funkcją fastcgi_finish_request()), więc użytkownik dostaje odpowiedź, a listenery działają już w tle. To dobre miejsce na krótkie zadania, które nie muszą opóźniać odpowiedzi.
Trzy zastrzeżenia, o których warto pamiętać:
- Pod innymi serwerami odpowiedź trafia do klienta dopiero po zakończeniu wszystkich listenerów kernel.terminate.
- Zmiany w obiekcie Response wprowadzone w tym zdarzeniu są pod PHP-FPM i FrankenPHP ignorowane, bo odpowiedź została już wysłana. W trybie debugowania mogą jednak zadziałać, co prowadzi do różnic między dev a produkcją.
- Proces PHP pozostaje zajęty do końca listenerów. Ciężkie lub długie zadania, np. generowanie raportów czy wywołania zewnętrznych API, lepiej przekazać do kolejki przez komponent Messenger.
kernel.exception: jeden punkt obsługi błędów
Cała metoda handle() jest objęta blokiem try/catch. Wyjątek zgłoszony na dowolnym etapie, w listenerze, kontrolerze czy szablonie, wywołuje kernel.exception. Listenery mogą ustawić własną odpowiedź albo podmienić wyjątek na inny.
Domyślnie zajmuje się tym ErrorListener. Zamienia wyjątek w FlattenException i ustala kod odpowiedzi:
- wyjątek implementujący HttpExceptionInterface, np. NotFoundHttpException czy AccessDeniedHttpException, przekazuje swój kod statusu i nagłówki,
- wyjątek implementujący RequestExceptionInterface daje kod 400,
- każdy inny wyjątek daje kod 500.
Następnie listener uruchamia kontroler błędów, który renderuje stronę błędu: szczegółową w dev, a w produkcji szablon z katalogu templates/bundles/TwigBundle/Exception/, np. error404.html.twig. Komponent Security ma własny ExceptionListener, który wyjątki dostępu zamienia w przekierowanie na logowanie lub odpowiedź 403.
Po obsłużeniu wyjątku odpowiedź błędu również przechodzi przez kernel.response, więc globalne nagłówki trafiają także do stron błędów.
Sub-requesty: żądania wewnątrz żądania
Podczas obsługi jednego żądania aplikacja może wywołać HttpKernel::handle() ponownie, z typem HttpKernelInterface::SUB_REQUEST. Takie żądanie podrzędne przechodzi pełny cykl zdarzeń, od kernel.request do kernel.response, ale nie jest wysyłane do przeglądarki jako osobna odpowiedź.
W praktyce sub-requesty powstają w trzech sytuacjach:
| Sposób | Gdzie | Typowe zastosowanie |
|---|---|---|
| $this->forward(’App\\Controller\\…’) | kontroler (AbstractController) | przekazanie obsługi do innego kontrolera bez przekierowania |
| {{ render(controller(’…’)) }} | szablon Twig | osadzenie fragmentu strony, np. koszyka czy menu |
| {{ render_esi(controller(’…’)) }} | szablon Twig z reverse proxy | fragment z własnym czasem cache (Edge Side Includes) |
Co trzeba wiedzieć, pisząc listenery
Listener podpięty do zdarzenia kernela uruchomi się dla każdego żądania, także podrzędnego. Jeśli logika ma działać raz na wizytę użytkownika, np. logowanie, liczniki, nagłówki bezpieczeństwa czy limity zapytań, trzeba to sprawdzić jawnie:
public function __invoke(RequestEvent $event): void
{
if (!$event->isMainRequest()) {
return;
}
// logika tylko dla żądania głównego
}
Część listenerów Symfony, np. związanych z bezpieczeństwem, sama działa tylko dla żądania głównego. W usługach poza listenerami do bieżącego żądania służy RequestStack: metoda getMainRequest() zwraca żądanie główne, getCurrentRequest() aktualnie obsługiwane, a getParentRequest() żądanie nadrzędne.
Każdy sub-request to kolejny pełny cykl z routingiem, resolverami i listenerami. Strona osadzająca kilkanaście fragmentów przez render(controller()) płaci za to czasem odpowiedzi, dlatego w nowych projektach do składania widoków z komponentów częściej sięga się po Twig Components, które nie tworzą osobnych żądań.
Własny listener zdarzeń kernela: dwa przykłady
Dzięki autokonfiguracji wystarczy klasa z atrybutem #[AsEventListener] w katalogu src/. Nie trzeba niczego rejestrować w plikach konfiguracyjnych.
Przykład 1: nagłówki bezpieczeństwa na każdej odpowiedzi
namespace App\EventListener;
use Symfony\Component\EventDispatcher\Attribute\AsEventListener;
use Symfony\Component\HttpKernel\Event\ResponseEvent;
use Symfony\Component\HttpKernel\KernelEvents;
#[AsEventListener(event: KernelEvents::RESPONSE)]
final class SecurityHeadersListener
{
public function __invoke(ResponseEvent $event): void
{
if (!$event->isMainRequest()) {
return;
}
$headers = $event->getResponse()->headers;
$headers->set(’X-Content-Type-Options’, 'nosniff’);
$headers->set(’Referrer-Policy’, 'strict-origin-when-cross-origin’);
$headers->set(’X-Frame-Options’, 'DENY’);
}
}
Listener działa na kernel.response, więc nagłówki trafią do każdej odpowiedzi głównego żądania: zwykłych stron, odpowiedzi API, przekierowań i stron błędów.
Przykład 2: tryb konserwacji z wczesną odpowiedzią
namespace App\EventListener;
use Symfony\Component\DependencyInjection\Attribute\Autowire;
use Symfony\Component\EventDispatcher\Attribute\AsEventListener;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Event\RequestEvent;
use Symfony\Component\HttpKernel\KernelEvents;
#[AsEventListener(event: KernelEvents::REQUEST, priority: 64)]
final class MaintenanceListener
{
public function __construct(
#[Autowire(env: 'bool:APP_MAINTENANCE’)]
private readonly bool $maintenance,
) {
}
public function __invoke(RequestEvent $event): void
{
if (!$this->maintenance || !$event->isMainRequest()) {
return;
}
$event->setResponse(new Response(
'Trwają prace serwisowe. Wróć za kilka minut.’,
Response::HTTP_SERVICE_UNAVAILABLE,
[’Retry-After’ => '600′],
));
}
}
Priorytet 64 jest wyższy niż priorytet routingu (32), więc listener działa, zanim Symfony zacznie dopasowywać trasę czy sprawdzać uprawnienia. Ustawienie odpowiedzi zatrzymuje dalszą obsługę i przenosi cykl od razu do kernel.response. Zmienną APP_MAINTENANCE=0 dodaj do pliku .env, aby aplikacja działała także wtedy, gdy na serwerze nie jest ustawiona. Kod 503 z nagłówkiem Retry-After informuje wyszukiwarki, że przerwa jest tymczasowa i strona nie powinna wypaść z indeksu.
Listener czy subscriber?
| Listener (#[AsEventListener]) | Subscriber (EventSubscriberInterface) | |
|---|---|---|
| Liczba zdarzeń | jedno zdarzenie na metodę, atrybut można powtórzyć | wiele zdarzeń w jednej klasie |
| Konfiguracja | atrybut na klasie lub metodzie | metoda getSubscribedEvents() |
| Kiedy wybrać | prosta, pojedyncza reakcja na zdarzenie | kilka powiązanych reakcji, np. start i koniec pomiaru czasu |
Obie formy działają tak samo w trakcie cyklu żądania. To kwestia organizacji kodu, a nie wydajności.
Debugowanie i wydajność cyklu żądania
Narzędzia do podglądu
| Narzędzie | Co pokazuje |
|---|---|
| php bin/console debug:event-dispatcher | wszystkie zdarzenia z listenerami i priorytetami; z nazwą zdarzenia tylko jego listenery |
| php bin/console router:match /sciezka | która trasa i który kontroler obsłużą dany adres |
| php bin/console debug:router | listę wszystkich tras z metodami HTTP i ścieżkami |
| Profiler, panel Events | listenery wywołane w konkretnym żądaniu i te, które się nie uruchomiły |
| Profiler, panel Performance | oś czasu żądania z podziałem na zdarzenia, listenery, kontroler i szablony |
| Profiler, panel Request | atrybuty żądania, w tym _route i _controller, oraz sub-requesty |
Gdy listener „nie działa”, panel Events zwykle od razu pokazuje przyczynę: listener nie został zarejestrowany, ma zbyt niski priorytet albo wcześniejszy listener zatrzymał propagację, ustawiając odpowiedź.
Wydajność: listenery działają przy każdym żądaniu
Listener zdarzenia kernela wykonuje się przy każdym żądaniu, a często także przy każdym sub-requeście. Kilka zasad, które stosujemy w projektach:
- Wychodź z listenera jak najwcześniej. Sprawdzenie isMainRequest(), trasy czy nagłówka powinno poprzedzać jakąkolwiek kosztowną operację.
- Nie wykonuj zapytań do bazy ani wywołań HTTP w kernel.request dla wszystkich tras. Jeśli dane są potrzebne tylko w części aplikacji, lepszy jest resolver wartości albo atrybut kontrolera.
- Ciężkie zależności ładuj leniwie. Usługi oznaczone jako lazy, np. przez #[Autowire(lazy: true)], powstają dopiero przy pierwszym użyciu, a nie przy każdym utworzeniu listenera.
- Prace po odpowiedzi przenoś do kolejki. kernel.terminate nie spowalnia użytkownika, ale blokuje proces PHP-FPM.
Tryb worker: jeden kernel dla wielu żądań
Pod PHP-FPM każde żądanie zaczyna się od zera: tworzony jest nowy kernel i nowy kontener usług. W trybie worker FrankenPHP (a także w RoadRunnerze) aplikacja jest uruchamiana raz, a ten sam kernel obsługuje kolejne żądania. Daje to wyraźnie krótsze czasy odpowiedzi, ale zmienia zasady gry:
- Stan usług przechodzi między żądaniami. Właściwość ustawiona w usłudze podczas jednego żądania, np. bieżący klient czy bufor danych, będzie widoczna w następnym. Usługi przechowujące stan powinny implementować ResetInterface, aby Symfony czyściło je po każdym żądaniu.
- Wycieki stanu to także ryzyko bezpieczeństwa. Dane jednego użytkownika mogą trafić do odpowiedzi dla innego, jeśli usługa nie zostanie zresetowana.
- Bezpiecznik w Symfony 8.1. Zmienna FRANKENPHP_RESET_KERNEL=1 sprawia, że po każdym żądaniu powstaje świeży kernel z już skompilowanego kontenera. To rozwiązanie przejściowe na czas audytu usług, kosztem części zysku wydajności.
Więcej o optymalizacji opisuje artykuł Optymalizacja wydajności Symfony, a o trybie worker artykuł Runtime component: FrankenPHP i RoadRunner.
Typowe błędy związane z cyklem żądania
- Listener nie sprawdza isMainRequest(). Logika wykonuje się kilka razy na jedną wizytę, bo strona osadza fragmenty przez render(controller()). Skutek: zdublowane wpisy w logach, podwójnie naliczone limity, zbędne zapytania.
- Zły priorytet listenera. Listener na kernel.request, który potrzebuje parametrów trasy lub zalogowanego użytkownika, musi działać po routingu lub po firewallu, czyli z odpowiednio niższym priorytetem. Ustawiony za wysoko dostanie puste dane.
- Modyfikowanie odpowiedzi w kernel.terminate. W dev zmiana bywa widoczna, w produkcji pod PHP-FPM już nie, bo odpowiedź została wysłana. Nagłówki i treść zmieniaj w kernel.response.
- Długie zadania w kernel.terminate. Użytkownik nie czeka, ale proces PHP-FPM jest zajęty. Przy większym ruchu kończą się wolne procesy i kolejne żądania czekają w kolejce. Takie zadania przenieś do Messengera.
- Łapanie wyjątków w każdym kontrolerze. Powtarzane bloki try/catch zastępuje jeden listener kernel.exception, np. zamieniający wyjątki domenowe na odpowiedzi API w formacie JSON. Kod jest krótszy, a błędy obsługiwane spójnie.
- Stan w usługach przy trybie worker. Kod pisany pod PHP-FPM zakłada, że usługi powstają od nowa przy każdym żądaniu. Po przejściu na FrankenPHP w trybie worker usługi bez ResetInterface przenoszą dane między użytkownikami.
- Kosztowna logika w kernel.request dla wszystkich tras. Zapytanie do bazy wykonywane w listenerze spowalnia także zasoby statyczne obsługiwane przez Symfony, endpointy health check i API. Ogranicz listener do tras, które faktycznie potrzebują tych danych.
[Do uzupełnienia przez eksperta: przykład z projektu Codefia, np. błąd wykryty w panelu Events lub problem z przejściem na tryb worker.]
FAQ: cykl życia żądania w Symfony
Ile zdarzeń kernela ma Symfony?
Osiem: kernel.request, kernel.controller, kernel.controller_arguments, kernel.view, kernel.response, kernel.finish_request, kernel.terminate oraz kernel.exception, wywoływane przy wyjątku na dowolnym etapie. Od Symfony 8.1 kernel wysyła też zdarzenia dla atrybutów kontrolera.
Czym jest HttpKernel w Symfony?
HttpKernel to komponent, który zamienia obiekt Request w obiekt Response. Sam nie zawiera logiki routingu ani bezpieczeństwa: wywołuje zdarzenia w ustalonej kolejności, rozwiązuje kontroler i jego argumenty, a resztę pracy wykonują listenery.
Jaka jest różnica między kernel.response a kernel.terminate?
kernel.response działa przed wysłaniem odpowiedzi i pozwala ją zmienić. kernel.terminate działa po wysłaniu odpowiedzi: służy do prac w tle, a zmiany w odpowiedzi nie trafią już do użytkownika.
Kiedy wywoływane jest zdarzenie kernel.view?
Tylko wtedy, gdy kontroler nie zwróci obiektu Response, np. zwróci tablicę lub obiekt DTO. Listener kernel.view musi wtedy zamienić ten wynik w odpowiedź, tak jak robi to atrybut #[Template].
Jak sprawdzić, które listenery działają w mojej aplikacji?
Polecenie php bin/console debug:event-dispatcher wypisze wszystkie zdarzenia z listenerami i priorytetami. Dla konkretnego żądania tę samą informację, wraz z listenerami, które się nie uruchomiły, pokazuje panel Events w Profilerze.
Czy listener może zatrzymać wywołanie kontrolera?
Tak. Jeśli listener kernel.request ustawi odpowiedź metodą setResponse(), propagacja zdarzenia zostaje zatrzymana, kontroler nie jest wywoływany, a cykl przechodzi od razu do kernel.response. Tak działa m.in. przekierowanie na stronę logowania.
Podsumowanie
Cykl życia żądania w Symfony to prosta konstrukcja: front controller i Runtime uruchamiają kernel, HttpKernel wywołuje zdarzenia w stałej kolejności, a całą pracę wykonują listenery. Znajomość tej kolejności pozwala umieścić logikę we właściwym miejscu, szybko diagnozować problemy w Profilerze i bezpiecznie przejść na tryb worker.
Więcej o frameworku znajdziesz w przewodniku Symfony: kompletny przewodnik po frameworku PHP, a o wersjach i ich wsparciu w artykule Cykl wydań Symfony: wersje LTS i okresy wsparcia.