Symfony La Guia Definitiva

425 Pages·3.141 MB·Spanish

by  Potencier Fabien

www.librosweb.es

Symfony
la guía definitiva

Fabien Potencier, François Zaninotto
Symfony 1.2, la guía definitiva
Sobre este libro...
▪ Los contenidos de este libro están bajo una licencia Creative Commons Reconocimiento -
No Comercial - Sin Obra Derivada 3.0 (http://creativecommons.org/licenses/by-nc-nd/
3.0/deed.es)
▪ Esta versión impresa se creó el 30 de diciembre de 2008 y todavía está incompleta.
La versión más actualizada de los contenidos de este libro se puede encontrar en
http://www.librosweb.es/symfony_1_2
▪ Si quieres aportar sugerencias, comentarios, críticas o informar sobre errores, puedes
enviarnos un mensaje [email protected]
www.librosweb.es 2
Symfony 1.2, la guía definitiva
Capítulo 1. Introducción a Symfony............................................................................................................7
1.1. Symfony en pocas palabras.....................................................................................................................7
1.2. Conceptos básicos.................................................................................................................................11
1.3. Resumen................................................................................................................................................17
Capítulo 2. Explorando el interior de Symfony...........................................................................................18
2.1. El patrón MVC........................................................................................................................................18
2.2. Organización del código........................................................................................................................29
2.3. Herramientas comunes.........................................................................................................................34
2.4. Resumen................................................................................................................................................37
Capítulo 3. Ejecutar aplicaciones Symfony.................................................................................................38
3.1. Instalando el entorno de pruebas.........................................................................................................38
3.2. Instalando las librerías de Symfony.......................................................................................................40
3.3. Crear una aplicación web......................................................................................................................42
3.4. Configurar el servidor web....................................................................................................................44
3.5. Resolución de problemas......................................................................................................................47
3.6. Versionado del código fuente................................................................................................................48
3.7. Resumen................................................................................................................................................50
Capítulo 4. Introducción a la creación de páginas......................................................................................51
4.1. Crear el esqueleto del módulo..............................................................................................................51
4.2. Enlazando a otra acción.........................................................................................................................56
4.3. Obteniendo información de la petición.................................................................................................58
4.4. Resumen................................................................................................................................................59
Capítulo 5. Configurar Symfony.................................................................................................................61
5.1. El sistema de configuración...................................................................................................................61
5.2. Un vistazo general a los archivos de configuración...............................................................................66
5.3. Entornos................................................................................................................................................71
5.4. La cache de configuración.....................................................................................................................75
5.5. Accediendo a la configuración desde la aplicación...............................................................................76
5.6. Trucos para los archivos de configuración.............................................................................................79
5.7. Resumen................................................................................................................................................81
Capítulo 6. El Controlador.........................................................................................................................82
6.1. El Controlador Frontal...........................................................................................................................82
6.2. Acciones.................................................................................................................................................84
6.3. Accediendo a la petición........................................................................................................................92
6.4. Sesiones de Usuario...............................................................................................................................93
6.5. Seguridad de la Acción...........................................................................................................................97
6.6. Métodos de Validación y Manejo de Errores......................................................................................101
6.7. Filtros...................................................................................................................................................103
6.8. Configuración del Módulo...................................................................................................................109
6.9. Resumen..............................................................................................................................................109
Capítulo 7. La Vista..................................................................................................................................111
7.1. Plantillas..............................................................................................................................................111
www.librosweb.es 3
Symfony 1.2, la guía definitiva
7.2. Fragmentos de código.........................................................................................................................117
7.3. Configuración de la vista.....................................................................................................................124
7.4. Slots de componentes.........................................................................................................................133
7.5. Mecanismo de escape.........................................................................................................................135
7.6. Resumen..............................................................................................................................................139
Capítulo 8. El modelo..............................................................................................................................140
8.1. ¿Por qué utilizar un ORM y una capa de abstracción?........................................................................140
8.2. Esquema de base de datos de Symfony..............................................................................................142
8.3. Las clases del modelo..........................................................................................................................144
8.4. Acceso a los datos................................................................................................................................146
8.5. Conexiones con la base de datos.........................................................................................................154
8.6. Extender el modelo.............................................................................................................................156
8.7. Sintaxis extendida del esquema..........................................................................................................159
8.8. No crees el modelo dos veces.............................................................................................................165
8.9. Resumen..............................................................................................................................................167
Capítulo 9. Enlaces y sistema de enrutamiento........................................................................................169
9.1. ¿Qué es el enrutamiento?...................................................................................................................169
9.2. Reescritura de URL..............................................................................................................................173
9.3. Helpers de enlaces...............................................................................................................................175
9.4. Configuración del sistema de enrutamiento.......................................................................................180
9.5. Trabajando con rutas en las acciones..................................................................................................187
9.6. Resumen..............................................................................................................................................188
Capítulo 10. Formularios.........................................................................................................................189
10.1. Helpers de formularios......................................................................................................................189
10.2. Helpers de formularios para objetos.................................................................................................197
10.3. Validación de formularios..................................................................................................................201
10.4. Validaciones complejas.....................................................................................................................213
10.5. Resumen............................................................................................................................................217
Capítulo 11. Integración con Ajax............................................................................................................218
11.1. Helpers básicos de JavaScript............................................................................................................218
11.2. Prototype...........................................................................................................................................221
11.3. Helpers de Ajax..................................................................................................................................223
11.4. Parámetros para la ejecución remota...............................................................................................228
11.5. Creando efectos visuales...................................................................................................................232
11.6. JSON...................................................................................................................................................233
11.7. Interacciones complejas con Ajax......................................................................................................235
11.8. Resumen............................................................................................................................................240
Capítulo 12. Uso de la cache....................................................................................................................241
12.1. Guardando la respuesta en la cache..................................................................................................241
12.2. Eliminando elementos de la cache....................................................................................................250
12.3. Probando y monitorizando la cache..................................................................................................254
12.4. HTTP 1.1 y la cache del lado del cliente.............................................................................................256
www.librosweb.es 4
Symfony 1.2, la guía definitiva
12.5. Resumen............................................................................................................................................259
Capítulo 13. Internacionalización y localización.......................................................................................260
13.1. Cultura del usuario............................................................................................................................260
13.2. Estándares y formatos.......................................................................................................................263
13.3. Información textual en la base de datos...........................................................................................265
13.4. Traducción de la interfaz...................................................................................................................267
13.5. Resumen............................................................................................................................................273
Capítulo 14. Generador de la parte de administración.............................................................................274
14.1. Generación de código en función del modelo...................................................................................274
14.2. Creando la parte de administración de las aplicaciones...................................................................275
14.3. Configuración del generador.............................................................................................................280
14.4. Modificando el aspecto de los módulos generados..........................................................................299
14.5. Resumen............................................................................................................................................303
Capítulo 15. Pruebas unitarias y funcionales...........................................................................................304
15.1. Automatización de pruebas...............................................................................................................304
15.2. Pruebas unitarias...............................................................................................................................307
15.3. Pruebas funcionales...........................................................................................................................315
15.4. Recomendaciones sobre el nombre de las pruebas..........................................................................324
15.5. Otras utilidades para pruebas...........................................................................................................325
15.6. Resumen............................................................................................................................................330
Capítulo 16. Herramientas para la administración de aplicaciones..........................................................331
16.1. Logs....................................................................................................................................................331
16.2. Depuración de aplicaciones...............................................................................................................335
16.3. Utilizando Symfony fuera de la web..................................................................................................344
16.4. Cargando datos en una base de datos...............................................................................................347
16.5. Instalando aplicaciones.....................................................................................................................350
16.6. Resumen............................................................................................................................................355
Capítulo 17. Personalizar Symfony..........................................................................................................356
17.1. Eventos..............................................................................................................................................356
17.2. Factorías............................................................................................................................................364
17.3. Integrando componentes de otros frameworks................................................................................367
17.4. Plugins...............................................................................................................................................369
17.5. Resumen............................................................................................................................................385
Capítulo 18. Rendimiento........................................................................................................................387
18.1. Optimizando el servidor....................................................................................................................387
18.2. Optimizando el modelo.....................................................................................................................388
18.3. Optimizando la vista..........................................................................................................................396
18.4. Optimizando la cache........................................................................................................................398
18.5. Desactivando las características que no se utilizan...........................................................................403
18.6. Optimizando el código fuente...........................................................................................................404
18.7. Resumen............................................................................................................................................406
Capítulo 19. Configuración avanzada.......................................................................................................407
www.librosweb.es 5
Symfony 1.2, la guía definitiva
19.1. Opciones de Symfony........................................................................................................................407
19.2. Extendiendo la carga automática de clases.......................................................................................415
19.3. Estructura de archivos propia............................................................................................................418
19.4. Comprendiendo el funcionamiento de los manejadores de configuración......................................421
19.5. Resumen............................................................................................................................................425
www.librosweb.es 6
Symfony 1.2, la guía definitiva Capítulo 1. Introducción a Symfony
Capítulo 1. Introducción a Symfony
¿Qué puedes hacer con Symfony? ¿Qué necesitas para utilizarlo? Este capítulo responde a todas
estas preguntas.
1.1. Symfony en pocas palabras
Unframework simplifica eldesarrollo deunaaplicación mediante laautomatización dealgunos
delospatronesutilizadospararesolverlastareascomunes.Además,unframeworkproporciona
estructura al código fuente, forzando al desarrollador a crear código más legible y más fácil de
mantener. Por último, un framework facilita la programación de aplicaciones, ya que encapsula
operaciones complejas en instrucciones sencillas.
Symfony es un completo framework diseñado para optimizar, gracias a sus características, el
desarrollo de las aplicaciones web. 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. El resultado de todas estas ventajas es que no se debe
reinventar la rueda cada vez que se crea una nueva aplicación web.
SymfonyestádesarrolladocompletamenteconPHP5.Hasidoprobadoennumerososproyectos
realesyseutilizaensitioswebdecomercioelectrónicodeprimernivel.Symfonyescompatible
conlamayoríadegestoresdebasesdedatos,comoMySQL,PostgreSQL,OracleySQLServerde
Microsoft. Se puede ejecutar tanto en plataformas *nix (Unix, Linux, etc.) como en plataformas
Windows. A continuación se muestran algunas de sus características.
1.1.1. Características de Symfony
Symfony se diseñó para que se ajustara 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 y *nix estándares)
▪ Independiente del sistema gestor de bases de datos
▪ Sencillo de usar en la mayoría de casos, pero lo suficientemente flexible como para
adaptarse a los casos más complejos
▪ Basado en la premisa de"convenir en vez de configurar", en la que el desarrollador solo
debe configurar aquello que no es convencional
▪ Sigue la mayoría demejores prácticasy 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
www.librosweb.es 7
Symfony 1.2, la guía definitiva Capítulo 1. Introducción a Symfony
▪ 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 librerías desarrolladas por terceros
1.1.1.1. Automatización de características de proyectos web
Symfony automatiza la mayoría de elementos comunes de los proyectos web, como por ejemplo:
▪ La capa de internacionalización que incluye Symfony permite la traducción de los datos y
de la interfaz, así como la adaptación local de los contenidos.
▪ La capa de presentación utiliza plantillas ylayoutsque pueden ser creados por
diseñadoresHTMLsin ningún tipo de conocimiento del framework. Loshelpersincluidos
permiten minimizar el código utilizado en la presentación, ya que encapsulan grandes
bloques de código en llamadas simples a funciones.
▪ Los formularios incluyen validación automatizada y relleno automático de datos
("repopulation"), lo que asegura la obtención de datos correctos y mejora la experiencia de
usuario.
▪ Los datos incluyen mecanismos de escape que permiten una mejor protección contra los
ataques producidos por datos corruptos.
▪ La gestión de la caché reduce el ancho de banda utilizado y la carga del servidor.
▪ La autenticación y la gestión de credenciales simplifican la creación de secciones
restringidas y la gestión de la seguridad de usuario.
▪ El sistema de enrutamiento y lasURLlimpiaspermiten considerar a las direcciones de las
páginas como parte de la interfaz, además de estar optimizadas para los buscadores.
▪ El soporte de e-mail incluido y la gestión de APIs permiten a las aplicaciones web
interactuar más allá de los navegadores.
▪ Los listados son más fáciles de utilizar debido a la paginación automatizada, el filtrado y la
ordenación de datos.
▪ Los plugins, las factorías (patrón de diseño"Factory") y los"mixin"permiten realizar
extensiones a medida de Symfony.
▪ Las interacciones con Ajax son muy fáciles de implementar mediante loshelpersque
permiten encapsular los efectos JavaScript compatibles con todos los navegadores en una
única línea de código.
1.1.1.2. Entorno de desarrollo y herramientas
Symfony puede ser completamente personalizado para cumplir con los requisitos de las
empresas que disponen de sus propias políticas y reglas para la gestión de proyectos y la
programación de aplicaciones. Por defecto incorpora varios entornos de desarrollo diferentes e
incluye varias herramientas que permiten automatizar las tareas más comunes de la ingeniería
del software:
www.librosweb.es 8
Symfony 1.2, la guía definitiva Capítulo 1. Introducción a Symfony
▪ Las herramientas que generan automáticamente código han sido diseñadas para hacer
prototipos de aplicaciones y para crear fácilmente la parte de gestión de las aplicaciones.
▪ El framework de desarrollo de pruebas unitarias y funcionales proporciona las
herramientas ideales para el desarrollo basado en pruebas ("test-driven development").
▪ La barra de depuración web simplifica la depuración de las aplicaciones, ya que muestra
toda la información que los programadores necesitan sobre la página en la que están
trabajando.
▪ La interfaz de línea de comandos automatiza la instalación de las aplicaciones entre
servidores.
▪ Es posible realizar cambios"en caliente"de la configuración (sin necesidad de reiniciar el
servidor).
▪ El completo sistema de log permite a los administradores acceder hasta el último detalle
de las actividades que realiza la aplicación.
1.1.2. ¿Quién ha desarrollado Symfony y por qué motivo?
La primera versión de Symfony fue publicada en Octubre de 2005 por Fabien Potencier,
fundador del proyecto y coautor de este libro. Fabien es el presidente de Sensio
(http://www.sensio.com/), una empresa francesa de desarrollo de aplicaciones web conocida
por sus innovaciones en este campo.
En el año 2003, Fabien realizó una investigación sobre las herramientas de software libre
disponibles para el desarrollo de aplicaciones web con PHP. Fabien llegó a la conclusión de que
noexistíaningunaherramientaconesascaracterísticas.Despuésdellanzamientodelaversión5
de PHP, decidió que las herramientas disponibles habían alcanzado un grado de madurez
suficiente comoparaintegrarlas enunframework completo. Fabien empleó unañoentero para
desarrollar el núcleo de Symfony, basando su trabajo en el framework Mojavi (que también era
un framework que seguía el funcionamiento MVC), en la herramienta Propel para el mapeo de
objetos a bases de datos (conocido como ORM, de "object-relational mapping") y en los helpers
empleados por Ruby on Rails en sus plantillas.
Fabien desarrolló originalmente Symfony para utilizarlo en los proyectos de Sensio, ya que
disponerdeunframeworkefectivoeslamejorayudaparaeldesarrolloeficienteyrápidodelas
aplicaciones. Además, el desarrollo web se hace más intuitivo y las aplicaciones resultantes son
másrobustasymásfácilesdemantener.Elframeworkseutilizóporprimeravezeneldesarrollo
deunsitiodecomercioelectrónicoparaunvendedordelenceríayposteriormente seutilizóen
otros proyectos.
DespuésdeutilizarSymfonyenalgunosproyectos,Fabiendecidiópublicarlobajounalicenciade
softwarelibre.Susrazonesparaliberarelproyectofueronparadonarsutrabajoalacomunidad,
aprovechar la respuesta de los usuarios, mostrar la experiencia de Sensio y porque considera
que es divertido hacerlo.
Nota¿Por qué lo llamaron"Symfony"y no"CualquierNombreFramework"? Porque Fabien quería
una nombre corto que tuviera una letra 's' (de Sensio) y una letra 'f' (de framework), que fuera
www.librosweb.es 9
Symfony 1.2, la guía definitiva Capítulo 1. Introducción a Symfony
fácil de recordar y que no estuviera asociado a otra herramienta de desarrollo. Además, no le
gustan las mayúsculas. "Symfony" era muy parecido a lo que estaba buscando, aunque no es una
palabra correcta en el idioma inglés (la palabra correcta es"symphony"), y además estaba libre
como nombre de proyecto. La otra alternativa era"baguette".
Para que Symfony fuera un proyecto de software libre exitoso, debía tener una documentación
amplia y en inglés, para aumentar la incorporación de usuarios al proyecto. Fabien pidió a su
compañerodetrabajoFrançoisZaninotto,elotrocoautordeestelibro,queinvestigaraelcódigo
fuente del programa y escribiera un libro sobre Symfony. Aunque el proceso fue arduo, cuando
el proyecto se lanzó públicamente, la documentación era suficiente como para atraer a muchos
desarrolladores. El resto es historia.
1.1.3. La comunidad Symfony
En cuanto se abrió al público el sitio web de Symfony (http://www.symfony-project.org/)
muchos desarrolladores de todo el mundo se descargaron e instalaron el framework,
comenzaron a leer la documentación y construyeron sus primeras aplicaciones con Symfony,
aumentando poco a poco la popularidad de Symfony.
En ese momento, los frameworks para el desarrollo de aplicaciones web estaban en pleno
apogeo, y era muy necesario disponer de un completo framework realizado con PHP. Symfony
proporcionaba unasoluciónirresistible aesacarencia,debidoalacalidaddesucódigofuentey
a la gran cantidad de documentación disponible, dos ventajas muy importantes sobre otros
frameworks disponibles. Los colaboradores aparecieron en seguida proponiendo parches y
mejoras, detectando los errores de la documentación y realizando otras tareas muy importantes.
El repositorio público de código fuente y el sistema de notificación de errores y mejoras
mediante tickets permite varias formas de contribuir al proyecto y todos los voluntarios son
bienvenidos.Fabiencontinuasiendoelmayorcontribuidordecódigoalrepositorioyseencarga
de garantizar la calidad del código.
Actualmente, el foro de Symfony, las listas de correo y el IRC ofrecen otras alternativas válidas
para el soporte del framework, con el que cada pregunta suele obtener una media de 4
respuestas. Cada día nuevos usuarios instalan Symfony y el wiki y la sección de fragmentos de
códigoalmacenanunagrancantidaddedocumentacióngeneradaporlosusuarios.Cadasemana
el número de aplicaciones conocidas desarrolladas con Symfony se incrementa en 5 y el
aumento continua.
La comunidad Symfony es el tercer pilar del framework y esperamos que tu también te unas a
ella después de leer este libro.
1.1.4. ¿Es adecuado Symfony para mí?
Independientemente de que seas un experto programador de PHP 5 o un principiante en el
desarrollo de aplicaciones web, podrás utilizar Symfony de forma sencilla. El principal
argumento para decidir si deberías o no utilizar Symfony es el tamaño del proyecto.
Situproyectoconsisteendesarrollarunsitiowebsencillocon5o10páginasdiferentes,acceso
simpleabasesdedatosynoesimportanteasegurarungranrendimientoounadocumentación
www.librosweb.es 10