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.

Usando o Slim no GAE

Então eu estava pensando aqui em uma maneira de começar a implementar um projetinho de testes, e vou unir 2 coisas  que tenho usado muito ultimamente: o Slim e o GAE.

Todo mundo deve conhecer o Google App Engine, então não vou explicar nada da ferramenta, se você queiser tirar alguma dúvida, acessa a documentaçnao https://cloud.google.com/appengine/docs que com certeza vai esclarecer muito mais do que eu poderia aqui no blog, sem contar que não é este o nosso objetivo.

Configurando o ambiente

Antes de mais nada eu criei uma aplicação no GAE, e você pode acessar ela através do link: http://myslimerp.appspot.com/, eu pretendo utilizar esta app de exemplo pra todos os testes e demonstrações aqui do blog tá...

1 - Vamos colocar o slim framework na nossa aplicação (vou usar o composer pq é bem mais fácil né :), se você ainda não usa composer, segue ai como instalar ó o link é de ambiente mac, que é o que eu uso, mas pra windows não deve ser muito diferente ).  Então logo após eu ter clonado minha app do GAE, eu ja usei o composer no diretório da minha app pra instalar nosso amigão.

composer require slim/slim

2 - Agora vamos configurar nosso app.yaml, para definir o index.php como o nosso handler padrão.

application: id-da-sua-aplicacao-aqui
version: 1
runtime: php
api_version: 1

handlers:
# ...
- url: /.*
  script: public_html/index.php

3 - Bora criar nosso index.php, e já criar nossa primeira rota pra receber as requisições:

<?php
require 'vendor/autoload.php';

$app = new \Slim\Slim();

// Google App Engine não define a $_SERVER['PATH_INFO']
$app->environment['PATH_INFO'] = $_SERVER['REQUEST_URI'];

$app->get('/', function () {
    echo "Uhuuu o Slim esta vivo !!!";
});

$app->run();

Prontinho, nosso slim já esta rodando no GAE.
Agora já podemos começar a codar nossa aplicação utilizando o GAE, que ótimo né :)...

Até a próxima, e fico ai no aguardo por sugestões de temas para os próximos posts. Ah! e eu não esqueci da série sobre os protocolos HTTP que havia prometido nos posts anteriores. Vou dar continuidade neles sim.

Abraços

Slim 2.6.0 e voltando a blogar

Boa tarde povo, foi liberada a versão nova do slim, a 2.6.0, e esta é a minha desculpa pra voltar a blogar depois deste tempo parado, já que eu comecei a blogger e acabei parando.

Bom, sobre a versão nova tem como principal característica uma correção na classe SessionCookie. Ela corrige uma vulnerabilidade que permitia injections na mesma, e por esse motivo a atualização é altamente recomendada.

Vou começar a blogar de acordo com um projeto no qual estou trabalhando neste momento e postando de acordo com as dificuldades que tiver, e conforme forem surgindo novidades no framework eu vou postando aqui..