Comment fonctionne le cycle de vie d'une requête dans Laravel ?

Question

IT Interview Practice · Accepted Answer

Chaque requête Laravel entre par un unique front controller, `public/index.php`, est pilotée par le **HTTP Kernel** à travers une pile de **middleware** et le **router** vers un **controller**, et retourne une `Response` — après quoi le middleware **terminable** s'exécute.

## Les étapes

```
public/index.php  ── autoload + bootstrap de l'app
   ▼
HTTP Kernel::handle($request)
   ▼
Bootstrappers  ── env, config, providers (register + boot)
   ▼
Global middleware  ── (TrustProxies, HandleCors, ...)
   ▼
Router dispatch  ── associe route
   ▼
Route / group middleware  ── (auth, throttle, verified, ...)
   ▼
Controller (ou closure)  ── votre logique → retourne une Response
   ▼
Response ──▶ client
   ▼
Kernel::terminate  ── terminable middleware (ex. sauvegarde de session, logging)
```

1. **Front controller** — `index.php` charge l'autoload de Composer et bootstrappe le container de l'application.
2. **Kernel::handle** — le HTTP Kernel reçoit la `Request` et exécute les **bootstrappers** : chargement de env + config, register et **boot** des service providers (c'est ici que le framework et vos bindings se câblent).
3. **Global middleware** — s'exécute pour chaque requête (CORS, mode maintenance, trimming des chaînes, confiance dans les proxys).
4. **Routing** — le router associe l'URI + le verbe à une route.
5. **Route/group middleware** — le middleware assigné à la route ou à son groupe (`auth`, `throttle`, `verified`) s'exécute avant le controller ; chacun peut court-circuiter.
6. **Controller** — votre action (ou closure de route) s'exécute, utilise les models/services, et retourne une `Response` (view, JSON, redirect). La logique « après » du middleware s'exécute pendant que la response remonte.
7. **terminate** — après l'envoi de la response, `Kernel::terminate` exécute le terminable middleware pour le travail différé.

```php
// app/Http/Middleware/Timing.php  → 3/5. middleware
public function handle($request, Closure $next)
{
    $request->attributes->set('started', microtime(true));
    $response = $next($request);          // passe à la couche suivante / controller
    $response->headers->set('X-Time', '...');  // logique « après »
    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));
}
```

## Pourquoi c'est important

Le cycle de vie de Laravel est construit autour du **service container** et du **middleware pipeline**, donc connaître l'ordre — bootstrap/providers, puis global middleware, puis routing, puis route middleware, puis controller, puis `terminate` — vous indique exactement où placer auth, rate limiting, CORS et nettoyage. Cela explique pourquoi un service doit être bind dans un provider avant d'être injecté, pourquoi `throttle` rejette une requête avant l'exécution de votre controller, et comment différer le travail lent vers du terminable middleware afin que l'utilisateur ne soit pas laissé en attente.

Les étapes

Pourquoi c'est important

Questions connexes