Documentacion Laravel
3.6-POO: Inyección de dependencias
en Laravel (IV)
Esta es la cuarta parte de la mini serie de inyección de dependencias en Laravel, lee la primera, la segunda y la tercera antes de continuar.
Necesitas conocimientos básicos de Laravel y POO para hacer este tutorial. Vimos en capítulos anteriores que la inyección de dependencias, pese a su nombre complicado, es realmente un concepto simple que permite escribir objetos “desacoplados”, es decir, que no sean dependientes uno del otro. La inyección de dependencias nos permite diseñar ORMs que en vez de estar atado a un solo motor de DB, reciban como parámetro clases MySQL o Postgresql o incluso de MongoDB que funcionen siempre que cumplan con una “interfaz”. El “contenedor de inyección de dependencias” es como una máquina ensambladora que conecta una parte con otra y hace que todo el sistema funcione.
También vimos que manipular las dependencias de nuestro sistema puede ser difícil, por eso el contenedor de Laravel es inteligente, y aún así sigue siendo simple! Para demostrarlo les creé un demo.
Bien ahora dejémonos de demos y vamos a usar el contenedor real de Laravel! Para enseñarles cómo usar la inyección de dependencias en Laravel necesito 3 pasos:
Primero crearemos una clase de ejemplo y luego la integraremos con el contenedor de Laravel.
Paso 1: Clase Alert de ejemplo
Yo creé para uds. una mini versión de mi clase Alert que es un helper para enviar mensajes del controlador a las vistas, en mi caso uso los estilos de Bootstrap pero es adaptable.
<?php namespace Components;
use Illuminate\Session\Store as Session; use Illuminate\View\Environment as View; class Alert {
const SESSION_NAME = 'AlertMessages';
public function __construct(Session $session, View $view) {
$this->session = $session; $this->view = $view;
}
public function message($message, $type) {
$messages = $this->session->get(static::SESSION_NAME, array());
$messages[] = compact('message', 'type');
$this->session->flash(static::SESSION_NAME, $messages); }
public function render($template = 'alert') {
$messages = $this->session->get(static::SESSION_NAME, null);
if ($messages != null) {
$this->session->flash(static::SESSION_NAME, null); return
$this->view->make($template)->with('messages', $messages); }
return ""; }
}
Esta clase tiene dos métodos: message graba mensajes y render los muestra. La clase usa la Sesión de Laravel para guardar mensajes entre una petición y otra y la clase de Vista para los templates.
Para usarla:
1. Dentro de app creen las carpetas y el archivo: app/library/Components/Alert.php allí copien y peguen el código de arriba.
2. Abran composer.json y en “autoload” -> “classmap” agreguen "app/library/Components" ejemplo:
"autoload": {
"classmap": [
……...
"app/library/Components"
3. Ejecuten en la consola “php artisan dump-autoload”.
4. En la carpeta app/views creen un archivo llamado alert.blade.php y copien lo siguiente:
app/views/alert.blade.php
@foreach ($messages as $msg)
<div class="alert alert-block alert-{{ $msg['type'] }} fade in"> <button type="button" class="close"
data-dismiss="alert">×</button>
<p><strong>{{ $msg['message'] }}</strong></p> </div>
@endforeach
Esta es la plantilla que usará la clase Alert por defecto.
Veamos un ejemplo de cómo usarla, en un método cualquiera de un controlador agreguen esto:
$alert = new Components\Alert(App::make('session.store'),
App::make('view'));
$alert->message('Laravel es genial', 'info');
Asignen la variable $alert a la vista:
return View::make('admin/users/list')->with('alert', $alert); Y en cualquier Vista simplemente:
{{ $alert->render() }}
Si usan una plantilla que implemente Bootstrap verán un bonito mensaje en azul que dirá “Laravel es genial”.
Paso 2: Usar el contenedor de inyección de dependencias de Laravel El código anterior se enfrenta al menos a dos inconvenientes.
1. Usarlo es complicado, es decir instanciar la clase, es demasiado código y difícil de recordar:
$alert = new Components\Alert(App::make('session.store'), App::make('view'));
De hecho podría ser peor, pero yo tomé un atajo y usé el contenedor de Laravel (alias “App”) para traerme la clase de session y la clase de view:
App::make('session.store')
De lo contrario haría falta instanciar esas clases y cada una de sus dependencias, lo cual podría volverse fácilmente unas 10 líneas de código.
2. La clase y variable $alert debe pasarse siempre a la vista, de lo contrario obtendremos un error de que la variable no está definida.
Con el contenedor de Laravel podemos resolver ambos problemas muy fácilmente:
Usando los ServiceProviders
Laravel le llama Service Providers a las clases que almacenan la configuración de la inyección de dependencias, son como los ensambladores de la aplicación. 1. Creen un archivo nuevo en app/library/Components/AlertProvider.php y peguen este código:
<?php namespace Components;
use Illuminate\Support\ServiceProvider; use Illuminate\Foundation\AliasLoader;
class AlertProvider extends ServiceProvider { public function register()
{
$this->registerAlert(); }
public function registerAlert() {
$this->app->bind('alert', function($app) {
return new Alert($app['session.store'], $app['view']);
}); }
}
2. Ejecuten nuevamente php artisan dump-autoload. 3. Vamos a decirle a Laravel que queremos incluir este ServiceProvider en nuestra App, vamos a app/config/app.php y en el array “providers” agregaremos
'Components\AlertProvider' a la lista: 'providers' => array( ………… ………... 'Components\AlertProvider' ),
4. ¡Ya podemos instanciar nuestra clase Alert con el contenedor de dependencias!
Es decir:
$alert = App::make('alert');
$alert->message('Laravel es genial', 'info');
Paso 3: Uso de los Facades en Laravel
Aún App::make(„alert‟) se ve algo extraño, no? A pesar de que es más limpio, no sería mejor tener algo como Route::get ? De hecho “Route::get” es lo que Taylor Otwell llamó facades.
Creemos el nuestro:
1. Creen el archivo app/library/Components/AlertFacade.php 2. Y coloquen lo siguiente:
<?php namespace Components;
use Illuminate\Support\Facades\Facade; class AlertFacade extends Facade { /**
* Get the registered name of the component. *
* @return string */
protected static function getFacadeAccessor() { return
'alert'; } }
2. Luego regresemos a nuestro ServiceProvider y vamos a crear un Alias para el Facade:
<?php namespace Components;
use Illuminate\Support\ServiceProvider; use Illuminate\Foundation\AliasLoader;
class AlertProvider extends ServiceProvider { public function register()
{
$this->registerAlert(); $this->setAliases(); }
public function registerAlert() {
$this->app->bind('alert', function($app) {
return new Alert($app['session.store'], $app['view']);
}); }
public function setAliases() {
$this->app->booting(function () {
$loader = AliasLoader::getInstance(); // Facades
$loader->alias('Alert', 'Components\AlertFacade');
}); }
}
3. No olviden ejecutar el dump-autoload.
4. Una vez hecho estos tres pasos en nuestro controlador ya podemos usar el Alert así:
Alert::message('Laravel es genial', 'info');
Noten que NO estamos instanciando la clase, por lo tanto tampoco necesitamos la variable $alert, en la vista queda así:
{{ Alert::render() }}
Más limpio y bonito imposible. Sin embargo noten que tampoco estamos haciendo uso de clases estáticas, lo cual es una mala práctica casi siempre, lo que ocurre es que el Facade se encarga de interactuar con el contenedor de inyección de dependencias de Laravel que a su vez instancia y almacena la clase por nosotros. Es decir, cada vez que haz hecho Route::get o View::make en realidad estabas trabajando con inyección de dependencias sin darte cuenta!. Les recomiendo seguir la documentación de Laravel IoC Container y Facades para aprender más de estos geniales conceptos.
1 - Laravel, un framework PHP
El 2012 sirvió para ver como la oveja negra a PHP. Todos se deslumbraban con nuevos lenguajes/paradigmas como Node.js, Ruby On Rails y demás. Si mencionabas PHP te comenzaban a ver como aquel hombre de 45 años, divorciado, con un trozo de pizza en su escritorio y programando en COBOL.
Es cierto que se resaltaron muchas de las carencias del tan popular PHP, pero eso lejos de matarlo, lo fortaleció. Se empezó a trabajar en versiones mejoradas, se aprendió de los nuevos lenguajes y empezaron a llegar Frameworks de alto nivel, prácticos, fáciles de usar y con un futuro muy prometedor.
Laravel, un framework para PHP
He trabajado en un par de proyectos utilizando el Framework de Laravel para PHP, y el resultado hasta ahora ha sido fantástico. La curva de aprendizaje es relativamente sencilla.Nunca antes había sido tan fácil:● asociar una ruta a un controller y a una vista,
● crear restful APIs está a dos pasitos,
● el ORM es tan práctico como cualquiera que se base en el patrón ActiveRecord ...en sí es un Framework muy bien diseñado.
Laravel se basa en la elegancia y simpleza. Programar ya no tiene que ser tan doloroso y de hecho puede ser agradable con las herramientas necesarias. Laravel es una de esas herramientas.
Está pensado para todos los programadores, inclusive los nuevos programadores que están iniciando con PHP, y ofrece grandes experiencias de desarrollo a los programadores avanzados.
Gracias a la arquitectura única de Laravel, posibilita a los desarrolladores a crear y diseñar su propia infraestructura para sus aplicaciones de la manera más flexible. Para mí, Laravel, es la bandera más fuerte que me hace seguir apostando por PHP. Debo mencionar que he hecho proyectos con Node.js, y me parece muy bueno, no estoy casado con ningún lenguage, simplemente creo que aún hay muchas razones para seguir trabajando con PHP. Se habla mucho de de las diferencias de performance, en casos prácticos se invita a que se demuestre eso, por ejemplo, aqui Node.js tarda 0.389 seconds en procesar 1000 requests, en cambio PHP 0.130 seconds.
No dejen de leer este artículo donde dan mas detalles de las cosas buenas que se vienen para PHP.
4 - Cómo usar múltiples bases de
datos en Laravel
Laravel hace posible la conexión a diferentes bases de datos de la manera más fácil posible, actualmente soporta los motores de base de datos más populares:MySQL, PostgreSQL, SQLite y SQLServer, y por eso nos hace siempre felices.
En aplicaciones y proyectos web sencillos es común tener una conexión a una sola base de datos, la cual es más que suficiente para almacenar y leer la información administrada por nuestro proyecto. En aplicaciones web más robustas, de mayor tamaño o con requerimientos muy especiales surge la necesidad de utilizar múltiples bases de datos, una para leer, otra para escribir la información o tal vez una base de datos que tiene algún propósito especial en otro sistema.
Configuración
Primero que todo debemos realizar la configuración de las conexiones, esta configuración se hace en el archivoCódigo:
app/config/database.php
.
En este archivo puedes establecer la configuración para todas las bases de datos que necesites, de forma predeterminada Laravel provee cuatro configuraciones de ejemplo para cada uno de los motores de base de datos mencionados: Código :
'connections' => array( 'sqlite' => array(
'driver' => 'sqlite',
'database' => __DIR__.'/../database/production.sqlite', 'prefix' => '',
),
'mysql' => array(
'host' => 'localhost', 'database' => 'database', 'username' => 'root', 'password' => '', 'charset' => 'utf8', 'collation' => 'utf8_unicode_ci', 'prefix' => '', ), 'pgsql' => array( 'driver' => 'pgsql', 'host' => 'localhost', 'database' => 'database', 'username' => 'root', 'password' => '', 'charset' => 'utf8', 'prefix' => '', 'schema' => 'public', ), 'sqlsrv' => array( 'driver' => 'sqlsrv', 'host' => 'localhost', 'database' => 'database', 'username' => 'root', 'password' => '', 'prefix' => '', ), ),
Si necesitas una nueva conexión solo basta con añadirla al arreglo de conexiones y establecerle un nombre único:
Código : 'connections' => array( 'stark' => array( 'driver' => 'mysql', 'host' => 'westeros', 'database' => 'database',
'username' => 'JonSnow', 'password' => 'Y0uN0th1ngJ0nS4nw', 'charset' => 'utf8', 'collation' => 'utf8_unicode_ci', 'prefix' => '', ), 'lannister' => array( 'driver' => 'mysql', 'host' => 'westeros', 'database' => 'database', 'username' => 'Joffrey', 'password' => 'Wh0R3memb3rTh4atL1ttleB1tch?', 'charset' => 'utf8', 'collation' => 'utf8_unicode_ci', 'prefix' => '', ), ),
En el archivo de configuración también se puede establecer la conexión de base de datos que se usará de forma predeterminada, es la opción siguiente: Código :
'default' => 'mysql'
Uso de múltiples conexiones en Laravel
El uso de diferentes conexiones es, como bien sabemos, muy fácil e intuitivo en Laravel:
Esquema
Para definir el esquema de base de datos usa el método: Código :
Código :
Schema::connection('stark')->create('deaths', function($table) {
$table->increments('id'); $table->string('type'); $table->string('name'); });
Consultas
Si estás usando el constructor de consultas simples usa el método: Código :
DB::connection Código :
$users = DB::connection('lannister')->select(...); Eloquent
Si estás usando Eloquent puedes definir la conexión de base de datos en el modelo a través de la propiedad.
Código :
$connection
Código : <?php
class Death extends Eloquent {
protected $connection = 'stark'; }
Tiempo de ejecución
Si necesitas cambiar de conexión de base de datos durante la ejecución de alguna función puedes hacerlo con el método:
Código :
setConnection
el cual recibe como parámetro el nombre de la conexión: Código :
<?php
class KillController extends BaseController { public function decapitate()
{
$death = new Death;
$death->setConnection('lannister'); $joffrey = $death->find(1);
return $joffrey; }
}
Como vimos Laravel ofrece soluciones sencillas a los problemas comunes que surgen en nuestras aplicaciones web.
4.1 - Análisis y extensión de clases
en PHP con ReflectionMethod
Reflection es una clase o más bien un conjunto de clases de PHP que permiten saber todo sobre tus otras clases, métodos, funciones, parámetros, etcétera... Quizás es una de las funcionalidades más c00l que PHP ha agregado recientemente y quizás una de las que menos se conoce o se usa: ReflectionMethod.
Por acá les dejo un código que me pareció bastante práctico y su siguiente explicación:
Supongamos que necesitan llamar a un método de una clase (un controlador o algo así) usando call_user_func_array desde alguna parte de nuestro script, pero antes de llamarlo directamente, quieren validar que:
● El método a llamar sea público.
● La cantidad de parámetros enviados no es menor que la cantidad de parámetros requeridos por el método.
Y adicionalmente les gustaría no sólo pasar los parámetros como parámetros ordinarios, sino también tenerlos disponibles en una clase aparte, es decir, que al llamar a una función como:
Código :
function verLista($year, $month)
Con los siguientes valores: Código :
call_user_func_array(array($controller, 'verLista'), array(2008, 10));
Permita generar en el Controller un objeto con los siguientes valores: Código :
$this->params->year = 2008; $this->params->month = 10;
Lo cual tal vez sería util si más adelante se necesita pasar estos valores de un método a otro dentro del controlador sin necesidad del uso de parámetros y si se quiere agregar una seguridad extra al script (como bloquear la posibilidad de sobreescribir o reemplazar parametros)
En fin, esta es la idea.. Aquí el código:
Primeramente tenemos una clase básica llamada ControllerParams que permite guardar y obtener datos / parámetros:
Código :
class ControllerParams
{
private $params = array();
function __set($name, $value) {
$this->params[$name] = $value; }
function __get($name) {
return $this->params[$name]; }
}
Y aquí el método que hace la funcionalidad ya descripta: Código :
class Controller
{
protected $params = null;
final function execute($action, $params = null) //funcion intermedia
{
$reflectionMethod = new ReflectionMethod($this, $action); //se crea una instancia de ReflectionMethod con la referencia al metodo que necesitamos llamar
//asi ya tenemos disponible las funcionalidades de ReflectionMethod:
if(($action == 'execute') || !>isPublic() || (count($params) < $reflectionMethod->getNumberOfRequiredParameters()))
{
//LANZAR ERROR }
$parametros = $reflectionMethod->getParameters(); //con esto obtenemos los parametros de nuestro metodo
$this->params = new ControllerParams();
foreach($parameters as $key => $parameter) //y hacemos un ciclo con ellos
{
$name = $parameter->getName(); //obtenemos el nombre if(isset($params[$key])) //si el usuario mandó algun valor lo asignamos
{
$this->params->$name = $params[$key]; }
else {
$parameter->getDefaultValue(); //sino tambien podemos tomar el valor por defecto
} }
call_user_func_array(array(&$this, $action), $params); //y por ultimo hacemos el llamado de costumbre
} }
Redimensionar imágenes en PHP
con clases abstractas
Las clases abstractas en la programación orientada a objetos son clases de las que no se pueden crear instancias/objetos directamente de ella.
¿Para qué defino una clase como abstracta si no puedo crear objeto de ella?
Si puedes crear instancias pero solo de clases que hereden dicha clase (que no sean abstractas por supuesto). El objetivo principal de la herencia es mejorar la clase heredada. Así que sabiendo esto, las clases abstractas en su más pura esencia son clases mejorables!
Una clase abstracta puede tener métodos y propiedades como cualquier otra clase.
¿Cuando debo definir una clase abstracta?
Cuando puedas crear diferentes clases que tengan propiedades y métodos comunes, y aún sabiendo que en el futuro que puedes crear más clases del mismo tipo.
En la clase abstracta se definirían las propiedades y métodos comunes, para que las clases que la hereden no tengan la necesidad implementar esos métodos o definir las propiedades.
Métodos Abstractos
Así como hay clases abstractas, también hay métodos abstractos. Estos métodos no son implementados en su definición, pero obliga a las clases que hereden el método a implementarlo.
Un método abstracto se puede definir en casi cualquier clase, no necesariamente debe ser una clase abstracta. Un ejemplo en las que no se deberían definir métodos abstractos serian en las clases finales, pues no se podrían implementar.
Las clases finales: son las clases engreídas en la POO su lema principal: ¡Nadie me puede mejorar!. Es decir, que no se pueden heredar. Entonces se podría decir que son las opuestas a las clases abstractas que son la de baja autoestima su lema: "Soy inútil sola, mejorame por favor ".
Redimensionar imágenes en PHP usando clase abstracta
Definimos una clase abstracta llamada ImageBase. Todas las clases que hereden esta clase tendrán:
Las propiedades width y height, con sus respectivos setters y getters. Además de dos metodos comunes los cuales son: gdFromFile y gdToFile. Obliga a la clase que le herede a implementar el metodo save Código :
abstract class ImageBase
{
protected $width; protected $height;
public function setWidth($w) {
// gd solo maneja enteros, ergo obligamos que ancho sea entero.
$w = (int) $w;
// ancho debe ser mayor que 0
if ($w > 0) $this->width = $w; }
public function getWidth() {
return $this->width; }
public function setHeight($h) {
// gd solo maneja enteros, ergo obligamos que alto sea entero
$h = (int) $h;
if ($h > 0) $this->height = $h; }
public function getHeight() {
return $this->height; }
/**
* Genera una imagen gd del archivo con nombre $filename * Retorna FALSE si ocurrior algun error, por ejemplo: el tipo no es soportado
*
* @param string $filename nombre del archivo
* @param int $type Tipo de imagen para saber que funcion usar
* @return resource Una imagen gd. */
protected function gdFromFile($filename, $type) { $gd = false; switch ($type) { case IMAGETYPE_PNG: $gd = imagecreatefrompng($filename); break; case IMAGETYPE_JPEG: $gd = imagecreatefromjpeg($filename); break; case IMAGETYPE_GIF: $gd = imagecreatefromgif($filename); break; } return $gd; } /**
* Guarda una imagen gd en el archivo de nombre $filename *
* @param resource $gd La imagen a guardar * @param string $filename nombre del archivo
* @param int $type Tipo de imagen para saber que funcion usar
* @return bool TRUE en caso de exito, FALSE en caso contrario
* */
protected function gdToFile($gd, $filename, $type) {
$success = false;
// si $filename es nulo las funciones posteriores imprimiran en la salida directamente
// aqui tratamos de evitar eso $filename = (string) $filename; if (trim($filename) != "")
{
// no tiene sentido verificar si el archivo existe, pues si no existe se creara
// las siguientes funciones retornan false si ocurrio algun error, true en caso de exito
switch ($type) {
case IMAGETYPE_PNG:
$success = imagepng($gd, $filename); break;
case IMAGETYPE_GIF:
$success = imagegif($gd, $filename); break;
case IMAGETYPE_JPEG:
$success = imagejpeg($gd, $filename); break;
} }
return $success; }
// Obligamos a que las clases que hereden esta clase implementen este método
/**
* La intencion de este metodo es que guarde la imagen creada en un archivo
*
* @param string $filename Nombre del archivo
* @return bool TRUE en caso de exito, FALSE en caso contrario
abstract public function save($filename); }
Creamos ImageResize que hereda ImageBase. Código :
class ImageResize extends ImageBase
{
private $src;
private $origWidth; private $origHeight; private $origType;
private $hasError = false;
public function __construct($src) {
$this->setSrc($src); }
private function setSrc($src) {
if (is_file($src)) {
// getimagesize retorna un arreglo si tuvo exito con la informacion de la imagen
// false en caso contrario $info = getimagesize($src); if ($info !== FALSE)
{
$this->src = $src;
$this->origWidth = $info[0]; // ancho de la imagen $this->origHeight = $info[1]; // alto de la imagen $this->origType = $info[2]; // constante de php que tiene el tipo de imagen, un entero
// por defecto usaremos las dimensiones de la imagen original
$this->resize($this->origHeight, $this->origHeight); }
{
$this->throwError("$src is not an image file", E_USER_ERROR);
} } else {
$this->throwError("$src is not file valid", E_USER_ERROR);
} } /**
* Asigna los valores a los que se redimensionara la imagen *
* @param int $w ancho * @param int $h alto */
public function resize($w, $h) {
if ($w < 1) $this->throwError("Ancho debe ser mayor que 0", E_USER_NOTICE);
if ($h < 1) $this->throwError("Alto debe ser mayor que 0", E_USER_NOTICE);
$this->setWidth($w); $this->setHeight($h); }
/**
* Redimensiona la imagen con el ancho y alto asignado en resize
* y la guarda en el archivo de nombre $filename *
* @param string $filename nombre del archivo
* @return bool TRUE en caso de exito, FALSE si algo salio mal
*/
public function save($filename) {
$success= false;
$orig = $this->gdFromFile($this->src, $this->origType); if ($gd !== FALSE) // si lo obtuvimos
{
// creamos una imagen vacia con ancho y alto, servira de contenedor
$base = imagecreatetruecolor(>width, $this->height);
// aqui redimensionamos la imagen
// la imagen redimensionada queda en $base, esta funcion retorna TRUE si tuvo exito, FALSE en caso contrario
$resized = imagecopyresampled($base, $orig, 0, 0, 0, 0, >width, >height, >origWidth,
$this->origHeight);
if ($resized) // pudimos redimensionar {
// guardamos gd en el archivo $filename
if (!>gdToFile($base, $filename, $this->origType))
{
$this->throwError("Archivo no generado", E_USER_WARNING);
} else {
// todo salio bien $success = true;
// liberamos los recursos gd imagedestroy($base); imagedestroy($orig); } } } else {
$this->throwError("Gd no fue generado.", E_USER_WARNING);
}
return $success; }
private function throwError($msg, $level) {
trigger_error($msg, $level); } } ?> Uso de ImageResize Código : <?php $src = "archivo.jpg"; $dest = "archivo150x150.jpg"; $resize = new ImageResize($src); $resize->resize(150,150);
if (!@$resize->save($dest)) {
echo "Archivo no fue generado. Error: " . error_get_last(); }
else {
echo "Archivo $dest generado."; }
¿Qué otra clase pudiera heredar ImageBase?
¿Que tantas clases puede crear con la libreria gd de php? Captcha: una clase que genere captcha.Gráficos: una clase que genere gráficos.Thumbs: si no te gusta ImageResize, mejorala o crea tu propia clase. ¿Se te ocurre una otra? Comenta aquí.
Nota: la implementación de ambas clases se pueden mejorar. La única intención de estas implementaciones es mostrar un ejemplo real de como se deben usar y lo útil que son las clases abstractas.
1.3 - Porqué elegir Laravel en vez de
Codeigniter
Empezar a programar con PHP nunca ha sido sencillo. El sitio oficial tiene una documentación muy completa de todas las funcionalidades del lenguaje, sin embargo, no es un buen punto de partida para aprender a hacer algo
funcional, por ejemplo un módulo con PHP.
Empezando mi carrera autodidacta para ser desarrollador web, recuerdo que imprimí TODA la documentación de PHP y la leí completa durante unas vacaciones.
Hice lo mismo con la documentación de MySQL. Al final no sabía hacer
Sí me sirvió de referencia aprender qué hacían las funciones del lenguaje, aunque hoy en día sigo consultando el sitio a menudo.
Entonces comencé a buscar tutoriales más prácticos de PHP. Por ejemplo las memorias de un aprendiz. ¿Alguien lo recuerda?
Pero hoy en día si quieres trabajar con PHP además tienes que: Elegir el Framework adecuado
Esto quiere decir que tenga:
Un desarrollo activo: te garantiza corrección de problemas de seguridad, mejoras, etc.
Una comunidad activa: la vas a necesitar cuando no sepas cómo hacer algo.
Buena documentación: puede ser el mejor framework del mundo pero si
nadie sabe cómo usarlo no sirve de nada.
Pero la mayoría de los frameworks ya tienen
eso: Symfony, Codeigniter, Laravel, entre otros, entonces: ¿Cuál framework elegir?
Hace unos años atrás era una respuesta difícil, mi decisión estaba entre Symfony y Codeigniter, a mí me gustaba más Symfony pero mi equipo de trabajo prefería el segundo.
Symfony era y sigue siendo complejo, muy difícil de aprender, por otro lado, CodeIgniter muy fácil de aprender porque es muy simple, carece de muchas utilidades necesarias en un verdadero framework.
En Symfony 1.4 gastaba el 80% del tiempo investigando cómo hacer algo y corrigiendo bugs y el 20% ejecutando, mientras que en CodeIgniter solo 20% investigando pero 80% ejecutando.
De vuelta al 2013
Hoy en día Symfony 2 es el framework para PHP más robusto que
existe, Fabien Potencier, su creador, es una máquina escribiendo código. Es increíble tener en PHP componentes como el DOM crawler (disponible también en Laravel) que te permite recorrer y revisar desde PHP el código HTML como lo harías conFirebug y eso se lo debemos a Fabien.
Sin embargo, Symfony parece no estar escrito para seres humanos.
Sólo algunos pocos privilegiados son capaces de aprovechar todo su potencial.
Lo que hace que muchos se hayan ido a CodeIginter, pero… Porqué elegir Laravel en vez CodeIgniter
CodeIgniter no ofrece nada más allá de sencillez, después de leerte su documentación en un día y tener que enfrentarte a las necesidades de un proyecto real quedas en frente de una carpeta de modelos vacía preguntándote ¿Y ahora qué? Es allí donde:
Si eres experto, instalas plugins o construyes un sub-framework encima de CodeIgniter para suplir sus carencias.
Si eres principiante empiezas a lanzar un montón de líneas de código en un controlador.
Codeigniter miente y no tiene ORM propio
Sólo tiene un constructor de queries que ellos dicen que es una versión “modificada” del patrón de diseño Active Record pero eso es falso.
El patrón Active Record permite trabajar tus tablas como si fueran clases y tus filas como objetos, con Laravel puedes (así como con Ruby on Rails):
Código :
$user = new User;
$user->name = „Duilio‟;
$user->save(); // This is awesome
En Codeigniter sería esto:
Código :
$this->db->insert(„users‟, array(„name‟ => „Duilio‟); // No active record at all
PHP 5 en adelante está orientado a poner a disposición de sus
programadores el potencial de la programación orientada a objetos. Si bien el enfoque de la base de datos de Codeigniter fue funcional en un tiempo, ya quedó en el pasado.
Laravel en constraste tiene un ORM llamado Eloquent y además tiene un constructor de queries llamado Fluent, ambos superan al “Active record” del otro framework.
No incentiva al uso de plantillas en las vistas En Codeiginiter:
Código :
<ul>
<?php foreach ($addressbook as $name):?>
<li><?=$name?></li>
<?php endforeach; ?>
</ul>
Contrastado con Laravel:
<ul>
@foreach ($addressbook as $name)
<li>{{ $name }}</li>
@endforeach
</ul>
La documentación de CodeIgniter miente de nuevo al decir que los pseudo-lenguajes de plantillas, como el sistema de plantillas Blade de Laravel, son más lentos en ejecutarse. Esto no es cierto porque todos al final se compilan a código PHP, y lo que se leerá una y otra vez será PHP y no
pseudo-lenguaje.
CodeIgniter ofrece un parser de plantillas muy simple, pero éste pierde el
concepto de un VERDADERO lenguaje de plantillas: convertir etiquetas de <?=name?> a {{ name }} es sólo la punta del iceberg.
Un verdadero lenguaje de plantillas debe tener herencia de plantillas (layouts) y muchas otras características que Smarty, Twig poseen,
Super Controlador al rescate...
Como Codeigniter es tan básico, muchos programadores terminan
escribiendo la mayor parte de la lógica de sus aplicaciones en un solo lugar: el controlador.
Por ejemplo la clase de rutas es tan simple, que se queda corta en los proyectos de la vida real y no queda más que lidiar con los segmentos de las URL desde el controlador, donde ya tu aplicación debería saber qué hacer.
Incluso en el mismo núcleo de Codeigniter, el controlador es una especie de super clase que está a cargo de casi todo, como lo demuestra esta imagen:
Al tratar de solucionar todos los problemas en una sola capa estarás
escribiendo un código difícil de leer y mantener y no estarás aprovechando las funcionalidades que un framework en el año 2013 debe tener para ti.
controladores puedan verse así:
Código :
public function edit($user) {
return View::make('admin.users.form')->with('form', $form); }
Puedes configurar una URL users/{id} para que Laravel consulte la BD por ti, te traiga el usuario correspondiente a la ID o lance un 404 si no es encontrado, todo eso antes de llegar al controlador.
En contraste con lo que sería Codeigniter:
Código :
public function edit($id) {
$user = $this->db->select('users', array('id' => $id));
if (is_null ($user)) $this->error404();
//etc...
Revisen la documentación de Codeigniter vs la de Laravel en el tema de rutas y comparen la diferencia.
Laravel es FÁCIL
Hace años justificaba que la gente trabajara con Codeigniter, Symfony es muy complejo y otras alternativas como CakePHP son inciertas. Hoy en día en el mundo de PHP tenemos un framework que está bien hecho, combina las mejores prácticas de desarrollo y hace que nosotros, programadores de PHP podamos escribir un código del cual sentirnos orgullosos.
En tu primer proyecto con Laravel usarás el 40% del tiempo para documentarte, otro 40% para desarrollarlo y un 20% para contemplar
cuán genial quedó tu código.
2 - Introducción a Laravel
Laravel es uno de los frameworks más fáciles de aprender para PHP, yo diría que tan fácil como Codeigniter. Sin embargo en Laravel, fácil no quiere decir simple. Este potente framework combina los features más modernos de PHP para brindarnos una interfaz elegante y hasta divertida de usar:
¿Quieren una ruta?
Código :
// En app/routes.php:
Route::get(„welcome‟, function() {
return “Bienvenidos a Laravel”;
});
¿Ahora quieren usar vistas con HTML?
Código :
<!-- En app/views/welcome.blade.php: -->
<h1>Bienvenidos a Laravel</h1>
¿Quieren que la vista tenga un header y un footer? Laravel usa un concepto más potente llamado Layout. Cambiamos nuestra plantilla welcome.blade.php a:
@extends(„layout‟)
@section(„content‟)
<h1>Bienvenidos a Laravel</h1> @stop
Y ahora creamos nuestro Layout
Código :
<!-- En app/views/layout.blade.php -->
<!doctype html>
<html> <head>
<title>Hacer vistas en Laravel es muy sencillo</title>
</head>
<body>
@yield(„content‟)
</body>
</html>
Cuando usemos nuestra vista "welcome", Laravel cargará
plantilla layout la línea @yield('content') por todo el HTML que hayamos escrito en la plantilla welcome entre @section('content') y stop, quedando el resultado así:
Código :
<!doctype html>
<html> <head>
<title>Hacer vistas en Laravel es muy sencillo</title>
</head>
<body>
<h1>Bienvenidos a Laravel</h1>
</body>
</html>
De esta forma tendremos 1 solo layout que usaremos en todas nuestras vistas, evitando repetir el código.
Ahora usar nuestras vistas es tan fácil como esto:
Código :
Route::get(„welcome‟, function() {
return View::make(„welcome‟);
});
Y así en adelante ¿Quieren hacer una redirección?
return Redirect::to(„goodbye‟)
¿Generar una URL?
Código :
URL::to(„welcome‟)
¿Que tal si quisiéramos pasar parámetros dinámicos a nuestra
vista? Tan fácil como esto: Código :
View::make(„welcome‟)->with(„name‟, „Duilio‟);
Nuestra vista welcome.blade.php quedaría de la siguiente manera:
Código :
<h1>Bienvenido, {{ name }}</h1>
O así (si prefieren usar PHP directamente):
Código :
Características de la versión 4 de Laravel
Lo más interesante de la versión 4 de Laravel es que detrás de toda esta interfaz tan fácil de usar se esconde una arquitectura bastante
sólida (SOLID).
Por ejemplo, los métodos estáticos que vimos hace poco no son más que una fachada (Facade). Por debajo se hace el llamado al contenedor de Laravel, el cual maneja todas las dependencias entre las clases del framework y de nuestra aplicación. Tanto si entendiste o no el último párrafo, tanto si eres un entusiasta que busca hacer sitios web de forma rápida y simple, o eres un experto que busca crear una robusta aplicación, fácil de mantener y probar: Laravel es el framework para ti.
La idea de este set de tutoriales es enseñarlos a usar Laravel desde lo más básico (rutas, vistas, formularios, bases de datos) hasta lo más avanzado (inyección de dependencias, pruebas unitarias).
2.1 - Cómo instalar Laravel y
Composer
En el capítulo anterior de Introducción a Laravel les mostré un poco sobre la fácil sintáxis de Laravel. También les mencioné brevemente que detrás de esta interfaz que nos permite casi hablarle al
framework: “redireccioname a”, “haz una vista… con este
parámetro/valor”, debajo de todo eso se esconde una
arquitectura SÓLIDA de desarrollo, haciendo a Laravel un framework de PHP ideal tanto para principiantes como para expertos.
Mi intención era despertar la curiosidad en la herramienta, si estás acá, quizás tuve éxito. Ahora es momento de ver cómo instalar Laravel y Composer.
Requisitos para Instalar Laravel
Laravel es un framework para PHP, obviamente tiene como
requisito tener instalado... PHP, en este caso, la versión de PHP 5.3.2. Además necesitaremos laextensión MCrypt de PHP.
También necesitan un servidor web como Apache y una base de
datos como MySQL. Hay cientos de artículos sobre cómo
conseguir todo esto, también hay herramientas como XAMPP que instalan todo esto por tí.
Más adelante necesitarán el módulo Rewrite (mod_rewrite) de
Apache. Si han trabajado antes con otros frameworks sabrán de
qué les hablo, sino, por ahora les comento que es un módulo que hace posible URLs amigables como las de Cristalab:
Código :
cristalab.com/tutoriales/introduccion-a-laravel-c111339l/
En vez de:Código :
cristalab.com/tutoriales.php?id=c111339I.
Estas son útiles para los motores de búsqueda y también para los usuarios. En otro tutorial hablaremos de esto.
“plus” si saben de programación orientada a objetos o si ya han usado otros frameworks. Igual trataré de explicar todo
detalladamente y además tenemos la sección de comentarios donde pueden hacer preguntas, con suerte además de mí, otros usuarios también quieran ayudar a aclarar dudas.
Cómo instalar Laravel y Composer
Si tienen experiencia con PHP sabrán que éste es un lenguaje interpretado, básicamente una library para PHP (un framework por ej.) no es más que una serie de archivos .php dentro de carpetas dentro de sub-carpetas, y para instalarlo por lo general no hace falta más que descargar archivos de un repositorio GIT o de una página, descomprimirlos en algún lado y listo.
Para instalar Laravel 4, hace falta un paso extra. Pero no nos
preocupemos, en realidad es una ventaja que nos pondrá no sólo a Laravel sino a miles de paquetes a nuestra disposición, me refiero a Composer.
Composer
Composer es un excelente manejador de paquetes y
¿Qué son dependencias y paquetes?
Imagina que tienes un pequeño proyecto como ir de viaje de una ciudad a otra y para hacerlo necesitas un medio de transporte, en este caso, digamos, un automóvil.
Si fueras un programa de software el automóvil sería un paquete, y tu viaje sería la aplicación que "depende" de él.
Entonces, en este caso, Composer viene siendo como el personaje Tank de la película Matrix, tú le dices “Composer, necesito un auto para mi viaje” y Composer se encarga de buscar el paquete auto e instalarlo para ti. Luego “auto” le dirá a Composer que necesita también un paquete motor, otro paquete sistema de frenos, y así sucesivamente. Composer irá buscando e instalando cada
paquete y las dependencias de cada subpaquete,
recursivamente, hasta armar el auto, todo lo cual será transparente
Cómo instalar Composer
Aquí tienen las instrucciones de la página oficial, básicamente hay dos formas:
Instalar Composer en Linux:
Ejecuten desde su consola el siguiente comando:
Código :
curl -sS https://getcomposer.org/installer | php
O si no tienen CURL instalado:
Código :
php -r
"eval('?>'.file_get_contents('https://getcomposer.org/installer' ));"
Si todo sale bien ya podrán usar Composer con el siguiente comando:
Código :
Instalar Composer globalmente.
Es mejor instalar y tener disponible Composer en todo todo el sistema, para ello hay que renombrar el archivo a “composer” (sin extensión) y moverlo a /usr/local/bin.
Si no tienes el directorio /usr/local/bin puedes ejecutar echo $PATH en la consola para obtener las carpetas adecuadas.
Instalar Composer en Windows:
Descarga el instalador desde aquí o desde la página oficial (para desconfiados), ejecútalo y presiona: siguiente, siguiente, finalizar.
También les hará falta una consola de GIT, yo uso ésta. Mismo proceso: descarguen, ejecuten, siguiente, siguiente, finalizar.
Instalar Laravel
Una vez instalado composer, usando la consola/terminal (si estamos en Windows usaremos la consola de GIT que recien instalamos), vamos a nuestra carpeta de proyectos, por ejemplo: cd /var/www o /home/usuario/proyectos_web/ o /c/xampp/httpdocs/ y allí tipeamos:
Código :
Para usuarios de Linux que no instalaron Composer globalmente:
(El comando sería php composer.phar y necesitarían obviamente tener el archivo composer.phar en la misma carpeta desde donde ejecutan el comando)
Tiempo de ir por un café.
Mientras nos tomamos un descanso, Composer se encargará de descargar el proyecto base de Laravel, el framework y todas sus dependencias.
Si son curiosos verán cómo la consola va descargando decenas de paquetes que serán usados por Laravel más adelante.
Algunos de estos paquetes pertenecen al framework Symfony.
¿Symfony?
Sí, antes cuando elegíamos un framework como Codeigniter,
Symfony o Cake, elegíamos una herramienta y descartábamos las otras. Si nos gustaba lo fácil que era Codeigniter pero también nos gustaba el ORM de symfony 1.4 teníamos que decidirnos por uno o por otro, o elegir Codeigniter y buscar en foro tras foro cómo integrar el ORM usado por symfony nativamente (Doctrine 1.2 en este caso) en Codeigniter, cruzar los dedos y esperar que todo saliera bien. O supongamos que queríamos crear un nuevo CMS para PHP, pero
aún así estábamos totalmente satisfechos con la forma en cómo symfony maneja las rutas. No había forma fácil de usar sólo las rutas de symfony, porque era un framework "acoplado" y teníamos que elegir usar todo o nada.
Con la salida de proyectos como Symfony 2 y Composer, esto cambió radicalmente. De hecho la versión Symfony 2 fue
liberada como un conjunto de componentes que pueden ser usados por separado, de manera que proyectos como Drupal 8 integran ciertos componentes de Symfony, y así lo hace Laravel.
Todo lo cual lleva el desarrollo de PHP a otro nivel, donde
nosotros, los programadores podemos aprovechar el trabajo de otros y fácilmente poner parte de nuestro trabajo al alcance de otros, en vez de seguir reinventando la rueda una y otra vez.
Pero volviendo a la instalación de Laravel...
Una vez que se complete la descarga de los paquetes, verificamos nuestro directorio, el cual debe lucir similar a éste:
..con todas las carpetas instaladas por Composer.
Y, como personas impacientes que somos, también iremos corriendo al navegador, y tipearemos, en mi caso:
Código :
Directorio público:
(Es importante acceder a la carpeta /public que es la puerta de nuestro proyecto para la web, más adelante veremos esto en detalle)
Y si todo ha salido bien:
Si leíste “you have arrived” en tu navegador, estás listo para la tercera parte, sino tienes varios días, los comentarios de abajo y Google para investigar qué salió mal y prepararte para la siguiente entrega, donde explicaré lo que contienen las carpetas y archivos instalados por Composer, entre otros temas. Stay tuned
2.2 - Configurar Base de Datos y
crear tablas con Laravel
En los tutoriales anteriores, vimos una introdución al framework
Laravel y aprendimos cómo instalar Laravel y Composer. De
ahora en adelante comenzaremos un tutorial teórico - práctico de
Laravel.
Crear un módulo de Usuarios con Laravel
Si bien no es el módulo más emocionante del mundo, lo considero práctico dado que hace falta en la mayoría de las aplicaciones. Para comenzar, necesitamos configurar nuestra base de datos y crear la tabla de usuarios.
Cómo configurar la base de datos en Laravel
Lo haremos en cuatro sencillos pasos:
1 - Abrimos el archivo database.php localizado en:
Código :
app/config/database.php
2 - En la línea 29, encontraremos lo siguiente:
'default' => 'mysql'
Si estamos trabajando con MySQL, como es mi caso, dejaremos la línea intacta, sino editaremos el valor entre comillas a sqlite, pgsql, etc. según sea el caso.
Entre las bases de datos soportadas por defecto en Laravel encontramos: MySQL, SQL Lite, PostgreSQL y SQL Server.
3 - Usamos PHPMyAdmin o cualquier otra herramienta de nuestra preferencia para crear la base de datos, en mi caso,
con PHPMyAdmin y MySQL crearé una DB llamada
“pruebalaravel”: Código :
CREATE DATABASE `pruebalaravel` ;
4 - Una vez creada la DB debemos indicarle a Laravel el nombre de nuestra base de datos y un usuario con acceso a ella, para MySQL tenemos en el mismo archivo database.php lo siguiente (línea 55):
Código : 'mysql' => array( 'driver' => 'mysql', 'host' => 'localhost', 'database' => 'pruebalaravel', 'username' => 'root', 'password' => 'CLAVE_ULTRA_SECRETA',
'charset' => 'utf8', 'collation' => 'utf8_unicode_ci', 'prefix' => '', ),
Allí cambiamos „database‟ por el nombre de nuestra base de datos:
Código :
'database' => 'pruebalaravel',
Y más abajo el usuario que hayan configurado cuando instalaron MySQL, comúnmente „root‟, luego, en la línea siguiente, el password que dependiendo de su instalación pudiese estar en blanco o ser una clave ultra secreta.
Una vez configurada la DB, veamos:
Cómo crear las tablas en la base de datos con Laravel
Para ello usaremos migraciones.
Las migraciones permiten configurar y modificar la estructura de una base de datos. Creando una especie de “control de
versiones” de base de datos que puede ser usada por una o más
personas dentro del equipo de desarrollo. Por ejemplo:
Inicialmente crearemos una tabla llamada “users”.
En unas semanas necesitaremos otra tabla llamada “tasks”. Luego agregaremos un campo adicional llamado “role” en la tabla “users” para dividir los administradores de los usuarios normales. Cada uno de estos pasos implicará crear una migración diferente con la que el framework sabrá cómo modificar la base de datos, tanto hacia el nuevo esquema (del paso 1 al paso 2) como al esquema anterior (por ejemplo: de vuelta al paso 2 desde el paso 3).
Ahora veamos:
Cómo instalar el sistema de migraciones en Laravel
Abrimos nuestra consola o terminal (recuerden usar la consola instalada por GIT si usan Windows) y tipeamos lo siguiente:
Código :
php artisan migrate:install
Artisan es la interface de comandos de consola que trae Laravel Si configuramos bien la base de datos deberíamos recibir el siguiente mensaje:
Código :
(Sino recibes este mensaje, vuelve al punto anterior sobre configurar la base de datos y revisa que todo esté bien)
¿Tabla de migración creada con éxito?
Sí, si vuelves a tu herramienta de base de datos (ej. PHPMyAdmin) verás la siguiente tabla:
Esta es una sencilla tabla que usa Laravel para conocer el estado de la migración en tu servidor, por ahora está vacía.
Siguiente paso:
Crear nuestra primera migración con Artisan y Laravel
Para ello ejecutamos el siguiente comando:
Código :
Si todo salió bien, recibiremos un mensaje similar a éste:
Código :
Created Migration: 2013_09_03_211545_create_user_table
Generating optimized class loader
El primer mensaje (migración creada…) nos indica que fue creado el archivo donde vamos a:
Crear el esquema de nuestra tabla usando el Schema Builder
Abrimos el archivo localizado en:
Código :
app/database/migrations/2013_09_03_211545_create_user_table.php
El nombre del archivo además de lo especificado por nosotros
(create_user_table) contiene una fecha/hora que permite indicarle al framework el orden en que fueron creadas las migraciones, en mi caso 2013_09_03_21...
Ok, abrimos el archivo, tenemos la siguiente estructura:
Código :
use Illuminate\Database\Migrations\Migration;
class CreateUserTable extends Migration {
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
//
}
/**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
//
}
Básicamente tenemos una clase llamada CreateUserTable y dentro tiene dos métodos up and down.
El método up servirá, en este caso, para definir nuestra tabla,
reemplacemos el método vacío por lo siguiente:
Código :
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
Schema::create('users', function($table)
{
$table->increments('id');
$table->string('email'); $table->string('password'); $table->string('full_name');
$table->timestamps();
});
}
Dentro tenemos un llamado al
[url=http://es.wikipedia.org/wiki/Facade_(patr%C3%B3n_de_dise%C 3%B1o)]facade[/url] Schema::create que nos permite crear el
esquema de una tabla usando una interfaz de PHP orientada a objetos, es decir, como si nuestra tabla fuera un objeto.
Schema::create acepta como primer parámetro el nombre de
nuestra tabla, en este caso: “users”
El segundo parámetro es una closure o función anónima al cual se le inyecta el objeto $table, dicho objeto nos permitirá definir los campos de nuestra tabla, por ejemplo:
Código :
$table->increments('id');
Le dice a Laravel que nuestra tabla tendrá un campo de tipo auto incremento llamado id, el cual es muy común en MySQL.
Luego le decimos a Laravel que necesitamos un campo string llamado email:
Código :
Pero en MySQL no existe el campo de tipo “string”...
Laravel se encarga de ello convirtiendo al tipo adecuado de acuerdo a la base de datos que hayamos configurado al principio, en el caso de MySQL nuestro campo resultante será de tipo VARCHAR.
Lo mismo para password y full_name, al final tenemos lo siguiente:
Código :
$table->timestamps();
¿?
Básicamente este método le dice a Laravel que queremos crear 2 campos, uno llamado “created_at” y otro “updated_at” ambos de tipo TIMESTAMP que servirán para saber cuando fue creado o
modificado cada uno de los registros de nuestra tabla.
Ok, ¿Están listos? Vamos a ejecutar la migración: vamos de nuevo a la consola y escribimos lo siguiente:
Código :
php artisan migrate
Si todo salió bien recibiremos un mensaje así:
Código :
Voilà!
Sé que están emocionados con nuestra nueva tabla, pero -aunque suene doloroso- tendremos que deshacernos de ella, no se
preocupen, crearemos una nueva más tarde y nadie notará la diferencia:
Reemplacemos el método down por lo siguiente:
Código :
/**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
Schema::drop('users');
}
Sí:
Código :
Schema::drop('users');
users, ahora tomen valor y escriban en la consola:
Código :
php artisan migrate:rollback
Recibiremos el siguiente mensaje:
Código :
Rolled back: 2013...create_user_table
Indicándonos que migración se ha descartado. Corremos a
PHPMyAdmin pero nuestra tabla users… no está, it’s gone… Se ha ido.
¡No puede ser!
Rápidamente regresamos a la consola y tipeamos de nuevo:
Código :
php artisan migrate
Volvemos a PHPMyAdmin y ¡Nuestra tabla users está de nuevo con nosotros! Déjenla allí por ahora, la necesitaremos en un próximo tutorial.
Además de agregar drama a nuestra vida, el rolled back sirve tanto si cometimos un error definiendo una tabla, como si queremos regresar nuestra base de datos a un estado anterior. Más adelante aprenderemos un poco más sobre las migraciones en Laravel.
Es todo por ahora ¿Qué les pareció el tutorial? Cuéntanos en los comentarios. Además me gustaría saber si quieren que les explique un poco más sobre programación orientada a objetos en PHP 5.3, por ejemplo: ¿Qué es un namespace? En un próximo tutorial.
Usa los enlaces claves dentro del mismo tutorial para descubrir artículos interesantes relacionados con el tema.
2.3 - Primeros pasos con Laravel
¿Ya sabes qué es Laravel, ya lo instalaste y configuraste la base de datos? Muy bien, porque pronto comenzaremos a
programar nuestro módulo! Pero antes, en esta cuarta entrega, hablaremos un poco sobre cómo funciona la web:
Los sitios web funcionan con un protocolo llamado HTTP que permite que un cliente se comunique con un servidor y viceversa. Veamos un par de gráficos sencillos sobre esto:
Veamos, esta es una sencilla petición (request) donde tu navegador (Firefox) solicita obtener (GET) la información de la página
cristalab.com/tags/laravel. Una vez que leas el tutorial querrás
dejar un comentario, para ello llenarás el formulario al final del post
y apretarás el botón enviar comentario, en ese momento se producirá otra solicitud:
Ahora Firefox le dice al servidor de cristalab.com que quiere publicar (POST) un comentario, y obviamente le envía la información
correspondiente (tu email, tu comentario) y Cristalab devolverá un código 200 (todo bien, la página fue encontrada, el servidor funciona bien), sin embargo el HTML contendrá un mensaje de éxito o un mensaje de error.
En resumen cada petición (Request) tiene un verbo (GET, POST son los más comunes) y una dirección (cristalab.com/tags,
laravel.com/docs, etc.). Una respuesta (Response), por otro lado, se constituye de un código (200 si todo está bien, 404 si no fue
encontrada la página, 500 error de server, etc.) y el cuerpo de la respuesta, que es por lo general HTML.
Los programadores expertos dirán: ¿Y que hay de los HEADERS?
¿Y las variables de sesión? ¡No te olvides de las cookies!
Lo sé, pero quería mantener esto sencillo; veamos, además de lo que ya les expliqué cada petición y respuesta transporta otros datos como headers, variables de sesión y cookies.
Por ejemplo, un header en una petición puede tener la información de la IP del usuario, en PHP prueben
imprimiendo $_SERVER['REMOTE_ADDR'] o de donde proviene el usuario $_SERVER['HTTP_REFERER'] o el navegador que usa $_SERVER['HTTP_USER_AGENT']
Ok pero esta información no es segura…
Dicen los expertos y sí, tienen razón, pero mantengámoslo simple por ahora.
Las variables de sesión (Session) almacenan tu información
cuando, por ejemplo, haces login en una página y se borran cuando haces logout. Si le dices a un sitio web que recuerde tu usuario por dos semanas, probablemente eso vaya a una Cookie, que es un pequeño archivo que se almacena en tu computador. Más adelante veremos todo esto en detalle.
Por ahora recuerden Solicitud = Verbo + Dirección. Respuesta = Código + Texto.
Ok, comencemos a programar con Laravel…
¡Está bien! Tranquilos. Vamos a comenzar abriendo el archivo app/routes.php
¿Listos?. En este archivo se manejan las rutas de Laravel. Es, digamos, la primera capa de nuestra aplicación.
¿Y qué es lo que hace una ruta?
Verán, una ruta recibe una petición (Request) del usuario y luego de un determinado proceso debe devolver una respuesta (Response): Entonces esto:
Código :
Route::get('/', function()
{
return View::make('hello');
});
Significa que cuando el usuario solicite (GET) la página de inicio ( / ) va a recibir respuesta código 200: todo bien y el HTML de la vista hello (views/hello.php).
Como ven Laravel nos brinda una interfaz elegante y sencilla para poder manejar las solicitudes y devolver las respuestas adecuadas. Por debajo, Laravel se apoya en el excelente componente HTTP Foundation de Symfony2 que encapsula, mejora y normaliza todas las funcionalidades que ya trae el lenguaje PHP para manejar requests y responses.
Obviamente nuestra aplicación necesitará mucho más que una página para funcionar, veamos cómo hacer una segunda página: Guiándonos por la ruta inicial vamos a escribir otra debajo de esa, así:
Route::get('cristalab', function() {
return View::make('cristalab');
});
Ahora copien y peguen el archivo app/views/hello.php dentro de la misma carpeta, cambien el nombre a cristalab.php, y cambien el contenido de app/views/cristalab.php que hay dentro del <body> </body> por este HTML:
Código :
<div class="welcome"> <a href="http://cristalab.com" title="Cristalab"><img src="http://www.cristalab.com/images/header/logo.png"></a> <h1>Hello Cristalab!</h1> </div> Ahora escriban en el navegador http://localhost/pruebalaravel/public/cristalab Excelente, ¿no?
Sí, pero parece muy simple…
Está bien, compliquemos un poco las cosas. Nuestras rutas pueden tener “parámetros” que nos permitirán tener rutas dinámicas, y más
complejas, por ejemplo:
Código :
Route::get('hello/{usuario}', function($usuario) {
return "Hello $usuario";
});
Si el resultado de una ruta es una cadena de texto (string), Laravel devolverá una respuesta de tipo 200 (todo bien) y el cuerpo será dicho texto.
Ahora en su navegador tipeen: hello/tu-nombre
¡Exacto! Así pueden tener una URL dinámica que responda a cualquier nombre. Lo mismo nos serviría para tags, tutoriales, etc. Otro ejemplo:
Código :
Route::get('tags/{tag}', function($tag) {
return "You are browsing $tag tag"; });
¿Quieren limitar un parámetro a que sólo sea números, por ejemplo? Sencillo: