¿Cómo funciona el ciclo de vida de una petición en Laravel?

Question

IT Interview Practice · Accepted Answer

Cada petición de Laravel entra a través de un único front controller, `public/index.php`, es conducida por el **HTTP Kernel** a través de una pila de **middleware** y el **router** hasta un **controlador**, y devuelve una `Response` — tras lo cual se ejecuta el middleware **terminable**.

## Las etapas

```
public/index.php  ── autoload + bootstrap de la app
   ▼
HTTP Kernel::handle($request)
   ▼
Bootstrappers  ── env, config, providers (register + boot)
   ▼
Global middleware  ── (TrustProxies, HandleCors, ...)
   ▼
Router dispatch  ── coincide route
   ▼
Route / group middleware  ── (auth, throttle, verified, ...)
   ▼
Controller (or closure)  ── tu lógica → devuelve una Response
   ▼
Response ──▶ client
   ▼
Kernel::terminate  ── terminable middleware (p. ej. guardar sesión, logging)
```

1. **Front controller** — `index.php` carga el autoload de Composer y hace bootstrap del contenedor de la aplicación.
2. **Kernel::handle** — el HTTP Kernel recibe la `Request` y ejecuta los **bootstrappers**: cargar env + config, registrar y **arrancar (boot)** los service providers (aquí es donde el framework y tus bindings se conectan).
3. **Global middleware** — se ejecuta para cada petición (CORS, modo mantenimiento, recorte de cadenas, confianza en el proxy).
4. **Routing** — el router hace coincidir la URI + el verbo con una route.
5. **Route/group middleware** — el middleware asignado a la route o a su grupo (`auth`, `throttle`, `verified`) se ejecuta antes del controlador; cada uno puede cortocircuitar.
6. **Controller** — tu action (o route closure) se ejecuta, usa modelos/servicios y devuelve una `Response` (view, JSON, redirección). La lógica "after" del middleware se ejecuta mientras la respuesta burbujea de vuelta hacia fuera.
7. **terminate** — tras enviar la respuesta, `Kernel::terminate` ejecuta el middleware terminable para trabajo diferido.

```php
// app/Http/Middleware/Timing.php  → 3/5. middleware
public function handle($request, Closure $next)
{
    $request->attributes->set('started', microtime(true));
    $response = $next($request);          // pasa a la siguiente capa / controlador
    $response->headers->set('X-Time', '...');  // lógica "after"
    return $response;
}

// routes/web.php  → 4. routing (+ middleware)
Route::get('/items/{id}', [ItemController::class, 'show'])->middleware('auth');

// app/Http/Controllers/ItemController.php  → 6. controlador
public function show(int $id)
{
    return response()->json(Item::findOrFail($id));
}
```

## Por qué es importante

El ciclo de vida de Laravel está construido en torno al **service container** y la **middleware pipeline**, por lo que conocer el orden — bootstrap/providers, luego global middleware, luego routing, luego route middleware, luego controlador, luego `terminate` — te dice exactamente dónde encajan la auth, el rate limiting, CORS y la limpieza. Explica por qué un servicio debe estar registrado (bound) en un provider antes de inyectarse, por qué `throttle` rechaza una petición antes de que tu controlador se ejecute, y cómo diferir trabajo lento a middleware terminable para no dejar al usuario esperando.

Las etapas

Por qué es importante

Preguntas relacionadas