Symfony
Symfony es un completo framework diseñado para
optimizar el desarrollo de las aplicaciones web basado en el patrón
Modelo Vista Controlador (MVC). Para empezar, separa la lógica de
negocio, la lógica de servidor y la presentación de la aplicación web.
Proporciona varias herramientas y clases encaminadas a reducir el tiempo
de desarrollo de una aplicación web compleja. Además, automatiza las
tareas más comunes, permitiendo al desarrollador dedicarse por completo a
los aspectos específicos de cada aplicación.
Symfony fue diseñado para ajustarse a los siguientes requisitos:
- Fácil de instalar y configurar en la mayoría de plataformas (y con la garantía de que funciona correctamente en los sistemas Windows, Unix y Linux estándares).
- Independiente del sistema gestor de bases de datos. Su capa de
abstracción y el uso de Propel, permiten cambiar con facilidad de SGBD en cualquier fase del proyecto.
- Utiliza programación orientada a objetos, de ahí que sea imprescindible PHP 5 o superior.
- Sencillo de usar en la mayoría de casos, aunque es preferible para
el desarrollo de grandes aplicaciones Web que para pequeños
proyectos.
- Aunque utiliza MVC (Modelo Vista Controlador), tiene su propia
forma de trabajo en este punto, con variantes del MVC clásico como la
capa de abstracción de base de datos, el controlador frontal y las
acciones.
- Basado en la premisa de “convenir en vez de configurar”, en la que
el desarrollador sólo debe configurar aquello que no es convencional.
- Sigue la mayoría de mejores prácticas y patrones de diseño para la web.
- Preparado para aplicaciones empresariales y adaptable a las
políticas y arquitecturas propias de cada empresa, además de ser lo
suficientemente estable como para desarrollar aplicaciones a largo
plazo.
- Código fácil de leer que incluye comentarios de phpDocumentor y que permite un mantenimiento muy sencillo.
- Fácil de extender, lo que permite su integración con las bibliotecas de otros fabricantes.
- Una potente línea de comandos que facilitan generación de código, lo cual contribuye a ahorrar tiempo de trabajo.
Las características más comunes para el desarrollo de proyectos web están automatizadas en symfony, tales como:
- Permite la internacionalización para la traducción del texto de la interfaz, los datos y el contenido de localización.
- La presentación usa templates y layouts que pueden ser construidos por diseñadores de HTML que no posean conocimientos del framework.
- Los formularios soportan la validación automática, lo cual
asegura mejor calidad de los datos en las base de datos y una mejor
experiencia para el usuario.
- El manejo de cache reduce el uso de banda ancha y la carga del servidor.
- La facilidad de soportar autenticación y credenciales facilita la
creación de áreas restringidas y manejo de seguridad de los usuarios.
- El enrutamiento y las URLs inteligentes hacen amigable las direcciones de las páginas de la aplicación.
- Las listas son más amigables, ya que permite la paginación, clasificación y filtraje automáticos.
- Los plugins proveen un alto nivel de extensibilidad.
- La interacción con AJAX es mucho más sencilla.
Requisitos para instalar Symfony 2 y crear proyecto PHP con acceso a base de datos MySQL
Para instalar el framework Symfony 2 necesitaremos un equipo con el sistema operativo
Linux o
Windows, en nuestro caso usaremos
Linux, por lo que deberemos disponer de un equipo con
GNU Linux. En los siguientes enlaces mostramos cómo instalar estos sistemas operativos (tanto en máquinas virtuales como físicas):
Symfony también necesitará de un servidor web con
Apache y
PHP. Hay que tener en cuenta que Symfony requiere de
PHP 5 o superior. A continuación mostramos algunos enlaces donde explicamos cómo montar un servidor web con
Apache y
PHP:
Hoy en día gran parte de los sitios web requieren de
un motor de base de datos para proporcionar características avanzadas y
dinámicas. En este tutorial explicaremos cómo acceder a un servidor de
base de datos
MySQL Server usando Symfony, por lo tanto necesitaremos también un equipo con el motor de base de datos
MySQL Server. En los siguientes enlaces mostramos cómo instalarlo tanto en
Linux como en
Windows:
Instalar Symfony 2 en Linux Ubuntu Server
Symfony puede instalarse mediate varios métodos: svn
(subversion), PEAR (PHP Extension and Application Repository) o incluso
manualmente descargando el fichero de la web oficial y descomprimiéndolo
en la carpeta raíz del servidor web
Apache.
A partir de la versión 2 de Symfony, es altamente recomendable instalarlo mediante
Composer. A continuación explicamos cómo instalar Symfony 2 en un equipo con
Linux Ubuntu Server utilizando Composer.
Instalar curl en Linux
En primer lugar instalaremos (si no lo tenemos aún)
la utilidad "curl" que usaremos más adelante para descargar Composer.
Para ello ejecutaremos el
comando linux:
sudo apt-get install curl
Instalar Composer en 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 diseñado
por Linus Torvalds, pensando en la eficiencia y la confiabilidad del
mantenimiento de versiones de aplicaciones cuando estas tienen un gran
número de archivos de código fuente. Symfony usa Git de forma interna
para la gestión de las versiones, por lo que deberemos tenerlo instalado
en nuestro equipo. Para instalar Git en un equipo con
Linux Ubuntu Server es tan sencillo como ejecutar el siguiente
comando linux:
apt-get install git-core
Para realizar una configuración básica 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 ubicación del equipo, para poder acceder vía web, necesitaremos añadir 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
configuración web de Symfony, 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.
- Parámetro de configuración de zona horaria de PHP "date.timezone".
Y recomendaciones como la versión de
PHP más óptima (PHP 5.3.8 o superior), extensión "intl",
PHP eAccelerator:
A continuación subsanaremos los posibles problemas de configuración 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
sudo chmod 777 /var/www/symfony2/app/cache
sudo chmod 777 /var/www/symfony2/app/cache
Editaremos el fichero de configuración de
PHP para añadir el parámetro "date.timezone" con el
comando linux:
sudo nano /etc/php5/apache2/php.ini
Añadiremos la línea (o la descomentaremos si ya existe comentada):
date.timezone = Europe/Madrid
(cambiaremos la zona por la correspondiente)
Modificaremos el parámetro (si existe) "short_open_tag" con el valor "Off" añadiendo o modificando la línea (si existe):
short_open_tag = Off
Guardaremos los cambios en el fichero php.ini pulsando Control + O y cerraremos la edición de nano pulsando Control + X:
Reiniciaremos el servicio de
Apache para que se apliquen los cambios:
services apache2 restart
( también con sudo /etc/init.d/apache2 restart)
Intalaremos también el paquete php-int con:
sudo apt-get install php5-int
Symfony 2 recomienda tener instalado PHP eAccelerator, en el siguiente enlace explicamos cómo hacerlo:
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 configuración, cuando estén todos solucionados pulsaremos
en "Configure your Symfony Application online":
Estableremos el Secreto Global (Global Secret):
El asistente nos indicará que Symfony 2 ya está configurado:
Y ya tendremos configurado Symfony 2 en nuestro equipo:
Primera aplicación web PHP con Symfony 2
A continuación indicados los pasos a seguir para crear una página web
PHP con el framework Symfony 2. Explicamos cómo crear el paquete (
bundle), la ruta (
route), el controlador (
controller), la plantilla (
template) y la configuración de la aplicación.
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, imágenes, ...) que componen el proyecto
(un blog, un foro, etc.). Para crear el bundle (paquete) ejecutaremos lo
siguiente en la línea 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 notación 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 automáticas del kernel del bundle,
actualización automática de la ruta (route), etc.:
El asistente habrá creado la estructura de carpetas que compone el proyecto Symfony2:
Route (ruta) en Symfony 2
De forma predeterminada, el archivo de configuración de enrutamiento en una aplicación Symfony2 se encuentra en:
... /src/nombre_bundle/Resources/config/routing.yml
Al igual que toda la configuración en Symfony2, también se puede optar por utilizar XML o PHP,
por supuesto el fichero de ruta puede alojarse fuera de la ubicación
por defecto, aunque es conveniente mantener la estructura estándar
recomendada.
El enrutamiento de URLs sirve para generar URLs
amigables y más legibles para el usuario y para los motores de
búsqueda. Por ejemplo, el enrutamiento sirve para cambiar las típicas URLs:
http://www.ajpdsoft.com/modules.php?name=News&file=article&sid=640
Por
URLs más legibles, amigables y óptimas para el posicionamiento SEO (Search Engine Optimization):
http://www.ajpdsoft.com/servidor-web-ubuntu-server-12
Además, 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 ubicación predeterminada con el siguiente contenido:
ajpd_soft_acme_hola_mundo_homepage:
pattern: /hello/{name}
defaults: { _controller: AjpdSoftAcmeHolaMundoBundle:Default:index }
Básicamente la ruta anterior añadida de forma automática 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 función "index" de dicho
controlador, por lo que el fichero
DefaultController.php
tendrá una función o procedimiento llamado "indexAction", también
pasará el parámetro "name" que será el texto que se escriba en la
URL después 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 ubicación 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 más información es recomendable consultar la
documentación oficial de Symfony: rutas con marcadores de posición,
rutas con parámetros (_controller, _format, _locale) y métodos (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 función
PHP que obtiene la información de la solicitud (desde la
ruta) y devuelve una respuesta
HTTP (o un objeto en Symfony2). La respuesta puede ser una página
HTML, un documento
XML, una matriz
JSON
serializado, una imagen, una redirección, un error 404 o cualquier otra
cosa. El controlador puede contiene cualquier lógica arbitraria que la
aplicación necesite para representar el contenido de una página.
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 añadido el siguiente contenido:
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 diseñado para
la programación por capas, separando claramente la lógica de negocio
(controller) de la lógica de diseño (
template) y de la capa de
datos. Los controladores en Symfony los usaremos para establecer toda la lógica de negocio.
Template (plantilla) en Symfony 2
Las plantillas en symfony permiten separar la capa de lógica de diseño de la de la lógica de negocio (
controlador). En las plantilas podemos añadir toda la presentación de nuestro sitio web (por ejemplo, el código
HTML) que quedará separado y podrán reutilizarse diferentes partes del diseño de la página. En lugar de escribir el código
HTML dentro del controlador (también 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":
Hola Mundo - Aplicacion PHP con Symfony
Esto es una prueba de proyecto con Symfony.
Nombre: {{name}}
Fecha: {{fecha}}
Mensaje: {{mensaje}}
El ejemplo de salida de nuestra primera aplicación
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 configuración
para comprobar que están establecidos los datos de acceso al servidor
de base de datos. Dicho fichero de configuración está ubicado en:
...www/symfony2/app/config
Y se llama:
parameters.yml
Si hemos establecido los datos de conexión con el servidor
MySQL Server en este paso de la instalación de Symfony 2 ya estará creado el fichero "parameters.yml" con los parámetros de conexión:
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: 0c2fc1ff32d2b78120a612
database_path: null
Como vemos en los parámetros anteriores, nos conectaremos a un servidor de
MySQL Server alojado en el mismo servidor que Symfony2, mediante el puerto 3306, con usuario de
MySQL Server
"admin" y contraseña "00" y utilizaremos el catálogo (base de datos)
"symfony". Más adelante veremos que si dicho catálogo no existe se podrá
crear con
Doctrine.
Para trabajar con base de datos desde Symfony2 usaremos
Doctrine, Symfony2 ya lleva integrado este sistema que permite mapear objetos de una base de datos.
Crear base de datos desde Doctrine
A continuación explicamos cómo crear la base de datos
MySQL
si aún 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 parámetro
database_name del fichero
parameters.yml)
podremos hacerlo o bien por el método tradicional (desde MySQL
Administrator, MySQL Workbench, o desde la línea 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 instalación 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 contraseña indicados en el fichero de parámetros
parameters.yml para la conexión con
MySQL Server, por lo que dicho usuario debe tener permisos suficientes para crear catálogos.
Ahora podremos comprobar que la base de datos ha sido creada desde la línea de comandos ejecutando:
mysql --user="admin" --password="contraseña"
(donde "admin" será un usuario con permisos suficientes en
MySQL Server y "contraseña" será su contraseña)
Una vez conectados al servidor de MySQL ejecutaremos el siguiente comando para mostrar las bases de datos:
show databases;
Entre las bases de datos deberá aparecer la indicada en el parámetro database_name, en nuestro caso "symfony":
Crear entidad y tabla en base de datos con Doctrine
Tras crear la base de datos (si no la teníamos 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: Número, Importe, Fecha,
Código 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 creación.
- Factura: nombre de la entidad (entity) que se corresponderá con el nombre de la tabla de MySQL
donde persistirán los datos. Es importante mencionar la "F" mayúscula,
si usamos mayúsculas en el nombre habrá que usarlas también en las
definiciones posteriores donde hagamos uso de dicha entidad.
- fields: en este parámetro 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 pequeño asistente para crear
la entidad, donde podremos elegir cambiar el nombre especificado y
añadir más campos. También podremos elegir el tipo de notación para la
entidad (yml, xml, php o annotation), elegiremos todas las opciones por
defecto pulsando INTRO:
La entidad podría crearse de forma manual pero es un poco tedioso,
Doctrine
con este parámetro nos permite crear la entidad y todos sus métodos
básicos (get y set) de forma automática. Para consultar el fichero de
entidad resultante accederemos a la carpeta Controller de nuestro
proyecto Symfony2, habrá creado una subcarpeta llamada "Entity" (si no
existía) y habrá creado el fichero "Factura.php":
Con "cat Factura.php" podremos consultar su
contenido. Por supuesto podremos modificar este fichero añadiendo o
eliminando métodos:
Para ver el contenido del fichero generado por el asistente de
Doctrine: "Factura.php" pulsa
aquí.
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 automática 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
Ahora podremos consultar desde
MySQL que se ha creado la tabla "Factura" con los campos indicandos en la entidad mediante
Doctrine. Para consultar la tabla podremos hacerlo desde la línea de comandos accediendo a
MySQL Server, utilizando el catálogo con:
use symfony;
mostrando las tablas del catálogo con:
show tables;
y mostrando los campos de la tabla "Factura" con:
desc factura;
Podremos consultar también la tabla creada desde MySQL Administrator o cualquier otro cliente con acceso a
MySQL:
Por supuesto, la tabla de
MySQL también puede crearse de forma externa sin usar
Doctrine, además,
Doctrine incluye un comando para recargar posibles cambios en las tablas de
MySQL
y regenerar las propiedades y métodos de todas las entidades de las
tablas de la base de datos de forma automática, explicamos este comando
aquí.
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
(Es importante destacar que debemos usar los nombres de los
ficheros de forma correcta para luego establecer el routing sin
problemas, por ejemplo, nuestro controlador se llamará "Factura" y el
fichero de PHP se llamará "FacturaController.php")
Añadiremos el siguiente código al controlador, este código insertará una factura, añadirá un registro a la tabla "Factura" de
MySQL.
Como ejemplo utilizaremos datos fijos, lo lógico sería mostrar un
formulario para que el usuario introdujera los datos, esto lo
explicaremos en futuros tutoriales:
El código del controlador para insertar una factura:
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 continuación explicamos algunas líneas del código:
- use AjpdSoft\AcmeHolaMundoBundle\Entity\Factura: en esta línea 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 corresponderán con los campos de la tabla Factura).
- El resto de líneas las utilizaremos para persistir los datos establecidos para la entidad en la tabla de MySQL.
Para probar el controlador y el código que insertará
un registro en una tabla añadiremos 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
Añadiremos las siguientes líneas:
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":
Nota: si se produce algún error lo capturará Symfony y nos mostrará información detallada para solventarlo.
Ahora podremos comprobar que el registro se ha insertado correctamente en la tabla de
MySQL desde nuestra aplicación Symfony2, desde la línea de comandos accediendo a
MySQL:
mysql --user="usuario" --password="contraseña"
uses symfony;
select * from factura;
Mostrar registros de tabla MySQL con Symfony y Doctrine
A continaución explicaremos cómo 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 añadiremos la siguiente función:
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
Añadiremos el siguiente código HTML para mostrar el array de facturas obtenido desde el Controller:
FACTURAS
| Numero |
Fecha |
Importe |
Cliente |
{% for factura in facturas %}
| {{ factura.id }} |
{{ factura.numero }} |
{{ factura.fecha | date('d-m-Y') }} |
{{ factura.codigocliente }} |
{% endfor %}
Añadiremos 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 automáticamente
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
automática cada vez que lo necesitemos. A continuación 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 también la tabla "Factura" añadiendo algún campo:
Ahora explicaremos cómo actualizar las entidades existentes y cómo regenerar las nuevas usando
Doctrine. Desde la carpeta de la instalación de Symfony2 ejecutaremos:
php app/console doctrine:mapping:convert xml
.../symfony2/src/AjpdSoft/AcmeHolaMundoBundle/Resources/config/doctrine/metadata/orm
--from-database --force
(donde ".../symfony2/src/AjpdSoft/AcmeHolaMundoBundle" será la carpeta de nuestro proyecto Symfony2)
Si todo es correcto (los datos de conexión a la BD y la ubicación 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 parámetros
"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:
Abrá añadido todos los métodos get y set para cada campo de cada tabla de la base de datos:
Anexo
Instalar PHP eAccelerator
Symfony 2 recomienda encericamente tener instalado
PHP eAccelerator en nuestro servidor web Apache, para mejorar los
tiempos de respuesta. No es obligatorio instalarlo para el
funcionamiento de Symfony, pero mejora el rendimiento.
Para instalar PHP eAccelerator, en primer lugar, instalaremos el paquete
php-dev con el
comando linux:
sudo apt-get install php5-dev
Descargaremos el fichero comprimido de la última
versión disponible de PHP eAccelerator, una vez que sepamos cuál es la
URL introduciremos el siguiente
comando linux para descargarlo:
wget https://github.com/eaccelerator/eaccelerator/tarball/master/eaccelerator-eaccelerator-42067ac.tar.gz
Una vez descargado lo descomprimimos con:
gunzip eaccelerator-eaccelerator-42067ac.tar.gz | tar -xvf eaccelerator-eaccelerator-42067ac.tar
Accedemos a la carpeta descomprimida con:
cd eacceleraton-eaccelerator-42067ac
Generaremos el fichero de configuración necesario para la compilación con:
phpize
Y:
./configure --enable-eaccelerator=shared --with-php-config=/usr/bin/php-config
Ejecutamos ahora:
make
Y:
make install
Modificaremos el fichero de configuración de
PHP, lo editaremos con:
sudo nano /etc/php5/apache2/php.ini
Y añadiremos las siguientes líneas:
extension="eaccelerator.so"
eaccelerator.shm_size="16"
eaccelerator.cache_dir="/tmp/eaccelerator"
eaccelerator.enable="1"
eaccelerator.optimizer="1"
eaccelerator.check_mtime="1"
eaccelerator.debug="0"
eaccelerator.filter=""
eaccelerator.shm_max="0"
eaccelerator.shm_ttl="0"
eaccelerator.shm_prune_period="0"
eaccelerator.shm_only="0"
eaccelerator.compress="1"
eaccelerator.compress_level="9"
Guardamos los cambios en php.ini pulsando Control + O y cerramos la edición de nano pulsando en Control + X:
Para activar PHP eAccelerator deberemos reiniciar el servicio de
Apache, podemos hacerlo con el
comando linux:
sudo service apache2 restart
Resultado ejecución comandos
root@ajpdsoft:/# composer create-project symfony/framework-standard-edition /var/www/symfony2
Installing symfony/framework-standard-edition (v2.2.0)
- Installing symfony/framework-standard-edition (v2.2.0)
Loading from cache
Created project in /var/www/symfony2
Loading composer repositories with package information
Installing dependencies from lock file
- Installing twig/twig (v1.12.2)
Loading from cache
- Installing psr/log (1.0.0)
Loading from cache
- Installing doctrine/common (2.3.0)
Loading from cache
- Installing symfony/symfony (v2.2.0)
Loading from cache
- Installing jdorn/sql-formatter (v1.2.0)
Loading from cache
- Installing doctrine/dbal (2.3.2)
Loading from cache
- Installing doctrine/doctrine-bundle (v1.2.0-beta1)
Loading from cache
- Installing doctrine/orm (2.3.2)
Loading from cache
- Installing jms/cg (1.0.0)
Loading from cache
- Installing phpoption/phpoption (1.1.0)
Loading from cache
- Installing jms/parser-lib (1.0.0)
Loading from cache
- Installing jms/metadata (1.2.0-RC)
Loading from cache
- Installing jms/aop-bundle (1.0.0)
Loading from cache
- Installing jms/di-extra-bundle (1.3.0)
Loading from cache
- Installing jms/security-extra-bundle (1.4.0)
Loading from cache
- Installing sensio/distribution-bundle (v2.2.0)
Loading from cache
- Installing sensio/framework-extra-bundle (v2.2.0)
Loading from cache
- Installing sensio/generator-bundle (v2.2.0)
Loading from cache
- Installing kriswallsmith/assetic (v1.1.0-alpha3)
Loading from cache
- Installing symfony/assetic-bundle (v2.1.2)
Loading from cache
- Installing monolog/monolog (1.4.0)
Loading from cache
- Installing symfony/monolog-bundle (v2.2.0)
Loading from cache
- Installing swiftmailer/swiftmailer (v4.3.0)
Loading from cache
- Installing symfony/swiftmailer-bundle (v2.2.0)
Loading from cache
- Installing twig/extensions (v1.0.0-alpha)
Loading from cache
kriswallsmith/assetic suggests installing leafo/lessphp
(Assetic provides the integration with the lessphp LESS compile
r)
kriswallsmith/assetic suggests installing leafo/scssphp (Assetic
provides the integration with the scssphp SCSS compile
r)
kriswallsmith/assetic suggests installing leafo/scssphp-compass
(Assetic provides the integration with the SCSS compass
plugin)
kriswallsmith/assetic suggests installing ptachoire/cssembed
(Assetic provides the integration with phpcssembed to embe
d data uris)
monolog/monolog suggests installing doctrine/couchdb (Allow sending log messages to a CouchDB server)
monolog/monolog suggests installing ext-amqp (Allow sending log messages to an AMQP server (1.0+ required))
monolog/monolog suggests installing ext-mongo (Allow sending log messages to a MongoDB server)
monolog/monolog suggests installing mlehner/gelf-php (Allow sending log messages to a GrayLog2 server)
monolog/monolog suggests installing raven/raven (Allow sending log messages to a Sentry server)
Generating autoload files
Clearing the cache for the dev environment with debug true
Installing assets using the hard copy option
Installing assets for Symfony\Bundle\FrameworkBundle into web/bundles/framework
Installing assets for Acme\DemoBundle into web/bundles/acmedemo
Installing assets for Sensio\Bundle\DistributionBundle into web/bundles/sensiodistribution
- Información inicial la primera vez que accedemos a Symfony
Welcome!
Welcome to your new Symfony project.
This script will guide you through the basic configuration of
your project. You can also do the same by
editing the ‘app/config/parameters.yml’ file directly.
Major problems
Major problems have been detected and must be fixed before continuing:
- Change the permissions of the "app/cache/" directory so that the web server can write into it.
- Change the permissions of the "app/logs/" directory so that the web server can write into it.
- Set the "date.timezone" setting in php.ini* (like Europe/Paris).
Recommendations
Additionally, to enhance your Symfony experience,
it’s recommended that you fix the following:
- Install PHP 5.3.8 or newer if your project uses annotations.
- Install and enable the intl extension (used for validators).
- Install and enable a PHP accelerator like APC (highly recommended).
- Set short_open_tag to off in php.ini*.
*
Changes to the php.ini file must be done in
"/etc/php5/apache2/php.ini".
- Resultado de la ejecución del comando:
./configure --enable-eaccelerator=shared --with-php-config=/usr/bin/php-config
root@proyectoa:/accelerator/eaccelerator-eaccelerator-42067ac# phpize
Configuring for:
PHP Api Version: 20090626
Zend Module Api No: 20090626
Zend Extension Api No: 220090626
root@proyectoa:/accelerator/eaccelerator-eaccelerator-42067ac#
./configure --enable-eaccelerator=shared
--with-php-config=/usr/bin/php-config
checking for grep that handles long lines and -e... /bin/grep
checking for egrep... /bin/grep -E
checking for a sed that does not truncate output... /bin/sed
checking for cc... cc
checking whether the C compiler works... yes
checking for C compiler default output file name... a.out
checking for suffix of executables...
checking whether we are cross compiling... no
checking for suffix of object files... o
checking whether we are using the GNU C compiler... yes
checking whether cc accepts -g... yes
checking for cc option to accept ISO C89... none needed
checking how to run the C preprocessor... cc -E
checking for icc... no
checking for suncc... no
checking whether cc understands -c and -o together... yes
checking for system library directory... lib
checking if compiler supports -R... no
checking if compiler supports -Wl,-rpath,... yes
checking build system type... i686-pc-linux-gnu
checking host system type... i686-pc-linux-gnu
checking target system type... i686-pc-linux-gnu
checking for PHP prefix... /usr
checking for PHP includes... -I/usr/include/php5
-I/usr/include/php5/main -I/usr/include/php5/TSRM
-I/usr/include/php5/Zend -I/usr/include/php5/ext
-I/usr/include/php5/ext/date/lib -D_LARGEFILE_SOURCE
-D_FILE_OFFSET_BITS=64
checking for PHP extension directory... /usr/lib/php5/20090626+lfs
checking for PHP installed headers prefix... /usr/include/php5
checking if debug is enabled... no
checking if zts is enabled... no
checking for re2c... no
configure: WARNING: You will need re2c 0.13.4 or later if you want to regenerate PHP parsers.
checking for gawk... no
checking for nawk... nawk
checking if nawk is broken... no
checking whether to enable eaccelerator support... yes, shared
checking for ANSI C header files... yes
checking for sys/types.h... yes
checking for sys/stat.h... yes
checking for stdlib.h... yes
checking for string.h... yes
checking for memory.h... yes
checking for strings.h... yes
checking for inttypes.h... yes
checking for stdint.h... yes
checking for unistd.h... yes
checking for unistd.h... (cached) yes
checking limits.h usability... yes
checking limits.h presence... yes
checking for limits.h... yes
checking sys/param.h usability... yes
checking sys/param.h presence... yes
checking for sys/param.h... yes
checking sched.h usability... yes
checking sched.h presence... yes
checking for sched.h... yes
checking mandatory system headers... yes
checking whether union semun is defined in sys/sem.h... no
checking for sysvipc shared memory support... yes
checking for mmap shared memory support... yes
checking for mmap on /dev/zero shared memory support... yes
checking for anonymous mmap shared memory support... yes
checking for posix mmap shared memory support... no
checking for best shared memory type... sysvipc
checking for spinlock semaphores support... yes
checking for pthread semaphores support... yes
checking for posix semaphores support... no
checking for sysvipc semaphores support... yes
checking for fcntl semaphores support... yes
checking for flock semaphores support... yes
checking for best semaphores type... spinlock
checking for a sed that does not truncate output... (cached) /bin/sed
checking for fgrep... /bin/grep -F
checking for ld used by cc... /usr/bin/ld
checking if the linker (/usr/bin/ld) is GNU ld... yes
checking for BSD- or MS-compatible name lister (nm)... /usr/bin/nm -B
checking the name lister (/usr/bin/nm -B) interface... BSD nm
checking whether ln -s works... yes
checking the maximum length of command line arguments... 1572864
checking whether the shell understands some XSI constructs... yes
checking whether the shell understands "+="... yes
checking for /usr/bin/ld option to reload object files... -r
checking for objdump... objdump
checking how to recognize dependent libraries... pass_all
checking for ar... ar
checking for strip... strip
checking for ranlib... ranlib
checking command to parse /usr/bin/nm -B output from cc object... ok
checking for dlfcn.h... yes
checking for objdir... .libs
checking if cc supports -fno-rtti -fno-exceptions... no
checking for cc option to produce PIC... -fPIC -DPIC
checking if cc PIC flag -fPIC -DPIC works... yes
checking if cc static flag -static works... yes
checking if cc supports -c -o file.o... yes
checking if cc supports -c -o file.o... (cached) yes
checking whether the cc linker (/usr/bin/ld) supports shared libraries... yes
checking whether -lc should be explicitly linked in... no
checking dynamic linker characteristics... GNU/Linux ld.so
checking how to hardcode library paths into programs... immediate
checking whether stripping libraries is possible... yes
checking if libtool supports shared libraries... yes
checking whether to build shared libraries... yes
checking whether to build static libraries... no
configure: creating ./config.status
config.status: creating config.h
config.status: executing libtool commands
- Contenido fichero "factura.php":
id;
}
/**
* Set numero
*
* @param string $numero
* @return Factura
*/
public function setNumero($numero)
{
$this->numero = $numero;
return $this;
}
/**
* Get numero
*
* @return string
*/
public function getNumero()
{
return $this->numero;
}
/**
* Set importe
*
* @param \float $importe
* @return Factura
*/
public function setImporte(\float $importe)
{
$this->importe = $importe;
return $this;
}
/**
* Get importe
*
* @return \float
*/
public function getImporte()
{
return $this->importe;
}
/**
* Set fecha
*
* @param \DateTime $fecha
* @return Factura
*/
public function setFecha($fecha)
{
$this->fecha = $fecha;
return $this;
}
/**
* Get fecha
*
* @return \DateTime
*/
public function getFecha()
{
return $this->fecha;
}
/**
* Set codigocliente
*
* @param integer $codigocliente
* @return Factura
*/
public function setCodigocliente($codigocliente)
{
$this->codigocliente = $codigocliente;
return $this;
}
/**
* Get codigocliente
*
* @return integer
*/
public function getCodigocliente()
{
return $this->codigocliente;
}
}
-
Resultado ejecución Doctrine para crear entidad Factura:
Welcome to the Doctrine2 entity generator
This command helps you generate Doctrine2 entities.
First, you need to give the entity name you want to generate.
You must use the shortcut notation like AcmeBlogBundle:Post.
The Entity shortcut name [AjpdSoftAcmeHolaMundoBundle:Factura]:
Determine the format to use for the mapping information.
Configuration format (yml, xml, php, or annotation) [annotation]:
Instead of starting with a blank entity, you can add some fields now.
Note that the primary key will be added automatically (named id).
Available types: array, simple_array, json_array, object,
boolean, integer, smallint, bigint, string, text, datetime, datetimetz,
date, time, decimal, float, blob, guid.
New field name (press to stop adding fields):
Do you want to generate an empty repository class [no]?
Summary before generation
You are going to generate a "AjpdSoftAcmeHolaMundoBundle:Factura" Doctrine2 entity
using the "annotation" format.
Do you confirm generation [yes]?
Entity generation
Generating the entity code: OK
You can now start using the generated code!
Artículos relacionados
Créditos
