Mostrando entradas con la etiqueta php. Mostrar todas las entradas
Mostrando entradas con la etiqueta php. Mostrar todas las entradas

viernes, 11 de diciembre de 2015

PHP 7.0.0 liberado

Acaba de hacerse oficial el lanzamiento de PHP 7.0.0. La nueva versión del lenguaje incluye numerosas mejoras y sobre todo un aumento de rendimiento considerable. Algunas de las nuevas características de PHP 7 son:

  • Tipo de retorno en las funciones: Por fin se podrá declarar que devuelve una función o método. Esta es una característica que siempre he echado en falta en PHP. Sobre todo cuando se diseñan interfaces o clases abstractas, poder indicar que debe devolver un método es algo muy útil. Ejemplos.
  • Declaración de tipos escalares: Se trata de poder definit el tipo de una variable para int, float, string y bool. Esto es útil por ejemplo para definir los parámetros de una función o método. También se definen dos niveles de exigencia: normal y estricto. El segundo se controla mediante la directiva declare(strict_types=1); (en la primera línea del script) e implica un control estricto de los tipos escalares provocando errores de tipo E_RECOVERABLE_ERROR en caso de incumplimiento. Ejemplos.
  • Nuevo operador ?? (coalesce): El operador de doble interrogación ?? permite devolver un valor específico si una variable no está definida. Por ejemplo $username = $_GET('username') ?? null; sería equivalente a $username = isset($_GET('username')) ? $_GET('username') : null;. Ejemplos.
  • Nuevo operador de comparación <=> (spaceship): La operación $a <=> $b devuelve 0 si $a y $b son iguales; devuelve -1 si $a es menor que $b; y devuelve 1 si $a es mayor que $b. Es decir lo mismo que strcmp() pero no limitado a strings. Funciona con variables de tipo int, float, string, array e incluso object. Ejemplos.
  • Sintaxis uniforme de variables: Se ha añadido soporte completo a construcciones de variables complejas, pero con consistencia. Por ejemplo [$obj1, $obj2][0]->prop, $foo->bar()(), (function() { ... })(), "string"->toLower(), etc. Ejemplos.
  • Solución de errores históricos.

Enlaces

miércoles, 2 de diciembre de 2015

Ya está aquí Symfony 3

SensioLabs ha anunciado esta semana la liberación de dos nuevas versiones del popular framework Symfony: La 2.8, que es la última versión de Symfony 2 y cuenta con soporte extendido; y la esperada versión 3.0 que inaugura la tercera iteración del framework PHP.

La versión 2.8 cuenta con retrocompatibilidad con las anteriores versiones de Symfon 2, mientras que la versión 3.0 elimina todas las funciones obsoletas (deprecated) que se han ido sustituyendo en las sucesivas versiones de Symfony 2. Es decir en esencia las versiones 2.8 y 3.0 de Symfony son idénticas excepto que la versión 2.8 mantiene la retrocompatibilidad con las versiones anteriores mientras que la 3.0 no lo hace.

La liberación de las nuevas versión hace que actualmente haya cinco versiones de Symfony con soporte:

Versión LTS Liberación Soporte bugs Soporte seguridad
2.3 x MAY-2013 MAY-2016 MAY-2017
2.6 NOV-2014 JUL-2015 ENE-2016
2.7 x MAY-2015 MAY-2018 MAY-2019
2.8 x NOV-2015 NOV-2018 NOV-2019
3.0 NOV-2015 JUL-2016 ENE-2017

La siguiente versión LTS (Long Time Suport) de Symfony está previsto que sea la 3.3 y la fecha prevista para su liberación es Mayo de 2017. Por ello si hay que empezar un proyecto nuevo con Symfony lo recomendable por ahora es usar la versión 2.8 que tiene 5 años de soporte, teniendo cuidado de no usar funciones obsoletas de Symfony 2 de forma que en el futuro sea factible realizar la migración a Symfony 3.

Enlaces

jueves, 19 de noviembre de 2015

¿Como evitar bloqueos de sesión en PHP?

PHP

Por defecto PHP escribe los datos de la sesión en un fichero en disco. La función session_start() bloquea el fichero de la sesión de forma que nadie más puede leerlo. Ese bloqueo durará hasta que se acaba la ejecución del script o hasta que se libere manualmente usando alguna de las siguientes funciones: session_abort(), session_commit(), session_destroy() o session_write_close().

El problema

La mayoría de los programadores inician la sesión al principio del script, pero la dejan abierta hasta el final. Eso en entornos con múltiples peticiones sobre la misma sesión (por ejemplo con mucho AJAX) es posible que acabe causando un cuello de botella en momentos putuales. En el momento que una petición tarde demasiado en responder (debido por ejemplo a una query complicada) las demás peticiones no podrán acceder al fichero de sesión que estará bloqueado con el resultado de un tiempo de respuesta significativamente elevado. Pero sólo en momentos puntuales.

La solución

Lo más fácil es liberar el fichero de sesión justo después del session_start(). Los datos de sesión seguirán disponibles para lectura a través de la variable superglobal $_SESSION, pero no se podrá encribir nada en la sesión.

<?php
// Start the session
session_start();

// Session is open to read/write ops
$_SESSION['latestRequestTime'] = time();

// Close the session
session_write_close();

// Now session is read-only
$user = $_SESSION['userNAme'];

Alternativas

Si no es posible cerrar la sesión justo después de abrirla (por ejemplo porque haya que escribir datos después de obtenerlos y/o procesarlos) hay algunas alternativas que pueden utilizarse: Guardar la sesión en una base de datos MySQL, ya que el motor de base de datos no bloquea la sesión, o bien guardar la sesión en algún sistema de caché como Redis, Memcache, etc.

Enlaces

jueves, 22 de octubre de 2015

Evitando el consumo excesivo de memoria con Doctrine y Symfony2

Doctrine es el ORM que utiliza el framework Symfony2. Es un producto muy completo, con muchas opciones, pero tiene un pequeño problema cuando se manejan grandes cantidades de información.


El problema

He tenido un problema con un script que mantiene sincronizadas dos bases de datos (una MySQL y otra PostgreSQL, en servidores remotos, aunque no venga al caso). Se trata de un comando de consola de Symfony2 que se ejecuta periódicamente a través de un cron. Llevaba meses funcionando bien hasta que de repente:

Fatal error: Allowed memory size of 134217728 bytes exhausted (tried to allocate 1454 bytes).

Vi el problema enseguida: La cantidad de datos a sincronizar ha crecido últimamente; Así que rediseñé el algoritmo para que funcionase con bloques de 500 registros en lugar de tratar de golpe todos los registros.

Pero eso no solucionó el problema.


La solución

Podría haber puesto el sufrido ini_set("memory_limit", -1) pero eso sólo haría que el proceso gastase más y más memoria del sistema. El recolector de basura de PHP no libera los objetos mientras haya referencias apuntando a los mismos y Doctrine internamente mantiene esas referencias a no ser que se liberen manualmente.

Para ello el EntityManager de Doctrine en Symfony2 cuenta con un par de funciones: detach y clear. Veamos un ejemplo:

$em = $this->getDoctrine()->getManager();
$entities = $em->getRepository('...')->findBy(array('...'));
foreach ($entities as $entity) {
    $entity->doSomething();
    // (....)
    $em->detach($entity);
    unset($entity);
}
$em->clear();

La instrucción detach desvincula una entidad del EntityManager; es decir elimina cualquier referencia a la entidad. Los cambios realizados en la entidad, incluyendo su borrado, no se sincronizarán con la base de datos posteriormente a la desvinculación. Por su parte clear desvincula de golpe todas las entidades cargadas en el EntityManager.


Referencias

miércoles, 8 de abril de 2015

¿Como poner en producción un proyecto Symfony 2?

Symfony 2 es uno de los frameworks MVC basados en lenguaje PHP que más de moda están en los últimos tiempos. La documentación oficial de Symfony 2 es muy extensa, pero se hecha en falta una sección dedicada sobre como poner en producción un proyecto ya terminado (o una beta) en un servidor real. Lo que llamamos desplegar el proyecto (del inglés deploy).

Los requisitos de Symfony 2 no son demasiado elevados: Basta un servidor web como Apache o Nginx y PHP 5.3.3 o superior (aunque se recomienda PHP superior a 5.3.16). Siempre es recomendable aunque no obligatorio que sea un servidor dedicado sobre el que tengamos acceso root. Es perfectamente posible desplegar un proyecto Symfony 2 en un servidor compartido aunque eso sí: es necesario tener acceso al shell del servidor (vía SSH típicamente). Symfony 2 no puede desplegarse simplemente subiendo los archivos por FTP.


Conceptos previos

Cualquier proyecto Symfony 2 está compuesto por una carpeta de código fuente del proyecto (src), una carpeta de librerías externas entre las que se incluye el propio framework (vendors), una carpeta de configuración y recursos globales (app) y una carpeta frontal (web). Todas ellas son necesarias, pero no todas tienen la misma importancia.

Carpetas de un proyecto Symfony

  • app: Esta carpeta contiene la configuración del proyecto (subcarpeta app/config), pero también los recursos comunes (subcarpeta app/Resources), los logs (subcarpeta app/logs) y también la cache (subcarpeta app/cache), que es donde se crean una serie de clases autogeneradas que aceleran la ejecución del proyecto (es algo similar a tener código compilado sólo que sigue siendo PHP). En la carpeta app también está la consola que es un componente necesario para instalar el proyecto.
  • src: Esta carpeta contiene el código fuente del proyecto. Internamente el código se divide en bundles y cada bundle puede tener controladores, entidades, vistas, recursos, etc.
  • vendor: Esta carpeta contiene el código fuente de las librerías externas y bundles que usa el proyecto. Se trata de código es open-source que sus creadores ponen a disposición de los programadores para desarrollar sus propios proyectos.
  • web: Esta carpeta contiene el controlador frontal de Symfony 2 (programa app.php). Un proyecto Symfony 2 puede tener más de un controlador frontal, según los distintos entornos de ejecución que se definan: app_dev.php, app_test.php, etc. A la hora de ponerlo en explotación bastaría con el controlador frontal del entorno de producción producción. En la carpeta web también se copian automáticamente los assets del proyecto (imágenes, CSS, JS, etc.)

Entornos de un proyecto Symfony

Dentro de un único proyecto Symfony 2 se pueden definir diversos entornos; típicamente son tres, aunque pueden ser más: desarrollo (dev), pruebas (test) y producción (prod). El primero se usa para desarrollar en proyecto, el segundo es para pasar los test unitarios y funcionales y el tercero es para probar el proyecto tal y como debe funcionar en explotación.

Ojo: Nunca han que confundir los entornos de Symfony (dev, test, prod) con los entornos de una organización. Son cosas distintos. A la hora de poner en producción un proyecto Symfony 2 en un servidor real sólo tendremos en cuenta el entorno de producción. Los demás deben descartarse.

Cada entorno Symfony 2 tiene archivos de configuración diferentes en la carpeta app/config:

  • config.yml: Archivo de configuración común para todos los entornos.
  • config_dev.yml: Archivo de configuración del entorno de desarrollo de Symfony 2. Modifica la configuración de config.yml para el entorno dev. Permite por ejemplo evitar que se envíen mails al ejecutar los test.
  • config_test.yml: Archivo de configuración del entorno Symfony 2 de pruebas unitarias.
  • config_prod.yml: Archivo de configuración específico del entorno de producción.

Además del archivo de configuración puede haber otros archivos con configuración adicional:

  • security.yml: Configuración de la seguridad del proyecto Symfony 2.
  • routing.yml: Configuración de las rutas del proyecto Symfony 2.
  • routing_dev.yml, routing_test.yml, … rutas adicionales por entornos.

Por último existen dos archivos de configuración adicionales:

  • parameters.yml: Este archivo contiene la configuración dependiente de la instalación y es el único archivo que debería variar de un servidor a otro. Sirve por ejemplo para indicar la base de datos a usar, el servidor del API, el servidor de correo, etc. NUNCA debería distribuirse este archivo en una puesta en explotación.
  • parameters.yml.dist: Indica los valores por defecto del archivo “parameters.yml” y es usado por “composer.phar” para crear este último.

Por cada entorno Symfony 2 también habrá un controlador frontal en la carpeta web. Es decir que además del controlador app.php podremos tener app_dev.php y app_test.php. Si por ejemplo creamos un archivo config_beta.yml automáticamente se creará un controlador app_beta.php.

Herramientas

  • composer.phar: Herramienta para resolver dependencias en un proyecto PHP. Usado por Symfony 2 para instalar los vendor y para preparar los entornos.
  • app/console.php: Herramienta interna de Symfony 2 que permite limpiar la cache, instalar los assets y muchas más cosas.

Punto de partida

Para poner en producción un proyecto Symfony 2 hay dos puntos de partida:

  1. Partir de un repositorio (GIT, SVN, etc.)
  2. Partir de código fuente con los vendor.

Permisos

Debido a que es necesario que las carpetas app/cache y app/logs tengan permiso de escritura se recomienda que el usuario Linux que realice la instalación sea el mismo del servidor web (apache, nginx, etc). Si esto no fuera posible debería modificarse el propietario de todos los archivos de esas carpetas como paso final de la instalación o bien dar permisos de escritura sobre esas carpetas. Si esto no se hace no funcionará el proyecto.


Partiendo de un repositorio (GIT, SVN, etc.)

Pasos a seguir

  1. Copiar el proyecto desde el repositorio.
  2. Instalar los vendor.
    php composer.phar install
  3. Borrar controladores frontales y archivos de configuración sobrantes.
    rm -f app/config/*_dev.yml
    rm -f app/config/*_test.yml
    rm -f web/app_dev.yml
    rm -f web/app_test.yml
    (...)
  4. Copiar el archivo app/config/parameters.yml específico de esta instalación.
  5. Limpiar e inicializar la cache de Symfony 2.
    php app/console -e=prod cache:clear
  6. Instalar los assets del entorno de producción.
    php app/console assets:install web --symlink
    php app/console -e=prod assetic:dump
  7. Opcionalmente cambiar el propietario de las carpetas cache y logs.
    chown -R nginx:nginx app/cache
    chown -R nginx:nginx app/logs
  8. Opcionalmente dar permisos de escritura a las carpetas cache y logs.
    chmod -R a+w app/cache
    chmod -R a+w app/logs

Partiendo del código fuente completo (incluido vendor).

Lo normal es que un proyecto Symfony 2 se despliegue desde un repositorio de fuentes (GIT, SVN, etc), pero en ocasiones esto no es posible. En ese caso habrá que subir manualmente el código fuente al servidor, incluyendo la carpeta vendor.

Pasos a seguir

  1. Copiar todo el proyecto Symfony 2 a la carpeta de destino.
  2. Borrar las carpetas de “cache” y “logs”.
    rm -rf app/cache/*
    rm -rf app/logs/*
  3. Borrar controladores frontales y archivos de configuración sobrantes.
    rm -f app/config/*_dev.yml
    rm -f app/config/*_test.yml
    rm -f web/app_dev.yml
    rm -f web/app_test.yml
    (...)
  4. Copiar el archivo app/config/parameters.yml específico de esta instalación.
  5. Limpiar e inicializar la cache de Symfony 2.
    php app/console -e=prod cache:clear
  6. Instalar los assets del entorno de producción.
    php app/console assets:install web --symlink
    php app/console -e=prod assetic:dump
  7. Opcionalmente cambiar el propietario de las carpetas cache y logs.
    chown -R nginx:nginx app/cache
    chown -R nginx:nginx app/logs
  8. Opcionalmente dar permisos de escritura a las carpetas cache y logs.
    chmod -R a+w app/cache
    chmod -R a+w app/logs

miércoles, 3 de diciembre de 2014

Se ha publicado Symfony 2.6

El pasado 29 de noviembre se publicó la nueva versión 2.6 del popular framework PHP Symfony [EN]. Dicha versión incluye multitud de novedades como por ejemplo la inclusión de las llamadas AJAX en la barra de depuración [EN], el nuevo tema para formularios basado en Bootstrap 3 [EN], el nuevo instalador de Symfony [EN] y así hasta 100 cambios, mejoras y correcciones. Puedes consultar la lista completa de cambios de Symfony 2.6 [EN] y las actualizaciones necesarias para pasar de Symfony 2.5 a 2.6 [EN]. Symfony 2.6 se actualizará hasta julio de 2015 y tendrá soporte hasta enero de 2016.

Siguiendo con Symfony recientemente se ha dado a conocer la hoja de ruta para los próximos Symfony 2.7 [EN], con fecha de lanzamiento prevista en mayo de 2015, que será LTS con soporte hasta mayo de 2019 y la última versión de Symfony 2; y el futuro Symfony 3 [EN] que romperá la compatibilidad con las versiones anteriores pero que no supondrá un cambio trágico como lo fue el paso de Symfony 1 a Symfony 2. Las principales novedades que se conocen de Symfony 3 son que se aumentará el requisito de versión de PHP mínimo a PHP 5.5 o PHP 5.6 y que se eliminará código obsoleto, rompiendo compatibilidad con las versiones anteriores.

Referencias

domingo, 2 de noviembre de 2014

Symfony 2 avanzado: Cómo pasar el 'locale' a un servicio

Muchas aplicaciones Symfony 2 son multiidioma gracias a la capacidad del popular framework para manejar las traducciones. En este contexto la variable locale contendrá el identificador del idioma. Desde el controlador es muy sencillo obtener el locale a partir del request; basta pedirlo: $this->get('request')->getLocale(). En cambio no es tan sencillo inyectar el locale en el constructor de un servicio debido a los diferentes ámbitos (scopes) que pueden tener los servicios.

Sin embargo hay un truco para hacerlo:

<service
    id="mylocale"
    class="Symfony\Component\HttpFoundation\Request"
    factory-service="request"
    factory-method="getLocale">
</service>

<service
   id="myservice"
   class="%myservice.class%">
   <argument type="service" id="mylocale" on-invalid="null" />
</service>

Es decir, primero creamos un service factory que acceda al Request para obtener el locale y luego inyectamos el service factory en nuestro servicio. el parámetro on-invalid="null" es muy importante para solucionar aquellos casos en que el Request no existe; como por ejemplo los comandos de consola. Al implementar la clase hay que tener en cuenta que es posible que recibamos null en lugar del locale.

class MyService
{
    /**
     * @var string
     */
    private $locale;

    /**
     * @param string $locale
     */
    public function __construct($locale = null)
    {
        $this->locale = $locale;
    }

    // (...)
}

miércoles, 22 de octubre de 2014

Más sobre Composer

El otro día os hablaba de Composer el gestor de dependencias para proyectos en PHP que permite incorporar a nuestros proyecto en PHP multitud de librerías, gestionando sus dependencias de forma magistral. Pues hoy he encontrado el artículo Composer, gestor de dependencias para PHP que amplía la información que yo mismo puse aquí. Os recomiendo su lectura.

Actualización (23/10/2014): Los chicos de desarrolloweb.com han publicado hoy una segunda parte del artículo de Composer llamada Cómo Instalar Composer, donde se detallan las distintas formas de instalar Composer en los más populares sitemas poerativos: Windows, Linux, Max OSX, ...

lunes, 13 de octubre de 2014

Manual de buenas prácticas en Symfony2

Me acabo de enterar a través del fabuloso blog Symfony.es de Javier Eguiluz de la presentación del manual oficial de buenas prácticas para desarrollar aplicaciones en Symfony2. Si estás interesado puedes descargarlo en formato PDF en inglés o en español, aunque el propio Javier advierte que el contenido cambiará en los próximos días pues por ahora sólo se ha publicado una versión preliminar. También puedes consultar on-line el manual en Español.

Se trata de una serie de reglas que configuran un conjunto de buenas prácticas que recomiendan desde SensioLabs y que han sido aprobadas por el propio Fabien Potencier. Puedes estar de acuerdo o no con esta guía por lo que si eres desarrollador experto no es necesario que las sigas. Tampoco es obligatorio modificar un proyecto existente para seguirlas. Sin embargo me parece una gran ayuda especialmente para principiantes y para proyectos nuevos. Personalmente no estoy totalmente de acuerdo con todas pero me parece muy interesante especialmente las recomendaciones sobre como crear el bundle de aplicación, y donde poner los recursos como las vistas o las traducciones.

jueves, 28 de agosto de 2014

Herramientas para desarrollo web: Composer

Composer es una de las herramientas fundamentales para desarrollar aplicaciones y páginas web en lenguaje PHP, ya que permite administrar las dependencias de nuestro proyecto con las distintas librerías externas que necesitemos usar. Composer instala las librerías que el proyecto necesita en una carpeta del propio proyecto. Vamos a ver como funciona con un ejemplo:

Supongamos que nuestro proyecto PHP necesita generar archivos Excel. En lugar de crear todo el código necesario desde cero, miramos en Packagist si alguien ha creado una herramienta open-source que haga lo que necesitamos y vemos que existe una librería llamada PHPExcel. Esa librería a su vez necesitará otras, probáblemente. En lugar de descargar el código fuente de la librería y buscar las dependencias dejamos que sea Composer el que resuelva el problema.

Para ello lo primero será tener instalado Composer en el PC, ya sea de forma global o en el directorio raíz del proyecto. Composer es un programa escrito en php que descargaremos y ejecutaremos.

$ curl -sS https://getcomposer.org/installer | php

Obtendremos un archivo llamado composer.phar que luego para instalarlo globalmente podemos moverlo a un directorio del path como /usr/bin o /usr/local/bin, dándole permisos de ejecución.

$ mv composer.phar /usr/local/bin/composer
$ chmod a+x /usr/local/bin/composer

Una vez tenemos Composer instalado de forma global, creamos el archivo composer.json en la raíz de nuestro proyecto:

{
    "require": {
        "phpoffice/phpexcel": "dev-master"
    }
}

Y entonces usamos composer para que resuelva las dependencias:

$ composer install

La ejecución de composer crea la carpeta vendor y descarga automáticamente la librería phpexcel y las dependencias de ésta si las hay. También crea un archivo llamado autoload.php que será necesario incluir en nuestro proyecto para usar las librerías creadas por composer.

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

Requerimientos:

Al ser un programa escrito en PHP Composer es multiplataforma por lo que funciona tanto en Linux como en OSX y en Windows. Necesita una versión de PHP 5.3.2 o superior y puede requerir modificar alguna configuración en php.ini, pero el propio instalador informa de cualquier incompatibilidad. Además es conveniente tener instalado Git, Svn u otras herramientas para el control de código fuente.


Enlaces:

martes, 29 de julio de 2014

Silex, un micro-framework para PHP basado en Symfony2

Symfony2 es uno de los frameworks para PHP más completos, versátiles y potentes que existen actualmente en el mercado. Pero, ¿Qué ocurre si no necesitamos tanta potencia? ¿Que hacemos si queremos desarrollar una pequeña página corporativa donde la potencia de Symfony2 es más un estorbo que una ayuda? En esos casos en lugar de usar Symfony u otro framework potente como Zend se suele optar por personalizar un Wordpress, un Joomla o cualquier otro CMS. El problema entonces es que perdemos el control del desarrollo en temas como gestión de permisos, teniendo que adaptar nuestros requerimientos a lo que pueda hacer el CMS elegido. Sin embargo existe una tercera vía: El uso de un micro-framework que sin ser tan potente como un Symfony o un Zend nos proporcione la suficiente versatilidad para desarrollar una pequeña página web de forma ágil. Y en este caso la propia SensioLabs y Fabien Potencier, creadores de Symfony, nos dan la solución: Silex.

Silex es un micro-framework para lenguaje PHP basado en componentes de Symfony2. Funciona con PHP 5.3 o superior y tiene licencia MIT (código fuente libre). La gran potencia de Silex es que aprovecha gran parte de los componentes del núcleo de Symfony2, que están sobradamente probados, pero en cambio en mucho más fácil de usar que Symfony2. El paquete básico de Silex permite desarrollar páginas web desde cero, proporcionando un sencillo sistema de definición de rutas propio y poco más. Sin embargo es posible añadir a Silex multitud de componentes externos que también usa Symfony: desde Twig hasta Doctrine, pasando por Swiftmailer y algunos de los componentes más potentes de Symfony como sus formularios, su sistema de validación, su sistema de traducciones, etc.

La documentación de Silex es muy completa, en la línea de los otros productos de SensioLabs.


Ejemplo: Hola mundo en Silex

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

$app = new Silex\Application();

$app->get('/', function() {
    $output = 'Hola mundo.';
    return $output;
});

$app->run();

jueves, 22 de mayo de 2014

PHP avanzado: Llamadas recursivas en funciones anónimas (closures)

PHP

Una closure es una función sin nombre que puede por ejemplo asignarse a una variable o pasarse como parámetro a otra función. PHP soporta closures desde la versión 5.3 con una restricción importante: El ámbito de las variables es totalmente privado. Esto quiere decir que desde dentro de la closure no se puede acceder a variables externas a no ser que sean variables globales y las declares con la palabra clave global. Una excepción a esto son las variables superglobales. Además desde PHP 5.4 se puede acceder a $this si la closure se declara dentro de un método de una clase. Esa restricción no es un problema por si mismo, pero restringe el uso de variables locales cuando declaras la closure dentro de una función o de un método de una clase. Para solucionar eso se usa la palabra clave use. Entonces si queremos hacer una llamada recursiva a la closure tendremos que pasar una referencia a la propia closure a través de la palabra clave use. Por ejemplo (*):

$factorial = function( $n ) use ( &$factorial ) {
    if( $n == 1 ) return 1;
    return $factorial( $n - 1 ) * $n;
};

(*) Ejemplo sacado de Stack Overflow.

martes, 22 de abril de 2014

Cual es el mejor IDE para programar en PHP

Un IDE (Integrated Development Environment) o entorno de desarrollo integrado es la herramienta que los programadores usamos para programar. En realidad los programadores somos gente simple: lo único que de verdad necesitamos para programar es un buen editor de texto. Luego si queremos probar nuestro desarrollo necesitaremos el compilador o intérprete del lenguaje de programación que estemos usando y dependiendo del caso igual algunas herramientas adicionales como un servidor web o la máquina virtual de Java. Pero de entrada lo único imprescindible es un editor de texto.

Como editor de texto nos vale casi cualquier cosa: desde el inútil bloc de notas de Windows hasta el complejo EMACS de GNU, pasando por el Notepad++ o el Ultra Edit en Windows, el gEdit en Ubuntu o el VI o el Nano en cualquier distribución Linux. Los programadores que ya peinamos canas recordamos aun los tiempos en que los IDE no se habían generalizado y la nuestra única herramienta era un editor de textos.

¿Que es un IDE?

Un IDE es un conjunto de herramientas integradas en un único paquete que proporciona a los programadores un marco para el desarrollo de aplicaciones informáticas. Un IDE puede servir para programar en un único lenguaje, en varios lenguajes o ser de propósito general (para cualquier lenguaje, generalmente añadiendo plugins).

Un IDE puede tener algunas de las siguientes herramientas (o todas ellas):

¿Cual es el mejor para programar en PHP?

Y ahora que ya he explicado que es un IDE, ¿Cual es el mejor para programar en PHP? Pues la pregunta es complicada. Cada programador tendrá sus preferencias, pero personalmente después de haber probado varios tanto en Windows como en Linux me quedo con PhpStorm.

PhpStorm es un IDE comercial multiplataforma de JetBrains que incluye editores para PHP, HTML y JavaScript, análisis de código en tiempo real, prevención de errores y mucho más. A mi me gusta sobre todo porque es muy rápido y bastante intuitivo de usar. He probado otros IDE como Eclipse y NetBeans, ambos gratuitos y open source, pero prefiero la rapidez de PhpStorm.

viernes, 28 de marzo de 2014

Symfony2 avanzado: Usando un objeto Query para crear un QueryBuilder

Este caso es un poco difícil de explicar. Vamos a suponer lo siguiente: Tenemos una entidad Factura y un repositorio FacturaRepository que tiene una función findFacturas(). Dicha función recibe un parámetro obligatorio $usuario de clase Usuario y otro opcional $filtros que por defecto es un array vacío. La mencionada función, que está perfectamente testeada y no desea cambiarse, prepara dinámicamente una query DQL teniendo en cuenta los permisos del usuario y un montón de filtros y devuelve un objeto de clase Query que al ejecutarla devuelve la lista de facturas del usuario.

namespace Company\ContabilidadBundle\Entity;

class Factura {
  //...
}

class FacturaRepository {
  public function findFacturas(Usuario $usuario, $filtros = array( )) {
    //...
    return $query;
  }
}

Por otro lado, en otra parte de la aplicación, tenemos un formulario en el que necesitamos poder seleccionar una de las facturas del usuario mediante un cuadro de selección (combobox). Para ello lo más lógico es añadir al formulario un campo de tipo entity. El problema es que que no podemos aprovechar la query que tenemos en nuestro repositorio porque los campos entity se cargan con un QueryBuilder.

Hoy me he encontrado con este mismo problema. Quedaba totalmente descartado Convertir en un QueryBuilder una query DQL de dos palmos y medio de largo, perfectamente testeada, por su complejidad (y porque no me daba la gana), así que me he puesto a investigar si había alguna forma de convertir o cargar un objeto Query en un objeto QueryBuilder. No ha sido fácil pero lo he conseguido...

Este es el resultado:

namespace Company\ContabilidadBundle\Form\Type;

class FormularioFormType extends AbstractType {

  //...

  public function buildForm(FormBuilderInterface $builder, array $options) {

    //...

    $builder->add(
      'factura',
      'entity',
      array(
        'class' => 'CompanyContabilidadBundle:Factura',
        'query_builder' => function(EntityRepository $repository) use($usuario) {

          $query = $repository->findFacturas($usuario);
          $qb = $repository->createQueryBuilder('f');
          $qb->where($qb->expr()->in('f', $query->getDql()));
          $qb->setParameters($query->getParameters());
          return $qb;
        }
    ));
  }
}

Veámoslo paso a paso:

  1. En primer lugar obtenemos el objeto Query del repositorio. Dicho objeto estará listo para ser ejecutado devolviendo el resultado que deseamos.
  2. En segundo lugar extraemos la sentencia DQL y los parámetros del objeto Query con las instrucciones $query->getDql() y $query->getParameters().
  3. En último lugar creamos un nuevo objeto QueryBuilder y simulamos una subquery como esta: SELECT * FROM Facturas f WHERE f IN (...), poniendo la sentencia DQL original en el lugar de los puntos suspensivos.

Es rebuscado pero funciona perfectamente.

sábado, 1 de marzo de 2014

Symfony 2: Añadiendo bundles externos

Esta es la tercera parte del mini-curso de Symfony 2 que empecé hace tiempo. En el último capítulo creamos nuestro primer proyecto Symfony 2. El proyecto recién creado traerá todas las dependencias necesarias para empezar a programar con el framework Symfony. Sin embargo una de las grandes ventajas de Symfony 2 es que es fácilmente ampliable mediante librerías externas programadas por terceros llamadas bundles.

Hay bundles para todos los gustos: unos añaden características nuevas a Symfony 2, otros mejoran su seguridad, otros amplían funcionalidades, etc. La forma de instalar un bundle externo es nuevamente mediante el uso de composer. Para ello hay que añadir las dependencias en el archivo composer.json que encontraremos en la raíz de nuestro proyecto Symfony de la siguiente forma:

{
    "require": {
        "vendor/package": "version",
    }
}

En este caso vendor y package forma el nombre del bundle mientras que version es el número de versión (por ejemplo: 1.2.3 o 1.2.* o >1.2.3 o >1.2.3,<1.3, etc. Para buscar bundles compatibles podemos ir a Packagist, que es el repositorio de paquetes instalables vía Composer.


En ejemplo: añadiendo Bootstrap

Vamos a verlo con un ejemplo. Supongamos que queremos añadir el framework CSS Bootstrap a nuestro proyecto Symfony. Podríamos descargarnos la librería de Bootstrap y añadirla manualmente a nuestro proyecto, pero en Symfony siempre que sea posible preferiremos hacerlo vía bundle externo. Buscando en Packagist encontramos que hay varios bundles que añaden Bootstrap a Symfony. Yo he elegido Mopa Bootstrap porque lo conozco de antes, pero además es uno de los que más descargas y mejor valoración tienen en Packagist. Visitamos la página web oficial del proyecto Mopa Bootstrap en Github y allí la sección de instalación nos indica como añadir el bundle a Symfony 2; hay que añadir el siguiente código en el archivo composer.json:

{
    "require": {
        "mopa/bootstrap-bundle": "v3.0.0-beta3",
        "twbs/bootstrap": "v3.0.0"
    }
}

Una vez hecho esto hay que ejecutar composer update desde el directorio principal del proyecto para que se actualicen las dependencias y se descarguen las librerías.

$ composer update
Loading composer repositories with package information
Updating dependencies (including require-dev)
  - Installing mopa/composer-bridge (v1.3.0)
    Downloading: 100%

  - Installing mopa/bootstrap-bundle (v3.0.0-beta3)
    Downloading: 100%

  - Installing twbs/bootstrap (v3.0.0)
    Downloading: 100%

Como podemos ver además de los dos bundles indicados nos ha instalado un tercero: mopa/composer-bridge (v1.3.0). Esto es porque Composer sabe que es necesario instalarlo o sino mopa/bootstrap-bundle (v3.0.0-beta3) no podrá funcionar. Ahora ya podemos empezar a usar Bootstrap en nuestro proyecto web. Pero, ¿Como se usa mopa/bootstrap en Symfony? Para saber eso hay que leerse la documentación.


Mini-curso de Symfony 2

  • Primeros pasos: Conceptos y definiciones sobre Symfony 2.
  • Primer proyecto: Como empezar un proyecto Symfony 2.
  • Añadiendo bundles externos: Agregar dependencias a composer.json.

jueves, 5 de diciembre de 2013

Symfony 2 avanzado: Ordenando relaciones OneToMany (Doctrine)

En Doctrine, Las relaciones OneToMany son un mecanismo muy potente para acceder a una lista de objetos hijo. El ejemplo más claro de uso de las relaciones OneToMany sería una factura y las líneas de factura o un pedido y el detalle del pedido; y en general cualquier relación maestro-esclavo o padre-hijo en la que la clave foránea se encuentra en la tabla hija.

Así en los proyectos Symfony 2 que usan Doctrine obtener la lista de objetos hijo desde el padre es tan sencillo como acceder a la propiedad del objeto. Internamente Doctrine convierte eso en una query a la base de datos, pero el resultado obtenido por defecto no viene ordenado. Podemos garantizar el orden añadiendo la cláusula OrderBy a la declaración de la propiedad OneToMany, pero esa ordenación es muy limitada. Veamos un ejemplo:

use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity()
 * @ORM\Table(name="facturas")
 */
class Factura
{
  /**
   * @var integer
   * 
   * @ORM\Id
   * @ORM\Column(name="id_factura", type="integer", nullable=false)
   */
  private $id;

  /**
   * @var \DateTime
   *
   * @ORM\Column(name="fac_fecha", type="text", nullable=false)
   */
  private $fecha;

  /**
   *
   * @ORM\OneToMany(targetEntity="Lineas", mappedBy="factura", cascade={"all"})
   * @ORM\OrderBy({"id" = "ASC"})
   */
  private $lineas;

  // ...
}

/**
 * @ORM\Entity()
 * @ORM\Table(name="lineas_factura")
 */
class Lineas
{
  /**
   * @var integer
   * 
   * @ORM\Id
   * @ORM\Column(name="id_linea", type="integer", nullable=false)
   */
  private $id;

  /**
   * @var \DateTime
   *
   * @ORM\Column(name="lin_fecha", type="text", nullable=false)
   */
  private $fecha;

  /**
   * @var integer
   * 
   * @ORM\ManyToOne(targetEntity="Factura", inversedBy="lineas")
   * @ORM\JoinColumn(name="id_factura", referencedColumnName="id_factura")
   */
  private $factura;

  /**
   * @var integer
   *
   * @ORM\OneToOne(targetEntity="Producto", cascade={"all"})
   * @ORM\JoinColumn(name="id_producto", referencedColumnName="id_producto")
   */
  private $producto;

  // ...
}

/**
 * @ORM\Entity()
 * @ORM\Table(name="productos")
 */
class Producto
{
  /**
   * @var integer
   * 
   * @ORM\Id
   * @ORM\Column(name="id_producto", type="integer", nullable=false)
   */
  private $id;

  /**
   * @var string
   *
   * @ORM\Column(name="prod_nombre", type="text", nullable=false)
   */
  private $nombre;

  /**
   * @var float
   *
   * @ORM\Column(name="prod_precio", type="float", nullable=false)
   */
  private $precio;

  // ...
}

En este ejemplo la propiedad lineas de la clase Factura tiene una cláusula OrderBy que hace que la lista resultado se obtenga ordenada por id. ¿Pero que ocurriría si quisiéramos que el resultado viniese ordenado por algún dato del producto asociado como el nombre o el precio? ¿No hay forma de hacerlo con Doctrine?

Pues no, no la hay. Pero algo se puede hacer: podríamos ordenar el resultado después de obtenerlo. Al fin y al cabo se trata de un simple array de objetos. ¿Pero como hacerlo para que esté disponible en toda la aplicación y para cualquier tipo de lista? Sencillo: Con un servicio y más concretamente con una extensión Twig.

class MyExtension extends \Twig_Extension
{
  public function getName()
  {
    return 'MyExtension';
  }

  public function getFilters()
  {
    return array(
      'sortCollection' => new \Twig_Filter_Method($this, 'sortCollection'),
    );
  }

  public function sortCollection($collection, $properties) {

    $objects = $collection->getValues();
    if($properties == null) {
      return $objects;
    }

    if(is_string($properties)) {
      $property = $properties;
      $properties = array( );
      $properties[] = $property;
    }

    if(is_array($properties)) {

      usort($objects, function ($a, $b) use ($properties) {

        foreach($properties as $property) {

          $objA = $a;
          $objB = $b;

          if(is_string($property)) {

            $property = explode('.', $property);
            foreach($property as $method) {

              if($objA == null || $objB == null) {
                break;
              }

              $getter = 'get' . $method;

              if(method_exists($objA, $method)) {
                $objA = $objA->$method();
              }
              elseif(method_exists($objA, $getter)) {
                $objA = $objA->$getter();
              }
              else {
                $objA = null;
              }

              if(method_exists($objB, $method)) {
                $objB = $objB->$method();
              }
              elseif(method_exists($objB, $getter)) {
                $objB = $objB->$getter();
              }
              else {
                $objB = null;
              }
            }
          }

          if($objA != null && $objB == null) {
            return -1;
          }
          elseif($objA == null && $objB != null) {
            return 1;
          }
          elseif($objA < $objB) {
            return -1;
          }
          elseif($objA > $objB) {
            return 1;
          }
        }

        return 0;
      });
    }

    return $objects;
  }
}

¿Pero como lo usamos? Pues básicamente en Twig, para obtener una lita de líneas de factura ordenadas por el nombre del producto, haríamos lo siguiente:

<ul>
{% for linea in factura.lineas | sortCollection([ 'producto.nombre' ]) %}
  <li>
    {{ linea.producto.nombre }}
  </li>
{% endfor %}
</ul>

Una extensión Twig, también puede definirse como servicio y por lo tanto, también podríamos ordenar una colección de objetos Doctrine directamente desde el controlador. Por ejemplo podríamos necesitar una lista de líneas de factura ordenadas primero por precio del producto asociado y segundo por el nombre (para productos del mismo precio). Sería como sigue:

$myExtension = $this->get('twig.extension.MyExtension');
$list = $myExtension->sortCollection($factura->getLineas(), array(
  'producto.precio',
  'producto.nombre'
));

jueves, 10 de octubre de 2013

Symfony 2: Primer proyecto

En este segundo capítulo del mini-curso de Symfony 2 explicaré como crear un proyecto Symfony 2 desde cero para entornos Linux. Por supuesto existe la posibilidad de utilizar Symfony 2 en Windows y en Mac OS X, pero yo voy a centrarme en Linux y concretamente en Ubuntu, que es lo que uso habitualmente. La instalación en Mac OS X probablemente sea similar a la de Linux y para Windows seguro que existen otros manuales.

Lo primero y más importante: Vamos a suponer que el usuario dispone de un PC con sistema operativo Linux y que ha instalado tanto el servidor web Apache como el lenguaje PHP. Symfony 2 requiere al menos la versión 5.3.3 de PHP y algunas extensiones específicas. Aquí puede consultar todos los requerimientos de Symfony 2.


Composer

Empezaremos por el principio: Instalando Composer.

Composer es una herramienta imprescindible para desarrollar aplicaciones y sitios web en Symfony 2. Los proyectos Symfony utilizan diversas librerías externas (llamadas dependencias) que a su vez puede que usen otras librerías y Composer es la herramienta que se encarga de mantener actualizadas esas dependencias. Por ejemplo cuando queremos cambiar la versión usada de una librería o del propio Symfony, Composer se encarga de comprobar la compatibilidad de las otras librerías del proyecto, descargando si es necesario las versiones compatibles o avisando de las posibles incompatibilidades. A la hora de crear un proyecto Symfony 2, Composer comprueba la lista de dependencias del proyecto, decide qué librerías hay que instalar, qué versiones concretas se instalan y el orden correcto de instalación. Es una herramienta muy potente.

Para instalar Composer globalmente hay que seguir los siguientes pasos:

  1. Abre una terminal y escribe:
  2. $ curl -s https://getcomposer.org/installer | php
  3. Aparecerá un nuevo archivo llamado composer.phar. Para comprobar que se ha instalado correctamente, ejecuta el siguiente comando que muestra el menú de opciones de Composer:
  4. $ php composer.phar
  5. Por último mueve el archivo composer.phar a un directorio de ejecutables del sistema:
  6. $ sudo mv composer.phar /usr/local/bin/composer
  7. Comprueba que todo funciona como es debido ejecutando el comando composer sin opciones desde cualquier directorio.

Con esto habremos instalado Composer de forma global en el ordenador. De esta forma para actualizar la versión de Composer de todos los proyectos bastará con ejecutar el siguiente comando desde un terminal:

$ sudo composer self-update

Creando un proyecto base

Una vez hemos instalado Composer, podemos usarlo para crear un proyecto Symfony 2 básico:

$ composer create-project symfony/framework-standard-edition
<carpeta> <version>

En este caso <carpeta> es el directorio raíz del proyecto (por ejemplo "/var/www/vhosts/masquecursos/") y <version> es la versión de Symfony 2 a instalar. En el momento de escribir estas líneas la última versión estable de Symfony es la 2.3.5 y otras versiones disponibles serían la anterior 2.2.8 y la siguiente 2.4.0-BETA1. Más información en la página de instalación de Symfony.

El programa de instalación pedirá algunos datos necesarios para la misma:

  • Driver de base de datos: Generalmente será MySQL (pdo_mysql), pero podría ser SQLite (pdo_sqlite), PostgreSQL (pdo_pgsql), Microsoft SQL Server (pdo_sqlsrv), Oracle-PDO (pdo_oci), Oracle-No PDO (oci8), etc.
  • Host de base de datos: Por defecto 127.0.0.1.
  • Puerto de base de datos: Por defecto null.
  • Nombre de base de datos: Depende del proyecto.
  • Nombre del usuario de base de datos: Depende del proyecto.
  • Clave de acceso del usuario de base de datos: Depende del proyecto.
  • Protocolo de transporte para envío de emails: Por defecto smtp.
  • Host para envío de emails: Por defecto 127.0.0.1.
  • Nombre del usuario para envío de emails: Depende del proyecto.
  • Clave de acceso del usuario para envío de emails: Depende del proyecto.
  • Identificador local (locale): Por defecto en.
  • Clave secreta: Para configurar el sistema de seguridad.

Se pueden dejar los valores por defecto pues más adelante podremos cambiarlos. El programa de instalación creará la estructura básica de directorios de un proyecto Symfony 2 que es la siguiente:

  • proyecto/
    • composer.json
    • composer.lock
    • app/
      • check.php
      • console
      • cache/
      • config/
      • logs/
    • bin/
    • src/
    • vendor/
    • web/
      • app.php
      • app_dev.php
      • config.php

Cada una de las subcarpetas contiene a su vez otros archivos y carpetas, pero los que aparecen aquí son los más importantes. Más adelante hablaremos de lo que hay en cada carpeta y para que sirve cada archivo. Por ahora basta con saber que Composer nos crea todo esta estructura de carpetas y archivos.


Comprobaciones post-instalación

Todo proyecto Symfony 2 viene con un programa que permite comprobar si el ordenador cumple todos los requerimientos necesarios para el correcto funcionamiento del framework. Para ejecutarlo basta con abrir el terminal, entrar en el directorio del proyecto y teclear:

$ php app/check.php

Al ejecutar dicha utilidad, obtendremos una lista de requerimientos indicando en cada caso si tenemos la instalación correcta (OK) o si hay algún error (ERROR) o aviso (WARNING). Los errores (mandatory requirements) es necesario corregirlos antes de nada porque sino probablemente el proyecto no funcionará. Los avisos (optional checks) es conveniente corregirlos, pero no obligatorio.

Una vez comprobado que todos los requisitos están soportados por nuestra instalación se debe ejecutar otra utilidad llamada console.

$ app/console

Si todo es correcto se nos mostrará una lista de opciones de la consola Symfony. Más adelante veremos que esta consola es muy útil y se usa mucho para acciones comunes: limpiar la cache, crear la base de datos, crear entidades Doctrine, crear bundles, etc.


El problema de los permisos

Symfony 2 necesita permisos de escritura sobre dos carpetas del proyecto app/cache/ y app/logs/. Todas las demás carpetas pueden ser de sólo lectura, pero esas dos no. El problema es que el usuario Linux de la consola no es el mismo que el del navegador web (Apache) y ambos necesitan acceso a esos directorios, lo que puede provocar diversos problemas tipo "RuntimeException: Could not create cache directory" y otros similares. Para solucionarlo basta dar permisos de escritura a todos los usuarios para esos dos directorios concretos:

$ sudo chmod -R 777 app/cache/ app/logs/

Siendo puristas habría que dar permisos de escritura sólo al usuario www-data (Apache) o arreglar el tema de permisos vía grupo de trabajo que son las opciones recomendadas para entornos de producción, pero para el entorno de desarrollo sirve el chmod 777. Aquí puedes encontrar más información sobre cómo solucionar el problema de los permisos de Symfony 2.


Configurando el entorno

Para que el entorno de desarrollo sea lo más parecido posible al entorno de producción y aprovechando las características del servidor web Apache, vamos a crear un virtual host para este proyecto. Para ello en Ubuntu crearemos un archivo en la carpeta /etc/apache2/sites-available/ (ojo se necesitan permisos de root) y lo llamaremos como el proyecto (por ejemplo masquecursos). El contenido será el siguiente:

<VirtualHost *:80>
  ServerName masquecursos.me
  ServerAdmin webmaster@masquecursos.me
  DocumentRoot /var/www/vhosts/masquecursos/web
  DirectoryIndex app.php
  <Directory /var/www/vhosts/masquecursos/web>
    AllowOverride All
    Allow from All
  </Directory>
</VirtualHost>

Cada distribución de Linux es distinta y dicho archivo puede ser necesario crearlo en otra carpeta, aunque el contenido será el mismo. En Ubuntu posteriormente a la creación del archivo en /etc/apache2/sites-available/ es necesario crear un enlace simbólico en /etc/apache2/sites-enabled/. También habrá que editar el archivo /etc/hosts y asociar el nombre del virtual host con la IP 127.0.0.1. Posteriormente será necesario reiniciar el servidor Apache. La secuencia completa sería la siguiente:

$ sudo gedit /etc/apache2/sites-available/masquecursos
$ cd /etc/apache2/sites-enabled/
$ ln -s /etc/apache2/sites-available/masquecursos
$ sudo gedit /etc/hosts
$ sudo service apache2 restart

Con esto habremos configurado el entorno de ejecución y podremos acceder a nuestro sitio web desde http://masquecursos.me/, pero no lo pruebes todavía pues aun no funcionará. Por ahora para ver el contenido del proyecto es necesario usar el controlador de desarrollo http://masquecursos.me/app_dev.php. Más adelante veremos que es eso y porque aun no funciona con el controlador frontal app.php.


Configuraciones finales

Si entramos en nuestro navegador preferido y escribimos http://masquecursos.me/config.php veremos una página web con una bienvenida de Symfony. En caso de que la instalación no cumpla los requerimientos técnicos se mostrará una pantalla de error con la misma información que nos daba el archivo app/check.php. A estas alturas esos errores ya deberían estar corregidos. Desde la pantalla de bienvenida podemos acceder a otra de configuración del entorno desde la que se pueden configurar los mismos parámetros que cuando creamos el proyecto con Composer. En cualquier caso esos parámetros de configuración del entorno están en el archivo app/config/parameters.yml por lo que pueden modificarse a mano de forma sencilla.

¡Y ya está! Ya hemos creado un primer proyecto Symfony 2 vacío. En el siguiente capítulo veremos como crear el primer bundle y haremos el típico Hola Mundo con Symfony.


Más información


Mini-curso de Symfony 2

  • Primeros pasos: Conceptos y definiciones sobre Symfony 2.
  • Primer proyecto: Como empezar un proyecto Symfony 2.

sábado, 5 de octubre de 2013

Symfony 2: Primeros pasos

Llevo algún tiempo trabajando con Symfony 2 y, aunque aun no soy un experto, voy a intentar explicar cual es la estructura global de una aplicación Symfony y cuales son los primeros pasos para desarrollar una página web este popular framework PHP. Voy a dar por supuesto que ya sabéis qué es Symfony. Empezaré por algunos conceptos:


Bundles

Toda aplicación Symfony 2 está formada por bundles. Básicamente un bundle es una carpeta que contiene tu código fuente PHP, archivos de configuración y otros recursos como imágenes, hojas de estilos CSS, archivos HTML, javascripts, etc. Todo ello dentro de una estructura predeterminada de subcarpetas jerarquizadas.

Una aplicación Symfony 2 debe contener al menos un bundle, pero no hay límite en el número de bundles que se pueden crear. Algunos programadores ponen todo el código en un único bundle gigantesco mientras que otros prefieren crear un bundle por cada división lógica de la aplicación. Por ejemplo se puede crear un MainBundle para la parte principal de la web y un AdminBundle para la parte de administración.


Entidades (Doctrine)

Symfony es un framework PHP que implementa el patrón MVC (Modelo-Vista-Controlador), en el cual toda aplicación de divide en tres capas: modelo, vista y controlador. La primera capa es el modelo y se encarga del manejo y persistencia de los datos de la aplicación. En Symfony la capa del modelo está controlada por una herramienta llamada Doctrine que se encarga precisamente del acceso a los datos y su persistencia. Doctrine hace que nuestra aplicación sea independiente del motor de bases de datos, de forma que no será necesario escribir ni una sola sentencia SQL sino que tendremos que definir una serie de objetos PHP llamados entidades y Doctrine se encargará de lo demás.

A priori puede parece complicado pero es justo lo contrario. Las entidades se guardan como archivos PHP en una carpeta llamada Entity dentro de cada bundle.


Vistas (Twig)

En el patrón MVC, la capa vista es la que se encarga de la presentación en pantalla y de la interacción con el usuario. En symfony se utiliza un motor de plantillas llamado Twig que simplifica la creación de las vistas. Aquí puedes consultar más información sobre Twig en Español. Las vistas se guardan como archivos Twig en una carpeta llamada Resources/views dentro de cada bundle.


Controladores

En el patrón MVC, la capa controlador se encarga de procesar las peticiones, obtener los datos a través del modelo y lanzar las vistas. En symfony 2 los controladores son clases PHP que se derivan de la clase Controller y que se guardan como archivos PHP en una carpeta llamada Controller dentro de cada bundle.


Enrutamiento

Symfony permite controlar todas las rutas que acepta un sitio web. Cada ruta puede ser estática de tipo /seccion/accion/ o tener parámetros, que se encierran entre corchetes, como /seccion/ver/{param}. Al final cada ruta se corresponde a un método de uno de los controladores y los parámetros serán los argumentos del método. Por ejemplo el sitio MasQueCursos.org podría configurar las siguientes rutas:

  • "/" Página principal.
  • "/cursos" Lista de cursos.
  • "/cursos/buscar" Buscador avanzado de cursos.
  • "/cursos/{nombre}" Detalle de un curso.
  • "/centros" Lista de centros de formación.
  • "/centros/{nombre}" Detalle de un centro de formación.
  • "/temas" Lista de temas disponibles.
  • "/temas/{nombre}" Lista de cursos de un tema.
  • Etc.

Además en Symfony cada ruta debe tener un nombre único que lo identifique y estar asociada a un controlador y a una acción (método de la clase). Por ejemplo:

  • Página principal:
    • Nombre="indice", Ruta="/"
    • Controlador="@MasQueCursosBundle/Controller/DefaultController"
    • Accion="indexAction"
  • Lista de cursos:
    • Nombre="lista_cursos", Ruta="/cursos"
    • Controlador="@MasQueCursosBundle/Controller/CursosController"
    • Accion="listaAction"
  • Buscardor de cursos:
    • Nombre="buscar_cursos", Ruta="/cursos/buscar"
    • Controlador="@MasQueCursosBundle/Controller/CursosController"
    • Accion="buscarAction"
  • Detalle de un curso:
    • Nombre="ver_curso", Ruta="/cursos/{nombre}"
    • Controlador="@MasQueCursosBundle/Controller/CursosController"
    • Accion="verAction"
  • Etc.

Todo el sistema de rutas se puede configurar en Symfony de dos formas: a través de los archivos de configuración o a través de anotaciones, un sistema directamente heredado de Java, que consiste en poner datos de configuración directamente en los comentarios. Por ejemplo la siguiente clase es un controlador con anotaciones: Hay una anotación @Route a nivel del controlador y otra para cada método de la clase.

namespace Ifraktal\MasQuecursosBundle\Controller;

use Sensio\Bundle\FrameworkExtraBundle\Configuration\Method;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Template;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;

/**
 * @Route("/cursos")
 */
class CursosController extends Controller {

    /**
     * @Route("/", name="lista_cursos")
     */
    public function listaAction()
    {
        // ...
    }

    /**
     * @Route("/buscar", name="buscar_cursos")
     */
    public function buscarAction()
    {
        // ...
    }

    /**
     * @Route("/{nombre}", name="ver_curso")
     */
    public function verAction($nombre)
    {
        // ...
    }

    // ...
}

Hasta aquí la primera entrada. En próximas entradas explicaré la estructura de carpetas de un proyecto symfony; cómo crear un proyecto Symfony 2 desde cero; etc.

lunes, 23 de septiembre de 2013

¿Qué es Symfony?

Es difícil explicar qué es Symfony. Sería correcto decir que Symfony es un framework basado en lenguaje PHP, diseñado para optimizar el desarrollo de las aplicaciones web usando en el patrón Modelo Vista Controlador (MVC). Algo así pone en la Wikipedia en su entrada Symfony. Pero eso es quedarse terriblemente corto. Esa misma definición encaja por ejemplo con Codeigniter y en realidad son dos cosas totalmente distintas, aunque persigan el mismo fin.

En la página web oficial de Symfony lo describen como un framework PHP, una filosofía y una comunidad; todos trabajando juntos en armonía. Esa es una definición "de libro", pero tampoco explica bien que es Symfony.

En realidad Symfony es más bien un conjunto de herramientas y servicios heterogéneos que, trabajando juntos, permiten desarrollar páginas y aplicaciones web complejas de forma eficiente, reduciendo el tiempo de desarrollo y automatizando las tareas comunes. Entre las herramientas que proporciona Symfony se encuentra un framework PHP, un gestor de plantillas (Twig) y un gestor ORM (Doctrine) y mucho más. Además es sumamente sencillo incorporar herramientas y aplicaciones de terceros.

La diferencia principal entre Symfony y otros frameworks PHP como Codeigniter es que mientras Codeigniter es un framework PHP puro (y ya está), Symfony es mucho más. Symfony proporciona toda una nueva filosofía de trabajo, incorporando multitud de herramientas que ayudan al desarrollo web y dirigen el proyecto, pero también lo limitan. Una ver has adoptado Symfony no puedes hacer las cosas como quieras: tienes que adaptarte a su filosofía. También es cierto que la la curva de aprendizaje de Symfony es mucho más pronunciada que Codeigniter. Empezar de cero con Symfony no es fácil, por mucha experiencia que tengas en PHP y en otros frameworks.


Un poco de historia

Symfony es un proyecto de software libre creado en 2005 por Fabien Potencier, actual CEO de Sensio Labs. La versión 1.0 fue liberada en 2007 y actualmente va por la versión 2.3, estando en preparación la 2.4. Cada nueva versión de Symfony incorpora mejoras y nuevas herramientas. Por desgracia las nuevas versiones no siempre son retrocompatibles, siendo necesario realizar cambios en el código fuente de los proyectos para adaptarse, aunque el salto más grande se produjo entre la versión 1.4 y la 2.0 (Symfony 2).


Un vistazo rápido

El framework Symfony obliga desarrollar usando el patrón Modelo-Vista-Controlador (MVC). Dicho patrón divide el desarrollo del proyecto en tres partes: el Modelo que gestiona todo lo relacionado con los datos que maneja la aplicación, la Vista que gestiona todas las interacciones con el usuario y el Controlador que gestiona todo lo que ocurre en la aplicación. El controlador procesa las peticiones, recupera los datos usando el modelo y lanza las vistas que interaccionan con el usuario. En Symfony cada una de estas partes está regulada por un componente diferente:

  • Modelo: En Symfony la parte del modelo viene gestionada por Doctrine que es una una biblioteca de clases cuyo objetivo es dotar al proyecto de poderosas herramientas para facilitar la lectura/escritura de información desde/hacia una base de datos. Doctrine es compatible con la mayoría de gestores de bases de datos, como MySQL, PostgreSQL, Oracle, etc.

    Una de las características más importantes es que el código en Doctine es independiente del gestor de base de datos. En teoría se podría cambiar el gestor en cualquier momento sin tener que modificar una línea de código. Para ello en Doctrine las queries se escriben usando DQL (Doctrine Query Language) que es una especie de SQL orientado a objetos.

  • Vistas: La parte de las vistas en symfony se gestiona con el motor de plantillas Twig del que ya hablamos hace tiempo.

    Al igual que otros motores de plantillas, Twig ayuda a separar de forma sencilla la lógica de la aplicación (código PHP) de la presentación (HTML/CSS). Es una herramienta muy potente pero a la vez muy flexible que permite diseñar plantillas de presentación muy complejas sin usar instrucciones PHP, haciendo que el código HTML/CSS final sea mucho más legible. En Twig se pueden usar variables, filtros, funciones, estructuras de control (if, for, ...), macros, expresiones, comentarios y más.

  • Controlador: En el patrón MVC el controlador se encarga de recoger las peticiones HTML, procesarlas, recuperar los datos, generar nuevas peticiones y/o lanzar las vistas correspondientes. En Symfony la parte del controlador está gestionada por clases propias del framework. Se pueden definir múltiples controladores y dentro de cada controlador varias acciones.

  • Arquitectura: Toda aplicación Symfony se divide en paquetes (bundles). Cada bundle puede contener: controladores, entidades (modelo), plantillas (vistas), archivos de configuración y otros recursos (formularios, menús, traducciones, etc.). Todo ello se controla a través de de namespaces, una característica de PHP 5.3.

  • Configuración: Symfony es un producto altamente configurable que soporta además diversos métodos de configuración, de forma que en cada proyecto se puede escoger la que mejor se adapte a las necesidades, pudiendo incluso mezclarse. Symfony puede usar indistintamente configuración a través de archivos YAML, XML o PHP. También soporta Annotations para configurar por ejemplo las rutas de los controladores.

Referencias

lunes, 3 de junio de 2013

Herramientas de programación web: Twig

Hoy voy a hablar un poco de Twig, una herramienta más enfocada al diseño web que a la programación que viene integrada en el framework Symfony2, pero que puede utilizarse también por separado.

Twig es un motor de plantillas para PHP similar a Smarty. Es un proyecto de código abierto (open source) ofrecido bajo licencia BSD y desarrollado por Fabien Potencier, el creador de Symfony. Por ello es lógico que Twig sea el motor de plantillas por defecto de Symfony2.

Al igual que otros motores de plantillas, Twig ayuda a separar de forma sencilla la lógica de la aplicación (código PHP) de la presentación (HTML/CSS). Es una herramienta muy potente pero a la vez muy flexible que permite diseñar plantillas de presentación muy complejas sin usar instrucciones PHP, haciendo que el código HTML/CSS final sea mucho más legible.


Ejemplo

El siguiente es un ejemplo básico de plantilla Twig:

<!DOCTYPE html>
<html>
  <head>
    <title>Client List</title>
  </head>
  <body>
    <h1>Client List</h1>
    <ul>
    {# Recorrido por la lista de clientes #}
    {% for client in clients %}
      <li>
        <a> href="/client/{{ client.id }}">
          {{ client.name }}
        </a>
      </li>
    {% else %}
      No se han encontrado clientes.
    {% endfor %}
    </ul>
  </body>
</html>

Variables, filtros y funciones

Uando Twig podemos acceder al contenido de una variable simplemente poniendo su nombre entre llaves dobles: {{ var }}. Además podemos acceder a las propiedades de un objeto usando la sintaxis {{ obj.attr }}. Este mecanismo es tan potente y flexible en Twig que buscará primero como elemento (obj['attr']); si no existe buscará como atributo (obj.attr); y por último si no existe buscará como método (obj.getAttr()). Otra característica de Twig es que podemos aplicar filtros a las variables para modificar su comportamiento. Por ejemplo para formatear una fecha antes de imprimirla en pantalla: {{ date | date('d/m/Y H:i') }}. Los filtros además pueden encadenarse de forma que se ejecuten uno detras de otro. Así {{ text | striptags | upper }} eliminaría los tags HTML del texto y lo escribiría en mayúsculas.


Estructuras de control

En Twig hay una serie de instrucciones que se escriben entre {% ... %}.

  • {% if cond1 %}...{% elseif cond2 %}...{% else %}...{% endif %}
  • {% for item in array %}...{% else %}...{% endfor %}
  • {% set var = value %}
  • Etc.

Comentarios

Los comentarios se escriben entre {# ... #}:


Referencias