Laravel middleware como funciona

O middleware Laravel é uma camada de aplicativo intermediária que intervém entre a solicitação do usuário e a resposta do aplicativo.

Isso significa que quando o usuário (visualização Laravel) faz uma solicitação ao servidor (controlador Laravel), a solicitação passará pelo middleware. Desta forma o middleware pode verificar se a requisição está autenticada ou não: 

• se a requisição do usuário for autenticada, a requisição é enviada para o backend;
• se a solicitação do usuário não for autenticada, o middleware redirecionará o usuário para a tela de login.

O Laravel permite que você deficoncluir e usar middleware adicional para executar uma variedade de tarefas, exceto autenticação. 

Os middlewares Laravel, como autenticação e proteção CSRF, estão localizados no diretório aplicativo/Http/Middleware .

Podemos então dizer que o middleware é um filtro de requisições http, através do qual é possível verificar condições e realizar ações.

Criando middleware

Para criar um novo middleware, executamos o seguinte comando:

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

Nós criamos o middleware e nós chamamos isso CheckAge, artisan nos responderá da seguinte forma:

A janela acima mostra que o middleware foi criado com sucesso com o nome ” Verificar idade ".

Para ver se o middleware CheckAge foi criado ou não, acesse o projeto na pasta app/Http/Middleware, e você verá o arquivo recém criado

O arquivo recém-criado tem o seguinte código

<?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);
    }
}

Usar middleware

Para usar o middleware, precisamos registrá-lo.

Existem dois tipos de middleware no Laravel:

• Middleware globale
• Route Middleware

Il middleware global será executado em cada solicitação HTTP do aplicativo, enquanto o Middleware de rota será atribuído a um caminho específico. O middleware pode ser registrado em app/Http/Kernel.php. Este arquivo contém duas propriedades $middleware e $routeMiddleware . A propriedade $middleware é usado para registrar middleware global e propriedade $routeMiddleware é usado para registrar o middleware específico da rota.

Para registrar o middleware global, liste a classe no final da propriedade $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,
    ];

Para registrar o middleware específico da rota, adicione a chave e o valor à propriedade $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,
    ];

Nós criamos Verificar idade no exemplo anterior. Agora podemos registrar isso na propriedade de rota do middleware. O código para tal registro é mostrado abaixo.

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,
    ];

Parâmetros de middleware

Também podemos passar parâmetros com Middleware. 

Por exemplo, se seu aplicativo tiver funções diferentes, como usuário, administrador, superadministrador, etc. e você deseja autenticar a ação com base na função, pode fazê-lo passando os parâmetros com o middleware. 

O middleware que criamos contém a seguinte função e podemos passar argumentos personalizados após o argumento $próximo .

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

Agora vamos tentar definir o parâmetro role para um novo middleware que vamos criar do zero e, em seguida, criar o Role Middleware executando o seguinte comando

Modifique o método handle da seguinte maneira

<?php

namespace App\Http\Middleware;
use Closure;

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

adicionamos o parâmetro $role, e dentro do método a linha echo para escrever a saída o nome da função.

Agora vamos registrar o middleware RoleMiddleware para um caminho específico

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,
    ];

Agora para testar o middleware com o parâmetro, precisamos criar uma requisição e uma resposta. Para simular a resposta vamos criar o controller que chamaremos de TestController

php artisan make:controller TestController --plain

o comando acabado de executar criará um novo controlador dentro da pasta app/Http/TestController.phpe altere o método index com a linha 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.";
   }
}

Depois de configurar a resposta, construímos a solicitação editando o arquivo routes.phpadicionando o route role

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

neste ponto, podemos tentar o exemplo visitando a URL http://localhost:8000/role

e no navegador veremos os dois echo

Role editor
Test Controller

Middleware terminável

Il terminable Middleware executa algumas tarefas depois que a resposta é enviada ao navegador. Isso pode ser feito criando um middleware com o método terminar no middleware. Il terminable Middleware deve ser registrado no middleware global. O método terminate receberá dois argumentos $ pedido e $resposta. 

O método Terminate deve ser criado como mostrado no código a seguir.

php artisan make:middleware TerminateMiddleware

Depois que o middleware é criado app/Http/Middleware/TerminateMiddleware.php vamos modificar o código da seguinte forma

<?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.";
   }
}

neste caso temos um método handle e um método terminate com os dois parâmetros $request e $response.

Agora vamos registrar o 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,
    ];

Agora precisamos criar o controlador para simular a resposta

php artisan make:controller XYZController --plain

modificando o conteúdo da classe

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

Agora precisamos editar o arquivo routes/web.php adicionando as rotas necessárias para ativar a solicitação

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

neste ponto, podemos tentar o exemplo visitando a URL http://localhost:8000/terminate

e no navegador veremos as seguintes linhas

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

Ercole Palmeri

Você pode também estar interessado em:

• Service Providers no Laravel: o que são e como usar Service Providers no Laravel
• O que é um APM, Application Performance Management, introdução e alguns exemplos
• O que é um Framework em Engenharia de Software, defidefinição e tipos de frameworks
• Política de Privacidade de BlogInnovazione