1. El documento describe el sistema de enrutado de Symfony, el cual mapea URLs a controladores de manera flexible y configurable. 2. Las rutas se definen en archivos YAML o mediante anotaciones y mapean patrones de URL a controladores de acción. 3. El sistema de enrutado permite agregar parámetros, requisitos y nombres a las rutas para una configuración avanzada.

1. Routing
Realizada por:
Gonzalo Alonso |@GonzaloAlonsoD
Diego Barros |@Inmzombie
Para: Hydras C&S |@hydras_cs
Basada en Libro Symfony 2 en español Nacho Pacheco y The Book

2. Enrutando
URL feas: index.php?article_id=57
URL bonitas: /leer/intro-a-symfony.
Flexibilidad
Cambiar la URL de una página de /blog a
/noticias. ¿Cuántos enlaces necesitas
actualizar para hacer el cambio? Utilizando el
enrutador de Symfony, el cambio es sencillo.

3. Enrutador en Acción
Una ruta es un mapa desde un patrón URL
hasta un controlador.
# app/config/routing.yml
blog_show:
pattern: /blog/{slug}
defaults: { _controller: AcmeBlogBundle:Blog:show }

4. namespace AcmeBlogBundleController;
use SymfonyBundleFrameworkBundleControllerController;
class BlogController extends Controller
{
public function showAction($slug)
{
// usa la variable $slug para consultar la base de datos
$blog = ...;
return
$this->render('AcmeBlogBundle:Blog:show.html.twig',
array('blog' => $blog,));
}
}

5. /**
* @Route("/blog/{slug}")
*/
public function showAction($slug)
{
}
# app/config/routing.yml
blog_show:
pattern: /blog/{slug}
defaults: { _controller: AcmeBlogBundle:Blog:show }
YAML
ANNOTATIONS

6. Enrutando: Bajo el capó

7. Creando rutas
# app/config/config.yml
framework:
# ...
router: { resource: "%kernel.root_dir%/config/routing.yml" }
Symfony carga todas las rutas de tu aplicación
desde un archivo de configuración de enrutado.

8. Enrutando con marcadores de posición
Muchas rutas contienen uno o más «comodines» llamados
marcadores de posición:
blog_show:
pattern: /blog/{slug}
defaults: { _controller: AcmeBlogBundle:Blog:show }
/**
* @Route("/blog/{slug}")
*/
public function showAction($slug)
{
}

9. Los marcadores de posición opcionales
blog:
pattern: /blog/{page}
defaults: {_controller: AcmeBlogBundle:Blog:index, page:1}
Las rutas con parámetros opcionales al final no coincidirán con peticiones con
una barra inclinada final (es decir, /blog/ no coincidirá, en cambio /blog
concordará).
/**
* @Route("/blog/{page}, defaults={"page" = 1}")
*/
public function indexAction($page)
{
}

10. Agregando Requisitos
blog:
pattern: /blog/{page}
defaults:{_controller:AcmeBlogBundle:Blog:index,page:1}
requirements:
page: d+
Rutas anteriores siempre gana.
/**
* @Route("/blog/{page},
* requirements={"page" = "d+"},
* defaults={"page" = 1}")
*/
public function indexAction($page){}

11. homepage:
pattern: /{_locale}
defaults: { _controller: AcmeDemoBundle:Main:
homepage, _locale: en }
requirements:
_locale: en|fr
Los requisitos de los parámetros son
expresiones regulares, la complejidad y la
flexibilidad de cada requisito depende de uno.

12. Agregando requisitos de método
HTTP
contact:
pattern: /contact
defaults: { _controller: AcmeDemoBundle:Main:contact }
requirements:
_method: GET
contact_process:
pattern: /contact
defaults: { _controller: AcmeDemoBundle:Main:contactProcess
}
requirements:
_method: POST
Si no especificas el requisito _method, la ruta coincidirá con todos los métodos.

13. Agregando requisitos de método HTTP con
annotations
/**
* @Route("/contact", name="contact")
* @Method("post")
*/
public function indexAction()
{
}

14. Ejemplo de enrutado avanzado
article_show:
pattern: /articles/{_locale}/{year}/{title}.{_format}
defaults:{_controller:AcmeDemoBundle:Article:show,_format:
html}
requirements:
_locale: en|fr
_format: html|rss
year: d+
/articles/en/2010/my-post
/articles/fr/2010/my-post.rss
Si utilizas el parámetro _locale en una ruta, ese valor
también se almacenará en la sesión para las peticiones lo
cual evita guardar la misma región.

15. Patrón de nomenclatura para controladores
paquete:controlador:acción
Por ejemplo, un valor _controller de AcmeBlogBundle:Blog:show
Paquete Clase de
controlador
Nombre método
AcmeBlogBundle BlogController showAction
namespace AcmeBlogBundleController;
use SymfonyBundleFrameworkBundleControllerController;
class BlogController extends Controller
{
public function showAction($slug)
{ // ... }
}

16. Parámetros y argumentos del controlador
Los parámetros definidos en las configuraciones de las rutas son
importantes, cada uno de estos se transforma en una variable para el
método del controlador.
public function showAction($slug)
{
// ...
}

17. Incluyendo fuentes externas de rutas
Todas las rutas se cargan a través de un archivo de configuración
/app/config/routing.yml.
Si es necesario traer rutas desde otros lugares como otro archivo
dentro de un bundle por ejemplo se puede realizar de la siguiente
manera.
# app/config/routing.yml
acme_hello:
resource:
"@AcmeHelloBundle/Resources/config/routing.yml"

18. @Route and @Method - Activación
# app/config/routing.yml
# Importar rutas desde una clase de controlador
post:
resource: "@SensioBlogBundle/Controller/PostController.php"
type: annotation
# Importar rutas desde un directorio del controlador
blog:
resource: "@SensioBlogBundle/Controller"
type: annotation
post:
resource: "@SensioBlogBundle/Controller/PostController.php"
prefix: /blog
type: annotation

19. Nombre de ruta
/**
* @Route("/", name="blog_home")
*/
public function indexAction()
{
// ...
}
@Route le asigna un nombre predeterminado compuesto
por el nombre del paquete, el nombre del controlador y el
nombre de la acción.
Por ejemplo sensio_blog_comunicado_index;

20. Prefijo de ruta
/**
* @Route("/blog")
*/
class PostController extends Controller
{
/**
* @Route("/{id}")
*/
public function showAction($id)
{
}
}

21. Método de la ruta
use SensioBundleFrameworkExtraBundleConfigurationRoute;
use
SensioBundleFrameworkExtraBundleConfigurationMethod;
class PostController extends Controller
{
/**
* @Route("/edit/{id}")
* @Method({"GET", "POST"})
*/
public function editAction($id){}
}

22. Configuraciones en YAML
YAML (Ain't Markup Language), es una visualización amigable de los
datos para todos los lenguajes de programación.
YAML es un muy buen formato para los archivos de configuración son
igualmente expresivos que XML y tan fácil de leer como un INI.
El componente YAML de Symfony2 implementa la versión 1.2.

23. Tipos de datos
1 A string in YAML
1 'A singled-quoted string in YAML'
String:

24. Tipos de datos
Cuando los string contiene saltos de líneas se indica con el "|"
1
2
3
|
/ /| |/| |
/ / | | | |__
Alternativa ">"
1
2
3
4
5
>
This is a very long sentence
that spans several lines in the YAML
but which will be rendered as a string
without carriage returns.

25. Tipos de datos
1
2
# an integer
12
1
2
# an octal
014
1
2
# an hexadecimal
0xC
1
2
# a float
13.4
Números:

26. Tipos de datos
Nulls:
Nulls en YAML se pueden expresar con null o -.
Booleans:
true and false
Fecha:
YML usa la ISO-8601 para expresar días:
1 2001-12-14t21:59:43.10-05:00
1
2
# simple date
2002-12-14

27. Colecciones:
Por lo general YAML lo vamos a utilizar par definir colecciones de
configuraciones. Las colecciones pueden ser secuencias de datos o
mapeados por elementos. Las dos son convertidas por PHP a arrays.
Secuencias van seguidas de un guión medio y un espacio:
1
2
3
- PHP
- Perl
- Python
En PHP sería:
1 array('PHP', 'Perl', 'Python');

28. Colecciones:
Asignaciones utilizan ":" seguido de un espacio para marcar cada
clave/valor
1
2
3
PHP: 5.2
MySQL: 5.1
Apache: 2.2.20
Lo cual es equivalente en código PHP a:
1 array('PHP' => 5.2, 'MySQL' => 5.1, 'Apache' => '2.2.20');

29. YAML usa indentación para describir colecciones:
Equivalente en PHP:
1
2
3
4
5
6
"symfony 1.0":
PHP: 5.0
Propel: 1.2
"symfony 1.2":
PHP: 5.2
Propel: 1.3
1
2
3
4
5
6
7
8
9
10
array(
'symfony 1.0' => array(
'PHP' => 5.0,
'Propel' => 1.2,
),
'symfony 1.2' => array(
'PHP' => 5.2,
'Propel' => 1.3,
),
);

30. La forma en la que encontraremos los datos de la configuración de
symfony2 en general:
1 [PHP, Perl, Python]
1 { PHP: 5.2, MySQL: 5.1, Apache: 2.2.20 }
Se pueden mezclar ambas:
1
2
'Chapter 1': [Introduction, Event Types]
'Chapter 2': [Introduction, Helpers]
1
2
"symfony 1.0": { PHP: 5.0, Propel: 1.2 }
"symfony 1.2": { PHP: 5.2, Propel: 1.3 }

31. Comentarios:
Los comentarios se realizan con el prefijo del "#"
1
2
3
# Comment on a line
"symfony 1.0": { PHP: 5.0, Propel: 1.2 } # Comment at the end of a line
"symfony 1.2": { PHP: 5.2, Propel: 1.3 }

32. Veamos un pequeño ejemplo:
1
2
3
# app/config/routing.yml
conversation:
resource: "@ConversationBundle/Resources/config/routing.yml"
prefix: /
1
2
3
# src/Backend/ConversationBundle/Resources/config/routing.yml
conversation_admin_chat:
resource: "@ConversationBundle/Resources/config/routing/topicchat.yml"
prefix: /admin/chat
1
2
3
# src/Backend/ConversationBundle/Resources/config/routing/topicchat.yml
admin_chat:
pattern: /
default: { _controller : "@ConversationBundle/Resources/config/routing/topicchat.yml" }
.
.
.
*importante la clave identificadora no debe repetirse

33. Prefijo en las importaciones de las rutas
Las rutas pueden proveerse de un prefijo (prefix) que puede ser
importado a través de las rutas.
de forma que el patrón original se por ejemplo /amin/hello/{name} o
simplemente /hello/{name}
# app/config/routing.yml
acme_hello:
resource: "@AcmeHelloBundle/Resources/config/routing.yml"
prefix: /admin

34. Visualización y Debugging
Mientras vayamos agregando y configurando nuestras rutas. Es de
bastante ayuda poder visualizar un detalle de la información. Un forma
de ver todas las rutas en tu aplicación es a través del comando router:
debug
1 $ php app/console router:debug
1
2
3
4
5
6
homepage ANY /
contact GET /contact
contact_process POST /contact
article_show ANY /articles/{culture}/{year}/{title}.{_format}
blog ANY /blog/{page}
blog_show ANY /blog/{slug}

35. También se puede especificar una ruta por el nombre con el comando:
1 $ php app/console router:debug article_show
Se puede además usar el comando match para verificar si las
rutas coinciden con cierta petición:
1
2
$ php app/console router:match /articles/en/2012/article.rss
Route "article_show" matches

36. Si es necesario generar una url en el controlador es posible a través
de:
1
2
3
4
5
6
7
8
9
10
11
12
class MainController extends Controller
{
public function showAction($slug)
{
// ...
$url = $this->generateUrl(
'blog_show',
array('slug' => 'my-blog-post')
);
}
}

37. Generando URLs desde el template
El lugar más común donde se generan las URL es en las templates cuando generamos links entre las
páginas en la aplicación.
Helper path:
1
2
3
<a href="{{ path('blog_show', {'slug': 'my-blog-post'}) }}">
Read this blog post.
</a>
Para una ruta absoluta usaremos url:
1
2
3
<a href="{{ url('blog_show', {'slug': 'my-blog-post'}) }}">
Read this blog post.
</a>

38. Bueno vimos manejo de peticiones hacia el servidor y como se
resuelven, pero que tal si las peticiones van desde el servidor hacia el
exterior y necesitamos procesar estos datos.
Para esto podemos usar el CURL() o algún bundle que facilite la
petición.
Mostraremos un pequeñísimo ejemplo.
Para este ejemplo se usó el bundle(GremoBuzzBundle):
https://github.com/gremo/GremoBuzzBundle
Para consultar la API de Yahoo sobre el clima por ejemplo...

39. 1
2
3
4
5
6
7
8
9
10
11
12
class MainController extends Controller
{
public function weatherAction($codCountry)
{
$request = $this->getRequest();
if ($request->isXmlHttpRequest()) {
$query = rawurlencode('select item from weather.forecast where location="'$codCountry'"');
$url = "http://query.yahooapis.com/v1/public/yql?q=" . $query . "&format=json";
//instancia del bundle gremo buzz
$browser = $this->get('gremo_buzz');
//petición del json
$responseWeather = $browser->get($url);
//parceo el json y lo proceso
$weather = json_decode($responseWeather->getContent(), true);
//...
retrun $weather;//procesado
} else {
return '';
}
}
}

40. La variable $url contendría
http://query.yahooapis.com/v1/public/yql?q=select%20item%20from%
20weather.forecast%20where%20location%3D"ARCO0072"
&format=json
y si pasamos eso al browser...
Las respuestas json se procesan como clases standard de PHP o como
array con la opción a true del json_decode().