|
Symfony: Mi primera aplicación web en PHP con acceso a MySQL usando Symfony 2
Explicamos en este tutorial cómo instalar el framework Symfony 2 en Linux Ubuntu Server. Mostramos cómo crear una primera aplicación web PHP con Symfony 2 y cómo acceder a base de datos MySQL Server. Explicamos paso a paso cómo crear bundle, controller, route y cómo insertar registros y listarlos con Doctrine.
SymfonySymfony 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 está desarrollado completamente en PHP 5.3. Symfony es compatible con la mayoría de gestores de bases de datos, como MySQL, PostgreSQL, Oracle y Microsoft SQL Server. Se puede ejecutar tanto en plataformas *nix (Unix, Linux, etc.) como en plataformas Windows. Symfony fue diseñado para ajustarse a los siguientes requisitos:
Las características más comunes para el desarrollo de proyectos web están automatizadas en symfony, tales como:
Requisitos para instalar Symfony 2 y crear proyecto PHP con acceso a base de datos MySQLPara 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 ServerSymfony 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 LinuxEn 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:
Instalar Composer en LinuxInstalaremos Composer con el comando linux:
Instalar Git en LinuxGit 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:
Para realizar una configuración básica de Git ejecutaremos los siguientes comandos (para especificar el nombre y mail del administrador):
Instalar Symfony 2 con ComposerPara instalar Symfony con Composer ejecutaremos el comando linux:
Si no hemos instalado Composer de forma global podremos ejecutar:
El comando anterior habrá creado la carpeta "symfony2" en /var/www: Ya podremos comprobar y ejecutar el asistente de configuración web de Symfony. Si queremos ejecutar el asistente de configuración web de Symfony2 desde cualquier equipo de la red tendremos que editar el fichero ".../symfony2/web/config.php" y comentar las líneas:
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 añadiendo:
/* 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:
El asistente de Symfony analizará los requisitos y nos mostrará los posibles problemas a subsanar, por ejemplo:
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:
Con los comandos linux:
Editaremos el fichero de configuración de PHP para añadir el parámetro "date.timezone" con el comando linux:
Añadiremos la línea (o la descomentaremos si ya existe comentada):
Modificaremos el parámetro (si existe) "short_open_tag" con el valor "Off" añadiendo o modificando la línea (si existe):
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:
Intalaremos también el paquete php-int con:
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:
Nos indicará si hemos solucionado los posibles problemas de configuración, cuando estén 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 continuación, introduciendo los datos de acceso (usuario, IP, contraseña, ...): 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 2A 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 2En 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:
Introduciremos los datos para el bundle:
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 2De forma predeterminada, el archivo de configuración de enrutamiento en una aplicación Symfony2 se encuentra en:
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:
Por URLs más legibles, amigables y óptimas para el posicionamiento SEO (Search Engine Optimization):
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.
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:
Para realizar las compilaciones en desarrollo se ejecutará la URL:
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 2Un 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:
En la carpeta:
Hemos editado el fichero del controlador con un editor de texto plano y hemos añadido 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 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 2Las 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:
Y se aloja en la carpeta:
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}} El ejemplo de salida de nuestra primera aplicación PHP con Symfony2, lo compilaremos abriendo un navegador y accediendo a la URL:
Acceso a base de datos MySQL con Symfony 2 utilizando DoctrinePara 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:
Y se llama:
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:
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 DoctrineA 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:
Ahora podremos comprobar que la base de datos ha sido creada desde la línea de comandos ejecutando:
Una vez conectados al servidor de MySQL ejecutaremos el siguiente comando para mostrar las bases de datos:
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 DoctrineTras 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:
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:
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:
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:
mostrando las tablas del catálogo con:
y mostrando los campos de la tabla "Factura" con:
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 DoctrineAhora 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:
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:
<?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 continuación explicamos algunas líneas del código:
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:
Y editaremos el fichero "routing.yml":
Añadiremos las siguientes líneas:
Para probar el resultado será suficiente con abrir un navegador web y acceder a la URL:
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:
Mostrar registros de tabla MySQL con Symfony y DoctrineA 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:
Crearemos el fichero de plantilla (template), para ello crearemos la carpeta para las plantillas del controlador "Facturas" con:
Accederemos a la carpeta para la plantilla y la crearemos con:
Añadiremos el siguiente código 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> Añadiremos la ruta en el fichero de rutas de nuestro proyecto Symfony2:
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áticamenteCuando 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:
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):
Los ficheros generados: Por último ejecutaremos los siguientes comandos Doctrine para crear los ficheros de entidades en nuestro proyecto Symfony2 con formato "annotation":
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:
AnexoInstalar PHP eAcceleratorSymfony 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:
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:
Una vez descargado lo descomprimimos con:
Accedemos a la carpeta descomprimida con:
Generaremos el fichero de configuración necesario para la compilación con:
Y:
Ejecutamos ahora:
Y:
Modificaremos el fichero de configuración de PHP, lo editaremos con:
Y añadiremos las siguientes líneas:
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:
Resultado ejecución comandos
Welcome!
<?php namespace AjpdSoft\AcmeHolaMundoBundle\Entity; use Doctrine\ORM\Mapping as ORM; /** * Factura * * @ORM\Table() * @ORM\Entity */ class Factura { /** * @var integer * * @ORM\Column(name="id", type="integer") * @ORM\Id * @ORM\GeneratedValue(strategy="AUTO") */ private $id; /** * @var string * * @ORM\Column(name="numero", type="string", length=20) */ private $numero; /** * @var float * * @ORM\Column(name="importe", type="float") */ private $importe; /** * @var \DateTime * * @ORM\Column(name="fecha", type="date") */ private $fecha; /** * @var integer * * @ORM\Column(name="codigocliente", type="integer") */ private $codigocliente; /** * Get id * * @return integer */ public function getId() { return $this->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; } }
Artículos relacionados
CréditosArtículo realizado íntegramente por Alonsojpd, miembro del Proyecto AjpdSoft. Nota: Revisado por Alonso J. el 01-05-2013. Anuncios
Enviado el Domingo, 21 abril a las 23:36:30 por ajpdsoft
|
|