Libro Symfony2.4

8/11/2019 Libro Symfony2.4

1/102

Captulo 1.Symfony2 y los fundamentos deHTTPEnhorabuena! Aprender a programar con Symfony2es una de las mejores formas

de convertirse en un programador web ms productivo, completo y popular(bueno, esto ltimo en realidad depende de t). Symfony2 est diseado para

volver a lo bsico: herramientas de desarrollo que te permiten programar ms

rpido y construir aplicaciones ms robustas, y que afectan lo mnimo a tu forma

de trabajar.

Symfony est basado en las mejores ideas de muchas tecnologas: las

herramientas y conceptos que ests a punto de aprender representan el esfuerzo

de miles de personas, durante muchos aos. En otras palabras, no ests

aprendiendo "Symfony", ests aprendiendo los fundamentos de la web, buenasprcticas de desarrollo, y cmo utilizar algunas de las mejores libreras PHP

publicadas recientemente. Por lo tanto, preprate!

Fiel a la filosofa Symfony2, este captulo comienza explicando el concepto

fundamental comn para el desarrollo web: HTTP. No importa cul sea tu

experiencia previa o cules sean tus lenguajes de programacin favoritos, este

captulo es una lectura obligadapara todo el mundo.

1.1.HTTP es simpleHTTP ("HyperText Transfer Protocol") es un lenguaje basado en texto que permite

a dos mquinas comunicarse entre s. Eso es todo! La siguiente conversacines

la que por ejemplo tiene lugar cuando quieres acceder a la ltima tira cmica

publicada por el sitioxkcd:
http://xkcd.com/http://xkcd.com/http://xkcd.com/http://xkcd.com/


2/102

Figura 1.1Flujo HTTP para obtener la tira cmica ms reciente de Xkcd

Y aunque el lenguaje realmente utilizado es un poco ms formal, sigue siendo

bastante simple.

HTTP es el trmino utilizado para describir este lenguaje simple basado en texto.

Y no importa cmo desarrolles en la web, el objetivo de tu servidor siempre es

entender las peticiones de texto simple, y devolver respuestas en texto simple.

Symfony2 est diseado en base a esa realidad. Aunque a veces no te des

cuenta, HTTP es algo que usas todos los das. Con Symfony2, aprenders a

dominarlo.

1.1.1. Paso 1: El cliente enva una peticin

Todas las conversaciones en la web comienzan con una peticin. La peticin es

un mensaje de texto creado por un cliente (por ejemplo un navegador, una

aplicacin para el iPhone, etc.) en un formato especial conocido como HTTP. El

cliente enva la peticin a un servidor, y luego espera la respuesta.

Echa un vistazo a la primera parte de la interaccin (la peticin) entre unnavegador y el servidor web del sitio xkcd:


3/102

Figura 1.2Peticin HTTP para obtener la tira cmica ms reciente de Xkcd

Utilizando el lenguaje HTTP, esta peticin en realidad sera algo parecido a lo

siguiente:

GET / HTTP/1.1

Host: xkcd.com

Accept: text/html

User-Agent: Mozilla/5.0 (Macintosh)

Este sencillo mensaje comunica todo lo necesario sobre qu recursos

exactamente solicita el cliente. La primera lnea de una peticin HTTP es la ms

importante y contiene dos cosas: la URI y el mtodo HTTP.

La URI (por ejemplo, /, /contacto, etc.) es la direccin o ubicacin que identifica

unvocamente al recurso que solicita el cliente. El mtodo HTTP (por ejemplo, GET)

define lo que quieres hacer con el recurso. Los mtodos HTTP son los verbosde

la peticin y definen las pocas formas en que puedes actuar sobre el recurso:

Mtodo Accin

GET Recupera el recurso desde el servidor

POST Crea un recurso en el servidor


4/102

Mtodo Accin

PUT Actualiza el recurso en el servidor

DELETE Elimina el recurso del servidor

Teniendo esto en cuenta, puedes imaginar cmo sera por ejemplo la peticin

HTTP necesaria para borar un artculo especfico de un blog:

DELETE /blog/15 HTTP/1.1

NOTAEn realidad, hay nueve mtodos HTTP definidos por la especificacin HTTP,pero muchos de ellos no se utilizan o no estn soportados. De hecho, muchos

navegadores modernos no soportan los mtodos PUTy DELETE.

Adems de la primera lnea, una peticin HTTP contiene tambin otras lneas de

informacin conocidas como cabeceras de peticin. Las cabeceras proporcionan

mucha informacin, como el servidor (o host) solicitado, los formatos de respuesta

que acepta el cliente (Accept) y la aplicacin que utiliza el cliente para realizar la

peticin (User-Agent). Existen muchas otras cabeceras y se pueden encontrar en

el artculoLista de campos de las cabeceras HTTPen la Wikipedia.

1.1.2. Paso 2: El servidor devuelve una respuesta

Una vez que un servidor ha recibido la peticin, sabe exactamente qu recursos

necesita el cliente (a travs de la URI) y lo que el cliente quiere hacer con ese

recurso (a travs del mtodo). Por ejemplo, en el caso de una peticin GET, el

servidor prepara el recurso y lo devuelve en una respuesta HTTP. Considera la

respuesta del servidor web del sitio xkcd:
http://en.wikipedia.org/wiki/List_of_HTTP_header_fieldshttp://en.wikipedia.org/wiki/List_of_HTTP_header_fieldshttp://en.wikipedia.org/wiki/List_of_HTTP_header_fieldshttp://en.wikipedia.org/wiki/List_of_HTTP_header_fields


5/102

Figura 1.3Respuesta HTTP para obtener la tira cmica ms reciente de Xkcd

Traducida a HTTP, la respuesta enviada de vuelta al navegador es similar a lo

siguiente:

HTTP/1.1 200 OK

Date: Sat, 02 Apr 2011 21:05:05 GMT

Server: lighttpd/1.4.19

Content-Type: text/html

La respuesta HTTP contiene el recurso solicitado (en este caso, el contenido

HTML de una pgina web), as como otra informacin acerca de la respuesta. La

primera lnea es especialmente importante y contiene el cdigo de estado HTTP

(200en este caso) de la respuesta. El cdigo de estado indica el resultado globalde la peticin devuelta al cliente. Tuvo xito la peticin? Hubo algn error?

Existen diferentes cdigos de estado que indican xito, error o qu ms se

necesita hacer con el cliente (por ejemplo, redirigirlo a otra pgina). La lista

completa se puede encontrar en el artculoLista de cdigos de estado HTTPen la

Wikipedia.
http://es.wikipedia.org/wiki/Anexo:C%C3%B3digos_de_estado_HTTPhttp://es.wikipedia.org/wiki/Anexo:C%C3%B3digos_de_estado_HTTPhttp://es.wikipedia.org/wiki/Anexo:C%C3%B3digos_de_estado_HTTPhttp://es.wikipedia.org/wiki/Anexo:C%C3%B3digos_de_estado_HTTP


6/102

Al igual que la peticin, una respuesta HTTP contiene datos adicionales conocidos

como cabeceras HTTP. Por ejemplo, una cabecera importante de la respuesta

HTTP es Content-Type. Un mismo recurso se puede devolver en varios formatos

diferentes (HTML, XML, JSON, etc.) y la cabeceraContent-Typedice al cliente qu

formato se ha utilizado (para ello utiliza valores estndar comotext/htmlque seconocen como Internet Media Types). Puedes encontrar la lista completa de tipos

de contenido en el artculoLista de tipos de contenido de Interneten la Wikipedia.

Existen muchas otras cabeceras, algunas de las cuales son muy importantes. Por

ejemplo, ciertas cabeceras se pueden usar para crear un sistema de memoria

cach bastante interesante.

1.1.3. Peticiones, respuestas y desarrollo web

Esta conversacin peticin-respuesta es el proceso fundamental en el que se basa

toda la comunicacin en la web. Y a pesar de ser tan importante y poderoso, al

mismo tiempo es muy sencillo.

El concepto ms importante es el siguiente: independientemente del lenguaje que

utilices, el tipo de aplicacin que construyas (web, mvil, API), o la filosofa de

desarrollo que sigas, el objetivo final de una aplicacin siempre es entender cada

peticin y crear y devolver la respuesta adecuada.

Symfony est diseado para adaptarse a esta realidad.

TRUCOPuedes obtener ms informacin acerca de la especificacin HTTP, en la

referencia originalHTTP 1.1 RFC.Tambin puedes leer la referenciaHTTP Bis,

que es una versin actualizada y ms detallada de la referencia anterior. Una gran

herramienta para comprobar tanto la peticin como las cabeceras de la respuesta

mientras navegas es la extensinLive HTTP Headersde Firefox o elInspector

Webde los navegadores Chrome y Safari.

1.2.Peticiones y respuestas en PHPCmo interactas con la "peticin" y creas una "respuesta" utilizando PHP? En

realidad, PHP te abstrae un poco de todo el proceso:


7/102

$foo=$_GET['foo'];

header('Content-type: text/html');

echo'La URI solicitada es: '.$uri;

echo'El valor del parmetro "foo" es: '.$foo;

Por extrao que parezca, esta pequea aplicacin est obteniendo informacin de

la peticin HTTP y la utiliza para crear una respuesta HTTP. En lugar de analizar

el mensaje HTTP de la peticin, PHP crea variables

superglobalescomo $_SERVERy $_GETque contienen toda la informacin de la

peticin. Del mismo modo, en lugar de devolver la respuesta HTTP con formato de

texto, puedes usar la funcin header()para crear las cabeceras de la respuesta y

simplemente imprimir el contenido que se enviar en el mensaje de la respuesta.Despus PHP crea la verdadera respuesta HTTP que se devuelve al cliente:

HTTP/1.1 200 OK

Date: Sat, 03 Apr 2011 02:14:33 GMT

Server: Apache/2.2.17 (Unix)

Content-Type: text/html

La URI solicitada es: /testing?foo=symfony

El valor del parmetro "foo" es: symfony

1.3.Peticiones y respuestas en SymfonySymfony ofrece una alternativa al enfoque de PHP a travs de dos clases que te

permiten interactuar con la peticin HTTP y la respuesta de una manera ms fcil.

La clase Requestrepresenta la peticin HTTP siguiendo la filosofa de orientacin

a objetos. Con ella, tienes toda la informacin a tu alcance:

useSymfony\Component\HttpFoundation\Request;

$request=Request::createFromGlobals();


8/102

// la URI solicitada (p.e. /contacto) menos algunos parmetros de la consulta

$request->getPathInfo();

// recupera las variables GET y POST respectivamente

$request->query->get('foo');

$request->request->get('bar','valor utilizado si "bar" no existe');

// recupera las variables de SERVER

$request->server->get('HTTP_HOST');

// recupera una instancia del archivo subido identificado por 'foo'

$request->files->get('foo');

// recupera un valor de una COOKIE

$request->cookies->get('PHPSESSID');

// recupera una cabecera HTTP de la peticin, normalizada, con ndices en minscula

$request->headers->get('host');

$request->headers->get('content_type');

$request->getMethod(); // GET, POST, PUT, DELETE, HEAD

$request->getLanguages(); // un array de idiomas aceptados por el cliente

Una ventaja aadida es que la clase Requesthace un montn de trabajo adicional

del que no tienes que preocuparte. Por ejemplo, el

mtodo isSecure()internamente comprueba tres valores PHP diferentes que

pueden indicar si el usuario est conectado a travs de una conexin segura (es

decir,https).


9/102

ParameterBagsy atributos de la peticinComo vimos anteriormente, lasvariables $_GETy $_POSTson accesibles a travs de las

propiedadesqueryy requestde la clase Request, respectivamente. Cada uno de

estos objetos es un objeto de la clase ParameterBag, la cual cuenta con mtodos

cmo get(), has()y all()entre otros.De hecho, todas las propiedades pblicas utilizadas en el cdigo del ejemplo

anterior son un ejemplo del ParameterBag.

La clase Requesttambin tiene una propiedad pblica attributes, que almacena

informacin especial relacionada sobre el funcionamiento interno de la aplicacin.

En Symfony2, la propiedadattibutesguarda por ejemplo los valores relacionados

con el sistema de enrutamiento que se explicar ms adelante (como por

ejemplo, _controllery _route). El propsito de la propiedadattributeses el de

preparar y almacenar informacin del contexto especfico de la peticin.

Symfony tambin proporciona una clase Response, que simplifica la representacin

de la respuesta HTTP en PHP. Esto permite que tu aplicacin utilice una interfaz

orientada a objetos para construir la respuesta que ser devuelta al cliente:

useSymfony\Component\HttpFoundation\Response;

$response=newResponse();

$response->setContent('Hello world!');

$response->setStatusCode(Response::HTTP_OK);

$response->headers->set('Content-Type','text/html');

// imprime las cabeceras HTTP seguidas por el contenido

$response->send();

NOTALas constantes que definen los cdigos de estado de HTTP (como por

ejemploResponse::HTTP_OK) fueron aadidas en la versin 2.4 de Symfony.

Si Symfony no ofreciera nada ms, ya tendras un conjunto de herramientas para

acceder fcilmente a la informacin de la peticin y una interfaz orientada a


10/102

objetos para crear la respuesta. De hecho, a medida que aprendas muchas de las

caractersticas avanzadas de Symfony, nunca debes olvidar que el objetivo de tu

aplicacin es interpretar una peticin y crear la respuesta adecuada basada en la

lgica de tu aplicacin.

TRUCOLas clases Requesty Responseforman parte de un componente

independiente incluido en Symfony llamado HttpFoundation. Este componente se

puede utilizar en aplicaciones independientes de Symfony y tambin proporciona

clases para manejar sesiones y subir archivos.

1.4.El viaje desde la peticin hasta larespuestaAl igual que el mismo HTTP, los objetos Peticiny Responseson bastante simples.

La parte difcil de la construccin de una aplicacin es escribir lo que viene en el

medio.

En otras palabras, el verdadero trabajo viene al escribir el cdigo que interpreta la

informacin de la peticin y crea la respuesta.

Tu aplicacin probablemente hace muchas cosas, como enviar correo electrnico,

manejar los formularios presentados, guardar cosas en una base de datos,

reproducir las pginas HTML y proteger el contenido con seguridad. Cmo

puedes manejar todo esto y al mismo tiempo conseguir que tu cdigo est

organizado y sea fcil de mantener?

Symfony fue creado precisamente para resolver estos problemas y para que no

tengas que hacerlo a mano.

1.4.1. El controlador frontal

Antiguamente, las aplicaciones web se construan de modo que cada pgina web

del sitio tena su propio archivo fsico:index.php

contacto.php

blog.php


11/102

Esta filosofa de trabajo tiene varios problemas, como la falta de flexibilidad de

las URL(qu pasa si quieres cambiar blog.phpa noticias.phpsin romper todos

tus enlaces?) y el hecho de que cada archivo debe incluir a mano todos los

archivos necesarios para la seguridad, conexiones a base de datos y para aplicar

los estilos grficos del sitio.

Una solucin mucho mejor es usar un controlador frontal, que es un solo archivo

PHP que se encarga de servir todas las peticiones que llegan a tu aplicacin. Por

ejemplo:

Archivo solicitado Archivo realmente ejecutado

/index.php index.php

/index.php/contacto index.php

/index.php/blog index.php

TRUCOUsando el mdulo mod_rewritedeApache(o el equivalente en otros

servidores web), lasURLse pueden limpiarfcilmente para que quiten la parte

del index.phpy se queden simplemente en /, /contactoy /blog.

Ahora, todas las peticiones se manejan exactamente igual. En lugar de URL

individuales ejecutando diferentes archivos PHP, el controlador frontal siempre se

ejecuta, y la redireccin de cada URL a una parte diferente de la aplicacin se

realiza internamente. Esto resuelve los problemas comentados anteriormente.

Casi todas las aplicaciones web modernas siguen la filosofa del controlador

frontal, incluyendo aplicaciones como WordPress.

1.4.2. Mantente organizado

Una vez dentro del controlador frontal, cmo sabes qu pgina debes generar y

cmo puedes generar todas las pginas sin que la aplicacin se vuelva catica? El

truco consiste en comprobar la URI entrante y ejecutar diferentes partes de tu


12/102

cdigo en funcin de ese valor. Aunque es bastantechapucero, el siguiente cdigo

te podra servir para ello:

// Contenido del archivo index.php



$request=Request::createFromGlobals();

$path=$request->getPathInfo();// La ruta URI solicitada

if(in_array($path,array('','/')){

$response=newResponse('Bienvenido a nuestra portada.');

}elseif($path=='/contacto'){

$response=newResponse('Contctanos');

}else{

$response=newResponse('Pgina no encontrada.',Response::HTTP_NOT_FOUND);

}

$response->send();

Escalar el cdigo anterior para una aplicacin real es un problema difcil de

resolver. Afortunadamente esto es exactamente para lo que Symfony est

diseado.

1.4.3. El flujo de las aplicaciones Symfony

Cuando dejas que Symfony controle cada peticin, tu vida como programador es

mucho ms fcil. Symfony sigue el mismo patrn simple en cada peticin. Las

peticiones entrantes son interpretadas por el enrutador y pasadas a las funciones

controladoras, que devuelven objetos Response.


13/102

Figura 1.4Flujo de la peticin en Symfony2

Cada pgina de tu sitio est definida en un archivo de configuracin de rutas que

asigna a cada URL una funcin PHP diferente. El trabajo de cada funcin PHP

(conocida como controlador), es utilizar la informacin de la peticin junto con

muchas otras herramientas que Symfony pone a tu disposicin para crear y

devolver un objeto Response. En otras palabras, el controlador es donde est tu

cdigo: ah es dnde se interpreta la peticin y se crea una respuesta. As de

fcil!

Repasemos:

Cada peticin ejecuta un archivo controlador frontal;

El sistema de enrutado determina qu funcin PHP se ejecuta en base a la

informacin de la peticin y la configuracin de enrutado que hemos creado;

Se ejecuta la funcin PHP adecuada, donde tu cdigo crea y devuelve el

objeto Response.

1.4.4. Una peticin Symfony en la prctica

Sin entrar demasiado en los detalles, veamos este proceso en la prctica.

Supongamos que deseas agregar una pgina /contactoa tu aplicacin Symfony.

En primer lugar, empezamos agregando una entrada /contactoa tu archivo de

configuracin de rutas:


14/102

YAML

XML

PHP# app/config/routing.yml

contacto:

path: /contacto

defaults: {_controller: AcmeDemoBundle:Main:contacto }

NOTAEn este ejemplo utilizamos YAMLpara definir la configuracin de enrutado,

pero tambin se pueden utilizar los formatos XML y PHP.

Cuando alguien visita la pgina /contacto, Symfony2 detecta que se trata de esta

ruta y se ejecuta el controlador especificado. Como veremos en el captulo deenrutamiento, la cadenaAcmeDemoBundle:Main:contacto es un atajo que apunta al

mtodo contactoAction()de PHP dentro de una clase llamada MainController:

// src/Acme/DemoBundle/Controller/MainController.php

namespaceAcme\DemoBundle\Controller;


classMainController

{

publicfunctioncontactoAction()

{

returnnewResponse('Contctanos');

}

}

En este ejemplo sencillo, el controlador simplemente crea un objeto Responsecon

el cdigo HTML "Contctanos" . En el captulo dedicado a los

controladores aprenders cmo hacer que los controladores utilicen plantillas para

generar el contenido HTML en vez de tener que escribirlo directamente en el
http://librosweb.es/symfony_2_4/capitulo_1/el_viaje_desde_la_peticion_hasta_la_respuesta.html#select_tab_1_a3857http://librosweb.es/symfony_2_4/capitulo_1/el_viaje_desde_la_peticion_hasta_la_respuesta.html#select_tab_1_a3857http://librosweb.es/symfony_2_4/capitulo_1/el_viaje_desde_la_peticion_hasta_la_respuesta.html#select_tab_2_a3857http://librosweb.es/symfony_2_4/capitulo_1/el_viaje_desde_la_peticion_hasta_la_respuesta.html#select_tab_2_a3857http://librosweb.es/symfony_2_4/capitulo_1/el_viaje_desde_la_peticion_hasta_la_respuesta.html#select_tab_3_a3857http://librosweb.es/symfony_2_4/capitulo_1/el_viaje_desde_la_peticion_hasta_la_respuesta.html#select_tab_3_a3857http://librosweb.es/symfony_2_4/capitulo_1/el_viaje_desde_la_peticion_hasta_la_respuesta.html#select_tab_3_a3857http://librosweb.es/symfony_2_4/capitulo_1/el_viaje_desde_la_peticion_hasta_la_respuesta.html#select_tab_2_a3857http://librosweb.es/symfony_2_4/capitulo_1/el_viaje_desde_la_peticion_hasta_la_respuesta.html#select_tab_1_a3857


15/102

objeto Response. Esto hace que el controlador deba preocuparse slo de las cosas

difciles: la interaccin con la base de datos, la manipulacin de la informacin o el

envo de mensajes de correo electrnico.

1.5.Symfony2: construye tu aplicacin, no tusherramientasAhora sabemos que el objetivo de cualquier aplicacin es interpretar cada peticin

entrante y crear una respuesta adecuada. Cuando una aplicacin crece, es ms

difcil organizar tu cdigo y que a la vez sea fcil de mantener. Adems, siempre te

vas a encontrar con las mismas tareas complejas: la persistencia de informacin a

la base de datos, procesar y reutilizar plantillas, manejar los formularios, enviar

mensajes de correo electrnico, validar los datos del usuario, administrar la

seguridad del sitio web, etc.

La buena noticia es que todos los programadores web se encuentran con esos

mismos problemas. As que Symfony proporciona una plataforma completa, con

herramientas que te permiten construir tu aplicacin, no tus herramientas. Con

Symfony2, nada se te impone: eres libre de usar la plataforma Symfony completa,

o simplemente aquellas partes de Symfony que quieras.

1.5.1. Herramientas independientes: los componentes de Symfony2

Con todo lo anterior, qu es exactamente Symfony2?. En primer lugar, Symfony2

es una coleccin de ms de veinte libreras independientes que se pueden utilizar

dentro de cualquier proyecto PHP. Estas libreras, llamadas componentes de

Symfony2, son bastante tiles prticamente para cualquier aplicacin,

independientemente de cmo desarrolles tu proyecto. Las siguientes son algunas

de las ms destacadas:

HttpFoundation: contiene las clases Requesty Response, as como otras clases

para manejar sesiones y cargar archivos.

Routing: potente y rpido sistema de enrutado que te permite asignar una URI

especfica (por ejemplo /contacto) a cierta informacin acerca de cmo se

debe manejar dicha peticin (por ejemplo, ejecutar el

mtodo contactoAction()).


16/102

Form: una completa y flexible plataforma para crear formularios y procesar los

datos presentados en ellos.

Validator: un sistema para crear reglas sobre datos y as comprobar si los

datos que presenta el usuario son vlidos o no siguiendo esas reglas.

ClassLoader: una librera para cargar automticamente clases PHP sin

necesidad de aadir instrucciones requirea mano en los archivos que

contienen esas clases.

Templating: juego de herramientas para utilizar plantillas, que soporta desde

la herencia de plantillas (es decir, una plantilla est decorada con un diseo) y

hasta otras tareas comunes de las plantillas.

Security: una poderosa librera para manejar todo tipo de seguridad dentro deuna aplicacin.

Translation: plataforma para traducir cadenas de texto en tu aplicacin.

Todos y cada uno de estos componentes estn desacoplados, lo que significa que

puedes utilizarlos en cualquier proyecto PHP, independientemente de si utilizas la

plataforma Symfony2.

Cada componente est diseado para utilizarlo si es conveniente o para sustituirlocuando sea necesario.

1.5.2. La solucin completa: la plataforma Symfony2

Qu es la plataforma Symfony2? La plataforma Symfony2 es una librera PHP

que realiza dos tareas diferentes:

Proporciona una seleccin de componentes Symfony2 y algunas libreras de

terceros (por ejemplo, SwiftMailerpara enviar mensajes de correo

electrnico).

Define una configuracin adecuada e incluye una capa que integra todas las

diferentes partes (componentes, libreras, etc.)


17/102

El objetivo de la plataforma es integrar muchas herramientas independientes con

el fin de proporcionar una experiencia coherente al desarrollador.

Symfony2 proporciona un potente conjunto de herramientas para desarrollar

aplicaciones web rpidamente sin afectar excesivamente a tu forma de trabajar. Siests comenzando con Symfony2, lo mejor es que utilices una distribucin de

Symfony2, que proporciona un esqueletode un proyecto Symfony2 de prueba

con varios parmetros ya preconfigurados. Si eres un usuario avanzado, puedes

crearte tu propia distribucin o incluso utilizar componentes individuales de

Symfony2

Captulo 2.De PHP a Symfony2Por qu Symfony2 es mejor que escribir cdigo PHP a pelo?Si nunca has

usado una plataforma PHP, o no ests familiarizado con la filosofa MVC, o

simplemente te preguntas qu es todo ese ruidogenerado en torno a Symfony2,

este captulo es para ti. En vez de contarte que Symfony2 te permite desarrollar

software ms rpido y mejor que con PHP simple, vas a poder comprobarlo tu

mismo.

En este captulo, vamos a escribir una aplicacin sencilla en PHP simple, y luego

la reconstruiremos para que est mejor organizada. Podrs viajar a travs del

tiempo, viendo las decisiones de por qu el desarrollo web ha evolucionado en losltimos aos hasta donde est ahora.

Al final del captulo, vers cmo Symfony2 se encarga de todas las tareas

comunes (y aburridas) mientras que te permite recuperar el control de tu cdigo.

2.1.Un blog sencillo creado con PHP simpleEn este captulo, crearemos la tpica aplicacin de blog utilizando slo PHP

simple.

Para empezar, crea una pgina que muestre las entradas del blog que se han

persistido en la base de datos. Escribirla en PHP simple es rpido, pero un

poco sucio:


18/102

$link=mysql_connect('localhost','myuser','mypassword');

mysql_select_db('blog_db',$link);

$result=mysql_query('SELECT id, title FROM post',$link);

?>

List of Posts

List of Posts


19/102

El cdigo anterior es fcil de escribir y se ejecuta muy rpido, pero en cuanto la

aplicacin crece, es muy difcil de mantener. Sus principales problemas son los

siguientes:

No hay comprobacin de errores: qu sucede si falla la conexin a la basede datos?

Organizacin deficiente: si la aplicacin crece, este nico archivo cada vez

ser ms difcil de mantener, hasta que finalmente sea imposible. Dnde se

debe colocar el cdigo para manejar los formularios? Cmo se pueden

validar los datos? Dnde debe ir el cdigo para enviar mensajes de correo

electrnico?

Es difcil reutilizar el cdigo: ya que todo est en un archivo, no hay manerade volver a utilizar alguna parte de la aplicacin en otras pginas del blog.

NOTAOtro problema no mencionado aqu es el hecho de que la base de datos est

vinculada a MySQL. Aunque no se ha tratado aqu, Symfony2 integraDoctrine,

una librera que permite abstraer el acceso a la base de datos y el manejo de la

informacin.

Vamos a trabajar a continuacin en la solucin de estos y muchos otros problemas

ms.

2.1.1. Aislando la parte de la vista

El cdigo se puede mejorar fcilmente separando la lgica de la aplicacin (cdigo

PHP puro) y "la parte de la vista"o "presentacin", que est formada por todo lo

relacionado con el cdigo HTML:


20/102

$posts=array();

while($row=mysql_fetch_assoc($result)){

$posts[]=$row;

}

mysql_close($link);

// incluye el cdigo HTML de la vista

require'templates/list.php';

Ahora el cdigo HTML est guardado en un archivo separado

(templates/list.php). Este archivo contiene todo el cdigo HTML junto con

algunas pocas instrucciones PHP que utilizan la sintaxis alternativa recomendada

para las plantillas PHP:

List of Posts

List of Posts


21/102

Por convencin, el archivo que contiene toda la lgica de la aplicacin (index.php)

se conoce como"controlador". El trmino controladores una palabra que se utiliza

mucho, independientemente del lenguaje o plataforma que utilices. Simplemente

se refiere a la zona de tu cdigo que procesa la peticin del usuario y prepara la

respuesta.

En este caso, nuestro controlador obtiene los datos de la base de datos y, luego

los incluye en una plantilla para presentarlos al usuario. Con el controlador aislado,

podramos cambiar fcilmente slo el archivo de la plantilla si queremos servir los

contenidos del blog en otro formato (por ejemplo,list.json.phppara el

formatoJSON).

2.1.2. Aislando la lgica de la aplicacin (el dominio)

Por ahora la aplicacin slo contiene una pgina. Pero qu pasa si una segunda

pgina necesita utilizar la misma conexin a la base de datos, e incluso el mismo

resultado de la bsqueda de las entradas del blog? La solucin consiste en

refactorizar el cdigo para que todas estas funciones bsicas de acceso a datosde la aplicacin estn aisladas en un nuevo archivo llamado model.php:


22/102

}

functionclose_database_connection($link)

{

mysql_close($link);

}

functionget_all_posts()

{

$link=open_database_connection();

$result=mysql_query('SELECT id, title FROM post',$link);

$posts=array();

while($row=mysql_fetch_assoc($result)){

$posts[]=$row;

}

close_database_connection($link);

return$posts;

}

TRUCOSe utiliza el nombre model.phppara el archivo porque el acceso a la lgica y

los datos de una aplicacin se conoce tradicionalmente como la capa

del "modelo". En una aplicacin bien organizada, la mayora del cdigo que

representa tu "lgica de negocio"debe estar en el modelo (en lugar del

controlador). Y, a diferencia de este ejemplo, slo una parte (o ninguna) del

modelo realmente est interesada en acceder a la base de datos.

El controlador (index.php) ahora es muy sencillo:


23/102

require_once'model.php';

$posts=get_all_posts();


Ahora, la nica tarea del controlador es conseguir los datos de la capa del modelo

de la aplicacin (el modelo) y utilizar una plantilla para mostrar los datos.

Este es un ejemplo muy simple del patrn modelo - vista - controlador.

2.1.3. Aislando el diseo

La aplicacin ahora est dividida en tres partes distintas, lo que nos ofrece variasventajas y la oportunidad de volver a utilizar casi todo en diferentes pginas.

La nica parte del cdigo que no se puede reutilizar es el diseo HTML + CSS de

la pgina. Vamos a solucionar este problema creando un nuevo archivo

llamado base.php:

La plantilla original (templates/list.php) ahora se puede simplificar para que

utilice el archivobase.phpanterior como base:


24/102

List of Posts

El cdigo anterior introducido una metodologa que nos permite reutilizar el diseo.

Desafortunadamente, para conseguirlo estamos obligados a utilizar en la plantilla

algunas funciones de PHP poco recomendables (ob_start(), ob_get_clean()).Symfony2 utiliza un componente de plantillas (Templating) que nos permite realizar

esto de una manera ms limpiay sencilla. En breve lo

2.2.Agregando una pginashowal blogLa pgina listdel blog se ha rediseado para que el cdigo est mejor

organizado y sea reutilizable. Para probar que esto es as, aade una

pgina showal blog, que muestre una entrada individual del blog identificada por

un parmetro de consulta id.

Para empezar, crea una nueva funcin en el archivo model.phpque recupere un

resultado individual del blog basndose en un identificador dado:

// model.php

functionget_post_by_id($id)


25/102

{

$link=open_database_connection();

$id=mysql_real_escape_string($id);

$query='SELECT date, title, body FROM post WHERE id = '.$id;

$result=mysql_query($query);

$row=mysql_fetch_assoc($result);

close_database_connection($link);

return$row;

}

A continuacin, crea un nuevo archivo llamado show.php, que ser el controlador

para esta nueva pgina:


26/102

Como has visto, es muy fcil crear la segunda pgina sin duplicar cdigo. Sin

embargo, esta nueva pgina introduce algunos problemas adicionales que una

plataforma web puede resolver por ti. Por ejemplo, si el usuario proporciona un

valor ilegal para el parmetro ido un valor vaco, la consulta har que la pgina sebloquee. En este caso, sera mejor que la aplicacin generara una pgina de error

de tipo 404(algo que no es fcil con el cdigo actual de la aplicacin). Peor an, si

no te acuerdas de limpiarcon la funcin mysql_real_escape_string() el

parmetro idque te pasa el usuario, tu base de datos sera vulnerable a los

ataques de tipo inyeccin SQL.

Otro problema importante es que cada archivo de tipo controlador debe incluir el

archivo model.php. Qu pasara si cada archivo de controlador de repente tuviera

que incluir un archivo adicional o realizar alguna tarea global (por ejemplo, reforzarla seguridad)?

Tal como est ahora, el cdigo tendra que incluir a mano todos los archivos de los

controladores. Si olvidas incluir algo en un solo archivo, esperamos que no sea

alguno relacionado con la seguridad.

2.3.El controlador frontal al rescateUna solucin mucho mejor es usar un controlador frontal: un nico archivo PHP a

travs del cual se procesen todas las peticiones del usuario. Con un controlador

frontal, la URI de la aplicacin cambia un poco, pero se vuelve mucho ms flexible:

Sin controlador frontal:

/index.php => (ejecuta index.php) la pgina que lista los artculos.


27/102

/show.php => (ejecuta show.php) la pgina que muestra un artculo especfico.

Con index.php como controlador frontal

/index.php => (ejecuta index.php) la pgina que lista los artculos.

/index.php/show => (ejecuta index.php) la pgina que muestra un artculo especfico.

TRUCOEl nombre del archivo index.phpse puede eliminar en las URLs si utilizas

las reglas de reescritura del servidor web Apache (o las equivalentes de los dems

servidores web). En ese caso, la URI resultante de la pgina showdel blog sera

simplemente /show.

Cuando se usa un controlador frontal, un solo archivo PHP (index.phpen estecaso) procesa todas las peticiones. Para la pgina showdel

blog, /index.php/showrealmente ejecuta el archivo index.php, que ahora es el

responsable de dirigir internamente las peticiones basndose en la URI completa.

Como puedes ver, un controlador frontal es una herramienta muy poderosa.

2.3.1. Creando el controlador frontal

Ests a punto de dar un gran paso en la aplicacin. Con un archivo manejando

todas las peticiones, puedes centralizar cosas como el manejo de la seguridad, lacarga de la configuracin y el enrutamiento. En nuestra

aplicacin, index.phpahora debe ser lo suficientemente inteligente como para

mostrar la lista de entradas del blog o mostrar la pgina de una entrada particular

basndose en la URI solicitada:


28/102

// encamina la peticin internamente

$uri=$_SERVER['REQUEST_URI'];

if($uri=='/index.php'){

list_action();

}elseif($uri=='/index.php/show'&&isset($_GET['id'])){

show_action($_GET['id']);

}else{

header('Status: 404 Not Found');

echo'Page Not Found';

}

Para organizar mejor el cdigo, los dos controladores anteriores

(archivos index.phpy show.php) se han convertido en funciones PHP del nuevo

archivo controllers.php:

functionlist_action()

{



}

functionshow_action($id)

{

$post=get_post_by_id($id);

require'templates/show.php';

}

Como controlador frontal, index.phpha asumido un papel completamente nuevo,

que incluye la carga de los archivos principales de la aplicacin

(model.phpy controllers.php) y la decisin de ejecutar uno de los dos

controladores (las funciones list_action()y show_action()). En realidad, el


29/102

controlador frontal est empezando a parecerse y actuar como el mecanismo que

define Symfony2 para la manipulacin y enrutado de peticiones.

TRUCOOtra ventaja del controlador frontal es la flexibilidad de las URL. Ten en

cuenta que la URL de la pgina showdel blog se puede cambiarde /showa /readcambiando el cdigo en un nico lugar. Antes, era necesario

cambiar todo un archivo para cambiar el nombre. En Symfony2, las URL son

incluso ms flexibles.

Por ahora, la aplicacin ha evolucionado de un nico archivo PHP, a una

estructura organizada que permite la reutilizacin de cdigo. Debes estar contento,

pero an lejos de estar satisfecho. Por ejemplo, el sistema de enrutamiento es

muy mejorable, ya que no reconoce por ejemplo que la pginalist(/index.php)

tambin debe ser accesible a travs de /(si has agregado las reglas dereescritura deApache). Adems, en lugar de programar el blog, hasperdidotu

tiempo en preparar la "arquitectura" del cdigo (por ejemplo, el enrutamiento, los

controladores, las plantillas, etc.) Y pronto tendrs que perder ms tiempo en la

gestin de los formularios, la validacin de la informacin, crear un archivo de log,

la gestin de la seguridad, etc.

Por qu tienes que dedicarte a solucionar estos problemas que se repiten una y

otra vez en todos los proyectos?

2.3.2. Aadiendo un toque de Symfony2

Symfony2 al rescate! Antes de utilizar Symfony2, debes descargar sus archivos.

Para ello se utiliza la herramienta llamada Composer, que se encarga de

descargar la versin correcta de los archivos de Symfony, todas sus dependencias

y tambin proporciona un cargador automtico de clases (llamadoclass loaderen

ingls). Un cargador automtico es una herramienta que permite empezar a utilizar

clases PHP sin incluir explcitamente el archivo que contiene la clase.

Dentro del directorio raz del proyecto crea un archivo llamado composer.jsoncon

el siguiente contenido:

{

"require":{

"symfony/symfony":"2.4.*"


30/102

},

"autoload":{

"files":["model.php","controllers.php"]

}

}

A continuacin,descarga Composery ejecuta despus el siguiente cdigo para

descargar Symfony dentro del directorio vendor/del proyecto:

$ php composer.phar install

Adems de descargar todas las dependencias, Composergenera un archivo

llamadovendor/autoload.php, que se encarga de cargar automticamente todas las

clases del frameworkSymfony y de todas las libreras que aadas en laseccin autoloaddel archivo composer.json.

La esencia de la filosofa Symfony es que el trabajo principal de una aplicacin es

interpretar cada peticin y devolver una respuesta. Con este fin, Symfony2

proporciona las clases Requesty Response. Estas clases son representaciones

orientadas a objetos de la peticin HTTP que se est procesando y la respuesta

HTTP que se devolver. salas para mejorar el blog:


31/102

$response=list_action();

}elseif($uri=='/show'&&$request->query->has('id')){

$response=show_action($request->query->get('id'));

}else{

$html='Page Not Found';

$response=newResponse($html,Response::HTTP_NOT_FOUND);

}

// enva las cabeceras y la respuesta

$response->send();

Los controladores se encargan de devolver un objeto Response. Para simplificar la

generacin del cdigo HTML de la respuesta, crea una nueva funcin

llamada render_template(), la cual, por cierto, acta un poco como el motor de

plantillas de Symfony2:

// controllers.php


functionlist_action()

{


$html=render_template('templates/list.php',array('posts'=>$posts));

returnnewResponse($html);

}

functionshow_action($id)

{


32/102

$post=get_post_by_id($id);

$html=render_template('templates/show.php',array('post'=>$post));

returnnewResponse($html);

}

// funcin ayudante para reproducir plantillas

functionrender_template($path,array$args)

{

extract($args);

ob_start();

require$path;

$html=ob_get_clean();

return$html;

}

Aunque solo ha aadido una pequesima parte de las ideas de Symfony2, la

aplicacin ahora es ms flexible y fiable. El objeto Requestproporciona una

manera segura para acceder a la informacin de la peticin HTTP. El

mtodo getPathInfo()por ejemplo devuelve una URI limpia (siempre

devolviendo/showy nunca /index.php/show).

Por lo tanto, incluso si el usuario va a /index.php/show, la aplicacin es lo

suficientemente inteligente para encaminar la peticin hacia show_action().

El objeto Responseproporciona flexibilidad al construir la respuesta HTTP,permitiendo que las cabeceras HTTP y el contenido se definan a travs de una

interfaz orientada a objetos.

Y aunque las respuestas en esta aplicacin son simples, esta flexibilidad ser muy

til en cuanto tu aplicacin crezca.


33/102

2.3.3. Aplicacin de ejemplo en Symfony2

El blog ha mejorado bastante, pero todava contiene una gran cantidad de cdigo

para ser una aplicacin tan simple. Durante las mejoras de la aplicacin, se ha

creado un sistema de enrutamiento muy sencillo y otro mtodo que

utiliza ob_start()y ob_get_clean()para procesar plantillas. Si vas a continuardesarrollando este blog, lo mejor es que utilices los

componentes Routingy Templatingde Symfony para mejorar esa parte sin

esfuerzo.

En lugar de resolver de nuevo los mismos problemas de siempre, deja que

Symfony2 se encargue de ellos por ti. Aqu est la misma aplicacin de ejemplo,

pero construida ahora con Symfony2:


34/102

publicfunctionshowAction($id)

{

$post=$this->get('doctrine')

->getManager()

->getRepository('AcmeBlogBundle:Post')

->find($id);

if(!$post){

// hace que se muestre la pgina de error 404

throw$this->createNotFoundException();

}

return$this->render('AcmeBlogBundle:Blog:show.html.php',array('post'=>$post));

}

}

Los dos controladores siguen siendo ms o menos pequeos. Cada uno utiliza la

librera ORM de Doctrine para recuperar objetos de la base de datos y el

componente Templatingpara generar el cdigo HTML con una plantilla y devolver

un objeto Response. La plantilla listahora es un poco ms simple:

List of Posts


35/102

NOTATe vamos a dejar como ejercicio la plantilla show, porque debera ser trivial

crearla basndote en la plantilla list.

Cuando arranca el motor de Symfony2 (llamado kernel), necesita un mapapara

saber qu controladores ejecutar en base a la informacin solicitada por los

usuarios. Este mapase crea con la configuracin de enrutamiento, que

proporciona esta informacin en formato legible:

# app/config/routing.yml

blog_list:

path: /blog


36/102

defaults: {_controller: AcmeBlogBundle:Blog:list }

blog_show:

path: /blog/show/{id}

defaults: {_controller: AcmeBlogBundle:Blog:show }

Ahora que Symfony2 se encarga de todas las tareas repetitivas, el controlador

frontal es muy simple. Y ya que hace tan poco, nunca tienes que volver a tocarlo

una vez creado (y si utilizas una distribucin Symfony2, ni siquiera tendrs que

crearlo!):


37/102

Tu aplicacin cuenta con cdigo claro y bien organizado(aunque Symfony

no te obliga a ello). Esto facilita la reutilizacinde cdigo y permite a los

nuevos desarrolladores ser productivos en el proyecto con mayor rapidez.

El 100% del cdigo que escribes es para tu aplicacin. No necesitasdesarrollar o mantener herramientas de bajo nivelcomo la carga

automtica de clases, el enrutamiento o los controladores.

Symfony2 te proporciona acceso a herramientas de software libretales

como Doctrine, plantillas, seguridad, formularios, validacin y traduccin (por

nombrar algunas).

La aplicacin ahora dispone de URLs totalmente flexiblesgracias al

componente Routing.

La arquitectura centrada en HTTP de Symfony2 te da acceso a herramientas

muy potentes, como por ejemplo la cach HTTP(mediante la cach HTTP

interna de Symfony2o mediante herramientas ms avanzadas

comoVarnish). Esto se explica ms adelante en el captulo sobre la cach.

Y lo mejor de todo, utilizando Symfony2, ahora tienes acceso a un conjunto de

herramientas desoftware libre de alta calidad desarrolladas por la comunidad

Symfony2!

Puedes encontrar una buena coleccin de herramientas comunitarias de

Symfony2 enKnpBundles.com.

2.4.Mejorando las plantillasSi quieres utilizarlo, Symfony2 incluye de serie un motor de plantillas

llamadoTwigque hace que las plantillas se escriban ms rpido y sean ms

fciles de leer.

En otras palabras, la aplicacin de ejemplo desarrollada anteriormente podra

incluso tener menos cdigo. Considera por ejemplo la siguiente

plantilla listreescrita con Twig:

{# src/Acme/BlogBundle/Resources/views/Blog/list.html.twig #}
http://www.varnish-cache.org/http://www.varnish-cache.org/http://www.varnish-cache.org/http://knpbundles.com/http://knpbundles.com/http://twig.sensiolabs.org/http://twig.sensiolabs.org/http://twig.sensiolabs.org/http://twig.sensiolabs.org/http://knpbundles.com/http://www.varnish-cache.org/


38/102

{%extends"::base.html.twig"%}

{%blocktitle%}List of Posts{%endblock%}

{%blockbody%}

List of Posts

{%forpostinposts%}

{{post.title}}

{%endfor%}

{%endblock%}

Tambin es muy fcil escribir la plantilla base.html.twigcorrespondiente:

{# app/Resources/views/base.html.twig #}

{%blocktitle%}Default title{%endblock%}

{%blockbody%}{%endblock%}


39/102

Twig est completamente integrado en Symfony2. Aunque Symfony2 siempre

soportar las plantillas PHP, en los siguientes captulos se van a seguir

presentando algunas de las muchas ventajas de Twig respecto a las plantillas

PHP. Para ms informacin, consulta el captulo sobre las plantillas.

Captulo 4.Creando pginas en Symfony2Crear una nueva pgina en Symfony2 es un proceso muy sencillo de dos pasos:

Crear una ruta: una ruta define la URL de tu pgina (por ejemplo /sobre) y

especifica el controlador (que en realidad es una funcin PHP) que Symfony2

ejecuta cuando la URL de la peticin del usuario coincida con el patrn de la

ruta.

Crear un controlador: un controlador es una funcin PHP que obtiene lapeticin del usuario y la transforma en el objeto Responsecon el que Symfony2

crea la respuesta que se enva al usuario .

Nos encanta este enfoque simple porque coincide con la forma en que funciona la

Web. Cada interaccin en la Web se inicia con una peticin HTTP. El trabajo de la

aplicacin simplemente es interpretar la peticin y devolver la respuesta HTTP

adecuada.

Symfony2 sigue esta filosofa y te proporciona las herramientas y convencionespara mantener organizada tu aplicacin a medida que crece en usuarios y

complejidad.

4.1.La pginaHola Symfony!Vamos a empezar con una aplicacin derivada del clsico "Hola Mundo!". Cuando

hayamos terminado, el usuario podr recibir un saludo personal (por

ejemplo, "Hola Symfony") al ir a la siguiente URL:

http://localhost/app_dev.php/hello/Symfony

Ms adelante podrs sustituir la palabra Symfonycon cualquier otro nombre al que

darle la bienvenida. Para crear la pgina, sigue el proceso simple de dos pasos.

NOTAEste captulo supone que ya has descargado Symfony2 y configurado tu

servidor web. En la URL del ejemplo anterior se supone que localhostapunta al


40/102

directorio webde tu nuevo proyecto Symfony2. Para obtener una informacin ms

detallada sobre cmo hacerlo, consulta la documentacin del servidor Web que

ests usando.

Estos son los enlaces a las pginas de documentacin adecuadas para los dosservidores web ms populares:

Para el servidor Apache, consulta la documentacin deApache sobre

DirectoryIndex.

Para Nginx, consulta la documentacin deubicacin HttpCoreModule de

Nginx.

4.2.Antes de empezar, crea el bundleAntes de empezar, tendrs que crear un bundle(que se podra traducir

como "paquete"). En Symfony2, un bundle es como unplugin, con la salvedad de

que todo el cdigo de tu aplicacin se almacena dentro de bundles.

Un bundle no es ms que un directorio que almacena todo lo relacionado con una

funcin especfica, incluyendo clases PHP, configuracin, e incluso hojas de estilo

y archivos deJavascript.

Para crear un bundle llamado AcmeHelloBundle(el bundle de ejemplo que vamos a

construir en este captulo), ejecuta el siguiente comando y sigue las instrucciones

en pantalla (acepta todas las opciones predeterminadas):

$ php app/console generate:bundle --namespace=Acme/HelloBundle --format=yml

Sin que te des cuenta, se ha creado un directorio para el bundle

en src/Acme/HelloBundle. Adems se ha aadido automticamente una lnea en el

archivo app/AppKernel.phppara registrar el bundle en el ncleo de Symfony:

// app/AppKernel.php

publicfunctionregisterBundles()

{

$bundles=array(

...,
http://httpd.apache.org/docs/2.0/mod/mod_dir.htmlhttp://httpd.apache.org/docs/2.0/mod/mod_dir.htmlhttp://httpd.apache.org/docs/2.0/mod/mod_dir.htmlhttp://httpd.apache.org/docs/2.0/mod/mod_dir.htmlhttp://wiki.nginx.org/HttpCoreModule#locationhttp://wiki.nginx.org/HttpCoreModule#locationhttp://wiki.nginx.org/HttpCoreModule#locationhttp://wiki.nginx.org/HttpCoreModule#locationhttp://wiki.nginx.org/HttpCoreModule#locationhttp://wiki.nginx.org/HttpCoreModule#locationhttp://httpd.apache.org/docs/2.0/mod/mod_dir.htmlhttp://httpd.apache.org/docs/2.0/mod/mod_dir.html


41/102

newAcme\HelloBundle\AcmeHelloBundle(),

);

// ...

return$bundles;

}

Ahora que ya est configurado el bundle, puedes comenzar a construir tu

aplicacin dentro del bundle.

4.2.1. Paso 1: Creando la ruta

Por defecto, el archivo de configuracin de enrutamiento en una aplicacinSymfony2 se encuentra enapp/config/routing.yml . Si lo prefieres, y al igual que

en el resto de la configuracin en Symfony2, puedes utilizar el formato XML o PHP

para configurar tus rutas.

Si te fijas en el archivo de enrutamiento principal, vers que Symfony ya ha

agregado una entrada al generar el bundle AcmeHelloBundle:

YAML

XML

PHP# app/config/routing.yml

acme_hello:

resource: "@AcmeHelloBundle/Resources/config/routing.yml"

prefix: /

Esta directiva de configuracin le dice a Symfony que cargue la configuracin de

enrutamiento del archivo Resources/config/routing.ymlque se encuentra en elinterior del bundle AcmeHelloBundle.

En otras palabras, puedes configurar tus rutas directamente en el

archivo app/config/routing.ymlo puedes definirlas en varias partes de la

aplicacin y despus las importas desde ese archivo.
http://librosweb.es/symfony_2_4/capitulo_4/antes_de_empezar_crea_el_bundle.html#select_tab_1_eb7a3http://librosweb.es/symfony_2_4/capitulo_4/antes_de_empezar_crea_el_bundle.html#select_tab_1_eb7a3http://librosweb.es/symfony_2_4/capitulo_4/antes_de_empezar_crea_el_bundle.html#select_tab_2_eb7a3http://librosweb.es/symfony_2_4/capitulo_4/antes_de_empezar_crea_el_bundle.html#select_tab_2_eb7a3http://librosweb.es/symfony_2_4/capitulo_4/antes_de_empezar_crea_el_bundle.html#select_tab_3_eb7a3http://librosweb.es/symfony_2_4/capitulo_4/antes_de_empezar_crea_el_bundle.html#select_tab_3_eb7a3http://librosweb.es/symfony_2_4/capitulo_4/antes_de_empezar_crea_el_bundle.html#select_tab_3_eb7a3http://librosweb.es/symfony_2_4/capitulo_4/antes_de_empezar_crea_el_bundle.html#select_tab_2_eb7a3http://librosweb.es/symfony_2_4/capitulo_4/antes_de_empezar_crea_el_bundle.html#select_tab_1_eb7a3


42/102

Ahora que el archivo routing.ymldel bundle se importa desde el archivo de

enrutamiento principal de la aplicacin, aade la nueva ruta que define la URL de

la pgina que ests a punto de crear:

YAML

XML

PHP# src/Acme/HelloBundle/Resources/config/routing.yml

hello:

path: /hello/{name}

defaults: {_controller: AcmeHelloBundle:Hello:index }

La ruta se compone bsicamente de dos partes: el path, que es la URL con la quedebe coincidir la peticin del usuario para activar la ruta, y un array

llamado defaults, que especifica el controlador que se ejecuta. Las partes de la

URL encerradas entre comillas indican que su valor puede variar. De esta

forma, {name}significa que las URL /hello/Ryan, /hello/Fabieno cualquier otra

URI similar coincidir con esta ruta. El valor de las partes variables tambin se

pasa al controlador, que puede acceder a ellos a travs del nombre asignado en la

propia ruta (nameen este caso).

NOTAEl sistema de enrutamiento tiene muchas ms caractersticas para crear URI

flexibles y avanzadas en tu aplicacin. Para ms detalles, consulta el captulo de

enrutamiento.

4.2.2. Paso 2: Creando el controlador

Cuando el usuario solicita la URL /hello/Ryan, se activa la ruta hello, a la que

corresponde el controlador AcmeHelloBundle:Hello:index , que es realmente el

cdigo que se ejecuta. El segundo paso del proceso de creacin de pginas

consiste precisamente en crear ese controlador.

La cadena AcmeHelloBundle:Hello:indexes el nombre lgicodel controlador, que

se traduce como el mtodo indexAction()de una clase PHP

llamada Acme\HelloBundle\Controller\Hello . Crea en primer lugar este archivo

dentro de tu bundle AcmeHelloBundle:
http://librosweb.es/symfony_2_4/capitulo_4/antes_de_empezar_crea_el_bundle.html#select_tab_1_eb8b6http://librosweb.es/symfony_2_4/capitulo_4/antes_de_empezar_crea_el_bundle.html#select_tab_1_eb8b6http://librosweb.es/symfony_2_4/capitulo_4/antes_de_empezar_crea_el_bundle.html#select_tab_2_eb8b6http://librosweb.es/symfony_2_4/capitulo_4/antes_de_empezar_crea_el_bundle.html#select_tab_2_eb8b6http://librosweb.es/symfony_2_4/capitulo_4/antes_de_empezar_crea_el_bundle.html#select_tab_3_eb8b6http://librosweb.es/symfony_2_4/capitulo_4/antes_de_empezar_crea_el_bundle.html#select_tab_3_eb8b6http://librosweb.es/symfony_2_4/capitulo_4/antes_de_empezar_crea_el_bundle.html#select_tab_3_eb8b6http://librosweb.es/symfony_2_4/capitulo_4/antes_de_empezar_crea_el_bundle.html#select_tab_2_eb8b6http://librosweb.es/symfony_2_4/capitulo_4/antes_de_empezar_crea_el_bundle.html#select_tab_1_eb8b6


43/102

// src/Acme/HelloBundle/Controller/HelloController.php

namespaceAcme\HelloBundle\Controller;


classHelloController

{

}

En realidad, el controlador no es ms que un mtodo PHP que t creas y Symfony

ejecuta. Aqu es donde el cdigo utiliza la informacin de la peticin para construir

y preparar el recurso solicitado. Salvo en algunos casos avanzados, el resultadofinal de un controlador siempre es el mismo: un objeto Responsede Symfony2.

Crea el mtodo indexActionque Symfony ejecutar cuando se sirva la ruta hello:


// ...

classHelloController

{

publicfunctionindexAction($name)

{

returnnewResponse('Hello '.$name.'!');

}

}

El controlador es muy sencillo: crea un nuevo objeto de tipo Responsey cuyo

primer argumento es el contenido que se utiliza para crear la respuesta enviada al

usuario (en este caso, una pgina HTML muy simple).


44/102

Enhorabuena! Despus de crear solamente una ruta y un controlador ya tienes

una pgina completamente funcional! Si todo lo has configurado correctamente, la

aplicacin debe darte la bienvenida al acceder a la siguiente URL:

http://localhost/app_dev.php/hello/Ryan

TRUCOTambin puedes ver tu aplicacin en el entorno prodo de produccin

visitando:

http://localhost/app.php/hello/Ryan

Si se produce un error, probablemente sea porque necesitas vaciar la cach de

produccin ejecutando el siguiente comando:

php app/console cache:clear --env=prod --no-debug

El tercer y ltimo paso para crear una pgina es opcional pero casi todas lasaplicaciones lo hacen: crear una plantilla.

NOTALos controladores son el punto de entrada principal a tu cdigo y la clave en

la creacin de pginas. Puedes encontrar mucha ms informacin en el captulo

dedicado a los controladores.

4.2.3. Paso 3 opcional: Creando la plantilla

Las plantillas te permiten mover toda la parte de la vista (es decir, el cdigo HTML)

a un archivo separado y reutilizar diferentes partes del diseo de la pgina. En vez

de escribir el cdigo HTML dentro del controlador, genera el cdigo HTML a partir

de una plantilla:


namespaceAcme\HelloBundle\Controller;

useSymfony\Bundle\FrameworkBundle\Controller\Controller;

classHelloController extendsController

{

publicfunctionindexAction($name)


45/102

{

return$this->render('AcmeHelloBundle:Hello:index.html.twig',array('name'=>$name));

// si utilizas PHP en vez de Twig

// return $this->render('AcmeHelloBundle:Hello:index.html.php', array('name' => $name));

}

}

NOTAPara poder usar el mtodo render(), tu controlador debe extender de la

claseSymfony\Bundle\FrameworkBundle\Controller\Controller, la cual aade atajos

para las tareas ms comunes de los controladores. Esto se hace en el ejemploanterior aadiendo la declaracin usedebajo del namespacey luego aadiendo

el extends Controllera la clase.

El mtodo render()crea un objeto Responsey le aade el contenido resultante de

renderizar la plantilla. As que como cualquier otro controlador, el cdigo anterior

realmente est devolviendo un objeto de tipo Response.

Ten en cuenta que puedes procesar las plantillas de dos formas diferentes. Por

defecto Symfony2 admite dos lenguajes de plantillas: las clsicas plantillascreadas con PHP y las nuevas y concisas plantillas creadas con Twig. No te

asustes porque puedes elegir libremente cul utilizar o incluso mezclar las dos en

el mismo proyecto.

Al procesar la plantilla AcmeHelloBundle:Hello:index.html.twig, el controlador

utiliza la siguiente convencin de nomenclatura:

NombreBundle:NombreControlador:NombrePlantilla

Este es el nombre lgicode la plantilla, que se traduce a un archivo fsicoutilizando la siguiente convencin:

/Resources/views//

En este caso, AcmeHelloBundlees el nombre del bundle, Helloes el controlador

e index.html.twigla plantilla:


46/102

{# src/Acme/HelloBundle/Resources/views/Hello/index.html.twig #}

{%extends'::base.html.twig'%}

{%blockbody%}

Hello {{name}}!

{%endblock%}

Hello !

Veamos la situacin a travs de la plantilla Twiglnea por lnea:

La etiqueta extendsindica que se utiliza una plantilla padre donde se define el

diseo del sitio web.

La etiqueta blockindica que todo su contenido se debe colocar dentro de un

bloque llamado body. Como se explicar ms adelante, la plantilla padre

(base.html.twig) es la responsable de definir ese bloque y de mostrarlo en la

pgina HTML adecuadamente.

La plantilla padre se indica como ::base.html.twig, por lo que no incluye ni la

parte del nombre del bundle ni la del nombre del controlador (de ah los dos

puntos dobles (::) al principio). Esto significa que la plantilla no se encuentra

dentro de ningn bundle, sino en el directorio appdel proyecto:

{# app/Resources/views/base.html.twig #}

{%blocktitle%}Welcome!{%endblock%}

{%blockstylesheets%}{%endblock%}


47/102

{%blockbody%}{%endblock%}

{%blockjavascripts%}{%endblock%}

El archivo de la plantilla base define el diseo HTML y muestra el contenido del

bloque bodyque se defini en la plantilla index.html.twig. Tambin muestra elcontenido de un bloque llamado title, que si quieres puedes definir en la

plantilla index.html.twig. Como no has definido ese bloque en la plantilla, se

utiliza el valor predeterminado "Welcome!".


48/102

Las plantillas son realmente tiles para generar y organizar el contenido de las

pginas de la aplicacin. Una plantilla puede generar cualquier cosa, desde el

cdigo HTML o CSS hasta cualquier otra cosa que el controlador tenga que

devolver.

Dentro del ciclo peticin/respuesta, el motor de plantillas simplemente es una

herramienta opcional. Recuerda que el objetivo de cada controlador es devolver

un objeto Response. As que por muy potentes que sean, las plantillas son solo una

forma opcional de generar ese objeto Response.

4.3.La estructura de directoriosLas secciones anteriores explican la filosofa en la que se basa la creacin y

procesamiento de pginas en Symfony2. Tambin se ha mencionado cmo estn

estructurados y organizados los proyectos Symfony2. Al final de esta seccin,

sabrs dnde encontrar y colocar diferentes tipos de archivos y por qu.

Aunque se puede cambiar, por defecto todas las aplicaciones Symfony tienen la

misma estructura de directorios sencilla (y recomendada):

app/: contiene la configuracin de la aplicacin.

src/: aqu se encuentra todo el cdigo PHP de la aplicacin.

vendor/: por convencin aqu se guardan todas las libreras creadas por

terceros.

web/: este es el directorio web raz y contiene todos los archivos que se

pueden acceder pblicamente.

4.3.1. El directorio web

El directorio web raz es el lugar donde se encuentran todos los archivos pblicos

y estticos tales como imgenes, hojas de estilo y archivos JavaScript. Tambines el lugar donde se definen todos los controladores frontales, como por ejemplo

el siguiente:

// web/app.php

require_once__DIR__.'/../app/bootstrap.php.cache';


49/102

require_once__DIR__.'/../app/AppKernel.php';


$kernel=newAppKernel('prod',false);

$kernel->loadClassCache();

$kernel->handle(Request::createFromGlobals())->send();

El archivo del controlador frontal (app.phpen este ejemplo) es el archivo PHP que

realmente se ejecuta cuando utilizas una aplicacin Symfony2 y su trabajo

consiste en arrancar la aplicacinutilizando una clase del ncleo (AppKernel).

TRUCOTener un controlador frontal significa que se utilizan URL diferentes y ms

flexibles que las de una aplicacin PHP tpica. Cuando se dispone de un

controlador frontal, las URL se formatean de la siguiente manera:


El controlador frontal, app.php, se ejecuta y la URL interna: /hello/Ryanse dirige

internamente segn la configuracin de enrutamiento.

Si adems utilizas el mdulo mod_rewritede Apache, puedes forzar la ejecucin

del archivo app.phpsin necesidad de incluirlo en la URL, por lo que as las URL son

todava ms limpias:

http://localhost/hello/Ryan

Aunque los controladores frontales son esenciales para servir cada peticin, rara

vez los tendrs que modificar o incluso pensar en ellos. Los mencionaremos

brevemente de nuevo en la seccin dedicada a los entornos de ejecucin.

4.3.2. El directorio de la aplicacin (app)Como vimos en el controlador frontal, la clase AppKerneles el punto de entrada

principal de la aplicacin y es la responsable de toda la configuracin. Como tal,

se almacena en el directorio app/.


50/102

Esta clase debe implementar dos mtodos que definen todo lo que Symfony

necesita saber acerca de tu aplicacin. Ni siquiera tienes que preocuparte de

estos mtodos durante el arranque Symfony los rellena por ti con parmetros

predeterminados.

registerBundles(): devuelve un array con todos los bundles necesarios para

ejecutar la aplicacin.

registerContainerConfiguration(): carga el archivo de configuracin de

recursos de la aplicacin (consulta la seccin Configurando la aplicacin).

Durante el desarrollo de una aplicacin, normalmente el directorio app/solo los

utilizas para modificar la configuracin y los archivos de enrutamiento en el

directorio app/config/(consulta la seccinConfigurando la aplicacin).Este directorio tambin contiene el directorio cach de la aplicacin (app/cache), un

directorio de logs(app/logs) y un directorio para archivos de recursos globales,

tales como plantillas (app/Resources). Aprenders ms sobre cada uno de estos

directorios en captulos posteriores.

Carga automticaAl arrancar Symfony, se incluye un archivo especialllamado vendor/autoload.php. Este archivo, creado por Composer, se encarga de

configurar el cargador automtico de clases, que a su vez carga automticamente

todos los archivos de tu aplicacin que se encuentren en el directorio src/y todas

las libreras externas configuradas en el archivo composer.json.

Gracias al cargador automtico, nunca tendrs que preocuparte de usar

declaraciones includeorequire. Esto es posible porque Composer

utiliza namespaceo espacio de nombres de una clase para determinar su

ubicacin y as incluye automticamente el archivo en el instante en que necesitas

una clase.

El cargador automtico ya est configurado para buscar cualquiera de tus clasesPHP en el directorio src/. Para que funcione la carga automtica, el nombre de la

clase y la ruta del archivo deben seguir el mismo patrn:

Nombre de la clase: Acme\HelloBundle\Controller\HelloController


51/102

Ruta fsica del

archivo: src/Acme/HelloBundle/Controller/HelloController.php

4.3.3. El directorio fuente (src)

En pocas palabras, el directorio src/contiene todo el cdigo real (cdigo PHP,

plantillas, archivos de configuracin, estilos, etc.) que pertenece a tu aplicacin.

De hecho, al programar una aplicacin Symfony, la mayor parte de tu trabajo se

llevar a cabo dentro de uno o ms bundles creados en este directorio.

Pero, qu es exactamente un bundle?

4.4.El sistema de bundles

Un bundle es un concepto similar al de los plugins en otras aplicaciones, perotodava mejor. La diferencia clave es que en Symfony2 todoes un bundle,

incluyendo tanto la funcionalidad bsica de la plataforma como el cdigo escrito

para tu aplicacin.

Los bundles son la parte ms importante de Symfony2. Permiten utilizar

funcionalidades construidas por terceros o empaquetar tus propias funcionalidades

para distribuirlas y reutilizarlas en otros proyectos. Adems, facilitan mucho la

activacin o desactivacin de determinadas caractersticas dentro de una

aplicacin.

NOTAEn esta seccin solo se va a explicar lo bsico, pero hay un captulo

dedicado completamente al tema de los bundles.

Un bundle simplemente es un conjunto estructurado de archivos que se

encuentran en un directorio y que implementan una sola caracterstica. Puedes

crear por ejemplo un BlogBundle, un ForoBundleo un bundle para gestionar

usuarios (muchos de ellos ya existen como bundles de software libre). Cada

directorio contiene todo lo relacionado con esa caracterstica, incluyendo archivosPHP, plantillas, hojas de estilo, archivos Javascript, tests y cualquier otra cosa

necesaria.

Las aplicaciones Symfony se componen de bundles, tal como se define en el

mtodoregisterBundles()de la clase AppKernel:



52/102


{

$bundles=array(

newSymfony\Bundle\FrameworkBundle\FrameworkBundle(),

newSymfony\Bundle\SecurityBundle\SecurityBundle(),

newSymfony\Bundle\TwigBundle\TwigBundle(),

newSymfony\Bundle\MonologBundle\MonologBundle(),

newSymfony\Bundle\SwiftmailerBundle\SwiftmailerBundle(),

newSymfony\Bundle\DoctrineBundle\DoctrineBundle(),

newSymfony\Bundle\AsseticBundle\AsseticBundle(),

newSensio\Bundle\FrameworkExtraBundle\SensioFrameworkExtraBundle(),

);

if(in_array($this->getEnvironment(),array('dev','test'))){

$bundles[]=new Acme\DemoBundle\AcmeDemoBundle();

$bundles[]=newSymfony\Bundle\WebProfilerBundle\WebProfilerBundle(

);

$bundles[]=newSensio\Bundle\DistributionBundle\SensioDistributionBundle();

$bundles[]=newSensio\Bundle\GeneratorBundle\SensioGeneratorBundle();

}

return$bundles;

}

Con el mtodo registerBundles(), puedes controlar completamente los bundles

que utiliza tu aplicacin, incluso aquellos bundles que forman el ncleo del

framework.


53/102

TRUCOUn bundle se puede encontrar en cualquier directorio, siempre y cuando

Symfony2 lo pueda cargar automticamente (con el autocargador configurado

en app/autoload.php).

4.4.1. Creando un bundleLa edicin estndar de Symfony incluye un comando para crear bundles

totalmente funcionales de una manera muy sencilla. Por supuesto, tambin

puedes crear los bundles a mano si lo prefieres.

Para mostrarte lo sencillo que es el sistema de bundles, vamos a crear a mano y

activar un nuevo bundle llamado AcmeTestBundle.

TRUCOLa parte Acmees slo un nombre ficticio que debes sustituir por el nombre

del proveedor del bundle, es decir, el nombre o siglas de tu empresa (porejemplo, ABCTestBundlesi la empresa se llama ABC). Si es un bundle personal,

puedes utilizar tu nombre completo o las iniciales.

En primer lugar, crea un directorio src/Acme/TestBundle/ y aade un nuevo archivo

llamadoAcmeTestBundle.php ::

// src/Acme/TestBundle/AcmeTestBundle.php

namespaceAcme\TestBundle;

useSymfony\Component\HttpKernel\Bundle\Bundle;

classAcmeTestBundle extendsBundle

{

}

TRUCOEl nombre AcmeTestBundlesigue las convenciones estndar denomenclatura de bundles. Tambin puedes optar por acortar el nombre del bundle

simplemente a TestBundleal nombrar esta clase TestBundle(y el nombre del

archivo TestBundle.php).


54/102

Esta clase vaca es lo nico que necesitamos para crear nuestro nuevo bundle.

Aunque normalmente est vaca, esta clase te permite personalizar el

comportamiento del bundle.

Ahora que hemos creado nuestro bundle, tenemos que activarlo a travs de laclase AppKernel:



{

$bundles=array(

...,

// registra tus bundles

newAcme\TestBundle\AcmeTestBundle(),

);

// ...

return$bundles;

}

Aunque todava no hace nada, el bundle AcmeTestBundleya est listo para

utilizarlo.

Generar un bundle a mano es bastante sencillo, pero Symfony tambin

proporciona un comando para generar la estructura bsica del bundle:

php app/console generate:bundle --namespace=Acme/TestBundle

Como resultado este comando genera el esqueletodel bundle formado por un

controlador bsico, la plantilla y la configuracin del enrutamiento. Ms adelante

se explica en detalle la consola de comandos de Symfony2.


55/102

TRUCOCuando crees un nuevo bundle o uses un bundle de terceros, asegrate

siempre de habilitar el bundle en el mtodo registerBundles(). El

comando generate:bundlese encarga de hacerlo automticamente.

4.4.2. Estructura de directorios de un bundleLa estructura de directorios de un bundle es simple y flexible. Por defecto el

sistema de bundles sigue una serie de convenciones que ayudan a mantener el

cdigo consistente entre todos los bundles Symfony2. Echa un vistazo

a AcmeHelloBundle, ya que contiene algunos de los elementos ms comunes de un

bundle:

Controller/: contiene los controladores del bundle (por

ejemplo, HelloController.php).

DependencyInjection/: contiene elementos relacionados con el contenedor de

inyeccin de dependencias, un concepto muy avanzado que se explicar ms

adelante. Entre otras, contiene las extensiones para las clases de inyeccin

de dependencias, la configuracin que importan los servicios y registra uno o

ms pases del compilador (este directorio no es obligatorio).

Resources/config/: contiene la configuracin, incluyendo la configuracin de

enrutamiento (por ejemplo, routing.yml).

Resources/views/: contiene las plantillas organizadas segn el nombre del

controlador (por ejemplo, Hello/index.html.twig).

Resources/public/: contiene recursos web (imgenes, hojas de estilo, etc.) y

es copiado o enlazado simblicamente al directorio web/del proyecto con el

comando assets:install.

Tests/: tiene los tests unitarios y funcionales del bundle.

Un bundle puede ser tan pequeo o tan grande como sea necesario.

A medida que avances en el libro, aprenders cmo persistir objetos a una base

de datos, crear y validar formularios, crear traducciones para tu aplicacin, escribir

tests y mucho ms. Cada uno de estos tiene su propio lugar y rol dentro del

bundle.


56/102

4.5.Configurando la aplicacinLa aplicacin est formada por una coleccin de bundles que representan todas

las caractersticas y capacidades de tu aplicacin. Cada bundle se puede

personalizar a travs de archivos de configuracin escritos en YAML, XML o PHP.

De forma predeterminada, el archivo de configuracin principal se encuentra en el

directorio app/config/y se llama config.yml, config.xmlo config.phpen funcin

del formato que prefieras:

YAML

XML

PHP# app/config/config.yml

imports:

- { resource: parameters.yml }

- { resource: security.yml }

framework:

secret: "%secret%"

router: {resource: "%kernel.root_dir%/config/routing.yml"}

# ...

# Twig Configuration

twig:

debug: "%kernel.debug%"

strict_variables: "%kernel.debug%"

# ...

NOTAAprenders cmo cargar cada archivo y formato en la siguiente seccin

dedicada a los entornos de ejecucin.
http://librosweb.es/symfony_2_4/capitulo_4/configurando_la_aplicacion.html#select_tab_1_eba45http://librosweb.es/symfony_2_4/capitulo_4/configurando_la_aplicacion.html#select_tab_1_eba45http://librosweb.es/symfony_2_4/capitulo_4/configurando_la_aplicacion.html#select_tab_2_eba45http://librosweb.es/symfony_2_4/capitulo_4/configurando_la_aplicacion.html#select_tab_2_eba45http://librosweb.es/symfony_2_4/capitulo_4/configurando_la_aplicacion.html#select_tab_3_eba45http://librosweb.es/symfony_2_4/capitulo_4/configurando_la_aplicacion.html#select_tab_3_eba45http://librosweb.es/symfony_2_4/capitulo_4/configurando_la_aplicacion.html#select_tab_3_eba45http://librosweb.es/symfony_2_4/capitulo_4/configurando_la_aplicacion.html#select_tab_2_eba45http://librosweb.es/symfony_2_4/capitulo_4/configurando_la_aplicacion.html#select_tab_1_eba45


57/102

Cada opcin de nivel superior como frameworko twigdefine la configuracin de un

bundle especfico. Por ejemplo, la clave frameworkdefine la configuracin para el

ncleo de Symfony FrameworkBundlee incluye la configuracin de enrutamiento,

plantillas, y otros elementos del ncleo.

No te preocupes por el momento de las opciones de configuracin especficas de

cada seccin, ya que el archivo de configuracin viene con parmetros

predeterminados. A medida que leas y explores ms cada parte de Symfony2,

aprenders sobre las opciones de configuracin especficas de cada

caracterstica.

Formatos de configuracinA lo largo de los captulos, todos los ejemplos deconfiguracin muestran los tres formatos (YAML, XML y PHP). Cada uno tiene sus

propias ventajas y desventajas. T eliges cual utilizar:

YAML: sencillo, limpioy fcil de leer.

XML: ms poderoso que YAML y permite el autocompletado del IDE.

PHP: el ms potente, pero menos fcil de leer que los formatos de

configuracin estndar.

4.5.1. Obteniendo la configuracin por defectoEl nuevo comando config:dump-referencete permite volcar a la consola toda la

configuracin por defecto de un bundleen formato YAML. El siguiente ejemplo

muestra cmo volcar la configuracin delbundleFrameworkBundle:

$ app/console config:dump-reference FrameworkBundle

En vez de el nombre completo del bundle, tambin puedes utilizar el nombre de su

opcin de configuracin principal:

$ app/console config:dump-reference framework

4.6.EntornosUna aplicacin puede funcionar en diversos entornos. Los diferentes entornos

comparten el mismo cdigo PHP (solo es diferente el controlador frontal), pero

usan una configuracin diferente. Por ejemplo, un entorno de

desarrollo devguarda las advertencias y errores, mientras que un entorno de


58/102

produccin prodslo registra los errores. Algunos archivos se vuelven a generar

en cada peticin en el entorno dev(para mayor comodidad de los desarrolladores),

pero se cachean en el entorno prod. Todos los entornos se encuentran en la

misma mquina y ejecutan la misma aplicacin.

Un proyecto Symfony2 normalmente comienza con tres entornos

(dev, testy prod), aunque resulta sencillo crear nuevos entornos. Puedes ver tu

aplicacin en diferentes entornos con slo cambiar el controlador frontal en tu

navegador. Para ver la aplicacin en el entorno dev, accede a la aplicacin a

travs del controlador frontal de desarrollo:

http://localhost/app_dev.php/hello/Ryan

Si deseas ver cmo se comportar tu aplicacin en el entorno de produccin,

utiliza en su lugar el controlador frontal prod:


Como el entorno prodest optimizado para ser muy rpido, la configuracin, el

enrutamiento y las plantillas Twig se compilan en clases PHP simples y se

guardan en cach.

Si haces cualquier cambio en las plantillas, no lo vers en el entorno proda menos

que borres la cache de la aplicacin y as fuerces a Symfony a volver a compilar

las plantillas. Para borrar la cache del entorno de produccin, ejecuta el siguientecomando de consola:

php app/console cache:clear --env=prod --no-debug

NOTASi abres el archivo web/app.php, vers que est configurado explcitamente

para usar el entorno prod:

$kernel=newAppKernel('prod',false);

Puedes crear un nuevo controlador frontal para un nuevo entorno copiando el

archivo y cambiandoprodpor algn otro valor.

NOTAEl entorno testse utiliza cuando se ejecutan tests automticas y no se

puede acceder directamente a travs del navegador. Consulta el captulo dedicado

a los tests para obtener ms informacin.


59/102

4.6.1. Configurando entornos

La clase AppKerneles realmente la responsable de cargar el archivo de

configuracin segn el controlador que utilices:


publicfunction registerContainerConfiguration(LoaderInterface $loader)

{

$loader->load(__DIR__.'/config/config_'.$this->getEnvironment().'.yml');

}

Ya sabes que la extensin .ymlse puede cambiar a .xmlo .phpsi prefieres usar

XML o PHP para escribir tu configuracin. Adems, observa que cada entorno

carga su propio archivo de configuracin. Considera el archivo de configuracinpara el entorno dev.

YAML

XML

PHP# app/config/config_dev.yml

imports:

- { resource: config.yml }

framework:

router: {resource: "%kernel.root_dir%/config/routing_dev.yml"}

profiler: {only_exceptions: false }

# ...

La clave importses similar a una declaracin includede PHP y garantiza que en

primer lugar se carga el archivo de configuracin principal (config.yml). El resto

del archivo de configuracin predeterminado simplemente aumenta el nmero de

eventos que se registran en el log y realiza otros ajustes tiles para un entorno de

desarrollo.
http://librosweb.es/symfony_2_4/capitulo_4/entornos.html#select_tab_1_ebb7chttp://librosweb.es/symfony_2_4/capitulo_4/entornos.html#select_tab_1_ebb7chttp://librosweb.es/symfony_2_4/capitulo_4/entornos.html#select_tab_2_ebb7chttp://librosweb.es/symfony_2_4/capitulo_4/entornos.html#select_tab_2_ebb7chttp://librosweb.es/symfony_2_4/capitulo_4/entornos.html#select_tab_3_ebb7chttp://librosweb.es/symfony_2_4/capitulo_4/entornos.html#select_tab_3_ebb7chttp://librosweb.es/symfony_2_4/capitulo_4/entornos.html#select_tab_3_ebb7chttp://librosweb.es/symfony_2_4/capitulo_4/entornos.html#select_tab_2_ebb7chttp://librosweb.es/symfony_2_4/capitulo_4/entornos.html#select_tab_1_ebb7c


60/102

Ambos entornos (prody test) siguen el mismo modelo: cada uno importa el

archivo de configuracin bsico y luego modifica sus valores de configuracin para

adaptarlos a las necesidades especficas del entorno. Esto es slo una

convencin, pero te permite reutilizar la mayor parte de tu configuracin y

personalizar slo algunas opciones especficas.

4.7.ResumenEnhorabuena! Ahora ya conoces todos los aspectos fundamentales de Symfony2

y has descubierto lo fcil y flexible que puede ser. Aunque todava faltan muchas

caractersticas por explicar, asegrate de haber entendido bien los siguientes

puntos bsicos:

La creacin de una pgina es un proceso de tres pasos que requiere de

una ruta, uncontroladory (opcionalmente) una plantilla.

Cada proyecto contiene slo unos cuantos directorios

principales: web/(recursos web y controladores

frontales), app/(configuracin), src/(tus bundles), y vendor/(cdigo de

terceros). Tambin existe un directorio bin/que se utiliza para ayudarte a

actualizar las libreras de terceros.

Cada caracterstica de Symfony2 (incluyendo su propio ncleo) est

desarrollada con un bundle, que es un conjunto estructurado de archivos para

esa caracterstica.

La configuracinde cada bundle se encuentra en el directorio app/configy

se puede escribir en YAML, XML o PHP.

Cada entornoes accesible a travs de un controlador frontal diferente (por

ejemplo, app.phpyapp_dev.php) el cual a su vez carga un archivo de

configuracin diferente.

A partir de aqu, cada captulo explica conceptos ms avanzados de Symfony y

algunas de sus herramientas ms poderosas. Cuanto ms sepas sobre Symfony2,

ms apreciars la flexibilidad de su arquitectura y el poder que te proporciona para

desarrollar aplicaciones rpidamente.


61/102

Captulo 5.El controladorUn controlador es una funcin PHP creada por ti y que se encarga de obtener la

informacin de la peticin HTTP y de generar y devolver la respuesta HTTP (en

forma de objeto de tipo Responsede Symfony2). La respuesta puede ser una

pgina HTML, un documento XML, un array JSON serializado, una imagen, una

redireccin a otra pgina, un error de tipo 404 o cualquier otra cosa que se te

ocurra. El controlador contiene toda la lgica que tu aplicacin necesita para

generar el contenido de la pgina.

Para ver lo sencillo que es esto, echemos un vistazo a un controlador real de

Symfony2. El siguiente controlador genera una pgina que simplemente

imprime Hello world!:


publicfunctionhelloAction()

{

returnnewResponse('Hello world!');

}

El objetivo de un controlador siempre es el mismo: crear y devolver unobjeto Response. Para ello, a veces obtiene informacin de la peticin, o busca un

recurso en la base de datos, enva un correo electrnico, o guarda informacin en

la sesin del usuario. Independientemente de lo que haga, el controlador siempre

devuelve un objeto Responseque se utiliza para generar la respuesta que se enva

al usuario.

Como ves ni Symfony se comporta de forma automgicani existe ms requisitos

de los cuales preocuparse. Estos son algunos ejemplos de casos comunes:

Controlador Aprepara un objeto Responseque genera el contenido HTML de

la portada del sitio.

Controlador Blee el parmetro slugde la peticin para cargar una entrada del

blog desde la base de datos y crea un objeto Responsepara mostrar ese blog.


62/102


63/102

aplicacin tpica tiene un controlador frontal de produccin (por ejemplo, app.php) y

un controlador frontal de desarrollo (por ejemplo, app_dev.php). Probablemente

nunca necesites editar, ver o preocuparte por los controladores frontales en tu

aplicacin.

5.2.Un controlador sencilloA pesar de que un controlador puede ser cualquier cdigo ejecutable PHP (una

funcin, un mtodo en un objeto o un Closure), en Symfony2 un controlador suele

ser un mtodo dentro de un objeto de tipo controlador. Los controlador

Libro Symfony2.4

Documents

Transcript of Libro Symfony2.4