1. No category

Desarrollo fácil con Symfony2
Aprende a desarrollar con Symfony2 y otras herramientas
que te apoyarán y facilitarán en gran medida tu trabajo
como desarrollador web
Jon Torrado
Este libro está a la venta en http://leanpub.com/aprendesymfony2
Esta versión se publicó en 2015-09-09
This is a Leanpub book. Leanpub empowers authors and publishers with the Lean Publishing
process. Lean Publishing is the act of publishing an in-progress ebook using lightweight tools and
many iterations to get reader feedback, pivot until you have the right book and build traction once
you do.
©2014 - 2015 Jon Torrado
¡Twitea sobre el libro!
Por favor ayuda a Jon Torrado hablando sobre el libro en Twitter!
El hashtag sugerido para este libro es #aprendesymfony2.
Descubre lo que otra gente está diciendo sobre el libro haciendo click en este enlace para buscar el
hashtag en Twitter:
https://twitter.com/search?q=#aprendesymfony2
A todos aquellos que han aportado algo de conocimiento en mi vida, a todas esas personas que
cambiaron el rumbo de mi carrera profesional y que han hecho que ahora sea la persona que soy,
tanto en lo personal como en lo profesional. En este libro escribo un cachito de cada uno de vosotros.
Gracias.
Índice general
Introducción . . . . . . . . .
Por qué escribo este libro
Qué vas a aprender . . .
A quién está dirigido . .
Cómo se divide el libro .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
2
2
3
Capítulo 1: instalación y configuración
El instalador de Symfony . . . . . .
Composer . . . . . . . . . . . . . .
Base de datos MySQL . . . . . . . .
Los permisos de escritura . . . . . .
El servidor web . . . . . . . . . . .
Entorno de desarrollo . . . . . . . .
Truco 1 . . . . . . . . . . . . . . . .
Resumen . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4
4
5
6
6
7
7
8
8
Capítulo 2: los bundles de terceros
Buscando nuestro bundle . . . .
Instalando un nuevo bundle . . .
Truco 2 . . . . . . . . . . . . . .
Resumen . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
9
9
9
10
11
Capítulo 3: Admin Bundle . . . .
Instalando el Admin Bundle . .
Creando nuestra Admin Class .
Truco 3 . . . . . . . . . . . . .
Resumen . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
12
12
15
18
19
.
.
.
.
.
.
.
.
.
.
Introducción
Desde que comencé mi carrera profesional, prácticamente todo lo que he hecho ha estado relacionado
con el mundo de la web. Al terminar la universidad, mis conocimientos sobre el desarrollo en este
campo eran muy limitados. Tan solo conocía un puñado de elementos HTML y algo un poco más
sofisticado llamado Struts, un framework MVC en Java. Tuve que aprender en un tiempo récord
para estar a la altura del entorno en el que me estaba introduciendo, y esto fue posible gracias a la
amplia documentación y ayuda que se puede encontrar por Internet.
Comencé utilizando una serie de CMS para diferentes empresas, como Moodle o Drupal, para
posteriormente embarcarme en el desarrollo a medida. ¡Y tan a medida! Tuve que mantener una web
que estaba realizada de 0, sin ayuda de ningún framework ni nada por el estilo. ¡Y menos mal que tuve
que hacerlo! Este fue el proyecto que cambió mi rumbo profesional ya que pude sumergirme en las
entrañas de todo tipo de librerías y códigos espaguetti pertenecientes a gente realmente interesante.
Tras una serie de giros algo inesperados, comencé mi viaje en el mundo de Symfony 2. Gracias a su
excelente documentación, la cual aconsejo leer encarecidamente más de una vez al año, y de bundles
de terceros que mantiene una comunidad realmente activa, pronto estaba desarrollando webs
increíblemente potentes con un esfuerzo ridículo comparado a lo que había estado desarrollando
hasta ese momento.
Tras varios años desarrollando webs bajo Symfony, considero éste un momento oportuno para
escribir el libro que te encuentras leyendo. Aquí voy a recopilar lo que considero más importante para
comenzar a desarrollar un proyecto en Symfony y procuraré que seas capaz de utilizar tecnologías
que facilitarán tu trabajo en una medida que jamás habías imaginado (o por lo menos yo no lo
había hecho). Tampoco te creas que voy a escribir el libro definitivo y que dominará el mundo,
ya que día a día sigo aprendiendo en un sector en el que ocurre de todo a diario y en el que es
completamente imposible seguir el frenético ritmo cambiante en el que se encuentra. Pero… intentaré
estar a la altura, ya que soy de Bilbao¹. Tan solo quiero pedirte una cosa antes de leerte este libro:
lee la documentación de Symfony. La documentación está genial e incluso traducida al castellano,
así que no voy a repetir ninguna parte que ya se encuentra perfectamente explicada en otro sitio.
Tampoco hace falta que seas un profesional de la temática, pero al menos que sepas qué son y como
funcionan las rutas, los controladores y las plantillas, además de saber qué es la consola de Symfony
(en resumen, los 8 primeros capítulos del libro de la documentación). ¿Estás deseando empezar? Yo
también, así que “vamos al lío”.
Por qué escribo este libro
Una de las partes más importantes de mi vida es la que dedico a la enseñanza. Poder expandir tu
conocimiento a otras personas y hacer crecer este sector entre todos es algo que considero vital para
¹http://www.frikipedia.es/friki/Bilbao
Introducción
2
cualquier temática, no solo esta. Creo que en la sociedad actual necesitamos de profesores excelentes
que traten de mejorarse cada día ya que, dando lo mejor de ellos, conseguirán que sus alumnos den
lo mejor de sí mismos.
Esto que te acabo de contar lo conecto con dos conceptos japoneses muy interesantes. El primero
de ellos (aunque es una leyenda urbana, permíteme ser feliz contándotelo) es que, en su cultura, los
profesores son los únicos que no tienen que hacer una reverencia ante el emperador, porque éste
considera que sin ellos no existiría un emperador.
Por otro lado está uno de los conceptos que desde que lo leí han aplicado una mejora sustancial en
mi vida: Kaizen. Este concepto japonés viene a resumirse como el proceso de mejora que debemos
aplicarnos cada uno de nosotros a diario.
Todo lo que voy a escribir en este libro lo he aprendido gratuitamente durante muchas semanas,
incluso años, y decido compartirlo contigo para que no tengas que gastar tanto tiempo en aprenderlo
tú. Además considero que ponerle un precio a algo que he conseguido gratis y que actualmente me
da de comer es bastante absurdo. Es por esto que este libro es completamente gratuito, pero si al
finalizarlo te gusta y quieres agradecerme el trabajo que he realizado, puedes comprarlo por el precio
que consideres sabiendo que estás ayudando a una buena causa, ya que donaré el 50% de lo que
pagues por el libro a la plataforma de crowdfunding watchi² que proporciona todo tipo de ayuda
médica a gente de todo el mundo que lo necesita. Aprendes, disfrutas y ayudas a una buena causa.
Qué vas a aprender
Durante el libro realizaremos una serie de instalaciones y configuraciones de forma práctica para
disponer de un proyecto base que te servirá de cara al futuro para cualquiera de tus proyectos.
Algunas cosas puede que no sean necesarias en algunos de ellos; otras puede que haya añadir y que
tengas que descubrir por tu cuenta. Intentaré cubrir la mayoría de elementos que se utilizan a día de
hoy tanto de Symfony como del desarrollo web en general y que podamos incorporar a este proyecto
base.
No vas a aprender a utilizar Symfony desde 0. Considero que la documentación oficial de Symfony
es estupenda para este cometido. Pero tras leer esta parte básica compuesta por los 8 primeros
capítulos de su documentación, mi objetivo es que sepas utilizar Symfony de una manera más
profesional y orientada al producto final.
¿Hay algo que me he dejado fuera del tintero? No pasa nada, tienes mi Twitter para hacerme llegar
lo que creas conveniente e iré recopilando cada una de las cosas que me digáis. Procuraré mantener
el libro actualizado para que sirva como documentación extra de tus proyectos.
A quién está dirigido
El libro está dirigido a cualquier persona que esté interesada en aprender a desarrollar con Symfony
2, sepa previamente utilizar este framework o no. Incluso a las personas que no han programado en
²https://leanpub.com/causes/watsi
Introducción
3
PHP o ni siquiera han programado. Lógicamente, depende del punto en el que te encuentres, puede
que te cueste más o menos captar algunas de las cuestiones que plantearé durante el libro, pero esto
no significa que estás fuera del target ni mucho menos.
En cuanto al nivel del lector, me arriesgaré a decir que es un libro para principiante - intermedio.
Si ya llevas mucho tiempo con Symfony y en el desarrollo web, es posible que no aprendas nada.
Aún así, también cabe la posibilidad de que alguno de los capítulos dedicados a tecnologías externas
sean del interés de profesionales del sector, pero desde luego no está pensado para ese nivel de
desarrollador.
Ganas y fuerza de voluntad, es lo único que necesitas para adentrarte en este mundo, ¡ánimo!
Cómo se divide el libro
Cada capítulo contendrá una temática concreta explicada de la forma en la que yo trabajo. Además,
en cada uno de ellos, dedicaré una sección para revelarte un truco que o bien te ayudará a ser
más eficiente en el trabajo, o te permitirá hacer las cosas mejor mediante atajos y triquiñuelas que
circulan por la red.
Empezaremos la casa por el tejado y, tras instalar el framework lo llenaremos de un montón de
bundles de terceros antes de tocar ni una sola línea de código. Estos bundles nos permitirán tener
una base prefabricada para nuestros proyectos. Es posible que algunos de ellos no los necesites, pero
aunque éste sea el caso, es muy interesante que dediques algo de tiempo a saber cómo están hechos
por dentro. Ésto es algo que dejo en tus manos, ya que como desarrollador has de ser inquieto y
mirar más allá del “funciona y ya está”.
Es hora de empezar a trabajar. Comenzamos con la instalación y sus buenas prácticas.
Capítulo 1: instalación y
configuración
Sé que esta parte está muy bien cubierta en la documentación oficial³ de Symfony, pero existen
ciertos conceptos que están separados en varios capítulos. Algunos de ellos se pueden incluso realizar
de varias formas distintas. Y la pregunta es, ¿cuál es la mejor? La verdad es que muchas veces durante
este libro te responderé que “no hay una forma mejor o peor, sino que debes escoger la forma con
la que te sientas más cómodo”.
Existen unas buenas prácticas que normalmente los desarrolladores intentamos seguir, y junto a esas
buenas prácticas me gustaría añadir las buenas prácticas de Jon (ya te dije que soy de Bilbao) que
compartiré contigo en este libro. Antes de poner los pasos que normalmente sigo yo, debes saber
que utilizo prácticamente siempre Linux y/o OSX, por lo que si usas Windows tendrás que adaptar
lo que escribo durante los diferentes capítulos para que funcione en tu sistema operativo. Pero no te
asustes, todo lo relacionado con Windows está disponible en la documentación oficial.
El objetivo de este capítulo es aprender a instalar un proyecto Symfony, y a su vez dejar preparado
nuestro sistema operativo para que las futuras instalaciones del framework sean increíblemente más
sencillas. ¡Empecemos!
El instalador de Symfony
Desde hace ya un tiempo, Symfony cuenta con su propio instalador en un archivo .phar⁴. Antes de
disponer de este instalador, tenías que descargarte un archivo comprimido desde la web oficial de
Symfony y descomprimirlo en la carpeta sobre la que ibas a desarrollar; posteriormente añadieron
el proyecto en Packagist⁵ y el gestor de dependencias Composer⁶ hizo de instalador. Actualmente, lo
mejor que puedes hacer es mantener el instalador de Symfony como binario de tu sistema operativo
para que puedas ejecutarlo como cualquier otro comando. Para ello, utiliza los siguientes comandos
o los correspondientes a tu sistema operativo:
1
2
sudo curl -LsS http://symfony.com/installer -o /usr/local/bin/symfony
sudo chmod a+x /usr/local/bin/symfony
Una vez realizado, podrás ejecutar el comando symfony desde la ruta que quieras. Como consejo me
gustaría decirte que procures mantener el instalador de Symfony actualizado ejecutando el siguiente
comando:
³http://symfony.com/doc/current/book/installation.html
⁴http://php.net/manual/es/phar.using.intro.php
⁵https://packagist.org/
⁶https://getcomposer.org/
Capítulo 1: instalación y configuración
1
5
sudo symfony self-update
¡Genial! Ahora que ya dispones del instalador de forma global, ya puedes crear tu primer proyecto
Symfony. Para ello, ejecuta el siguiente comando:
1
symfony new aupa_bilbao
El comando anterior creará la carpeta aupa_bilbao con todo lo necesario para comenzar a trabajar
sin perder un solo minuto, todo ello automágicamente. Si has leído la documentación de Symfony
o has utilizado Composer con anterioridad, deberías saber que la carpeta vendor, situada en la raíz,
contiene todas las dependencias necesarias de tu proyecto. Estas dependencias se definen en el
archivo también situado en la raíz composer.json, archivo que utilizaremos en varias ocasiones
durante todo el libro. Sin embargo, el otro archivo situado a la par cuyo nombre es composer.lock
muestra las versiones bloqueadas, versiones exactas que se descargarán al ejecutar composer
install.
En este punto, ya hemos hablado varias veces sobre Composer, pero, ¿qué es Composer?
Composer
Composer es la herramienta por excelencia para la gestión de dependencias de PHP que nos ayuda a
introducir “paquetes” o librerías de terceros en nuestro proyecto y así poder utilizarlos de una forma
sencilla. Si has utilizado “npm” de Node o “bundler” de Ruby, esto es muy similar; si no es el caso y
nunca los has usado, no te preocupes puesto que en este libro tendrás la oportunidad de hacerlo.
Al igual que el instalador de Symfony, lo mejor es disponer de Composer como comando del sistema
operativo y, de esta forma, poder ejecutarlo desde cualquier ruta. Para esto, ejecuta los siguientes
comandos:
1
2
curl -sS https://getcomposer.org/installer | php
sudo mv composer.phar /usr/local/bin/composer
En cuanto al proyecto Symfony, gracias a su propio instalador, ya tenemos los “paquetes base”
descargados en la carpeta vendor y los archivos composer.json y composer.lock bien definidos.
Pero si el proyecto sobre el que estás trabajando es un proyecto descargado o estás desplegando el
proyecto en un servidor, lo correcto es que ejecutes el comando composer install en la raíz del
mismo. Este comando instalará las versiones concretas especificadas en el archivo composer.lock y
que, a su vez, deberían ser las versiones que están probadas y carecen de fallos o incompatibilidades.
Sin embargo, si lanzas el comando composer update, el proceso ignorará el archivo de bloqueo y
actualizará a la última versión posible que hayas definido en el archivo composer.json, actualizando
el archivo de bloqueo cuando termine el proceso de descarga.
¡Oye! No te olvides de actualizar tus dependencias, cada semana se corrigen bugs de seguridad o se
añaden nuevas funcionalidades que seguro que aportan valor a tu proyecto. Y, por supuesto, mantén
también tu Composer actualizado con el siguiente comando:
Capítulo 1: instalación y configuración
1
6
sudo composer self-update
Base de datos MySQL
Todavía hay días en los que me encuentro proyectos en codificación latin1. Te aconsejo que
evites esta codificación y utilices UTF-8 para cada uno de tus proyectos. En Symfony, la consola
se encargará de crear la base de datos por ti, pero para que automáticamente haga uso de esta
codificación por defecto, deberás modificar el archivo my.cnf en el que se encuentran los parámetros
de configuración de tu base de datos MySQL, añadiendo las dos líneas que te dejo a continuación
en la sección de [mysqld]:
1
2
3
[mysqld]
collation-server = utf8_general_ci
character-set-server = utf8
Hecho esto, solo te queda decirle a Symfony cuáles son tus datos de conexión a la base de datos.
Dirígete al archivo app/config/parameters.yml que automáticamente te ha creado el instalador, y
edita los parámetros que se encuentran en él introduciendo los datos que corresponden a tu máquina.
Una vez modificados, lanza el siguiente comando para crear la base de datos:
1
php app/console doctrine:database:create
¡Buen trabajo! Ya tienes tu base de datos creada para empezar a trabajar. Solo te queda saber una
cosilla más: Symfony hace uso de una serie de directorios a los que hay que darles permiso de
escritura. Dichos directorios los usará tanto tu servidor web como la consola del framework, por lo
que ambos usuarios del sistema operativo deben tener permiso para escribir en ellos.
Los permisos de escritura
Este es un error que me encuentro en muchos despliegues en local, y es que mucha gente se olvida
de darle permiso de escritura a las carpetas de cache y logs. Más adelante veremos que sacaremos
una tercera carpeta muy interesante junto a las dos mencionadas.
Todos estos directorios se encuentran dentro de la carpeta app. En este enlace⁷ puedes ver cómo
debes darle permiso a dichas carpetas, y si usas un sistema Linux basado en Ubuntu, los siguientes
comandos son los que te sirven:
⁷http://symfony.com/doc/current/book/installation.html#book-installation-permissions
Capítulo 1: instalación y configuración
1
2
3
4
7
HTTPDUSER=`ps aux | grep -E '[a]pache|[h]ttpd|[_]www|[w]ww-data|[n]ginx' | grep \
-v root | head -1 | cut -d\ -f1`
sudo setfacl -R -m u:"$HTTPDUSER":rwX -m u:`whoami`:rwX app/cache app/logs
sudo setfacl -dR -m u:"$HTTPDUSER":rwX -m u:`whoami`:rwX app/cache app/logs
La primera línea almacena en HTTPDUSER el usuario que está ejecutando nuestro servidor web, ya
que dependiendo del sistema operativo y del servidor, este usuario varía. Las otras dos líneas se
encargarán de darle a ese usuario y al usuario de la consola (es decir, el usuario con el que ejecutarás
los comandos en la terminal) permisos para escribir en dichas carpetas.
Otorgados los permisos pertinentes, ya estás a punto de terminar con la instalación.
El servidor web
Tienes la posibilidad de trabajar con Apache de forma nativa creando un VirtualHost en tu
ordenador. No entra dentro del alcance de este libro el mostrar cómo se hace ya que existe una
forma mucho más sencilla que, aunque es menos potente, didácticamente nos vale. Si quieres saber
cómo llegar a buen puerto con esta primera opción, visita este enlace⁸.
En este momento, y suponiendo que tienes PHP instalado en tu ordenador, te vale con ejecutar el
siguiente comando en la raíz del proyecto:
1
php app/console server:run
Tal y como te muestra la terminal, ya puedes acceder a tu proyecto Symfony navegando a la URL
http://127.0.0.1:8000/. Lamentablemente, todavía no hay nada que ver, pero lo solucionaremos muy
pronto.
Entorno de desarrollo
Si vas a desarrollar Symfony, te aconsejo que dispongas de un entorno de desarrollo. A día de hoy, el
IDE que mejor trabaja con Symfony es PhpStorm⁹. Existen muchos otros como NetBeans o Aptana,
e incluso editores como Sublime o Brackets que funcionan a la perfección. Pruébalos y escoge el que
mejor se adapte a tu forma de trabajar, aunque personalmente te aconsejo PhpStorm por algún que
otro truco que saldrá en futuros capítulos.
⁸http://symfony.com/doc/current/cookbook/configuration/web_server_configuration.html
⁹https://www.jetbrains.com/phpstorm/
Capítulo 1: instalación y configuración
8
Truco 1
En cada capítulo te daré un consejo que sin duda te ayudará bastante. Depende de ti el utilizar
estos consejos o no (¡úsalos insensat@!). A partir de ahora, utilizaremos muy a menudo la consola
de Symfony. Como has podido ver, para ejecutar los diferentes comandos has de introducir php
app/console cada vez que vayas a ejecutar cualquiera de ellos, y si además quieres que el entorno
de ejecución sea prod en vez de dev, que es el entorno por defecto para los comandos, deberás añadir
--env=prod al final de cada uno de los comandos.
Con el siguiente truco darás un respiro a tu teclado y, por descontado, a tus manos:
1
2
alias dev = php app/console --env=dev
alias prod = php app/console --env=prod
Estos alias no se mantienen tras reiniciar la máquina, por lo que busca en Internet cómo guardar
dichos alias para que permanezcan en el tiempo (no te lo iba a dar todo hecho, ¿no?).
Además del alias, tampoco hace falta introducir el comando completo: con tal de que sea
completamente discriminatorio vale. ¿Qué quiere decir esto? Como “un ejemplo vale más que mil
palabras”, a continuación te aclaro las ideas:
1
dev s:r
El comando anterior ejecutará php app/console --env=dev server:run. ¿Por qué? Porque los
comandos que empiezan por “s” son server y swiftmailer, pero dentro de éstos solo hay uno que
empiece por “r” que es server:run.
¡Enhorabuena! Ya eres más eficiente que muchos de los desarrolladores Symfony, los cuales
desconocen este pequeño truco :)
Resumen
En este capítulo hemos aprendido la forma correcta de desplegar un proyecto Symfony nuevo para
comenzar a trabajar con él. Gracias a la instalación global de su instalador y el gestor de dependencias
Composer, las posteriores nuevas instalaciones se harán en cuestión de minutos, ¡incluso segundos!
Capítulo 2: los bundles de terceros
Una de las grandes maravillas que tiene Symfony y que comparte con otras muchas aplicaciones
de código abierto es que la comunidad aporta elementos que enriquecen el framework. En Symfony
existen varias formas de colaborar, pero la creación y mantenimiento de bundles que dotan de
funcionalidades extra a las que ya trae por defecto es sin duda una de las piezas clave para que
su utilización esté tan extendida. Durante este capítulo, aprenderemos las bases para instalar
bundles de terceros, aunque luego cada uno suele disponer de algunas secciones de configuración
que difieren entre ellos. ¡Empecemos!
Buscando nuestro bundle
Antes de comenzar a desarrollar una nueva funcionalidad en tu proyecto, debes conocer este
concepto: DRY. Estas siglas significan Don’t Repeat Yourself, es decir, no te repitas o, como
decimos, “no reinventes la rueda”. Muchos de los desarrollos que vas a codificar para tu nueva
web seguramente ya están realizados por otras personas: gestión de usuarios, manejo de imágenes,
conexión y uso de bases de datos NoSQL… ¿por qué rehacer lo que otros ya han hecho y mantienen
por ti?
Es por esta razón que, si sabes que lo que deseas incorporar en tu código es lo suficientemente
genérico para que otros lo hayan hecho antes, te recomiendo que visites knpbundles.com¹⁰ y busques
en este sitio web lo que necesitas. Por supuesto que puedes buscar en Google o en Packagist “lo-quenecesito symfony bundle”, pero aquí podrás navegar entre los diferentes bundles que utilizan el resto
de personas, filtrarlos según varios criterios y, gracias a esto, quizás puedas nutrirte de algo que no
tenías previsto pero que es realmente interesante y te encaja perfectamente, ¿no crees?
Parece que ya te voy convenciendo y me voy ganando un pequeño pedazo de tu corazón de
desarrollador, así que vamos a ver cómo tienes que hacer para instalar cualquier bundle en tu
proyecto.
Instalando un nuevo bundle
Ya has encontrado lo que necesitas y es hora de empezar a usarlo en tu proyecto. Durante este libro,
instalaremos varios bundles de terceros para terminar con un proyecto base sólido y potente, pero
antes de instalar nada creo conveniente escribir sobre estos pasos genéricos para que los tengas en
cuenta a la hora de introducir cualquier bundle que consideres oportuno y de utilidad.
¹⁰http://knpbundles.com/
Capítulo 2: los bundles de terceros
10
Lo primero que debes hacer es actualizar el archivo de descripción de dependencias composer.json
para que al lanzar comando de actualización sea capaz de descargar las nuevas dependencias en la
carpeta vendor. Bien en la documentación del bundle o en Packagist encontrarás todo lo que tienes
que introducir en este archivo. Ten cuidado con las versiones tanto de las dependencias como del
propio Symfony, ya que no todos los bundles soportan todas las versiones de Symfony y viceversa.
Es posible que alguna vez te toque indagar un poco en la documentación para seleccionar la versión
correcta del bundle según tus necesidades.
Actualizado el archivo, debes lanzar el comando de actualización de Composer para que instale las
nuevas dependencias:
1
composer update
El siguiente paso es configurar el bundle. Al igual que con la versión de Composer, la mayoría
de los bundles disponen una configuración específica que deberás añadir en el archivo app/config/config.yml. La configuración concreta debe proporcionártela el creador del bundle y te
permitirá parametrizar tu nueva dependencia para que se adapte a tu proyecto y funcione como tú
quieres que lo haga. Cuidado: también hay bundles que requieren que modifiques otros archivos de
configuración del framework como el sistema de rutas, los servicios o la configuración relativa a la
seguridad. Al final, todos son archivos de configuración en los que deberás pegar una serie de líneas
que previamente habrás copiado de un archivo README o de documentación.
Hecho esto, el último paso es activar el bundle. Parece una chorrada pero cuando trabajas a diario
con esto, es una acción tan repetitiva que en algunas ocasiones te olvidas de realizarlo. Para activar las
nuevas dependencias, debes editar el archivo app/AppKernel.php y añadir las líneas de instanciación
necesarias que también se te habrán proporcionado en la documentación correspondiente. Si por
alguna razón no las encuentras en la documentación, puedes dirigirte a la carpeta vendor y buscar
el archivo principal del bundle para encontrar el nombre específico de la clase a instanciar.
¡Todo listo! “Tatúate” estos pasos en el código fuente de tu cerebro, aunque de momento puedes echar
de vez en cuando una ojeada a este capítulo. Son muy sencillos y te abrirán muchas posibilidades en
el mundo de Symfony, ¿todavía no te lo crees? No te preocupes, en los próximos capítulos, sin tocar
ni una sola línea de código, verás como tienes un Symfony con todo lo que siempre has deseado.
Truco 2
No se si llamar a esto un truco o un consejo, pero sin duda es algo que debes tener en cuenta en
tu día a día como desarrollador o desarrolladora. Como hemos visto a lo largo de este capítulo, la
web de knpbundles.com es un buen punto de referencia para bundles de terceros de Symfony. No te
limites a buscar aquí únicamente lo que necesitas y cuando lo necesitas, sino que debes visitar esta
web con asiduidad para saber lo que se está moviendo y lo que otros están utilizando. Sé curioso/a
y mantente a la última conociendo gran parte del trabajo de la comunidad. Claramente ganarás una
ventaja competitiva sobre todos los que están aislados de esta comunidad o se mantienen en su zona
Capítulo 2: los bundles de terceros
11
de confort reutilizando lo que llevan haciendo durante años. En el mundo en el que has decidido
embarcarte, un año significan tantos cambios y modificaciones que, o te subes al carro, o te quedas
atrás y no te dicen ni “hasta luego”.
Resumen
En este capítulo hemos aprendido las bases para instalar casi cualquier bundle realizado por
la comunidad. Hemos establecido una serie de pasos genéricos que te servirán en la instalación
y configuración de la mayoría de los desarrollos de la comunidad. En el siguiente capítulo
comenzaremos instalando uno de los bundles más potentes y más utilizados en el mundo Symfony:
el Admin Bundle del proyecto Sonata.
Capítulo 3: Admin Bundle
Como hemos visto en capítulos anteriores, existe una comunidad activa que aporta innumerables
elementos interesantes a la atmósfera de Symfony. Algunos lo hacen con más ahínco que otros,
y el proyecto Sonata es sin duda uno de los grandes a tener en cuenta. Dentro de su stack de
bundles¹¹ podrás encontrar un gran abanico de soluciones geniales. En el enlace anterior puedes
leer información acerca de los bundles en los que trabajan activamente para que vayas llenando tus
neuronas de información. Además, durante este libro probaremos algunos de estos bundles para que
veas cómo se instalan, cómo se configuran y, por supuesto, cómo se usan. El resto de ellos quedan
en tu tejado. ¡Vamos allá!
Instalando el Admin Bundle
Instalar el Admin Bundle es bastante sencillo a día de hoy ya que Sonata ha generado un desarrollo
padre llamado core bundle que facilita en gran medida la instalación de los diferentes bundles
que pertenecen a su stack de proyectos. Para este ejemplo didáctico, vamos a suponer que usamos
Doctrine ORM con una base de datos MySQL, pero tienes que saber que puedes utilizarlo con una
base de datos MongoDB que tan de moda se encuentra actualmente.
Lo primero que vamos a hacer es actualizar nuestras dependencias editando el archivo composer.json. Para ello, podemos hacerlo manualmente o podemos ejecutar el siguiente comando desde
la ruta raíz de nuestro proyecto:
1
composer require sonata-project/admin-bundle dev-master
Como consejo te diré que estés atento cada vez que instales un nuevo bundle, porque muchas veces
verás líneas como:
1
name1/bundle1 suggests installing name2/bundle2
Es recomendable que al menos te dirijas a la documentación de ese bundle recomendado porque
puede que sea muy interesante para tu proyecto ya que se encuentra estrechamente relacionado con
algo que acabas de instalar.
Hecho esto, el siguiente bundle a instalar es la conexión de nuestro admin con nuestra base de datos
MySQL:
¹¹https://sonata-project.org/bundles/
Capítulo 3: Admin Bundle
1
13
composer require sonata-project/doctrine-orm-admin-bundle dev-master
Lo siguiente que tenemos que hacer es activar el bundle y sus dependencias. En el capítulo
anterior dejábamos esto para el último paso. ¿Por qué? Porque si activas el bundle sin terminar
de configurarlo, te dará error (siempre y cuando lleve una configuración asociada, por supuesto),
por lo que si te quedas a medias en alguno de los pasos que vamos a realizar a continuación
y quieres seguir trabajando con lo que estabas, tendrás que volver a desactivarlo y terminar la
instalación más adelante. Como vamos a hacerlo todo seguido, realmente el orden no importa, pero
que sepas que puedes dejar este paso para más adelante. Para activar todo lo necesario, edita el
archivo app/AppKernel.php, añadiendo las siguientes líneas justo antes del AppBundle:
1
2
3
4
5
new
new
new
new
new
Sonata\CoreBundle\SonataCoreBundle(),
Sonata\BlockBundle\SonataBlockBundle(),
Knp\Bundle\MenuBundle\KnpMenuBundle(),
Sonata\DoctrineORMAdminBundle\SonataDoctrineORMAdminBundle(),
Sonata\AdminBundle\SonataAdminBundle(),
Para el siguiente paso tenemos que configurar los diferentes bundles que hemos activado. Todo
lo necesario está en la documentación oficial, y como decía uno de mis profesores: “un buen
programador sabe copiar y pegar con gusto”. Edita el archivo app/config/config.yml y añade la
siguiente configuración:
1
2
3
4
5
sonata_block:
default_contexts: [cms]
blocks:
sonata.admin.block.admin_list:
contexts:
[admin]
Además de esto, tenemos que activar el translator. Para ello, en el mismo config.yml, debes eliminar
la “#” que precede a translator en la parte superior del archivo. ¿Lo has encontrado? Entonces
seguimos.
En este momento, realizamos la primera “prueba de fuego”: copiamos los assets a la carpeta pública
y limpiamos la caché. Si alguno de los siguientes comandos te da un error tengo que anunciarte que
te has equivocado en alguno de los pasos previos que hemos hecho:
1
2
php app/console assets:install web --symlink
php app/console cache:clear
Para entender las líneas anteriores deberías leerte la documentación de Symfony (¡¿todavía no te la
has leído?!). Para los más rezagados: la primera línea del código anterior copia los assets (recursos
como archivos JavaScript, CSS, imágenes…) desde carpetas no públicas (src/...) a la carpeta pública
Capítulo 3: Admin Bundle
14
web, en este caso creando un enlace simbólico (la mejor opción para cuando estamos en proceso de
desarrollo, en producción no deberías escribir este último parámetro); la segunda línea simplemente
limpia la cache para regenerar elementos necesarios para un renderizado correcto.
¡Estupendo! Ya tenemos el admin instalado pero… todavía no es funcional. La siguiente parte de la
configuración nos permitirá acceder a él a través de nuestro navegador. Por eso, necesitamos editar
el archivo app/config/routing.yml y añadir las rutas que vienen en el vendor y harán accesible el
desarrollo. Añade la siguiente configuración en la parte superior del archivo:
1
2
3
4
5
6
7
8
admin:
resource: '@SonataAdminBundle/Resources/config/routing/sonata_admin.xml'
prefix: /admin
_sonata_admin:
resource: .
type: sonata_admin
prefix: /admin
¿Sabes qué ya dispones un admin que funciona? Si tienes el servidor web levantado, tan solo
dirígete a http://127.0.0.1:8000/admin y podrás ver su solitario y despoblado panel de administración.
Supongo que aquí ya te han surgido varias dudas:
• ¿Cómo introduzco elementos en este panel de administración?
• Ni siquiera tengo usuario y he podido entrar, ¿dónde está la seguridad?
• ¡Es muy feo! ¿Cómo modifico los estilos?
Tranquilo joven padawan, cada cosa llegará a su tiempo y de momento, este solo es el de responder
al primer punto que te planteo, ya que en el siguiente capítulo instalaremos un bundle que hace
uso de este administrador. Con él, automágicamente dispondremos de:
•
•
•
•
Gestión de usuarios: creación, email de activación, recuperación de contraseña, login, …
Administración de usuarios: desde el panel de administración, edición de roles, …
Seguridad en el admin: respondiendo a uno de los puntos anteriores.
Etc.
Lo mejor de todo esto es que la instalación del bundle de usuarios son tan solo 10 minutos, y la
potencia que te otorga es impresionante. Nunca más te preocuparás de hacer la gestión de usuarios
para ninguna de tus webs.
Capítulo 3: Admin Bundle
15
Creando nuestra Admin Class
De nada sirve tener un admin si no podemos introducir nuestros propios elementos. El ejemplo que
vamos a realizar a continuación te permitirá realizar el CRUD (Create, Read, Update, Delete) de una
entidad ejemplo añadiendo un sistema de filtrado y ordenación.
Para comenzar, debes crear la clase Product.php tal y como se indica en el capítulo de Doctrine de la
documentación¹² oficial de Symfony:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
<?php
// src/AppBundle/Entity/Product.php
namespace AppBundle\Entity;
use Doctrine\ORM\Mapping as ORM;
/**
* @ORM\Entity
* @ORM\Table(name="product")
*/
class Product
{
/**
* @ORM\Column(type="integer")
* @ORM\Id
* @ORM\GeneratedValue(strategy="AUTO")
*/
protected $id;
/**
* @ORM\Column(type="string", length=100)
*/
protected $name;
/**
* @ORM\Column(type="decimal", scale=2)
*/
protected $price;
/**
* @ORM\Column(type="text")
¹²http://symfony.com/doc/current/book/doctrine.html#add-mapping-information
Capítulo 3: Admin Bundle
33
34
35
16
*/
protected $description;
}
Recuerda generar los getters y setters y actualizar tu base de datos tras crear o modificar alguna de
tus entidades:
1
2
php app/console doctrine:generate:entities AppBundle
php app/console doctrine:schema:update --force
Lo siguiente que tienes que hacer es declarar la clase del admin que realizará el CRUD para esta
entidad. Si vienes de versiones anteriores de Symfony, sabrás que la inyección de dependencias
de cada bundle cargaba un archivo services.yml. Personalmente, me gusta modificar dicho archivo
para cargar un archivo admin.yml que también carga servicios, pero nos permite tener el código
bien “ordenadito”: cada cosa en su sitio. En el truco de este capítulo comparto contigo cómo lograr
este objetivo, pero para este ejemplo, deberás modificar el archivo app/config/services.yml para
cargar desde ahí nuestra admin class:
1
2
3
4
5
6
7
8
9
10
11
12
services:
sonata.admin.product:
class: AppBundle\Admin\ProductAdmin
tags:
- { name: sonata.admin, manager_type: orm, group: "Content", label: \
"Product" }
arguments:
- ~
- AppBundle\Entity\Product
- ~
calls:
- [ setTranslationDomain, [AppBundle]]
Excelente. Como puedes deducir del código anterior, nos hace falta crear una clase ProductAdmin
que es un “copy&paste” de la clase que puedes leer en la documentación, modificando únicamente
los campos de la entidad:
Capítulo 3: Admin Bundle
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
<?php
// src/AppBundle/Admin/ProductAdmin.php
namespace AppBundle\Admin;
use
use
use
use
Sonata\AdminBundle\Admin\Admin;
Sonata\AdminBundle\Datagrid\ListMapper;
Sonata\AdminBundle\Datagrid\DatagridMapper;
Sonata\AdminBundle\Form\FormMapper;
class ProductAdmin extends Admin
{
// Fields to be shown on create/edit forms
protected function configureFormFields(FormMapper $formMapper)
{
$formMapper
->add('name')
->add('price')
->add('description')
;
}
// Fields to be shown on filter forms
protected function configureDatagridFilters(DatagridMapper $datagridMapper)
{
$datagridMapper
->add('name')
->add('price')
;
}
// Fields to be shown on lists
protected function configureListFields(ListMapper $listMapper)
{
$listMapper
->addIdentifier('id')
->add('name')
->add('price')
->add('description')
->add('_action', 'actions', array(
'actions' => array(
'edit' => array()
17
Capítulo 3: Admin Bundle
43
44
45
46
18
)))
;
}
}
¡Lo tenemos! Si vuelves a visitar http://127.0.0.1:8000/admin podrás ver la parte correspondiente a
los productos. Prueba a crear, editar, filtrar y todo el resto de acciones que te permite el admin por
defecto.
A partir de aquí, aumentar tu panel de administración es “pan comido”: creas tu clase admin y la
activas en el archivo services.yml, sabiendo que tanto la clase PHP como la declaración del servicio
es prácticamente un “copy&paste” exacto de cualquier otro admin que ya hayas creado previamente.
En este ejemplo te he añadido algunas modificaciones con respecto a la documentación oficial, como
el botón de editar en el listado. Con este admin podrás incluso hacer tus propios botones asociados a
tus controladores, por lo que usa el admin para lo que se adapte a ti, y adapta el admin para el resto
de acciones que te falten. ¿Cómo hacer esto? Documentación y a probar, ¡ánimo! Por de pronto, aquí
te dejo la configuración base¹³ de Sonata Admin Bundle, para que cambies el título, el logo u otros
elementos que necesites.
Truco 3
Es posible que te guste tener la parte del admin completamente centralizada en tu bundle y no quieras
depender del archivo de servicios que está en la carpeta app. Esto se consigue con la inyección de
dependencias de una forma muy simple. Si creas un nuevo bundle, esta clase ya te viene creada por
defecto. Puedes probarlo con este comando:
1
php app/console generate:bundle
Pero sin duda, la mejor forma de aprender es “trasteando” (y rompiendo). Para ello, te dejo la
documentación necesaria en este¹⁴ enlace. Recuerda modificar la parte de XML por YAML:
1
2
3
4
$loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__.'/../Res\
ources/config'));
$loader->load('services.yml');
$loader->load('admin.yml');
Nota: el enlace anterior podría modificar su contenido debido a que la documentación del bundle
se encuentra en reestructuración.
¹³https://sonata-project.org/bundles/admin/master/doc/reference/configuration.html
¹⁴http://symfony.com/doc/current/cookbook/bundles/extension.html
Capítulo 3: Admin Bundle
19
Resumen
En este capítulo hemos aprendido a instalar el Admin Bundle del proyecto Sonata y a crear nuestra
primera clase aplicada al administrador. Durante el siguiente capítulo instalaremos la gestión de
usuarios basada en este administrador que nos dará control completo sobre ellos además de securizar
el recién instalado admin.