Cum funcționează ciclul de viață al unei cereri în Laravel?

Question

IT Interview Practice · Accepted Answer

Fiecare cerere Laravel intră printr-un singur front controller, `public/index.php`, este condusă de **HTTP Kernel** printr-o stivă de **middleware** și **router** către un **controller**, și returnează un `Response` — după care rulează middleware-ul **terminable**.

## Etapele

```
public/index.php  ── autoload + bootstrap aplicației
   ▼
HTTP Kernel::handle($request)
   ▼
Bootstrappers  ── env, config, providers (register + boot)
   ▼
Global middleware  ── (TrustProxies, HandleCors, ...)
   ▼
Router dispatch  ── potrivește route
   ▼
Route / group middleware  ── (auth, throttle, verified, ...)
   ▼
Controller (or closure)  ── logica ta → returnează un Response
   ▼
Response ──▶ client
   ▼
Kernel::terminate  ── terminable middleware (ex. salvare sesiune, logging)
```

1. **Front controller** — `index.php` încarcă autoload-ul Composer și face bootstrap la containerul aplicației.
2. **Kernel::handle** — HTTP Kernel primește `Request`-ul și rulează **bootstrapper-ele**: încarcă env + config, înregistrează și face **boot** la service providers (aici se conectează framework-ul și binding-urile tale).
3. **Global middleware** — rulează pentru fiecare cerere (CORS, mod mentenanță, trunchierea string-urilor, încrederea în proxy).
4. **Routing** — router-ul potrivește URI-ul + verbul cu o rută.
5. **Route/group middleware** — middleware-ul atribuit rutei sau grupului ei (`auth`, `throttle`, `verified`) rulează înainte de controller; fiecare poate scurtcircuita.
6. **Controller** — action-ul tău (sau closure-ul rutei) rulează, folosește modele/servicii și returnează un `Response` (view, JSON, redirect). Logica "after" a middleware-ului rulează pe măsură ce răspunsul urcă înapoi în afară.
7. **terminate** — după ce răspunsul este trimis, `Kernel::terminate` rulează terminable middleware pentru munca amânată.

```php
// app/Http/Middleware/Timing.php  → 3/5. middleware
public function handle($request, Closure $next)
{
    $request->attributes->set('started', microtime(true));
    $response = $next($request);          // transmite către stratul următor / controller
    $response->headers->set('X-Time', '...');  // logica "after"
    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));
}
```

## De ce contează

Ciclul de viață al Laravel este construit în jurul **service container**-ului și al **pipeline-ului de middleware**, deci cunoașterea ordinii — bootstrap/providers, apoi global middleware, apoi routing, apoi route middleware, apoi controller, apoi `terminate` — îți spune exact unde aparțin auth, rate limiting, CORS și curățarea. Explică de ce un serviciu trebuie legat (bind) într-un provider înainte de a fi injectat, de ce `throttle` respinge o cerere înainte ca controller-ul tău să ruleze, și cum să amâni munca lentă către terminable middleware pentru ca utilizatorul să nu fie ținut în așteptare.

Etapele

De ce contează

Întrebări conexe