Instalar Symfony 2

A partir de la versin 2 de Symfony, es altamente recomendable instalarlo mediante Composer. A

continuacin explicamos cmo instalar Symfony 2 en un equipo con Linux Ubuntu Server utilizando
Composer.
Instalar curl en Linux
En primer lugar instalaremos (si no lo tenemos an) la utilidad "curl" que usaremos ms adelante
para descargar Composer. Para ello ejecutaremos el comando linux: sudo apt-get install curl
Instalar Composer en Linux
Instalaremos Composer con el comando linux:
mkdir composer
cd composer
curl -sS http://getcomposer.org/installer | php
composer self-update
Instalar Git en Linux
Git es un software de control de versiones diseado por Linus Torvalds, pensando en la eficiencia y
la confiabilidad del mantenimiento de versiones de aplicaciones cuando estas tienen un gran
nmero de archivos de cdigo fuente. Symfony usa Git de forma interna para la gestin de las
versiones, por lo que deberemos tenerlo instalado en nuestro equipo. Para instalar Git en un equipo
con Linux Ubuntu Serveres tan sencillo como ejecutar el siguiente comando linux:
apt-get install git-core
Para realizar una configuracin bsica de Git ejecutaremos los siguientes comandos (para
especificar el nombre y mail del administrador):
git config --global user.name "Proyecto AjpdSoft"
git config --global user.email bas@ajpdsoft.com
Instalar Symfony 2 con Composer
Para instalar Symfony con Composer ejecutaremos el comando linux:
composer create-project symfony/framework-standard-edition /var/www/symfony2
Si no hemos instalado Composer de forma global podremos ejecutar:
php composer.phar create-project symfony/framework-standard-edition /var/www/symfony2
Nota: si queremos instalar Symfony en otra ubicacin del equipo, para poder acceder va web,
necesitaremos aadir un VirtualHost en Apache. En nuestro caso, puesto que hemos instalado
Symphony en una subcarpeta del servidor web Apache no ser necesario.
El comando anterior habr creado la carpeta "symfony2" en /var/www:
Ya podremos comprobar y ejecutar el asistente de configuracin web de Symfony. Si queremos
ejecutar el asistente de configuracin web de Symfony2 desde cualquier equipo de la red
tendremos que editar el fichero ".../symfony2/web/config.php" y comentar las lneas:

if (!in_array(@$_SERVER['REMOTE_ADDR'], array(
'127.0.0.1',
'::1',
))) {

header('HTTP/1.0 403 Forbidden');

exit('This script is only accessible from localhost.');
}
Por ejemplo aadiendo:
/*
if (!in_array(@$_SERVER['REMOTE_ADDR'], array(
'127.0.0.1',
'::1',
))) {
header('HTTP/1.0 403 Forbidden');
exit('This script is only accessible from localhost.');
}
*/
Ahora podremos acceder desde cualquier equipo de la red, introduciendo la siguiente URL en un
navegador web:
http://pcsymfony2/symfony2/web/config.php
(Donde "pcsymfony2" ser el nombre DNS del equipo con Symfony 2 o bien la IP)
El asistente de Symfony analizar los requisitos y nos mostrar los posibles problemas a subsanar,
por ejemplo:

Permisos en carpetas de Symfony como /app/cache y /app/logs.

Parmetro de configuracin de zona horaria de PHP "date.timezone".

Y recomendaciones como la versin de PHP ms ptima (PHP 5.3.8 o superior), extensin "intl", PHP
eAccelerator:
A continuacin subsanaremos los posibles problemas de configuracin de nuestro servidor con
Apache y PHP, por ejemplo establecer los permisos necesarios para las carpetas:
/var/www/symfony2/app/cache
/var/www/symfony2/app/logs
Con los comandos linux:
sudo chmod 777 /var/www/symfony2/app/cache
sudo chmod 777 /var/www/symfony2/app/cache
Editaremos el fichero de configuracin de PHP para aadir el parmetro "date.timezone" con el
comando linux:
sudo nano /etc/php5/apache2/php.ini
Aadiremos la lnea (o la des comentaremos si ya existe comentada):
date.timezone = Europe/Madrid
(Cambiaremos la zona por la correspondiente)

Modificaremos el parmetro (si existe) "short_open_tag" con el valor "Off" aadiendo o modificando
la lnea (si existe):
short_open_tag = Of
Guardaremos los cambios en el fichero php.ini pulsando Control + O y cerraremos la edicin de
nano pulsando Control + X:

Reiniciaremos el servicio de Apache para que se apliquen los cambios:

services apache2 restart
(Tambin con sudo /etc/init.d/apache2 restart)
Instalaremos tambin el paquete php-int con:
sudo apt-get install php5-int
Symfony 2 recomienda tener instalado PHP eAccelerator, en el siguiente enlace explicamos cmo
hacerlo:

Instalar PHP eAccelerator.

Tras solventar los problemas y recomendaciones para el correcto funcionamiento de Symfony 2

volveremos a abrir el navegador web en un equipo de la red y acceder a la URL:
http://pcsymfony2/symfony2/web/config.php
(Donde "pcsymfony2" ser el nombre DNS del equipo con Symfony 2 o bien la IP)

Nos indicar si hemos solucionado los posibles problemas de configuracin, cuando estn todos
solucionados pulsaremos en "Configure your Symfony Application online":

Si vamos a realizar aplicaciones web PHP que accedan a base de datos MySQL, SQLite, PostgreSQL,
Oracle, IBM DB2, o Microsoft SQL Server podremos indicarlo a continuacin, introduciendo los datos
de acceso (usuario, IP, contrasea, ...):
Establecemos el Secreto Global (Global Secret):
El asistente nos indicar que Symfony 2 ya est configurado:

Primera aplicacin web PHP con Symfony 2

A continuacin indicados los pasos a seguir para crear una pgina web PHP con el framework
Symfony 2. Explicamos cmo crear el paquete (bundle), la ruta (route), el controlador (controller), la
plantilla (template) y la configuracin de la aplicacin.
Bundle (paquete) en Symfony 2
En primer lugar crearemos el bundle. Un bundle (paquete) en Symfony es la carpeta que contiene
el conjunto de archivos (PHP, hojas de estilo, JavaScripts, imgenes) que componen el proyecto (un
blog, un foro, etc.). Para crear el bundle (paquete) ejecutaremos lo siguiente en la lnea de
comandos:
php app/console generate:bundle --namespace=Acme/HolaMundo --format=yml
Introduciremos los datos para el bundle:

Namespace: nombre del espacio de trabajo.

Bundle name: nombre del paquiete (bundle).

Target directory: directorio de trabajo.

Formato: formato de notacin que usaremos para nuestro proyecto Symfony2, podremos
elegir entre YAML, XML o PHP.

Responderemos a las preguntas que el asistente para crear un nuevo proyecto Symfony2 nos
realizar (crear estructura de directorios, actualizaciones automticas del kernel del bundle,
actualizacin automtica de la ruta (route), etc.:
Route (ruta) en Symfony 2
De forma predeterminada, el archivo de configuracin de enrutamiento en una aplicacin Symfony2
se encuentra en:
.../src/nombre_bundle/Resources/config/routing.yml
Al igual que toda la configuracin en Symfony2, tambin se puede optar por utilizar XML o PHP, por
supuesto el fichero de ruta puede alojarse fuera de la ubicacin por defecto, aunque es conveniente
mantener la estructura estndar recomendada.
El enrutamiento de URLs sirve para generar URLs amigables y ms legibles para el usuario y para
los motores de bsqueda. Por ejemplo, el enrutamiento sirve para cambiar las tpicas URLs:
http://www.ajpdsoft.com/modules.php?name=News&file=article&sid=640
Por URLs ms legibles, amigables y ptimas para el posicionamiento SEO (Search Engine
Optimization):
http://www.ajpdsoft.com/servidor-web-ubuntu-server-12
Adems, el enrutamiento de URLs de Symfony2 nos permitir modificar enlaces de forma sencilla,
enlaces que puedan estar referenciados en varias secciones de nuestra web. Ser suficiente con
cambiar el enlace en el fichero de rutas.
Con el procedimiento anterior Symfony ya habr creado el archivo de ruta "routing.yml" en la
ubicacin predeterminada con el siguiente contenido:
ajpd_soft_acme_hola_mundo_homepage:
pattern: /hello/{name}
defaults: { _controller: AjpdSoftAcmeHolaMundoBundle:Default:index }

Bsicamente la ruta anterior aadida de forma automtica al crear el bundle lo que har ser
ejecutar el controlador "Default", por lo que deber existir un fichero llamado DefaultController.php
en la carpeta /Controller de nuestro bundle, dicha ruta ejecutar el procedimiento o funcin "index"
de dicho controlador, por lo que el fichero DefaultController.php tendr una funcin o procedimiento
llamado "indexAction", tambin pasar el parmetro "name" que ser el texto que se escriba en la
URL despus de "hello". La ruta anterior se ejecutar en un navegador como:
http://..../hello/nombre_escrito_por_usuario
Para realizar las compilaciones en desarrollo se ejecutar la URL:
http://localhost/symfony2/web/app_dev.php/hello/ajpdsoft
Donde cambiaremos "localhost" por la IP o nombre DNS del servidor con Symfony y "symfony2"
ser la ubicacin de Symfony en nuestro servidor web con Apache. "ajpdsoft" ser el texto libre
introducido por el usuario, dicho texto se almacenar en la variable "name".
Existen numerosas opciones para el enrutamiento en Symfony, opciones que no enumeraremos en
este tutorial por ser bastante extensas. Para obtener ms informacin es recomendable consultar la
documentacin oficial de Symfony: rutas con marcadores de posicin, rutas con parmetros
(_controller, _format, _locale) y mtodos (GET, HEAD, POST, PUT, DELETE), rutas a recursos
externos, establecer prefijos para rutas, etc.
Controller (controlador) en Symfony 2
Un controlador (controller) en Symfony es una funcin PHP que obtiene la informacin de la
solicitud (desde la ruta) y devuelve una respuesta HTTP (o un objeto en Symfony2). La respuesta
puede ser una pgina HTML, un documento XML, una matriz JSON serializado, una imagen, una
redireccin, un error 404 o cualquier otra cosa. El controlador puede contiene cualquier lgica
arbitraria que la aplicacin necesite para representar el contenido de una pgina.
El asistente para crear el bundle habr creado un fichero de ejemplo de controlador:
DefaultController.php
En la carpeta:
.../www/symfony2/src/AjpdSoft/AcmeHolaMundoBundle/Controller
Hemos editado el fichero del controlador con un editor de texto plano y hemos aadido el siguiente
contenido:
<?php
namespace AjpdSoft\AcmeHolaMundoBundle\Controller;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
class DefaultController extends Controller
{
public function indexAction($name)

{
$params = array('mensaje' => 'Hola Mundo AjpdSoft - Primer proyecto PHP con Symfony2',
'fecha' => date('d-m-yyy'), 'name' => $name);
return $this->render('AjpdSoftAcmeHolaMundoBundle:Default:index.html.twig', $params);
}
}
El controlador anterior ser llamado usando la ruta establecida en el fichero de rutas, como
indicamos aqu. Obtendr algunos datos como la fecha actual del sistema y el valor pasado por la
URL de la ruta y los enviar para ser mostrados en la plantilla "index.html.twing".
Por lo tanto Symfony est perfectamente diseado para la programacin por capas, separando
claramente la lgica de negocio (controller) de la lgica de diseo (template) y de la capa de datos.
Los controladores en Symfony los usaremos para establecer toda la lgica de negocio.
Template (plantilla) en Symfony 2
Las plantillas en symfony permiten separar la capa de lgica de diseo de la de la lgica de negocio
(controlador). En las plantilas podemos aadir toda la presentacin de nuestro sitio web (por
ejemplo, el cdigo HTML) que quedar separado y podrn reutilizarse diferentes partes del diseo
de la pgina. En lugar de escribir el cdigo HTML dentro del controlador (tambin se puede hacer
pero no es recomendable), podremos hacer una plantilla en su lugar.
La plantilla que se crea por defecto usando el asistente, en este paso, es la siguiente:
index.html.twig
Y se aloja en la carpeta:
...www/symfony2/src/AjpdSoft/AcmeHolaMundoBundle/Resources/views/Default
Hemos modificado con un editor de texto plano la plantilla para adaptarla a nuestro sitio web, como
ejemplo de "Hola mundo":
<h1>Hola Mundo - Aplicacion PHP con Symfony </h1>
<h2>Esto es una prueba de proyecto con Symfony.</h2>
<b>Nombre</b>: {{name}}
<b>Fecha</b>: {{fecha}}
<b>Mensaje</b>: {{mensaje}}
El ejemplo de salida de nuestra primera aplicacin PHP con Symfony2, lo compilaremos abriendo un
navegador y accediendo a la URL: http://localhost/symfony2/web/app_dev.php/hello/ajpdsoft
(Cambiaremos "localhost/symfony2" por la IP o nombre DNS de nuestro servidor con Symfony y la
carpeta donde lo hayamos instalado)

Acceso a base de datos MySQL con Symfony 2 utilizando Doctrine

Para acceder a un motor de base de datos desde Symfony 2, en primer lugar deberemos revisar el
fichero de configuracin para comprobar que estn establecidos los datos de acceso al servidor de
base de datos. Dicho fichero de configuracin est ubicado en:
...www/symfony2/app/config/parameters.yml
Si hemos establecido los datos de conexin con el servidor MySQL Server en este paso de la
instalacin de Symfony 2 ya estar creado el fichero "parameters.yml" con los parmetros de
conexin:
parameters:
database_driver: pdo_mysql
database_host: 127.0.0.1
database_port: '3306'
database_name: symfony
database_user: admin
database_password: 00
mailer_transport: smtp
mailer_host: 127.0.0.1
mailer_user: null
mailer_password: null
locale: en
secret: 0c2fc1f32d2b78120a612
database_path: null
Crear base de datos desde Doctrine
A continuacin explicamos cmo crear la base de datos MySQL si an no existe, obviamente, si ya
tenemos creada la base de datos este paso no ser necesario. Para crear la base de datos
"symfony" (que es la establecida en el parmetro database_name del ficheroparameters.yml)
podremos hacerlo o bien por el mtodo tradicional (desde MySQL Administrator, MySQL Workbench,
o desde la lnea de comandos de MySQL) o bien usando el siguiente comando de Doctrine:
php app/console doctrine:database:create
(Este comando debe ejecutarse en la carpeta de instalacin de Symfony2, en nuestro caso en
/www/var/symfony2)
Si el proceso concluye correctamente mostrar el mensaje: "Created database for connection
named 'symfony'".
Nota: para crear la base de datos Doctrine usar el usuario y contrasea indicados en el fichero de
parmetros parameters.yml para la conexin con MySQL Server, por lo que dicho usuario debe
tener permisos suficientes para crear catlogos.
Crear entidad y tabla en base de datos con Doctrine
Tras crear la base de datos (si no la tenamos creada), ahora como ejemplo crearemos una entidad
(entity en Doctrine) que se corresponder con una tabla de la base de datos. En concreto
crearemos la entidad "Factura" con los campos: Nmero, Importe, Fecha, Cdigo de cliente. Para
crear una entidad en Doctrine usaremos el siguiente comando:
php app/console doctrine:generate:entity --entity="AjpdSoftAcmeHolaMundoBundle:Factura"
--fields="numero:string(20) importe:float fecha:date codigocliente:integer"
Donde:

AjpdSoftAcmeHolaMundoBundle: nombre que le asignamos al Budle en su creacin.

Factura: nombre de la entidad (entity) que se corresponder con el nombre de la tabla de

MySQL donde persistirn los datos. Es importante mencionar la "F" mayscula, si usamos
maysculas en el nombre habr que usarlas tambin en las definiciones posteriores donde
hagamos uso de dicha entidad.

fields: en este parmetro indicamos los campos y tipo de datos que queramos establecer
para la entidad y por lo tanto para la tabla de MySQL que posteriormente crearemos.

Doctrine nos mostrar un pequeo asistente para crear la entidad, donde podremos elegir cambiar
el nombre especificado y aadir ms campos. Tambin podremos elegir el tipo de notacin para la
entidad (yml, xml, php o annotation), elegiremos todas las opciones por defecto pulsando INTRO:
Si queremos hacer persistente el objeto entidad "Factura" de Doctrine creado anteriormente en la
base de datos MySQL como una tabla podremos hacerlo de forma automtica ejecutando el
comando:
php app/console doctrine:schema:update --force
Si todo es correcto devolver:
Updating database schema...
Database schema updated successfully! "1" queries were executed
Insertar registros en tabla MySQL con Symfony y Doctrine
Ahora crearemos el controlador (controller) en nuestro proyecto Symfony2 para trabajar con la
entidad Factura, para crear el controller accederemos a la carpeta "Controller" de nuestro proyecto
"Symfony2" y ejecutaremos:
nano FacturaController.php
Aadiremos el siguiente cdigo al controlador, este cdigo insertar una factura, aadir un registro
a la tabla "Factura" de MySQL. Como ejemplo utilizaremos datos fijos, lo lgico sera mostrar un
formulario para que el usuario introdujera los datos, esto lo explicaremos en futuros tutoriales:
<?php
namespace AjpdSoft\AcmeHolaMundoBundle\Controller;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use AjpdSoft\AcmeHolaMundoBundle\Entity\Factura;
use Symfony\Component\HttpFoundation\Response;
class FacturaController extends Controller
{
public function insertarfacturaAction()
{
$facturaIns = new Factura();
$facturaIns->setNumero('0001-2013');
$facturaIns->setImporte(1000.87);
$facturaIns->setCodigocliente(1);
$facturaIns->setFecha(new \DateTime("now"));
$em = $this->getDoctrine()->getManager();
$em->persist($facturaIns);
$em->flush();
return new Response('Creada factura ' . $facturaIns->getId());

}
A continuacin explicamos algunas lneas del cdigo:

use AjpdSoft\AcmeHolaMundoBundle\Entity\Factura: en esta lnea indicamos a Symfony que

utilice la entidad "Factura" creada mediante Doctrine.

$facturaIns = new Factura(): creamos un objeto de tipo "Factura".

$facturaIns->set...: estableceremos los valores para cada propiedad de la entidad (que se

correspondern con los campos de la tabla Factura).

El resto de lneas las utilizaremos para persistir los datos establecidos para la entidad en la
tabla de MySQL.

Para probar el controlador y el cdigo que insertar un registro en una tabla aadiremos una ruta
en el fichero de rutas de nuestro proyecto Symfony2 (routing.yml), para ello nos situaremos en la
carpeta del fichero de rutas:
cd /www/var/symfony2/src/AjpdSoft/AcmeHolaMundoBundle/Resources/config
Y editaremos el fichero "routing.yml": nano routing.yml
Aadiremos las siguientes lneas:
insertar_factura:
pattern: /insertarfactura
defaults: { _controller: AjpdSoftAcmeHolaMundoBundle:Factura:insertarfactura }
(Teniendo en cuenta que nuestro controlador se llama "Factura" y el procedimiento para insertar
factura del controlador se llama "insertarfacturaAction")
Para probar el resultado ser suficiente con abrir un navegador web y acceder a la URL:
http://ip_servidor_symfony/web/app_dev.php/insertarfactura
Si todo es correcto nos devolver "Creada factura 1":
Mostrar registros de tabla MySQL con Symfony y Doctrine
A continaucin explicaremos cmo mostrar una lista de registros de la base de datos en nuestro
proyecto Symfony2 usando Doctrine. En primer lugar editaremos nuestro fichero de controlador
para las facturas FacturaController.php (creado aqu) y aadiremos la siguiente funcin:
public function listarFacturasAction()
{
$em = $this->getDoctrine()->getManager();
$facturas = $em->getRepository('AjpdSoftAcmeHolaMundoBundle:Factura')->findAll();
return $this->render('AjpdSoftAcmeHolaMundoBundle:Factura:listaFacturas.html.twig',
array('facturas' => $facturas));
}
Crearemos el fichero de plantilla (template), para ello crearemos la carpeta para las plantillas del
controlador "Facturas" con:
mkdir /var/www/symfony2/src/AjpdSoft/AcmeHolaMundoBundle/Resources/views/Factura
Accederemos a la carpeta para la plantilla y la crearemos con: nano listaFacturas.html.twig
Aadiremos el siguiente cdigo HTML para mostrar el array de facturas obtenido desde el
Controller:

<h1>FACTURAS</h1>
<table border="1">
<tr>
<th>Numero</th>
<th>Fecha</th>
<th>Importe</th>
<th>Cliente</th>
</tr>
{% for factura in facturas %}
<tr>
<td>{{ factura.id }}</td>
<td>{{ factura.numero }}</td>
<td>{{ factura.fecha | date('d-m-Y') }}</td>
<td>{{ factura.codigocliente }}</td>
</tr>
{% endfor %}
</table>
Aadiremos la ruta en el fichero de rutas de nuestro proyecto Symfony2:
listar_factura:
pattern: /listafacturas
defaults: { _controller: AjpdSoftAcmeHolaMundoBundle:Factura:listarFacturas }
Y ya podremos probar nuestro controlador para mostrar un listado de las facturas de la base de
datos MySQL con Symfony y Doctrine:

Actualizar identidades de Symfony con Doctrine automticamente

Cuando se est desarrollando un proyecto Symfony2, puede que surjan nuevos cambios en la base
de datos: nuevas tablas, nuevos campos en tablas existentes, etc. Doctrine permite regenerar los
ficheros de entidades (entity) de forma automtica cada vez que lo necesitemos. A continuacin
realizaremos un ejemplo, en la base de datos que estamos usando para este proyecto Symfony2
tenemos una tabla creada "Factura" y su correspondiente entidad creada en nuestro proyecto
Symfony2 (Factura.php), todo esto ya ha sido explicado anteriormente.

Ahora crearemos una tabla en MySQL de forma "manual", sin usar Doctrine, para ello accederemos
por ejemplo con MySQL Administrator y crearemos la tabla "Cliente", con los campos: id, nombre y
cif:

Modificaremos tambin la tabla "Factura" aadiendo algn campo:

Ahora explicaremos cmo actualizar las entidades existentes y cmo regenerar las nuevas usando
Doctrine. Desde la carpeta de la instalacin de Symfony2 ejecutaremos:
php app/console doctrine:mapping:convert xml
.../symfony2/src/AjpdSoft/AcmeHolaMundoBundle/Resources/config/doctrine/metadata/orm --fromdatabase --force
(Donde ".../symfony2/src/AjpdSoft/AcmeHolaMundoBundle" ser la carpeta de nuestro proyecto
Symfony2)
Si todo es correcto (los datos de conexin a la BD y la ubicacin de las carpetas) Doctrine nos
mostrar el resultado de la recarga de las entidades, habr accedido a la base de datos
especificada en el fichero de parmetros "parameters.yml", habr recorrido todas las tablas y todos
los campos y habr generado un fichero xml por cada entidad (tabla):
Processing entity "Cliente"
Processing entity "Factura"
Exporting "xml" mapping information to
".../symfony2/src/AjpdSoft/AcmeHolaMundoBundle/Resources/config/doctrine/metadata/orm"
Los ficheros generados:

Por ltimo ejecutaremos los siguientes comandos Doctrine para crear los ficheros de entidades en
nuestro proyecto Symfony2 con formato "annotation":
php app/console doctrine:mapping:import AjpdSoftAcmeHolaMundoBundle annotation
php app/console doctrine:generate:entities AjpdSoftAcmeHolaMundoBundle
(Indicando siempre el nombre del bundle de nuestro proyecto Symfony2)

Doctrine habr generado en nuestro caso dos ficheros PHP correspondientes a las dos entidades
Factura y Cliente que a su vez se corresponden con las tablas Cliente y Factura de MySQL:

Habr aadido todos los mtodos get y set para cada campo de cada tabla de la base de datos: