Como funciona o ciclo de vida de uma requisição no Laravel?

Question

IT Interview Practice · Accepted Answer

Toda requisição no Laravel entra por um único front controller, `public/index.php`, é conduzida pelo **HTTP Kernel** através de uma pilha de **middleware** e do **router** até um **controller**, e retorna um `Response` — após o qual roda o middleware **terminable**.

## As etapas

```
public/index.php  ── autoload + bootstrap da aplicação
   ▼
HTTP Kernel::handle($request)
   ▼
Bootstrappers  ── env, config, providers (register + boot)
   ▼
Global middleware  ── (TrustProxies, HandleCors, ...)
   ▼
Router dispatch  ── casa a rota
   ▼
Route / group middleware  ── (auth, throttle, verified, ...)
   ▼
Controller (or closure)  ── sua lógica → retorna um Response
   ▼
Response ──▶ client
   ▼
Kernel::terminate  ── terminable middleware (ex. salvar sessão, logging)
```

1. **Front controller** — `index.php` carrega o autoload do Composer e faz o bootstrap do container da aplicação.
2. **Kernel::handle** — o HTTP Kernel recebe o `Request` e roda os **bootstrappers**: carrega env + config, registra e faz **boot** dos service providers (é aqui que o framework e seus bindings são conectados).
3. **Global middleware** — roda para toda requisição (CORS, modo de manutenção, corte de strings, confiança em proxy).
4. **Routing** — o router casa a URI + o verbo com uma rota.
5. **Route/group middleware** — o middleware atribuído à rota ou ao seu grupo (`auth`, `throttle`, `verified`) roda antes do controller; cada um pode interromper o fluxo.
6. **Controller** — sua action (ou closure da rota) roda, usa models/serviços e retorna um `Response` (view, JSON, redirecionamento). A lógica "after" do middleware roda conforme a resposta borbulha de volta para fora.
7. **terminate** — depois que a resposta é enviada, `Kernel::terminate` roda o terminable middleware para trabalho adiado.

```php
// app/Http/Middleware/Timing.php  → 3/5. middleware
public function handle($request, Closure $next)
{
    $request->attributes->set('started', microtime(true));
    $response = $next($request);          // passa para a próxima camada / controller
    $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. controller
public function show(int $id)
{
    return response()->json(Item::findOrFail($id));
}
```

## Por que isso importa

O ciclo de vida do Laravel é construído em torno do **service container** e do **pipeline de middleware**, então conhecer a ordem — bootstrap/providers, depois global middleware, depois routing, depois route middleware, depois controller, depois `terminate` — diz exatamente onde ficam auth, rate limiting, CORS e limpeza. Explica por que um serviço precisa ser registrado (bind) em um provider antes de ser injetado, por que `throttle` rejeita uma requisição antes do seu controller rodar, e como adiar trabalho lento para o terminable middleware para que o usuário não fique esperando.

As etapas

Por que isso importa

Perguntas relacionadas