Jak działa cykl życia żądania w Laravel?

Question

IT Interview Practice · Accepted Answer

Każde żądanie w Laravel wchodzi przez jeden front controller, `public/index.php`, jest sterowane przez **HTTP Kernel** przez stos **middleware** i **router** do **kontrolera**, i zwraca `Response` — po czym uruchamia się middleware **terminable**.

## Etapy

```
public/index.php  ── autoload + bootstrap aplikacji
   ▼
HTTP Kernel::handle($request)
   ▼
Bootstrappers  ── env, config, providers (register + boot)
   ▼
Global middleware  ── (TrustProxies, HandleCors, ...)
   ▼
Router dispatch  ── dopasuj route
   ▼
Route / group middleware  ── (auth, throttle, verified, ...)
   ▼
Controller (or closure)  ── Twoja logika → zwraca Response
   ▼
Response ──▶ client
   ▼
Kernel::terminate  ── terminable middleware (np. zapis sesji, logging)
```

1. **Front controller** — `index.php` ładuje autoload Composera i bootstrapuje kontener aplikacji.
2. **Kernel::handle** — HTTP Kernel odbiera `Request` i uruchamia **bootstrappery**: ładuje env + config, rejestruje i **bootuje** service providery (to tutaj framework i Twoje bindingi są spinane).
3. **Global middleware** — uruchamia się dla każdego żądania (CORS, tryb konserwacji, przycinanie stringów, zaufanie do proxy).
4. **Routing** — router dopasowuje URI + metodę HTTP do route.
5. **Route/group middleware** — middleware przypisany do route lub jej grupy (`auth`, `throttle`, `verified`) uruchamia się przed kontrolerem; każdy może przerwać łańcuch.
6. **Controller** — Twoja akcja (lub closure route) uruchamia się, używa modeli/serwisów i zwraca `Response` (widok, JSON, przekierowanie). Logika "after" middleware uruchamia się, gdy odpowiedź wraca na zewnątrz.
7. **terminate** — po wysłaniu odpowiedzi `Kernel::terminate` uruchamia terminable middleware dla odroczonej pracy.

```php
// app/Http/Middleware/Timing.php  → 3/5. middleware
public function handle($request, Closure $next)
{
    $request->attributes->set('started', microtime(true));
    $response = $next($request);          // przekaż do następnej warstwy / controllera
    $response->headers->set('X-Time', '...');  // logika "after"
    return $response;
}

// routes/web.php  → 4. routing (+ middleware)
Route::get('/items/{id}', [ItemController::class, 'show'])->middleware('auth');

// app/Http/Controllers/ItemController.php  → 6. controller
public function show(int $id)
{
    return response()->json(Item::findOrFail($id));
}
```

## Dlaczego to ważne

Cykl życia Laravel jest zbudowany wokół **service container** i **potoku middleware**, więc znajomość kolejności — bootstrap/providery, potem global middleware, potem routing, potem route middleware, potem controller, potem `terminate` — mówi Ci dokładnie, gdzie należą auth, ograniczanie liczby żądań, CORS i sprzątanie. Wyjaśnia, dlaczego serwis musi być zbindowany w providerze, zanim zostanie wstrzyknięty, dlaczego `throttle` odrzuca żądanie przed uruchomieniem Twojego kontrolera, i jak odroczyć wolną pracę do terminable middleware, aby użytkownik nie musiał czekać.

Etapy

Dlaczego to ważne

Powiązane pytania