Slim Framework 3 para quem não conhece - Entendendo o padrão MVC na prática Artigo

Conheça os cursos gratuitos do WebDevBr! - Inscreva-se!


Este artigo foi publicado a 1 ano, 3 meses, 2 semanas, 4 dias atrás.

Slim Framework é um microframework PHP que ajuda você a escrever rapidamente aplicações web simples mas poderosas e APIs.

Extremamente simples de se usar o Slim Framework oferece uma rápida e poderosa maneira de criar aplicações web com flexibilidade e a possibilidade de expansão de uma forma que frameworks como Laravel, CakePHP ou outros frameworks full stack não poderiam, claro que não é por falta de capacidade, mas por terem um esqueleto elaborado e bem definidos e sua natureza incrementada que acabam que por dificultar um pouco várias tarefas, como escolher o ORM favorito ou o template engine caso sejam diferentes do "original".

Quando me perguntam qual a diferença entre frameworks full stack e micro frameworks minha resposta é que framework full stack tentam prever e trazer todos os recursos que você pode precisar na hora de desenvolver, rapidamente e a mão. Micro frameworks trazem o mínimo e você adiciona o que precisa, claro, exige mais preparo e experiência por parte do desenvolvedor, mas com preparo e experiência o Slim Framework é tão produtivo quanto qualquer outra coisa. Acredito que o tamanho da aplicação influencie sim na hora de escolher entre um micro ou full stack, porém a própria experiência do programador conta muito na hora da decisão, eu me saio muito bem com o Slim e ele é minha escolha em vários cenários, principalmente para APIs RESTful.

Gostou deste artigo?

Receba atualizações semanais com novos artigos do WebDevBr e outras dicas!

Slim Framework como Controller

O Slim Framework vai nos servir de controller, ou seja, ele vai definir quando precisamos de um registro da model ou quando a view irá renderizar, para isso precisamos que o Controller tenha total acesso as requisições de entrada e saída e um bom suporte a rotas, o controller intermedia tudo, embora ele mesmo não saiba como fazer as coisas e sim quando devem ser feitas.

O controller gerencia o fluxo da aplicação. Apenas isso!

Incluindo um novo arquivo

No meu arquivo bootstrap.php vou incluir um novo arquivo chamado app.php, não esqueça de remover o exemplo de utilização do Eloquent da aula passada, o arquivo bootstrap.php completo está logo abaixo.

<?php

include __DIR__.'/vendor/autoload.php';

use WebDevBr\Mvc\Config;
use Illuminate\Database\Capsule\Manager as Db;

Config::init();

if (Config::get('debug')) {
    $db_config = Config::get('development');

    $run     = new Whoops\Run;
    $handler = new Whoops\Handler\PrettyPageHandler;
    $run->pushHandler($handler);
    $run->register();
} else {
    $db_config = Config::get('production');
}

$db = new Db;

$db->addConnection([
    'driver'    => 'mysql',
    'host'      => $db_config['host'],
    'database'  => $db_config['name'],
    'username'  => $db_config['user'],
    'password'  => $db_config['pass'],
    'charset'   => 'utf8',
    'collation' => 'utf8_unicode_ci',
    'prefix'    => '',
]);

$db->setAsGlobal();
$db->bootEloquent();

include __DIR__.'/app.php'; //nova linha

E é isso ai! Vamos ao Slim.

Usando o Slim Framework

No arquivo app.php vamos colocar o seguinte código.

<?php

use Illuminate\Database\Capsule\Manager as Db;

$app = new Slim\App;

$app->get('/', function() {
    $user = Db::table('users')->where('id',1)->get();
    return json_encode($user);
});

$app->run();

No exemplo acima, eu iniciei o Slim Framework na variável $app e em seguida usei o método get() para informar que sempre que acessar a url / (raiz, index, home, default... sei lá) ele irá executar a função anonima declarada no segundo parâmetro, que é onde eu uso o Eloquent para pegar o registro de id 1 no banco de dados e retornar como Json na tela, usei o mesmo exemplo do artigo passado para facilitar.

O parâmetro get() indica que eu vou acessar a rota informada (/) usando uma requisição GET, você pode fazer o mesmo usando outros verbos HTTP, como POST, PUT, DELETE, PATCH, OPTIONS e HEAD. Simplesmente use os métodos do Slim relativos a cada um deles.

  • post('/', function(){});
  • put('/', function(){});
  • delete('/', function(){});
  • patch('/', function(){});
  • options('/', function(){});
  • head('/', function(){});

Você ainda pode usar o any() para informar qualquer verbo HTTP ou o map() para informar alguns métodos, por exemplo:

$app->map(['GET', 'POST'], '/users/new', function () {

})

O Slim é bem completo nos quesitos URLs e Requisições, dando suporte a parâmetros, parâmetros opcionais, agrupamento de parâmetros, middleware, container de dependências e muito mais.

Integrando Slim com nossas configurações

Para começar vamos integrar o Slim ao arquivo de configurações do Phinx para exibir ou não os erros:

<?php

use Illuminate\Database\Capsule\Manager as Db;

//Começa aqui a alteração
$slim_config = [
    'settings' => [
        'displayErrorDetails' => WebDevBr\Mvc\Config::get('debug'),
    ],
];

$c = new Slim\Container($slim_config);

$app = new Slim\App($c);
//termina aqui

$app->get('/', function() {
    $user = Db::table('users')->where('id',1)->get();
    return json_encode($user);
});

$app->run();

Prontinho, simples né.

E também vou aproveitar para incluir um novo errorHandler, ou seja, um novo manipulador de erro, na verdade será o Whoops, mas precisamos de alguns truques para integrá-lo ao Slim, vamos ao arquivo app.php primeiro, vou aproveirar para colocar todas as classes no topo, com use.

<?php

use Slim\App;
use Slim\Container;
use WebDevBr\Mvc\Config;
use WebDevBr\Mvc\SlimWhoops;
use Illuminate\Database\Capsule\Manager as Db;

$slim_config = [
    'settings' => [
        'displayErrorDetails' => Config::get('debug'),
    ],
];

$c = new Container($slim_config);

//começa aqui a alteração
$c['errorHandler'] = function ($c) {
    return function ($request, $response, $exception) use ($c) {
        SlimWhoops::integrate($exception);
    };
};
//termina aqui

$app = new App($c);

$app->get('/', function() {
    $user = Db::table('users')->where('id',1)->get();
    return json_encode($user);
});

$app->run();

Note que eu inclui uma classe chamada WebDevBr\Mvc\SlimWhoops, vamos cria-lá em src/SlimWhoops.php com o seguinte código:

<?php

namespace WebDevBr\Mvc;

use Whoops\Run;
use Whoops\Handler\PrettyPageHandler;

class SlimWhoops
{
    protected static $whoops;

    public static function init()
    {
        if (!self::$whoops) {
            $run = new Run;
            $handler = new PrettyPageHandler;
            $run->pushHandler($handler);
            $run->register();

            self::$whoops = $run;
        }
    }

    public static function integrate($exception)
    {
        $whoops = self::$whoops;
        $handler = Run::EXCEPTION_HANDLER;
        $whoops->$handler($exception);
    }
}

E prontinho! Integramos o Slim com os erros e configuração de erro no nosso site.

No próximo artigo vamos conhecer o SlimView e usar o Twig para renderizar HTML.

Na quarta-feira desta semana vou publicar uma screencast sobre o Slim Framework para iniciantes e falar mais sobre ele, eu atualizo aqui com o link, cadastre-se no meu canal no Youtube ou assine a Newsletter do WebDevBr para ser avisado (um pouco mais pra cima, nesta página mesmo).

Até a próxima!


Cursos relacionados


* Parcelamento apenas cartão de crédito! Pode haver uma pequena variação no parcelamento em relação a simulações apresentadas!