Utilizamos cookies propias y de terceros. Al navegar entendemos que aceptas el uso de cookies. +Info.
Política de cookies
Proyecto AjpdSoft

· Inicio
· Buscar
· Contactar
· Cookies
· Descargas
· Foros
· Historia
· Nosotros
· Proponer
· Temas
· Top 10
· Trucos
· Tutoriales
· Usuario
· Wiki

Nick


Contraseña


Nuevo usuario


English

Symfony: Mi primera aplicación web en PHP con acceso a MySQL usando Symfony 2
Programación páginas web ASP, PHP, Java


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.



 

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 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:

  • 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 curl en Linux

 

Instalar Composer en Linux

Instalaremos Composer con el comando linux:

mkdir composer
cd composer

Instalar Composer en Linux

curl -sS http://getcomposer.org/installer | php

Instalar Composer en Linux

composer self-update

Instalar Composer en Linux

 

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

Instalar Git en Linux

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 Git en Linux

 

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.

Instalar Symfony 2 con Composer

El comando anterior habrá creado la carpeta "symfony2" en /var/www:

Instalar Symfony 2 con Composer

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:

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:

Instalar Symfony 2 con Composer

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

Con los comandos linux:

sudo chmod 777 /var/www/symfony2/app/cache

sudo chmod 777 /var/www/symfony2/app/cache

Instalar Symfony 2 con Composer

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

Instalar Symfony 2 con Composer

Añadiremos la línea (o la descomentaremos si ya existe comentada):

date.timezone = Europe/Madrid

(cambiaremos la zona por la correspondiente)

Instalar Symfony 2 con Composer

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:

Instalar Symfony 2 con Composer

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

services apache2 restart

( también con sudo /etc/init.d/apache2 restart)

Instalar Symfony 2 con Composer

Intalaremos también el paquete php-int con:

sudo apt-get install php5-int

Instalar Symfony 2 con Composer

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":

Instalar Symfony 2 con Composer

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, ...):

Instalar Symfony 2 con Composer

Estableremos el Secreto Global (Global Secret):

Instalar Symfony 2 con Composer

El asistente nos indicará que Symfony 2 ya está configurado:

Instalar Symfony 2 con Composer

Y ya tendremos configurado Symfony 2 en nuestro equipo:

Instalar Symfony 2 con Composer

 

 

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

Primera aplicación web PHP con Symfony 2

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.:

Primera aplicación web PHP con Symfony 2

El asistente habrá creado la estructura de carpetas que compone el proyecto Symfony2:

Primera aplicación web PHP con Symfony 2

 

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 }


Route (ruta) en Symfony 2

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:

<?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);
    }
}

Controller (controlador) en Symfony 2

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":

<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}}

Template (plantilla) en Symfony 2

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)

Ejemplo de salida de proyecto symfony 2

 

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

Acceso a base de datos MySQL con Symfony 2

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)

Acceso a base de datos MySQL con Symfony 2 utilizando Doctrine

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;

Acceso a base de datos MySQL con Symfony 2 utilizando Doctrine

Entre las bases de datos deberá aparecer la indicada en el parámetro database_name, en nuestro caso "symfony":

Acceso a base de datos MySQL con Symfony 2 utilizando Doctrine

 

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:

Acceso a base de datos MySQL con Symfony 2 utilizando Doctrine

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":

Acceso a base de datos MySQL con Symfony 2 utilizando Doctrine

Con "cat Factura.php" podremos consultar su contenido. Por supuesto podremos modificar este fichero añadiendo o eliminando métodos:

Acceso a base de datos MySQL con Symfony 2 utilizando Doctrine

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

Acceso a base de datos MySQL con Symfony 2 utilizando Doctrine

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;

Acceso a base de datos MySQL con Symfony 2 utilizando Doctrine

Podremos consultar también la tabla creada desde MySQL Administrator o cualquier otro cliente con acceso a MySQL:

Acceso a base de datos MySQL con Symfony 2 utilizando Doctrine

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

Acceso a base de datos MySQL con Symfony 2 utilizando Doctrine

(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:

Acceso a base de datos MySQL con Symfony 2 utilizando Doctrine

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:

  • 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

Acceso a base de datos MySQL con Symfony 2 utilizando Doctrine

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")

Acceso a base de datos MySQL con Symfony 2 utilizando Doctrine

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":

Acceso a base de datos MySQL con Symfony 2 utilizando Doctrine

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;

Acceso a base de datos MySQL con Symfony 2 utilizando Doctrine

 

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));
}

 

Mostrar registros de tabla MySQL con Symfony y Doctrine

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

Mostrar registros de tabla MySQL con Symfony y Doctrine

Accederemos a la carpeta para la plantilla y la crearemos con:

nano listaFacturas.html.twig

Mostrar registros de tabla MySQL con Symfony y Doctrine

Añadiremos el siguiente código HTML para mostrar el array de facturas obtenido desde el Controller:

Mostrar registros de tabla MySQL con Symfony y Doctrine

<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:

Mostrar registros de tabla MySQL con Symfony y Doctrine


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:

Mostrar registros de tabla 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:

Actualizar identidades de Symfony con Doctrine automáticamente

Modificaremos también la tabla "Factura" añadiendo algún campo:

Actualizar identidades de Symfony con Doctrine automáticamente

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)

Actualizar identidades de Symfony con Doctrine automáticamente

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:

Actualizar identidades de Symfony con Doctrine automáticamente

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)

Actualizar identidades de Symfony con Doctrine automáticamente

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:

Actualizar identidades de Symfony con Doctrine automáticamente

Abrá añadido todos los métodos get y set para cada campo de cada tabla de la base de datos:

Actualizar identidades de Symfony con Doctrine automáticamente

 

 

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

Instalar PHP eAccelerator

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

Instalar PHP eAccelerator

Accedemos a la carpeta descomprimida con:

cd eacceleraton-eaccelerator-42067ac

Generaremos el fichero de configuración necesario para la compilación con:

phpize

Instalar PHP eAccelerator

Y:

./configure --enable-eaccelerator=shared --with-php-config=/usr/bin/php-config

Instalar PHP eAccelerator

Ejecutamos ahora:

make

Instalar PHP eAccelerator

Y:

make install

Instalar PHP eAccelerator

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:

Instalar PHP eAccelerator

Para activar PHP eAccelerator deberemos reiniciar el servicio de Apache, podemos hacerlo con el comando linux:

sudo service apache2 restart

Instalar PHP eAccelerator

 

 

Resultado ejecución comandos

  • Resultado ejecución comando:

    php composer.phar create-project symfony/framework-standard-edition path/to/install

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:

  1. Change the permissions of the "app/cache/" directory so that the web server can write into it.
  2. Change the permissions of the "app/logs/" directory so that the web server can write into it.
  3. 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:

  1. Install PHP 5.3.8 or newer if your project uses annotations.
  2. Install and enable the intl extension (used for validators).
  3. Install and enable a PHP accelerator like APC (highly recommended).
  4. 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":
<?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;
    }
}


  • 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 <return> 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

Artículo realizado íntegramente por Alonsojpd, miembro del Proyecto AjpdSoft.

Artículo en inglés.



Nota:

Revisado por Alonso J. el 01-05-2013.

Anuncios


Enviado el Domingo, 21 abril a las 23:36:30 por ajpdsoft
Este sitio web NO CONTIENE malware, todos los programas con código fuente aquí. Autor: Alonso Javier Pérez Díaz Google+ Síguenos en Google+