Hvordan fungerer request-livssyklusen i Laravel?

Question

IT Interview Practice · Accepted Answer

Hver Laravel-request kommer inn gjennom én enkelt front controller, `public/index.php`, drives av **HTTP-kjernen** gjennom en **middleware**-stack og **routeren** til en **controller**, og returnerer en `Response` — hvoretter **terminable** middleware kjører.

## Stegene

```
public/index.php  ── autoload + bootstrap appen
   ▼
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 (eller closure)  ── logikken din → returnerer en Response
   ▼
Response ──▶ klient
   ▼
Kernel::terminate  ── terminable middleware (f.eks. lagre session, logging)
```

1. **Front controller** — `index.php` laster inn Composer autoload og bootstrapper applikasjonscontaineren.
2. **Kernel::handle** — HTTP-kjernen mottar `Request` og kjører **bootstrapperne**: last inn env + config, register og **boot** service providers (dette er der rammeverket og dine bindings kobles opp).
3. **Global middleware** — kjører for hver request (CORS, vedlikeholdsmodus, trimming av strenger, proxy-tillit).
4. **Routing** — routeren matcher URI + verb til en route.
5. **Route/group middleware** — middleware tilordnet routen eller gruppen dens (`auth`, `throttle`, `verified`) kjører før controlleren; hver kan kortslutte.
6. **Controller** — actionen din (eller route-closuren) kjører, bruker modeller/tjenester, og returnerer en `Response` (view, JSON, redirect). Middlewarens "etter"-logikk kjører når responsen bobler tilbake ut.
7. **terminate** — etter at responsen er sendt, kjører `Kernel::terminate` terminable middleware for utsatt arbeid.

```php
// app/Http/Middleware/Timing.php  → 3/5. middleware
public function handle($request, Closure $next)
{
    $request->attributes->set('started', microtime(true));
    $response = $next($request);          // send videre til neste lag / controller
    $response->headers->set('X-Time', '...');  // "etter"-logikk
    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));
}
```

## Hvorfor det er viktig

Laravels livssyklus er bygget rundt **service-containeren** og **middleware-pipelinen**, så å kjenne rekkefølgen — bootstrap/providers, så global middleware, så routing, så route middleware, så controller, så `terminate` — forteller deg nøyaktig hvor auth, rate limiting, CORS og opprydding hører hjemme. Det forklarer hvorfor en tjeneste må være bundet i en provider før den injectes, hvorfor `throttle` avviser en request før controlleren din kjører, og hvordan du kan utsette tregt arbeid til terminable middleware slik at brukeren ikke må vente.

Stegene

Hvorfor det er viktig

Relaterte spørsmål