Entendendo o Middleware

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.