Wie funktioniert der Request-Lebenszyklus in Laravel?

Question

IT Interview Practice · Accepted Answer

Jeder Laravel-Request tritt durch einen einzigen Front Controller ein, `public/index.php`, wird vom **HTTP Kernel** durch einen **Middleware**-Stapel und den **Router** zu einem **Controller** geführt und gibt eine `Response` zurück — danach läuft **terminable** Middleware.

## Die Phasen

```
public/index.php  ── autoload + bootstrap der App
   ▼
HTTP Kernel::handle($request)
   ▼
Bootstrappers  ── env, config, providers (register + boot)
   ▼
Global middleware  ── (TrustProxies, HandleCors, ...)
   ▼
Router dispatch  ── matche route
   ▼
Route / group middleware  ── (auth, throttle, verified, ...)
   ▼
Controller (or closure)  ── deine Logik → gibt eine Response zurück
   ▼
Response ──▶ client
   ▼
Kernel::terminate  ── terminable middleware (z. B. Session speichern, Logging)
```

1. **Front Controller** — `index.php` lädt den Composer-Autoload und bootstrappt den Anwendungscontainer.
2. **Kernel::handle** — der HTTP Kernel empfängt die `Request` und führt die **Bootstrapper** aus: env + config laden, Service Provider registrieren und **booten** (hier werden das Framework und deine Bindings verdrahtet).
3. **Global Middleware** — läuft für jeden Request (CORS, Wartungsmodus, Strings trimmen, Proxy-Vertrauen).
4. **Routing** — der Router matcht die URI + das Verb auf eine Route.
5. **Route-/Group-Middleware** — die der Route oder ihrer Gruppe zugewiesene Middleware (`auth`, `throttle`, `verified`) läuft vor dem Controller; jede kann abkürzen.
6. **Controller** — deine Action (oder Route-Closure) läuft, nutzt Models/Services und gibt eine `Response` (View, JSON, Redirect) zurück. Die "After"-Logik der Middleware läuft, während die Response wieder nach außen aufsteigt.
7. **terminate** — nachdem die Response gesendet wurde, führt `Kernel::terminate` terminable Middleware für aufgeschobene Arbeit aus.

```php
// app/Http/Middleware/Timing.php  → 3/5. Middleware
public function handle($request, Closure $next)
{
    $request->attributes->set('started', microtime(true));
    $response = $next($request);          // an die nächste Schicht / den Controller weitergeben
    $response->headers->set('X-Time', '...');  // "After"-Logik
    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));
}
```

## Warum es wichtig ist

Der Lebenszyklus von Laravel ist um den **Service Container** und die **Middleware-Pipeline** herum gebaut, daher sagt dir die Kenntnis der Reihenfolge — Bootstrap/Provider, dann Global Middleware, dann Routing, dann Route-Middleware, dann Controller, dann `terminate` — genau, wohin Auth, Rate Limiting, CORS und Cleanup gehören. Sie erklärt, warum ein Service in einem Provider gebunden sein muss, bevor er injiziert wird, warum `throttle` einen Request ablehnt, bevor dein Controller läuft, und wie man langsame Arbeit in terminable Middleware verschiebt, damit der Benutzer nicht warten muss.

Die Phasen

Warum es wichtig ist

Ähnliche Fragen