Hoe werkt de request-lifecycle in Laravel?

Question

IT Interview Practice · Accepted Answer

Elke Laravel-request komt binnen via één enkele front controller, `public/index.php`, wordt door de **HTTP Kernel** aangedreven door een **middleware**-stack en de **router** naar een **controller**, en geeft een `Response` terug — waarna **terminable** middleware draait.

## De fasen

```
public/index.php  ── autoload + bootstrap de app
   ▼
HTTP Kernel::handle($request)
   ▼
Bootstrappers  ── env, config, providers (register + boot)
   ▼
Global middleware  ── (TrustProxies, HandleCors, ...)
   ▼
Router dispatch  ── match route
   ▼
Route / group middleware  ── (auth, throttle, verified, ...)
   ▼
Controller (of closure)  ── jouw logica → geeft een Response terug
   ▼
Response ──▶ client
   ▼
Kernel::terminate  ── terminable middleware (bijv. sessie opslaan, logging)
```

1. **Front controller** — `index.php` laadt de Composer-autoload en bootstrapt de applicatiecontainer.
2. **Kernel::handle** — de HTTP Kernel ontvangt de `Request` en draait de **bootstrappers**: env + config laden, service providers registreren en **booten** (dit is waar het framework en jouw bindings worden aangesloten).
3. **Global middleware** — draait voor elke request (CORS, onderhoudsmodus, strings trimmen, proxy-vertrouwen).
4. **Routing** — de router matcht de URI + verb met een route.
5. **Route/group middleware** — middleware toegewezen aan de route of zijn groep (`auth`, `throttle`, `verified`) draait vóór de controller; elk ervan kan kortsluiten.
6. **Controller** — jouw action (of route-closure) draait, gebruikt models/services, en geeft een `Response` terug (view, JSON, redirect). De "na"-logica van middleware draait terwijl de response weer naar buiten borrelt.
7. **terminate** — nadat de response is verstuurd, draait `Kernel::terminate` de terminable middleware voor uitgesteld werk.

```php
// app/Http/Middleware/Timing.php  → 3/5. middleware
public function handle($request, Closure $next)
{
    $request->attributes->set('started', microtime(true));
    $response = $next($request);          // geef door aan volgende laag / controller
    $response->headers->set('X-Time', '...');  // "na"-logica
    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));
}
```

## Waarom het belangrijk is

De lifecycle van Laravel is opgebouwd rond de **service container** en de **middleware pipeline**, dus het kennen van de volgorde — bootstrap/providers, dan global middleware, dan routing, dan route middleware, dan controller, dan `terminate` — vertelt je precies waar auth, rate limiting, CORS en cleanup thuishoren. Het verklaart waarom een service in een provider gebonden moet zijn voordat hij geïnjecteerd wordt, waarom `throttle` een request afwijst voordat jouw controller draait, en hoe je traag werk kunt uitstellen naar terminable middleware zodat de gebruiker niet hoeft te wachten.

De fasen

Waarom het belangrijk is

Gerelateerde vragen