Hur fungerar request-livscykeln i Laravel?

Question

IT Interview Practice · Accepted Answer

Varje Laravel-request kommer in genom en enda front controller, `public/index.php`, drivs av **HTTP-kärnan** genom en **middleware**-stack och **routern** till en **controller**, och returnerar ett `Response` — varefter **terminable** middleware körs.

## Stegen

```
public/index.php  ── autoload + bootstrap appen
   ▼
HTTP Kernel::handle($request)
   ▼
Bootstrappers  ── env, config, providers (register + boot)
   ▼
Global middleware  ── (TrustProxies, HandleCors, ...)
   ▼
Router dispatch  ── matcha route
   ▼
Route / group middleware  ── (auth, throttle, verified, ...)
   ▼
Controller (eller closure)  ── din logik → returnerar ett Response
   ▼
Response ──▶ client
   ▼
Kernel::terminate  ── terminable middleware (t.ex. spara session, logging)
```

1. **Front controller** — `index.php` laddar Composer-autoload och bootstrappar applikationscontainern.
2. **Kernel::handle** — HTTP-kärnan tar emot `Request` och kör **bootstrappers**: laddar env + config, registrerar och **bootar** service providers (det är här ramverket och dina bindningar kopplas upp).
3. **Global middleware** — körs för varje request (CORS, underhållsläge, trimning av strängar, proxy-förtroende).
4. **Routing** — routern matchar URI + verb till en route.
5. **Route/group middleware** — middleware tilldelad routen eller dess grupp (`auth`, `throttle`, `verified`) körs före controllern; var och en kan kortsluta.
6. **Controller** — din action (eller route-closure) körs, använder modeller/tjänster och returnerar ett `Response` (view, JSON, redirect). Middlewares "efter"-logik körs när responsen bubblar tillbaka ut.
7. **terminate** — efter att responsen skickats kör `Kernel::terminate` terminable middleware för uppskjutet arbete.

```php
// app/Http/Middleware/Timing.php  → 3/5. middleware
public function handle($request, Closure $next)
{
    $request->attributes->set('started', microtime(true));
    $response = $next($request);          // skicka till nästa lager / controller
    $response->headers->set('X-Time', '...');  // "efter"-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));
}
```

## Varför det är viktigt

Laravels livscykel är byggd kring **service-containern** och **middleware-pipelinen**, så att känna till ordningen — bootstrap/providers, sedan global middleware, sedan routing, sedan route-middleware, sedan controller, sedan `terminate` — talar om exakt var auth, rate limiting, CORS och städning hör hemma. Det förklarar varför en tjänst måste bindas i en provider innan den injiceras, varför `throttle` avvisar en request innan din controller körs, och hur man skjuter upp långsamt arbete till terminable middleware så att användaren inte hålls väntande.

Stegen

Varför det är viktigt

Relaterade frågor