Middleware no Laravel age como um intermediário que gerencia as solicitações feitas em seu site. Em vez de ir diretamente para onde as coisas acontecem (o controller), a solicitação passa primeiro por esse Middleware. Em termos mais simples, é como uma verificação rápida que acontece antes da sua solicitação chegar ao destino final.
Pense na sua solicitação como um pacote que precisa ser entregue. O Middleware é como um ponto de controle que verifica se o pacote está em conformidade com algumas regras antes de ser processado. Essas regras podem incluir coisas como verificar se você está autenticado, se tem permissão para acessar determinadas áreas e assim por diante.
Quando alguém acessa seu site (faz uma requisição HTTP, como clicar em um link), essa solicitação passa por diversas etapas até chegar ao destino final, que geralmente é um controller no Laravel. O Middleware é como um guarda no meio desse caminho.
A sequência básica de uma requisição HTTP no Laravel é mais ou menos assim:
Você pode checar esse outro post onde eu mostro em mais detalhes esse fluxo. Mas então, o Middleware é essa camada intermédia que tem a oportunidade de verificar ou modificar a solicitação antes que ela atinja o controller. Isso é útil para adicionar medidas de segurança, verificar autenticação, modificar cabeçalhos HTTP, entre outras coisas, dependendo das necessidades do seu aplicativo. Ele se encaixa como um guardião entre a chegada da requisição e o processamento pelo controlador, permitindo a implementação de lógica adicional no fluxo padrão de uma requisição HTTP no Laravel.
Ok, existem duas formas de criar o seus middlewares, a primeira é criando a classe manualmente dentro da pasta app/Http/Middleware. A segunda, e bem mais fácil, é criar utilizando o comando artisan, que exatamente o que vamos fazer aqui.
Abra o terminal e digite o seguinte comando para criar um novo Middleware chamado VerificaAssinatura:
php artisan make:middleware VerificaAssinatura
Este comando cria um arquivo chamado VerificaAssinatura.php no diretório app/Http/Middleware.
Dentro dessa classe você vai encontrar apenas um método, handle(). Este método é executado antes que a solicitação alcance seu destino. É nessa classe que nós vamos adicionar as verificações que queremos fazer.
Nesse middleware, eu vou verificar se o usuário está logado e se a assinatura desse usuário ainda está ativa, se tudo estiver certo, o requisição segue adiante, caso contrário a gente redireciona o usuário para a tela de renovação de assinatura ou se você estive usando uma API, você pode retornar um erro HTTP com o código 401.
<?php
namespace App\Http\Middleware;
use Closure;
class VerificaAssinatura
{
public function handle($request, Closure $next)
{
// Verifica se o usuário está logado e tem uma assinatura ativa
if (auth()->check() && !auth()->user()->assinaturaAtiva()) {
return redirect('/renove-sua-assinatura');
}
// Se estiver tudo certo, continua com a solicitação
return $next($request);
}
}
Você precisa manualmente registrar o seu middleware pra você começar utiliza-lo. Pra registrar, é bem simples. Abra o arquivo app/Http/Kernel.php e adicione o seu Middleware ao array $routeMiddleware:
protected $routeMiddleware = [
// ... outros middlewares ...
'verifica.assinatura' => \App\Http\Middleware\VerificaAssinatura::class,
];
Agora, você pode aplicar o Middleware às rotas desejadas. Abra seu arquivo de rotas (web.php geralmente) e adicione o Middleware utilizando o helper ->middleware():
Route::get('/area-restrita', [AreaRestritaController::class,'index'])->middleware('verifica.assinatura');
Isso significa que sempre que alguém tentar acessar a rota /area-restrita, o Middleware VerificaAssinatura será acionado antes de permitir ou negar o acesso.
No Laravel, existem três tipos de middleware: global, de rota e de grupo. Cada um tem uma função diferente, e a escolha do tipo certo depende das necessidades do seu app ou site. Aqui, vou explicar as diferenças entre eles pra te ajudar a escolher o que é melhor pra sua aplicação.
No contexto do Laravel, um Middleware Global é como uma verificação geral que ocorre em todas as solicitações antes de chegarem aos controladores.
Por exemplo, um Middleware Global pode ser usado para verificar se o usuário está logado. Se o usuário não estiver logado, o Middleware Global pode redirecionar o usuário para a página de login.
Outro exemplo de Middleware Global é um Middleware que registra todas as solicitações recebidas pelo aplicativo em um Log, esse Middleware pode ser usado para fins de análise de desempenho ou segurança.
Por exemplo vamos criar um Middleware Global que verifica o idioma da aplicação e ajusta dinamicamente o idioma da resposta para o usuário. Suponha que você tenha diferentes traduções disponíveis em sua aplicação e deseja garantir que a resposta seja enviada no idioma correto.
// Em app/Http/Middleware/SetLanguage.php
namespace App\Http\Middleware;
use Closure;
class SetLanguage
{
public function handle($request, Closure $next)
{
// Verificar a preferência de idioma do usuário ou usar um padrão
$preferredLanguage = $request->getPreferredLanguage(['en', 'es']);
// Configurar o idioma da aplicação
app()->setLocale($preferredLanguage);
// Continuar com a solicitação
return $next($request);
}
}
Agora para registrar e aplicar esse middleware globalmente, dentro do arquivo app/Http/Kernel.php você vai registrar esse middleware dentro da variável $middleware:
protected $middleware = [
// ... outros middlewares ...
\App\Http\Middleware\SetLanguage::class,
];
O middleware de Rota já é mais específico. Ele é aplicado apenas às rotas que você escolher.
Se você quiser só verificar se um usuário está autenticado antes de acessar uma determinada rota, você primeiro, claro, vai criar um Middleware, CheckAuthentication por exemplo:
php artisan make:middleware CheckAuthentication
// Em app/Http/Middleware/CheckAuthentication.php
public function handle($request, Closure $next)
{
if (auth()->guest()) {
return redirect()->route('login');
}
return $next($request);
}
E lembra que você precisa registrar esse novo middleware no app/Http/Kernel.php também, mas diferentemente do middleware global, esse middleware você vai registrar na variável $routeMiddleware:
protected $routeMiddleware = [
// ... outros middlewares ...
'auth.check' => \App\Http\Middleware\CheckAuthentication::class,
];
Daí então, você pode aplicar esse Middleware em rotas específicas, utilizando o helper ->middleware():
Route::get('/dashboard', 'DashboardController@index')->middleware('auth.check');
O middleware de Grupo no Laravel é um jeito de agrupar verificações que você quer aplicar a várias rotas ao mesmo tempo.
O middleware de Grupo é uma forma de centralizar a lógica de autorização do seu aplicativo. Isso torna seu código mais fácil de manter e entender.
Por exemplo, você pode ter um middleware de Grupo que verifica se o usuário está logado e uma outra que verifica se o usuário é um admin, como já temos um middleware que verifica se o usuário está autenticado, só vamos criar mais um para verificar se o usuário é uma admin.
Pra criar um middleware de grupo, a gente segue o mesmo passo a passo, criando a classe manualmente ou rodando o comando artisan.
php artisan make:middleware CheckAdmin
// Em app/Http/Middleware/CheckAdmin.php
public function handle($request, Closure $next)
{
if (!auth()->user()->isAdmin()) {
return abort(403, 'Acesso negado! Você não é um administrador.');
}
return $next($request);
}
A diferença fica na hora de registrar esse middleware no app/Http/Kernel.php. Dentro do Kernel, você vai encontrar a variável, $middlewareGroups, nessa variável você provavelmente já vai ter definido alguns middlewares do próprio Laravel.
Aqui você pode tanto criar um novo grupo, ou adicionar o middleware que você acabou de criar em um dos grupos que já existem. Aqui eu criei um novo grupo chamado admin onde vou adicionar os dois middlewares.
protected $middlewareGroups = [
'web' => [
// ... outros middlewares ...
],
'admin' => [
\App\Http\Middleware\CheckAdmin::class,
\App\Http\Middleware\CheckAuthentication::class,
],
];
E então, você aplica esse grupo de Middleware às suas rotas. Aqui você vai usar o helper ->middleware() em junção com o helper group(), que aceita uma método callback, onde dentro desse método, você vai passar todas as rotas ao qual você quer aplicar o seus middlewares.
Route::middleware(['admin])->group(function () {
//
});
Bora resumir o que a gente viu sobre middleware no Laravel:
Além disso, vimos como criar um middleware personalizado. É bem simples:
.php na pasta app/Http/Middleware.Illuminate\Foundation\Http\Middleware\Middleware.handle().Entendendo esses conceitos, você estará pronto para implementar estratégias eficazes de controle e personalização no fluxo de requisições HTTP do seu aplicativo Laravel.
Deixe um comentário