Accentsconagua

Configura el enrutamiento en aplicaciones PHP usando el componente de enrutamiento de Symfony

Código
Share

Hoy pasaremos por el componente de enrutamiento de Symfony, que te permite configurar el enrutamiento en tus aplicaciones PHP.

¿Qué es el componente de enrutamiento de Symfony??

El componente de enrutamiento de Symfony es un componente de enrutamiento muy popular que está adaptado por varios marcos y proporciona mucha flexibilidad si deseas configurar rutas en tu aplicación PHP.

Si has creado una aplicación PHP personalizada y estás buscando una biblioteca de enrutamiento rica en características, el Componente de enrutamiento de Symfony vale más que un vistazo. También le permite definir rutas para su aplicación en el formato YAML..

Comenzando con la instalación y la configuración, veremos ejemplos reales para demostrar una variedad de opciones que el componente tiene para la configuración de rutas. En este artículo, aprenderás:

  • instalacion y configuracion
  • Cómo configurar rutas básicas.
  • Cómo cargar rutas desde el archivo YAML.
  • Cómo utilizar el enrutador todo en uno.

Instalacion y configuracion

En esta sección, vamos a instalar las bibliotecas que se requieren para configurar el enrutamiento en sus aplicaciones PHP. Supongo que ha instalado Composer en su sistema, ya que lo necesitaremos para instalar las bibliotecas necesarias que están disponibles en Packagist.

Una vez que haya instalado Composer, continúe e instale el componente de enrutamiento principal con el siguiente comando.

$ compositor requiere symfony / enrutamiento

Aunque el componente de enrutamiento en sí es suficiente para proporcionar funciones de enrutamiento integrales en su aplicación, seguiremos adelante e instalaremos algunos otros componentes para facilitar nuestra vida y enriquecer la funcionalidad de enrutamiento central existente..

Para empezar, seguiremos adelante e instalaremos el componente HttpFoundation, que proporciona un envoltorio orientado a objetos para variables globales de PHP y funciones relacionadas con la respuesta. Se asegura de que no necesite acceder a variables globales como $ _GET, $ _POST y similares directamente.

$ compositor requiere symfony / http-foundation

A continuación, si desea definir las rutas de su aplicación en el archivo YAML en lugar del código PHP, es el componente YAML el que viene al rescate, ya que le ayuda a convertir cadenas YAML a matrices PHP y viceversa..

$ compositor requiere symfony / yaml

Finalmente, instalaremos el componente Config, que proporciona varias clases de utilidad para inicializar y tratar los valores de configuración definidos en los diferentes tipos de archivos como YAML, INI, XML, etc. En nuestro caso, lo usaremos para cargar rutas del archivo YAML.

$ compositor requiere symfony / config

Así que esa es la parte de la instalación, pero ¿cómo se supone que la uses? De hecho, solo es cuestión de incluir el autoload.php archivo creado por Composer en su aplicación, como se muestra en el siguiente fragmento de código.

Configurar rutas básicas

En la sección anterior, pasamos por la instalación de los componentes de enrutamiento necesarios. Ahora, está listo para configurar el enrutamiento en su aplicación PHP de inmediato..

Sigamos adelante y creemos la basic_routes.php archivo con los siguientes contenidos.

 'FooController')); // Iniciar ruta con marcadores de posición dinámicos $ foo_placeholder_route = new Route ('/ foo / id', array ('controller' => 'FooController', 'method' => 'load'), array ('id' => '[0-9] +')); // Agregar objeto (s) de ruta al objeto RouteCollection $ route = new RouteCollection (); $ route-> add ('foo_route', $ foo_route); $ route-> add ('foo_placeholder_route', $ foo_placeholder_route); // Init RequestContext object $ context = new RequestContext (); $ context-> fromRequest (Request :: createFromGlobals ()); // Init UrlMatcher object $ matcher = new UrlMatcher ($ route, $ context); // Encuentra la ruta actual $ parameters = $ matcher-> match ($ context-> getPathInfo ()); // Cómo generar un generador URL de $ SEO = nuevo UrlGenerator ($ rutas, $ contexto); $ url = $ generador-> generar ('foo_placeholder_route', array ('id' => 123,)); eco '
'; print_r ($ parámetros); echo 'URL generada:'. $ url; salida;  catch (ResourceNotFoundException $ e) echo $ e-> getMessage (); 
La configuración de enrutamiento usando el componente de enrutamiento de Symfony generalmente se realiza a través de una serie de pasos como se detalla a continuación.
     
  • Inicializar el Ruta Objeto para cada una de tus rutas de aplicación..
    •  
  • Añadir todo Ruta objetos a la RouteCollection objeto.
    •  
  • Inicializar el RequestContext objeto que contiene la información de contexto de solicitud actual.
    •  
  • Inicializar el UrlMatcher objeto pasando el RouteCollection objeto y el RequestContext objeto.
    •  
Inicializar el objeto de ruta para diferentes rutas
Sigamos adelante y definamos un concepto bastante básico. foo ruta.
$ foo_route = new Route ('/ foo', array ('controller' => 'FooController'));
El primer argumento de la Ruta constructor es la ruta de URI, y el segundo argumento es la matriz de atributos personalizados que desea devolver cuando esta ruta en particular coincide. Por lo general, sería una combinación del controlador y el método al que le gustaría llamar cuando se solicita esta ruta.
A continuación, echemos un vistazo a la ruta parametrizada..
$ foo_placeholder_route = nueva Ruta ('/ foo / id', array ('controller' => 'FooController', 'method' => 'load'), array ('id' => '[0-9] + '));
La ruta anterior puede coincidir con URI como foo / 1, foo / 123 y similares. Tenga en cuenta que hemos restringido la carné de identidad parámetro a valores numéricos solamente, y por lo tanto no coincidirá con URI como foo / bar desde el carné de identidad el parámetro se proporciona como una cadena.
Agregar todos los objetos de ruta al objeto RouteCollection
El siguiente paso es agregar objetos de ruta que hemos inicializado en la sección anterior a la RouteCollection objeto.
$ rutas = nueva RouteCollection (); $ route-> add ('foo_route', $ foo_route); $ route-> add ('foo_placeholder_route', $ foo_placeholder_route);
Como puede ver, es bastante sencillo ya que solo necesita usar el añadir método de la RouteCollection Objeto para agregar objetos de ruta. El primer argumento de la añadir método es el nombre de la ruta y el segundo argumento es el propio objeto de la ruta.
Inicializar el RequestContext Objeto
A continuación, necesitamos inicializar el RequestContext objeto, que contiene la información de contexto de solicitud actual. Necesitaremos este objeto cuando inicialicemos UrlMatcher Objeto como lo haremos en un momento.
$ context = new RequestContext (); $ context-> fromRequest (Request :: createFromGlobals ());
Inicializar el UrlMatcher Objeto
Finalmente, necesitamos inicializar el UrlMatcher objeto junto con rutas e información de contexto.
// Init UrlMatcher object $ matcher = new UrlMatcher ($ route, $ context);
Ahora, tenemos todo lo que podríamos igualar con nuestras rutas..
Cómo hacer coincidir las rutas
Es el partido método de la UrlMatcher objeto que le permite hacer coincidir cualquier ruta con un conjunto de rutas predefinidas.
los partido El método toma el URI como primer argumento y trata de compararlo con las rutas predefinidas. Si se encuentra la ruta, devuelve atributos personalizados asociados con esa ruta. Por otro lado, arroja la ResourceNotFoundException excepción si no hay una ruta asociada con el URI actual.
$ parameters = $ matcher-> match ($ context-> getPathInfo ());
En nuestro caso, hemos proporcionado el URI actual al buscarlo en el $ contexto objeto. Entonces, si está accediendo a la http http: //your-domain/basic_routes.php/foo URL, $ context-> getPathInfo () devoluciones foo, y ya hemos definido una ruta para el foo URI, por lo que nos debe devolver lo siguiente..
Array ([controller] => FooController [_route] => foo_route)
Ahora, avancemos y probemos la ruta parametrizada accediendo a la URL http: //tu_dominio/basic_routes.php/foo/123.
Array ([controller] => FooController [method] => load [id] => 123 [_route] => foo_placeholder_route)
Funcionó si puedes ver que el carné de identidad parámetro está vinculado con el valor apropiado 123.
A continuación, intentemos acceder a una ruta inexistente como http: //your-domain/basic_routes.php/unknown-route, y debería ver el siguiente mensaje.
No se encontraron rutas para "/ unknown-route".
Así es como puedes encontrar rutas usando el partido método.
Aparte de esto, también podrías usar el Enrutamiento Componente para generar enlaces en su aplicación. Previsto RouteCollection y RequestContext objetos, el UrlGenerator Te permite construir enlaces para rutas específicas.
$ generator = new UrlGenerator ($ route, $ context); $ url = $ generador-> generar ('foo_placeholder_route', array ('id' => 123,));
El primer argumento de la generar método es el nombre de la ruta, y el segundo argumento es la matriz que puede contener parámetros si es la ruta parametrizada. El código anterior debe generar el /basic_routes.php/foo/123 URL.
Cargar rutas desde el archivo YAML
En la sección anterior, construimos nuestras rutas personalizadas usando el Ruta y RouteCollection objetos. De hecho, la Enrutamiento El componente ofrece diferentes formas en las que puede elegir para crear instancias de rutas. Usted puede elegir entre varios cargadores como YamlFileLoader, XmlFileLoader, y PhpFileLoader.
En esta sección, pasaremos por el YamlFileLoader cargador para ver cómo cargar rutas desde el archivo YAML.
El archivo de rutas YAML
Sigue adelante y crea el rutas.yaml archivo con los siguientes contenidos.
foo_route: path: / foo defaults: controller: 'FooController :: indexAction' foo_placeholder_route: path: / foo / id por defecto: controller: 'FooController :: loadAction' requisitos: id: '[0-9] + '
Un archivo de ejemplo
A continuación, sigue adelante y haz la load_routes_from_yaml.php archivo con los siguientes contenidos.
carga ('route.yaml'); // Init RequestContext object $ context = new RequestContext (); $ context-> fromRequest (Request :: createFromGlobals ()); // Init UrlMatcher object $ matcher = new UrlMatcher ($ route, $ context); // Encuentra la ruta actual $ parameters = $ matcher-> match ($ context-> getPathInfo ()); // Cómo generar un generador URL de $ SEO = nuevo UrlGenerator ($ rutas, $ contexto); $ url = $ generador-> generar ('foo_placeholder_route', array ('id' => 123,)); eco '
'; print_r ($ parámetros); echo 'URL generada:'. $ url; salida;  catch (ResourceNotFoundException $ e) echo $ e-> getMessage (); 
Lo único diferente en este caso es la forma en que inicializamos las rutas.!
$ fileLocator = new FileLocator (array (__ DIR__)); $ loader = new YamlFileLoader ($ fileLocator); $ route = $ loader-> load ('route.yaml');
Hemos utilizado el YamlFileLoader cargador para cargar rutas desde el rutas.yaml Archivo en lugar de inicializarlo directamente en el propio PHP. Aparte de eso, todo es igual y debería producir los mismos resultados que los de basic_routes.php expediente.
El enrutador todo en uno
Por último en esta sección, pasaremos por el Enrutador clase, que le permite configurar el enrutamiento rápidamente con menos líneas de código.
Sigue adelante y haz el all_in_one_router.php archivo con los siguientes contenidos.
fromRequest (Request :: createFromGlobals ()); $ router = new Router (nuevo YamlFileLoader ($ fileLocator), 'route.yaml', array ('cache_dir' => __DIR __. '/ cache'), $ requestContext); // Encuentre la ruta actual $ parameters = $ router-> match ($ requestContext-> getPathInfo ()); // Cómo generar una URL URL $ route = $ router-> getRouteCollection (); $ generator = new UrlGenerator ($ route, $ requestContext); $ url = $ generador-> generar ('foo_placeholder_route', array ('id' => 123,)); eco '
'; print_r ($ parámetros); echo 'URL generada:'. $ url; salida;  catch (ResourceNotFoundException $ e) echo $ e-> getMessage (); 
Todo es más o menos igual, excepto que hemos instanciado el Enrutador Objeto junto con las dependencias necesarias..
$ router = new Router (nuevo YamlFileLoader ($ fileLocator), 'route.yaml', array ('cache_dir' => __DIR __. '/ cache'), $ requestContext);
Con eso en su lugar, puede utilizar de inmediato el partido Método del objeto Router para la asignación de rutas..
$ parameters = $ router-> match ($ requestContext-> getPathInfo ());
Además, tendrá que utilizar el getRouteCollection Método del objeto Router para buscar rutas..
$ route = $ router-> getRouteCollection ();
Conclusión
Continúe y explore las otras opciones disponibles en el componente Enrutamiento. Me encantaría escuchar sus opiniones.!
Hoy, exploramos el componente de enrutamiento de Symfony, que hace que la implementación del enrutamiento en aplicaciones PHP sea muy fácil. En el camino, creamos un puñado de ejemplos para demostrar varios aspectos del componente Enrutamiento. 
Espero que hayas disfrutado de este artículo y siéntete libre de publicar tus pensamientos usando la siguiente información.!





	
	
			
	   
	







Código
×