Jak funguje životní cyklus požadavku v Laravelu?

Question

IT Interview Practice · Accepted Answer

Každý požadavek v Laravelu vstupuje přes jediný front controller, `public/index.php`, je řízen **HTTP Kernelem** přes zásobník **middleware** a **router** až k **controlleru** a vrací `Response` — poté běží **terminable** middleware.

## Fáze

```
public/index.php  ── autoload + bootstrap aplikace
   ▼
HTTP Kernel::handle($request)
   ▼
Bootstrappers  ── env, config, providers (register + boot)
   ▼
Global middleware  ── (TrustProxies, HandleCors, ...)
   ▼
Router dispatch  ── porovná route
   ▼
Route / group middleware  ── (auth, throttle, verified, ...)
   ▼
Controller (or closure)  ── vaše logika → vrací Response
   ▼
Response ──▶ client
   ▼
Kernel::terminate  ── terminable middleware (např. uložení session, logování)
```

1. **Front controller** — `index.php` načte Composer autoload a nabootuje kontejner aplikace.
2. **Kernel::handle** — HTTP Kernel přijme `Request` a spustí **bootstrappery**: načte env + config, zaregistruje a **nabootuje** service providery (zde se propojí framework a vaše bindings).
3. **Global middleware** — běží pro každý požadavek (CORS, režim údržby, ořezávání řetězců, důvěra proxy).
4. **Routing** — router porovná URI + verb s route.
5. **Route/group middleware** — middleware přiřazený k route nebo její skupině (`auth`, `throttle`, `verified`) běží před controllerem; každý může proces zkratovat.
6. **Controller** — vaše akce (nebo route closure) běží, používá modely/služby a vrací `Response` (view, JSON, redirect). Logika middleware "po" běží, jak odpověď probublává zpět ven.
7. **terminate** — po odeslání odpovědi spustí `Kernel::terminate` terminable middleware pro odloženou práci.

```php
// app/Http/Middleware/Timing.php  → 3/5. middleware
public function handle($request, Closure $next)
{
    $request->attributes->set('started', microtime(true));
    $response = $next($request);          // předá další vrstvě / controlleru
    $response->headers->set('X-Time', '...');  // logika "po"
    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));
}
```

## Proč je to důležité

Životní cyklus Laravelu je postaven kolem **service containeru** a **middleware pipeline**, takže znalost pořadí — bootstrap/providery, pak global middleware, pak routing, pak route middleware, pak controller, pak `terminate` — vám přesně řekne, kam patří autentizace, rate limiting, CORS a úklid. Vysvětluje, proč musí být služba zaregistrována (bound) v provideru, než se injektuje, proč `throttle` odmítne požadavek dřív, než se spustí váš controller, a jak odložit pomalou práci do terminable middleware, aby uživatel nemusel čekat.

Fáze

Proč je to důležité

Související otázky