Clase 4 routing
Post on 25-Jan-2015
293 Views
Preview:
DESCRIPTION
Transcript
Routing
Realizada por:Gonzalo Alonso |@GonzaloAlonsoDDiego Barros |@Inmzombie
Para: Hydras C&S |@hydras_csBasada en Libro Symfony 2 en español Nacho Pacheco y The Book
Enrutando
URL feas: index.php?article_id=57
URL bonitas: /leer/intro-a-symfony.
FlexibilidadCambiar 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.
Enrutador en Acción
Una ruta es un mapa desde un patrón URL hasta un controlador.
# app/config/routing.ymlblog_show: pattern: /blog/{slug} defaults: { _controller: AcmeBlogBundle:Blog:show }
namespace Acme\BlogBundle\Controller;use Symfony\Bundle\FrameworkBundle\Controller\Controller;
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,)); }}
/** * @Route("/blog/{slug}") */public function showAction($slug){}
# app/config/routing.ymlblog_show: pattern: /blog/{slug} defaults: { _controller: AcmeBlogBundle:Blog:show }
YAML
ANNOTATIONS
Enrutando: Bajo el capó
Creando rutas
# app/config/config.ymlframework: # ... 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.
Enrutando con marcadores de posiciónMuchas 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){}
Los marcadores de posición opcionalesblog: 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){}
Agregando Requisitosblog: 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){}
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.
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: POSTSi no especificas el requisito _method, la ruta coincidirá con todos los métodos.
Agregando requisitos de método HTTP con annotations
/** * @Route("/contact", name="contact") * @Method("post") */public function indexAction(){}
Ejemplo de enrutado avanzadoarticle_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.rssSi 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.
Patrón de nomenclatura para controladorespaquete:controlador:acciónPor ejemplo, un valor _controller de AcmeBlogBundle:Blog:show
Paquete Clase de controlador
Nombre método
AcmeBlogBundle BlogController showAction
namespace Acme\BlogBundle\Controller;use Symfony\Bundle\FrameworkBundle\Controller\Controller;class BlogController extends Controller{ public function showAction($slug) { // ... }}
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){ // ...}
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.ymlacme_hello: resource: "@AcmeHelloBundle/Resources/config/routing.yml"
@Route and @Method - Activación
# app/config/routing.yml# Importar rutas desde una clase de controladorpost: resource: "@SensioBlogBundle/Controller/PostController.php" type: annotation
# Importar rutas desde un directorio del controladorblog: resource: "@SensioBlogBundle/Controller" type: annotation
post: resource: "@SensioBlogBundle/Controller/PostController.php" prefix: /blog type: annotation
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;
Prefijo de ruta
/** * @Route("/blog") */class PostController extends Controller{ /** * @Route("/{id}") */ public function showAction($id) { }}
Método de la ruta
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;use Sensio\Bundle\FrameworkExtraBundle\Configuration\Method;
class PostController extends Controller{ /** * @Route("/edit/{id}") * @Method({"GET", "POST"}) */ public function editAction($id){}}
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.
Tipos de datos
1 A string in YAML
1 'A singled-quoted string in YAML'
String:
Tipos de datos
Cuando los string contiene saltos de líneas se indica con el "|"
123
| \/ /| |\/| | / / | | | |__
Alternativa ">"
12345
> This is a very long sentence that spans several lines in the YAML but which will be rendered as a string without carriage returns.
Tipos de datos
12
# an integer12
12
# an octal014
12
# an hexadecimal0xC
12
# a float13.4
Números:
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
12
# simple date2002-12-14
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:
123
- PHP- Perl- Python
En PHP sería:
1 array('PHP', 'Perl', 'Python');
Colecciones:
Asignaciones utilizan ":" seguido de un espacio para marcar cada clave/valor
123
PHP: 5.2MySQL: 5.1Apache: 2.2.20
Lo cual es equivalente en código PHP a:
1 array('PHP' => 5.2, 'MySQL' => 5.1, 'Apache' => '2.2.20');
YAML usa indentación para describir colecciones:
Equivalente en PHP:
123456
"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 910
array( 'symfony 1.0' => array( 'PHP' => 5.0, 'Propel' => 1.2, ), 'symfony 1.2' => array( 'PHP' => 5.2, 'Propel' => 1.3, ),);
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:12
'Chapter 1': [Introduction, Event Types]'Chapter 2': [Introduction, Helpers]
12
"symfony 1.0": { PHP: 5.0, Propel: 1.2 }"symfony 1.2": { PHP: 5.2, Propel: 1.3 }
Comentarios:Los comentarios se realizan con el prefijo del "#"
123
# 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 }
Veamos un pequeño ejemplo:
123
# app/config/routing.ymlconversation: resource: "@ConversationBundle/Resources/config/routing.yml" prefix: /
123
# src/Backend/ConversationBundle/Resources/config/routing.ymlconversation_admin_chat: resource: "@ConversationBundle/Resources/config/routing/topicchat.yml" prefix: /admin/chat
123
# src/Backend/ConversationBundle/Resources/config/routing/topicchat.ymladmin_chat: pattern: / default: { _controller : "@ConversationBundle/Resources/config/routing/topicchat.yml" } ...
*importante la clave identificadora no debe repetirse
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.ymlacme_hello: resource: "@AcmeHelloBundle/Resources/config/routing.yml" prefix: /admin
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
123456
homepage ANY /contact GET /contactcontact_process POST /contactarticle_show ANY /articles/{culture}/{year}/{title}.{_format}blog ANY /blog/{page}blog_show ANY /blog/{slug}
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:
12
$ php app/console router:match /articles/en/2012/article.rssRoute "article_show" matches
Si es necesario generar una url en el controlador es posible a través de:
1 2 3 4 5 6 7 8 9101112
class MainController extends Controller{ public function showAction($slug) { // ...
$url = $this->generateUrl( 'blog_show', array('slug' => 'my-blog-post') ); }}
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:
123
<a href="{{ path('blog_show', {'slug': 'my-blog-post'}) }}"> Read this blog post.</a>
Para una ruta absoluta usaremos url:
123
<a href="{{ url('blog_show', {'slug': 'my-blog-post'}) }}"> Read this blog post.</a>
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/GremoBuzzBundlePara consultar la API de Yahoo sobre el clima por ejemplo...
1 2 3 4 5 6 7 8 9101112
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 ''; }
}}
La variable $url contendría http://query.yahooapis.com/v1/public/yql?q=select%20item%20from%20weather.forecast%20where%20location%3D"ARCO0072"&format=jsony 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().
top related