Na semana passada, dia 17/03 pra ser mais exato, foi feito um post no twitter oficial do Slim, pedindo que quem tem middlewares prontos para o slim v3.x, que postassem, então, como eu estou vendo hoje a lista vazia, resolvi escrever um postzinho sobre o que são esses middlewares, e como eles funcionam no slim.
Vamos lá, antes de mais nada, é importante dizer os middlewares só são possiveis pela implementação do Rack, que é uma arquitetura pipeline muito usada em frameworks Ruby. Com esta arquitetura você consegue acessar, analisar e modificar o ambiente da sua aplicação. Além de muito elegante é realmente muito funcional.
Entendendo o Middleware
Uma aplicação no slim é a união de várias camadas, e cada camada dessa, é um middleware.
Existe uma ilustração, muito conhecida de quem desenvolve em slim, que esta em qualquer artigo sobre middleware:
Essa ilustração, considera que você esta utilizando cache em sua aplicação.
Nessa ilustração, a página(ou o conteúdo que você busca), esta no centro, logo fica claro, que até que você tenha o seu conteúdo gerado, passaremos por todas as camadas anteriores. Essas camadas vnao dizer se prosseguimos na execução ou se desviamos para qq outro lugar.
Quanto a ilustração:
1 - É verificada a autenticação do usuário, se não estiver autenticado o fluxo será interrompido e geramos um erro (401);
2 - Verificamos depois se existe cache da página que esta sendo criada, se sim, mostramos o cache, e interrompemos o fluxo;
3 - Criamos o conteúdo da página solicitada e exibimos.
Bem simples né, da pra entender bem o funcionamento. Quando você cria o seu próprio middleware, ele se tornará uma nova camada desta aplicação, acima de todas as outras existentes.
Implementando o seu middleware
O objetivo do middleware é inspecionar, analisar ou modificar o ambiente de aplicação, solicitação e resposta antes e / ou após que a aplicação Slim é invocada. Dentro do middlware, você pode obter referências para a aplicação facilmente:
<?php
class MeuMiddleware extends \Slim\Middleware
{
public function call()
{
//Acesso a aplicação
$app = $this->app;
//Acesso Ao ambiente
$env = $app->environment;
//Acesso ao objeto request
$req = $app->request;
//Acesso ao objeto response
$res = $app->response;
}
}
O que for alterado ao ambiente, request e response serão imediatamente propagadas para todo o ambiente da sua aplicação, uma vez que o objeto da aplicação (nosso famoso $app) é compartilhado por toda a aplicação.
Além das referências a aplicação propriamente dita, o middleware tem uma referência a cada inferior a aplicação, através do método $this->next->call(), Assim é possível encerrar seu ciclo de vida explicitamente.
<?php
class MeuMiddleware extends \Slim\Middleware
{
public function call()
{
//Chama o próximo middleware
$this->next->call();
}
}
Na documentação do slim, temos um exemplo bem simples de um middleware, que vai deixar toda a saída em maiúsculo.
<?php
class AllCapsMiddleware extends \Slim\Middleware
{
public function call()
{
// Pegamos a referencia a aplicação aqui
$app = $this->app;
// Chamamos o proximo middleware
$this->next->call();
// Aqui tornamos toda a resposta maiúscula
$res = $app->response;
$body = $res->getBody();
$res->setBody(strtoupper($body));
}
}
Para adicionar sua classe middleware á sua aplicação:
<?php
$app = new \Slim\Slim();
$app->add(new \AllCapsMiddleware());
$app->get('/foo', function () use ($app) {
echo "Hello";
});
$app->run();
Quando eu vi esta funcionalidade, a primeira coisa na qual eu pensei foi em um middleware para autenticação, acho que todo mundo pensa..rs, mas muita coisa pode ser feita, mesmo a implementação em cache, CSRF, e por ai vai...
Pra finalizar esse assunto, venho em breve falar sobre os hooks.
Abraços a todos ai.
