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!
