Álvaro José Agámez Licha - @CodeMaxter
MedellinPHP
Medellín - Colombia, 2014/09/11
A powerful yet easy-to-use PHP micro-framework designed to help you build dynamic and robust web applications - fast!
No se mete en tu camino
F3 no establece ningún extraño patrón MVC preestablecido que debamos seguir.
Podemos seguir el patrón MVC, RMR o simplemente procedural
Es increíblemente rápido
Debido a la simplicidad y reusabilidad de cada componente de F3 es increíblemente veloz
F3 soporta bases de datos SQL estándar y NoSQL: MySQL, SQLite, MSSQL/Sybase, PostgreSQL, DB2 y MongoDB. También viene con poderosos Mapeadores objeto-relacional para la abstracción y modelado de datos, que son tan ligeros como el framework. No es necesaria ninguna configuración adicional.
Fat-Free puede ser instalado vía composer muy fácilmente.
{
"name": "fat-free/medellin-php",
"require": {
"bcosca/fatfree": "3.3.0"
},
"authors": [
{
"name": "YourName",
"email": "your.email@outlook.com"
}
]
}
composer init
completar los datos requeridos
composer install
Una vez instalado fat-free podemos verificar que todo esté correcto y el soporte que tengamos configurado en nuestro PHP iniciando un servidor local en el directorio donde instalamos fat-free y navegador a http://localhost:8000/vendor/bcosca/fatfree/
php -S localhost:8000
Hello, World: The Less-Than-A-Minute Fat-Free Recipe
<?php
require(__DIR__ . '/vendor/autoload.php');
$f3 = require(__DIR__ . '/vendor/bcosca/fatfree/lib/base.php');
$f3->route('GET /', function() {
echo 'Hello, world!';
}
);
$f3->run();
F3 trae consigo un routing engine bastante potente y a la vez simple de usar; podemos generar rutas hacia funciones anónimas, métodos públicos de objetos o métodos estáticos públicos de clases.
$f3->route('GET /about', function() {
echo 'Donations go to a local charity... us!';
}
);
class WebPage
{
function display()
{
echo 'I cannot object to an object';
}
}
$f3->route('GET /about','WebPage->display');
$f3->route('GET /login','Auth::login');
$f3->route('GET /brew/@count', function($f3) {
echo $f3->get('PARAMS.count').' bottles of beer on the wall.';
}
);
$f3->route('GET /brew/@count', function($f3,$params) {
echo $params['count'].' bottles of beer on the wall.';
}
);
$f3->route('GET /brew/*', function() {
echo 'Enough beer! We always end up here.';
}
);
F3 nos permite definir rutas con token en ellas, donde recibiremos parámetros que podemos recuperar muy fácilmente.
El routing engine de F3 nos permite definir nombres para nuestras rutas y así poder usarlas de manera más cómoda, por ejemplo en las vistas.
$f3->route('GET @beer_list: /beer', 'Beer->list');
<a href="{{@ALIASES.beer_list}}">view beer list</a>
// a named route is a string value
$f3->reroute('@beer_list'); // note the single quotes
// if more than one token in your route is needed
$f3->route('GET @beer_village_list: /beer/@country/@village', 'Beer->byvillage');
$f3->reroute('@beer_village_list(@country=Germany,@village=Rhine)');
Hacer redirección de rutas en F3 es muy sencillo, como todo en F3:
$f3->route('GET|HEAD /obsoletepage', function($f3) {
$f3->reroute('/newpage');
}
);
$f3->error(404);
En tiempo de ejecución, F3 genera automáticamente un error HTTP 404 cuando ve que una solicitud HTTP entrante no coincide con ninguna de las rutas definidas en la aplicación. Sin embargo, hay casos cuando necesitamos activarlo por nosotros mismos.
Desarrollar un servicio ReST con F3 es supremamente sensillo, ya que el framework me permite mapear una clase con una ruta específica y F3 se encargará de enrutar las peticiones a los correspondientes métodos
class Item
{
function get()
{
}
function post()
{
}
function put()
{
}
function delete()
{
}
}
$f3=require('lib/base.php');
$f3->map('/cart','Item');
$f3->run();
En F3 puedes usar PHP como template o el sistema de templates integrado del framework. Personalmente me gusta este sistema y es el que aconsejo usar.
<p>Hello, <?php echo $name; ?>!</p>
<p>Hello, <?= $name ?></p>
$f3 = require('lib/base.php');
$f3->route('GET /',
function($f3) {
$f3->set('name','world');
$view = new View;
echo $view->render('template.htm');
// Previous two lines can be shortened to:
// echo View::instance()->render('template.htm');
}
);
$f3->run();
<p>Hello, {{ @name }}!</p>
$f3->set('buddy', ['Tom','Dick','Harry']);
<p>{{ @buddy[0] }}, {{ @buddy[1] }}, and {{ @buddy[2] }}</p>
$f3->set('func',
function($a,$b) {
return $a.', '.$b;
}
);
{{ @func('hello','world') }}
¿Y qué hay del rendimiento de este sistema de plantillas?
En tiempo de ejecución, F3 analiza y compila/convierte una plantilla F3 a código PHP la primera vez que se visualiza mediante $template->render(). F3 utiliza este código compilado en todas las llamadas subsiguientes. Por lo tanto, el rendimiento debe ser igual a los templates PHP, si no mejor debido a la optimización de código realizada por el compilador de plantillas cuando están involucradas plantillas complejas.
<check if="{{ @page=='Home' }}">
<false><span>Inserted if condition is false</span></false>
</check>
<check if="{{ @gender=='M' }}">
<true>
<div>Appears when condition is true</div>
</true>
<false>
<div>Appears when condition is false</div>
</false>
</check>
<repeat group="{{ @fruits }}" value="{{ @fruit }}">
<p>{{ trim(@fruit) }}</p>
</repeat>
<repeat group="{{ @div }}" key="{{ @ikey }}" value="{{ @idiv }}">
<div>
<p><span><b>{{ @ikey }}</b></span></p>
<p>
<repeat group="{{ @idiv }}" value="{{ @ispan }}">
<span>{{ @ispan }}</span>
</repeat>
</p>
</div>
</repeat>
No podría ser de otra manera, el manejo de la internacionalización en F3 es muy simple de realizar:
<?php
return array(
'love'=>'I love F3',
'today'=>'Today is {0,date}',
'pi'=>'{0,number}',
'money'=>'Amount remaining: {0,number,currency}'
);
<h1>{{ @love }}</h1>
<p>
{{ @today,time() | format }}.<br />
{{ @money,365.25 | format }}<br />
{{ @pi }}
</p>
$f3->set('LOCALES','dict/');
$f3->set('LANGUAGE','en');
Fat-Free está diseñado para hacer que el trabajo con bases de datos SQL sea muy fácil.
$db = new DB\SQL('sqlite:/absolute/path/to/your/database.sqlite'));
$db = new DB\SQL(
'mysql:host=localhost;port=3306;dbname=mysqldb',
'admin',
'p455w0rD'
);
Ya vimos que es muy fácil establecer una conexión con nuestras bases de datos, ¿pero cómo ejecuto sentencias SQL?
$f3->set('result', $db->exec('SELECT brandName FROM wherever'));
echo Template::instance()->render('abc.htm');
<repeat group="{{ @result }}" value="{{ @item }}">
<span>{{ @item.brandName }}</span>
</repeat>
Fat-Free realmente hace que todo sea muy fácil, así que el método exec puede recibir un array de sentencias SQL e iniciará una transacción por nosotros, haciendo rollback si algo falla, todo automágicamente.
$db->exec([
'DELETE FROM diet WHERE food="cola"',
'INSERT INTO diet (food) VALUES ("carrot")',
'SELECT * FROM diet'
]);
// También podemos iniciar y finalizar una transacción programativamente:
$db->begin();
$db->exec('DELETE FROM diet WHERE food="cola"');
$db->exec('INSERT INTO diet (food) VALUES ("carrot")');
$db->exec('SELECT * FROM diet');
$db->commit();
// Para obtener una lista de todas las instrucciones sobre la base de datos:
echo $db->log();
Los queries parametrizados nos ayudan a protegernos de los ataques más comunes de inyección SQL; Fat-Free nos hace nuevamente fácil la vida implementándolos.
$db->exec(
'SELECT * FROM users WHERE userID=?',
$f3->get('POST.userID')
);
$db->exec([
'DELETE FROM diet WHERE food=:name',
'INSERT INTO diet (food) VALUES (?)',
'SELECT * FROM diet',
], [
[':name' => 'cola'],
[1 => 'carrot'],
NULL,
]
);
F3 viene con Mapeadores objeto-relacional (ORM) fáciles de usar, que se integran entre nuestra aplicación y los datos (haciendo mucho más fácil y más rápido el escribir programas que manejen operaciones de datos comunes) como crear, consultar, actualizar y eliminar (CRUD) información de bases de datos SQL y NoSQL.
CREATE TABLE users (
userId VARCHAR(30),
password VARCHAR(30),
visits INT,
PRIMARY KEY(userID)
);
$db = new DB\SQL(
'mysql:host=localhost;port=3306;dbname=mysqldb',
'admin',
'wh4t3v3r'
);
$user = new DB\SQL\Mapper($db, 'users');
$user->load(['userId = ?', 'codemaxter']);
$db = new DB\Mongo('mongodb://localhost:27017', 'testdb');
$user = new DB\Mongo\Mapper($db, 'users');
$user->load(['userId'=>'codemaxter']);
Fat-Free contiene muchas más funcionalidades de las aquí presentadas, así que los invito a visitar la guía de usuario oficial para aprender mucho más
Gracias...