Middleware

Come usare i middleware di Laravel per filtrare e pre-elaborare le richieste HTTP.

​

Cos’è un middleware

Un middleware è un meccanismo per ispezionare e filtrare le richieste HTTP in arrivo. Puoi inserire logica prima e dopo che la richiesta arrivi al controller.

Ad esempio, Laravel include un middleware di autenticazione. Se l’utente non è autenticato, effettua il redirect alla schermata di login; se lo è, lascia proseguire la richiesta all’interno dell’applicazione.

Oltre all’autenticazione puoi creare middleware per registrazione dei log, protezione CSRF, rate limiting e altri scopi. Per i dettagli sulla protezione CSRF di Laravel 13 consulta Protezione CSRF.

I middleware definiti dall’utente si trovano di norma nella directory app/Http/Middleware.

​

Middleware integrati

Laravel prevede di default due gruppi di middleware: web e api. A routes/web.php viene applicato automaticamente il gruppo web e a routes/api.php il gruppo api.

Gruppo di middleware web
EncryptCookies
AddQueuedCookiesToResponse
StartSession
ShareErrorsFromSession
PreventRequestForgery (protezione CSRF)
SubstituteBindings

I middleware più comuni hanno inoltre degli alias per essere richiamati con nomi brevi.

Alias	Middleware
auth	Illuminate\Auth\Middleware\Authenticate
guest	Illuminate\Auth\Middleware\RedirectIfAuthenticated
verified	Illuminate\Auth\Middleware\EnsureEmailIsVerified
throttle	Illuminate\Routing\Middleware\ThrottleRequests

​

Creazione di un middleware

Crea un nuovo middleware con il comando Artisan make:middleware.

php artisan make:middleware EnsureTokenIsValid

Viene generato app/Http/Middleware/EnsureTokenIsValid.php. Scrivi la logica di elaborazione della richiesta nel metodo handle.

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class EnsureTokenIsValid
{
    /**
     * Gestisce la richiesta in arrivo
     *
     * @param  \Closure(\Illuminate\Http\Request): (\Symfony\Component\HttpFoundation\Response)  $next
     */
    public function handle(Request $request, Closure $next): Response
    {
        if ($request->input('token') !== 'my-secret-token') {
            return redirect('/home');
        }

        return $next($request);
    }
}

Chiamando $next($request) la richiesta prosegue nell’elaborazione successiva. Se la condizione non è soddisfatta, restituisci un redirect o una risposta per interrompere.

​

Elaborazione prima e dopo la richiesta

Il middleware può eseguire logica prima o dopo la richiesta.

// Elaborazione prima della richiesta
public function handle(Request $request, Closure $next): Response
{
    // Pre-elaborazione qui

    return $next($request);
}

// Elaborazione dopo la risposta
public function handle(Request $request, Closure $next): Response
{
    $response = $next($request);

    // Post-elaborazione qui

    return $response;
}

​

Registrazione dei middleware

​

Middleware globali

Se vuoi eseguire un middleware per ogni richiesta, aggiungilo allo stack globale in withMiddleware di bootstrap/app.php.

// bootstrap/app.php
use App\Http\Middleware\EnsureTokenIsValid;

return Application::configure(basePath: dirname(__DIR__))
    ->withMiddleware(function (Middleware $middleware): void {
        $middleware->append(EnsureTokenIsValid::class);
    });

append aggiunge in coda allo stack. Per aggiungere in testa usa prepend.

​

Applicazione a route

Per applicare il middleware solo a certe route, chiama il metodo middleware nella definizione della route.

use App\Http\Middleware\EnsureTokenIsValid;

Route::get('/profile', function () {
    // ...
})->middleware(EnsureTokenIsValid::class);

Per più middleware passa un array.

Route::get('/', function () {
    // ...
})->middleware([First::class, Second::class]);

Per escludere un middleware da una route specifica usa withoutMiddleware.

use App\Http\Middleware\EnsureTokenIsValid;

Route::middleware([EnsureTokenIsValid::class])->group(function () {
    Route::get('/', function () {
        // A questa route si applica il middleware
    });

    Route::get('/profile', function () {
        // Questa route esclude il middleware
    })->withoutMiddleware([EnsureTokenIsValid::class]);
});

​

Alias dei middleware

Puoi definire alias brevi per nomi di classi lunghi. Configura in bootstrap/app.php.

// bootstrap/app.php
use App\Http\Middleware\EnsureUserIsSubscribed;

return Application::configure(basePath: dirname(__DIR__))
    ->withMiddleware(function (Middleware $middleware): void {
        $middleware->alias([
            'subscribed' => EnsureUserIsSubscribed::class,
        ]);
    });

Poi puoi applicarli alle route tramite l’alias.

Route::get('/profile', function () {
    // ...
})->middleware('subscribed');

​

Gruppi di middleware

Raggruppando più middleware in un’unica chiave, applicarli alle route diventa più semplice. In bootstrap/app.php usa appendToGroup o prependToGroup.

// bootstrap/app.php
use App\Http\Middleware\First;
use App\Http\Middleware\Second;

return Application::configure(basePath: dirname(__DIR__))
    ->withMiddleware(function (Middleware $middleware): void {
        $middleware->appendToGroup('group-name', [
            First::class,
            Second::class,
        ]);
    });

Un gruppo si applica come un middleware normale.

Route::get('/', function () {
    // ...
})->middleware('group-name');

Route::middleware(['group-name'])->group(function () {
    // ...
});

Per aggiungere middleware ai gruppi esistenti web o api ci sono metodi dedicati.

// bootstrap/app.php
use App\Http\Middleware\EnsureUserIsSubscribed;

return Application::configure(basePath: dirname(__DIR__))
    ->withMiddleware(function (Middleware $middleware): void {
        $middleware->web(append: [
            EnsureUserIsSubscribed::class,
        ]);
    });

​

Parametri dei middleware

Il middleware può ricevere parametri aggiuntivi. Aggiungi il parametro dopo l’argomento $next del metodo handle.

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class EnsureUserHasRole
{
    public function handle(Request $request, Closure $next, string $role): Response
    {
        if (! $request->user()->hasRole($role)) {
            return redirect('/home');
        }

        return $next($request);
    }
}

Nella definizione della route separa nome del middleware e parametro con :.

use App\Http\Middleware\EnsureUserHasRole;

Route::put('/post/{id}', function (string $id) {
    // ...
})->middleware(EnsureUserHasRole::class.':editor');

Separa più parametri con la virgola.

Route::put('/post/{id}', function (string $id) {
    // ...
})->middleware(EnsureUserHasRole::class.':editor,publisher');

​

Esempio pratico: middleware di controllo dell’autenticazione

Esempio semplice che reindirizza gli utenti non autenticati.

php artisan make:middleware RedirectIfNotAuthenticated

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class RedirectIfNotAuthenticated
{
    public function handle(Request $request, Closure $next): Response
    {
        if (! $request->user()) {
            return redirect('/login');
        }

        return $next($request);
    }
}

Applicalo alla route.

Route::get('/dashboard', function () {
    return view('dashboard');
})->middleware(RedirectIfNotAuthenticated::class);

Laravel include il middleware auth per l’autenticazione. Prima di implementarne uno personalizzato, verifica se puoi soddisfare i tuoi requisiti con i middleware esistenti.

​

Prossimi passi

Richieste HTTP

Impara come ricevere i dati delle richieste nei controller.