Cicle de vida d'una petició

El punt d'entrada#

Totes les peticions a una aplicació Laravel comencen al fitxer public/index.php. Aquest és l'únic fitxer PHP directament accessible des del navegador: el servidor web (Apache, Nginx o caddy) redirigeix totes les peticions cap a ell. El seu treball és senzill però fonamental: carregar l'autoloader de Composer perquè totes les classes del projecte i de les dependències estiguin disponibles, i després arrencar l'aplicació.

// public/index.php (simplificat)
require __DIR__.'/../vendor/autoload.php';
 
$app = require_once __DIR__.'/../bootstrap/app.php';
 
$kernel = $app->make(Kernel::class);
 
$response = $kernel->handle(
    $request = Request::capture()
);
 
$response->send();
 
$kernel->terminate($request, $response);

El mètode Request::capture() pren les dades de la petició HTTP actual (la URL, els headers, el cos, els fitxers pujats) i les encapsula en un objecte Request de Laravel. A partir d'aquest punt, tota la informació de la petició és accessible a través d'aquest objecte en lloc de les superglobals de PHP com $_GET, $_POST o $_SERVER.

Un cop el kernel processa la petició i genera una resposta, el mètode send() l'envia al navegador. Finalment, terminate() executa qualsevol tasca de neteja pendent, com tancar connexions o desar logs.

L'arrencada de l'aplicació#

El fitxer bootstrap/app.php és on es crea la instància de l'aplicació Laravel. Aquí es configura el kernel HTTP, els middleware globals i les excepcions. A Laravel 11, aquest fitxer utilitza una sintaxi fluida que fa la configuració molt llegible:

// bootstrap/app.php
return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        api: __DIR__.'/../routes/api.php',
    )
    ->withMiddleware(function (Middleware $middleware) {
        // Configurar middleware globals i alias
    })
    ->withExceptions(function (Exceptions $exceptions) {
        // Configurar gestió d'excepcions
    })
    ->create();

El kernel HTTP#

El kernel HTTP és el punt central que orquestra tot el processament d'una petició. Quan rep una petició, segueix una seqüència precisa. Primer, carrega tots els service providers de l'aplicació, que registren serveis com la base de dades, la cache, les cues, el correu i moltes altres funcionalitats. Després, la petició passa per una cadena de middleware globals que poden inspeccionar-la, modificar-la o bloquejar-la. Finalment, el router s'encarrega de trobar quina ruta coincideix amb la URL i executa el controlador o closure associat.

Internament, el kernel utilitza el patró Pipeline per fer passar la petició a través dels middleware. Cada middleware rep la petició, fa la seva feina i la passa al següent:

// Flux simplificat del kernel
$response = (new Pipeline($this->app))
    ->send($request)
    ->through($this->middleware)
    ->then(fn ($request) => $this->router->dispatch($request));

Aquesta arquitectura de pipeline és elegant perquè cada middleware és independent: pots afegir-ne, treure'n o reordenar-los sense afectar la resta. El middleware de sessions no sap res del middleware de CSRF, i viceversa. Cadascun fa la seva feina i passa la petició al següent.

Service Providers#

Els Service Providers són el mecanisme d'arrencada de Laravel. Absolutament tot el que el framework ofereix (rutes, vistes, validació, cache, correu, cues...) es registra a través d'un service provider. Quan l'aplicació arrenca, Laravel carrega tots els providers llistats i executa els seus mètodes en dues fases.

La teva aplicació té el seu propi service provider a app/Providers/AppServiceProvider.php:

namespace App\Providers;
 
use Illuminate\Support\ServiceProvider;
 
class AppServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        // Fase 1: Registrar bindings al contenidor de serveis
        $this->app->bind(PaymentGateway::class, StripeGateway::class);
    }
 
    public function boot(): void
    {
        // Fase 2: Accions que s'executen després de registrar tots els serveis
        View::share('appName', config('app.name'));
    }
}

El mètode register() serveix exclusivament per vincular classes i interfícies al contenidor de serveis. No hauries de fer res més aquí, perquè en aquest moment alguns serveis encara podrien no estar disponibles. El mètode boot() s'executa un cop tots els providers han estat registrats, i és on pots definir comportaments que depenguin d'altres serveis ja disponibles: compartir dades amb les vistes, definir macros, registrar observers, etc.

El router#

Un cop la petició ha passat pels middleware globals, arriba al router. El router compara la URL i el mètode HTTP de la petició amb totes les rutes registrades a routes/web.php i routes/api.php. Quan troba una coincidència, executa els middleware assignats a aquella ruta concreta i després crida el controlador o closure associat.

Si cap ruta coincideix, Laravel llança una excepció NotFoundHttpException que es tradueix en un error 404. El sistema de gestió d'excepcions s'encarrega de mostrar una pàgina d'error adequada, ja sigui la vista errors/404.blade.php o una resposta JSON si la petició espera JSON.

El flux complet#

Per resumir tot el procés, aquest és el camí complet que segueix una petició a Laravel:

La petició HTTP arriba a public/index.php, que arrenca l'aplicació i crea una instància del kernel HTTP. El kernel carrega tots els service providers, que registren els serveis de l'aplicació (base de dades, cache, correu, etc.).

La petició passa pels middleware globals, que poden inspeccionar-la o bloquejar-la. Per exemple, el middleware de manteniment comprova si l'aplicació està en mode manteniment, i el middleware de sessions gestiona les dades de sessió.

El router busca quina ruta coincideix amb la URL i el mètode HTTP. Quan la troba, s'executen els middleware assignats a aquella ruta específica (com auth o verified). Després es crida el controlador o closure de la ruta, que conté la lògica de l'aplicació i genera una resposta.

Finalment, la resposta travessa els middleware en ordre invers (alguns fan feina tant a l'entrada com a la sortida), s'envia al navegador i s'executen els middleware terminables per a tasques de neteja.