Laravel middleware come funziona

Il middleware di Laravel è un livello applicativo intermedio che interviene tra la richiesta dell’utente e la risposta dell’applicativo.

Questo vuol dire che quando l’utente (view di Laravel) fa una richiesta al server (controller di Laravel), la richiesta passerà attraverso il middleware. In questo modo il middleware può verificare se la richiesta è autenticata o meno: 

• se la richiesta dell’utente è autenticata, la richiesta viene inviata al back-end;
• se la richiesta dell’utente non è autenticata, il middleware reindirizzerà l’utente alla schermata di login.

Laravel consente di definire e utilizzare middleware aggiuntivi per eseguire una serie di attività ad eccezione dell’autenticazione. 

I middleware di Laravel, come l’autenticazione e la protezione CSRF, si trovano nella directory app/Http/Middleware .

Possiamo quindi dire che il middleware è un filtro di richiesta http, mediante il quale è possibile verificare delle condizioni e fare delle azioni.

Creazione del middleware

Per creare un nuovo middleware eseguiamo il comando seguente:

php artisan make:middleware <name-of-middleware>

Creiamo il middleware e lo chiamiamo CheckAge, artisan ci risponderà come segue:

La finestra sopra mostra che il middleware è stato creato con successo con il nome ” CheckAge “.

Per vedere se il middleware CheckAge è stato creato o meno, vai nel progetto nel folder app/Http/Middleware, e vedrai il file appena creato

Il file appena creato ha il seguente codice

<?php

namespace App\Http\Middleware;

use Closure;

class CheckAge
{
    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @return mixed
     */
    public function handle($request, Closure $next)
    {
        return $next($request);
    }
}

Usare un middleware

Per usare un middleware, abbiamo bisogno di registrarlo.

Esistono due tipi di middleware in Laravel:

• Middleware globale
• Route Middleware

Il Global Middleware verrà eseguito su ogni richiesta HTTP dell’applicazione, mentre il Route Middleware verrà assegnato a un percorso specifico. Il middleware può essere registrato su app/Http/Kernel.php. Questo file contiene due proprietà $middleware e $routeMiddleware . La proprietà $middleware viene utilizzata per registrare il middleware globale e la proprietà $routeMiddleware viene utilizzata per registrare il middleware specifico della route.

Per registrare il middleware globale, elenca la classe alla fine della proprietà $middleware.

protected $middleware = [
        \App\Http\Middleware\TrustProxies::class,
        \App\Http\Middleware\CheckForMaintenanceMode::class,
        \Illuminate\Foundation\Http\Middleware\ValidatePostSize::class,
        \App\Http\Middleware\TrimStrings::class,
        \Illuminate\Foundation\Http\Middleware\ConvertEmptyStringsToNull::class,
    ];

Per registrare il middleware specifico della route, aggiungi la chiave e il valore alla proprietà $routeMiddleware.

protected $routeMiddleware = [
        'auth' => \App\Http\Middleware\Authenticate::class,
        'auth.basic' => \Illuminate\Auth\Middleware\AuthenticateWithBasicAuth::class,
        'bindings' => \Illuminate\Routing\Middleware\SubstituteBindings::class,
        'cache.headers' => \Illuminate\Http\Middleware\SetCacheHeaders::class,
        'can' => \Illuminate\Auth\Middleware\Authorize::class,
        'guest' => \App\Http\Middleware\RedirectIfAuthenticated::class,
        'password.confirm' => \Illuminate\Auth\Middleware\RequirePassword::class,
        'signed' => \Illuminate\Routing\Middleware\ValidateSignature::class,
        'throttle' => \Illuminate\Routing\Middleware\ThrottleRequests::class,
        'verified' => \Illuminate\Auth\Middleware\EnsureEmailIsVerified::class,
    ];

Abbiamo creato CheckAge nell’esempio precedente. Ora possiamo registrarlo nella proprietà route middleware. Il codice per tale registrazione è mostrato di seguito.

protected $routeMiddleware = [
        'auth' => \App\Http\Middleware\Authenticate::class,
        'auth.basic' => \Illuminate\Auth\Middleware\AuthenticateWithBasicAuth::class,
        'bindings' => \Illuminate\Routing\Middleware\SubstituteBindings::class,
        'cache.headers' => \Illuminate\Http\Middleware\SetCacheHeaders::class,
        'can' => \Illuminate\Auth\Middleware\Authorize::class,
        'guest' => \App\Http\Middleware\RedirectIfAuthenticated::class,
        'password.confirm' => \Illuminate\Auth\Middleware\RequirePassword::class,
        'signed' => \Illuminate\Routing\Middleware\ValidateSignature::class,
        'throttle' => \Illuminate\Routing\Middleware\ThrottleRequests::class,
        'verified' => \Illuminate\Auth\Middleware\EnsureEmailIsVerified::class,
        'Age' => \App\Http\Middleware\CheckAge::class,
    ];

Parametri del middleware

Possiamo anche passare i parametri con il Middleware. 

Ad esempio, se la tua applicazione ha ruoli diversi come utente, amministratore, super amministratore ecc. e desideri autenticare l’azione in base al ruolo, puoi farlo passando i parametri con il middleware. 

Il middleware che abbiamo creato contiene la seguente funzione, e possiamo passare argomenti personalizzati dopo l’argomento $next .

    public function handle($request, Closure $next)
    {
        return $next($request);
    }

Ora proviamo a impostare il parametro ruolo a un nuovo middleware che andiamo a creare ex-novo, quindi procediamo a creare Role Middleware eseguendo il seguente comando

Modificare il metodo handle nel modo seguente

<?php

namespace App\Http\Middleware;
use Closure;

class RoleMiddleware {
   public function handle($request, Closure $next, $role) {
      echo "Role: ".$role;
      return $next($request);
   }
}

abbiamo aggiunto il parametro $role, e all’interno del metodo la riga echo per scrivere il output il nome del ruolo.

Registriamo ora il middleware RoleMiddleware per uno specifico percorso

protected $routeMiddleware = [
        'auth' => \App\Http\Middleware\Authenticate::class,
        'auth.basic' => \Illuminate\Auth\Middleware\AuthenticateWithBasicAuth::class,
        'bindings' => \Illuminate\Routing\Middleware\SubstituteBindings::class,
        'cache.headers' => \Illuminate\Http\Middleware\SetCacheHeaders::class,
        'can' => \Illuminate\Auth\Middleware\Authorize::class,
        'guest' => \App\Http\Middleware\RedirectIfAuthenticated::class,
        'password.confirm' => \Illuminate\Auth\Middleware\RequirePassword::class,
        'signed' => \Illuminate\Routing\Middleware\ValidateSignature::class,
        'throttle' => \Illuminate\Routing\Middleware\ThrottleRequests::class,
        'verified' => \Illuminate\Auth\Middleware\EnsureEmailIsVerified::class,
        'Age' => \App\Http\Middleware\CheckAge::class,
        'Role' => \App\Http\Middleware\RoleMiddleware::class,
    ];

Ora per provare il middleware con il parametro, abbiamo la necessità di creare una richiesta e una risposta. Per simulare la risposta andiamo a creare il controller che chiameremo TestController

php artisan make:controller TestController --plain

il comando appena eseguito andrà a creare un nuovo controller all’interno del folder app/Http/TestController.php, e modifica il metodo index con la riga echo "<br>Test Controller.";

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Http\Requests;
use App\Http\Controllers\Controller;

class TestController extends Controller {
   public function index() {
      echo "<br>Test Controller.";
   }
}

Dopo aver impostato la risposta, costruiamo la richiesta modificando il file routes.php, aggiungendo la route role

Route::get('role',[
   'middleware' => 'Role:editor',
   'uses' => 'TestController@index',
]);

a questo punto possiamo provare l’esempio andando a visitare l’URL http://localhost:8000/role

e nel browser vedremo i due echo

Role editor
Test Controller

Terminable Middleware

Il terminable Middleware esegue alcune attività dopo che la risposta è stata inviata al browser. Ciò può essere ottenuto creando un middleware con il metodo terminate nel middleware. Il terminable Middleware deve essere registrato con il middleware globale. Il metodo terminate riceverà due argomenti $request e $response. 

Il metodo Terminate deve essere creato come mostrato nel codice seguente.

php artisan make:middleware TerminateMiddleware

Una volta creato il middleware app/Http/Middleware/TerminateMiddleware.php modifichiamone il codice nel modo seguente

<?php

namespace App\Http\Middleware;
use Closure;

class TerminateMiddleware {
   public function handle($request, Closure $next) {
      echo "Executing statements of handle method of TerminateMiddleware.";
      return $next($request);
   }
   
   public function terminate($request, $response) {
      echo "<br>Executing statements of terminate method of TerminateMiddleware.";
   }
}

in questo caso abbiamo un metodo handle e un metodo terminate con i due parametri $request e $response.

Ora registriamo il Middleware

protected $routeMiddleware = [
        'auth' => \App\Http\Middleware\Authenticate::class,
        'auth.basic' => \Illuminate\Auth\Middleware\AuthenticateWithBasicAuth::class,
        'bindings' => \Illuminate\Routing\Middleware\SubstituteBindings::class,
        'cache.headers' => \Illuminate\Http\Middleware\SetCacheHeaders::class,
        'can' => \Illuminate\Auth\Middleware\Authorize::class,
        'guest' => \App\Http\Middleware\RedirectIfAuthenticated::class,
        'password.confirm' => \Illuminate\Auth\Middleware\RequirePassword::class,
        'signed' => \Illuminate\Routing\Middleware\ValidateSignature::class,
        'throttle' => \Illuminate\Routing\Middleware\ThrottleRequests::class,
        'verified' => \Illuminate\Auth\Middleware\EnsureEmailIsVerified::class,
        'Age' => \App\Http\Middleware\CheckAge::class,
        'Role' => \App\Http\Middleware\RoleMiddleware::class,
        'terminate' => \App\Http\Middleware\TerminateMiddleware::class,
    ];

Ora dobbiamo creare il controller per simulare la risposta

php artisan make:controller XYZController --plain

modificandone il contenuto della classe

class XYZController extends Controller {
   public function index() {
      echo "<br>XYZ Controller.";
   }
}

Ora dobbiamo modificare il file routes/web.php aggiungendo le rotte che servono per attivare la richiesta

Route::get('terminate',[
   'middleware' => 'terminate',
   'uses' => 'XYZController@index',
]);

a questo punto possiamo provare l’esempio andando a visitare l’URL http://localhost:8000/terminate

e nel browser vedremo le seguenti righe

Executing statements of handle method of TerminateMiddleware
XYZController
Executing statements of terminate method of TerminateMiddleware

Ercole Palmeri

Potrebbe interessarti anche:

• Service Providers in Laravel: cosa sono e come si usano i Service Providers in Laravel
• Cosa è un APM, Application Performance Management, introduzione e alcuni esempi
• Cos’è un Framework nell’ingegneria del software, definizione e tipi di Framework
• Privacy Policy di BlogInnovazione