Configurer le routage dans les applications PHP à l'aide du composant de routage Symfony

Aujourd'hui, nous allons passer en revue le composant de routage Symfony, qui vous permet de configurer le routage dans vos applications PHP..

Qu'est-ce que le composant de routage Symfony??

Le composant de routage Symfony est un composant de routage très populaire, adapté à plusieurs frameworks et offrant une grande flexibilité si vous souhaitez configurer des itinéraires dans votre application PHP..

Si vous avez créé une application PHP personnalisée et recherchez une bibliothèque de routage riche en fonctionnalités, le composant de routage Symfony vaut bien plus qu'un coup d'oeil. Il vous permet également de définir des itinéraires pour votre application au format YAML..

À partir de l'installation et de la configuration, nous allons passer en revue des exemples concrets pour illustrer diverses options du composant en matière de configuration de routage. Dans cet article, vous apprendrez:

• installation et configuration
• comment configurer les itinéraires de base
• comment charger des routes à partir du fichier YAML
• comment utiliser le routeur tout-en-un
  

Installation et configuration

Dans cette section, nous allons installer les bibliothèques nécessaires pour configurer le routage dans vos applications PHP. Je suppose que vous avez installé Composer sur votre système car nous en aurons besoin pour installer les bibliothèques nécessaires disponibles sur Packagist..

Une fois Composer installé, installez le composant de routage principal à l’aide de la commande suivante..

$ composer nécessite symfony / routing

Bien que le composant de routage lui-même soit suffisant pour fournir des fonctionnalités de routage complètes dans votre application, nous allons également installer quelques autres composants pour nous simplifier la vie et enrichir les fonctionnalités de routage principales existantes..

Pour commencer, nous allons installer le composant HttpFoundation, qui fournit un wrapper orienté objet pour les variables globales PHP et les fonctions liées aux réponses. Cela garantit que vous n'avez pas besoin d'accéder à des variables globales telles que $ _GET, $ _POST et similaires directement.

$ composer nécessite symfony / http-foundation

Ensuite, si vous souhaitez définir vos routes d’application dans le fichier YAML au lieu du code PHP, c’est le composant YAML qui vient à la rescousse, car il vous aide à convertir les chaînes YAML en tableaux PHP et inversement..

$ composer exige symfony / yaml

Enfin, nous installerons le composant Config, qui fournit plusieurs classes d’utilitaires pour initialiser et gérer les valeurs de configuration définies dans les différents types de fichiers tels que YAML, INI, XML, etc. Dans notre cas, nous l’utiliserons pour charger des itinéraires. à partir du fichier YAML.

$ composer nécessite symfony / config

C'est donc la partie installation, mais comment êtes-vous censé l'utiliser? En fait, il s’agit simplement d’inclure le autoload.php fichier créé par Composer dans votre application, comme indiqué dans l'extrait suivant.

Configurer des itinéraires de base

Dans la section précédente, nous avons décrit l'installation des composants de routage nécessaires. Vous êtes maintenant prêt à configurer immédiatement le routage dans votre application PHP..

Allons-y et créons le basic_routes.php fichier avec le contenu suivant.

 «FooController»)); // Init route avec espaces réservés dynamiques $ foo_placeholder_route = new Route ('/ foo / id', array ('controller' => 'FooController', 'method' => 'load'), array ('id' => '[0-9] +')); // Ajouter un ou plusieurs objets Route à un objet RouteCollection $ routes = new RouteCollection (); $ routes-> add ('foo_route', $ foo_route); $ routes-> add ('foo_placeholder_route', $ foo_placeholder_route); // Objet RequestContext Init $ context = new RequestContext (); $ context-> fromRequest (Request :: createFromGlobals ()); // Init UrlMatcher object $ matcher = new UrlMatcher ($ routes, $ context); // Trouver la route actuelle $ parameters = $ matcher-> match ($ context-> getPathInfo ()); // Comment générer une URL de référencement $ generator = new UrlGenerator ($ routes, $ context); $ url = $ generateur-> generate ('foo_placeholder_route', array ('id' => 123,)); écho '
'; print_r ($ paramètres); echo 'URL générée:'. $ url; sortie;  catch (ResourceNotFoundException $ e) echo $ e-> getMessage (); 
La configuration du routage à l'aide du composant de routage Symfony s'effectue généralement en plusieurs étapes, comme indiqué ci-dessous.
 
Initialiser le Route objet pour chacun de vos itinéraires d'application.
 
Tout ajouter Route objets à la RouteCollection objet.
 
Initialiser le RequestContext objet qui contient les informations de contexte de demande en cours.
 
Initialiser le UrlMatcher objet en passant le RouteCollection objet et le RequestContext objet.
 
Initialiser l'objet Route pour différents itinéraires
Allons-y et définissons une jolie base foo route.
$ foo_route = new Route ('/ foo', array ('controller' => 'FooController'));
Le premier argument de la Route constructeur est le chemin de l'URI, et le deuxième argument est le tableau d'attributs personnalisés que vous voulez renvoyer lorsque cette route particulière est mise en correspondance. Généralement, il s'agirait d'une combinaison du contrôleur et de la méthode que vous souhaitez appeler lorsque cette route est demandée..
Ensuite, regardons la route paramétrée.
$ foo_placeholder_route = new Route ('/ foo / id', array ('controller' => 'FooController', 'method' => 'load'), array ('id' => '[0-9] + '));
L’itinéraire ci-dessus peut correspondre à des URI tels que foo / 1, foo / 123 et similaire. Veuillez noter que nous avons limité la id paramètre en valeurs numériques uniquement, et par conséquent, il ne correspondra pas aux URI tels que foo / bar depuis le id paramètre est fourni sous forme de chaîne.
Ajouter tous les objets d'itinéraire à l'objet RouteCollection
L'étape suivante consiste à ajouter des objets de route que nous avons initialisés dans la section précédente au RouteCollection objet.
$ routes = new RouteCollection (); $ routes-> add ('foo_route', $ foo_route); $ routes-> add ('foo_placeholder_route', $ foo_placeholder_route);
Comme vous pouvez le constater, c’est assez simple, il vous suffit d’utiliser le ajouter méthode du RouteCollection objet pour ajouter des objets de route. Le premier argument de la ajouter méthode est le nom de la route, et le second argument est l'objet route lui-même.
Initialiser le RequestContext Objet
Ensuite, nous devons initialiser le RequestContext objet, qui contient les informations de contexte de la demande en cours. Nous aurons besoin de cet objet lorsque nous initialiserons le UrlMatcher objecter comme nous le passerons dans un instant.
$ context = new RequestContext (); $ context-> fromRequest (Request :: createFromGlobals ());
Initialiser le UrlMatcher Objet
Enfin, nous devons initialiser le UrlMatcher objet avec les routes et les informations de contexte.
// Init UrlMatcher object $ matcher = new UrlMatcher ($ routes, $ context);
Maintenant, nous avons tout ce que nous pourrions faire correspondre nos routes contre.
Comment faire correspondre les itinéraires
C'est le rencontre méthode du UrlMatcher objet qui vous permet de faire correspondre n'importe quelle route à un ensemble de routes prédéfinies.
le rencontre method prend l'URI comme premier argument et tente de le faire correspondre à des itinéraires prédéfinis. Si la route est trouvée, elle renvoie les attributs personnalisés associés à cette route. D'autre part, il jette le ResourceNotFoundException exception s'il n'y a pas de route associée à l'URI actuel.
$ parameters = $ matcher-> match ($ context-> getPathInfo ());
Dans notre cas, nous avons fourni l’URI actuel en le récupérant à partir du $ contexte objet. Donc, si vous accédez à l’URL http: //votre-domaine/basic_routes.php/foo, le $ context-> getPathInfo () résultats foo, et nous avons déjà défini un itinéraire pour la foo URI, il devrait donc nous renvoyer ce qui suit.
Tableau ([contrôleur] => FooController [_route] => foo_route)
Maintenant, testons l’itinéraire paramétré en accédant à l’URL http: //votre-domaine/basic_routes.php/foo/123..
Array ([contrôleur] => FooController [méthode] => load [id] => 123 [_route] => foo_placeholder_route)
Cela a fonctionné si vous pouvez voir que le identifiant paramètre est lié à la valeur appropriée 123.
Essayons ensuite d’accéder à une route inexistante telle que http: //your-domain/basic_routes.php/unknown-route. Vous devriez voir le message suivant.
Aucune route trouvée pour "/ unknown-route".
Voilà comment vous pouvez trouver des itinéraires en utilisant le rencontre méthode.
En dehors de cela, vous pouvez également utiliser le Routage composant pour générer des liens dans votre application. À condition de RouteCollection et RequestContext objets, les UrlGenerator vous permet de créer des liens pour des itinéraires spécifiques.
$ generator = new UrlGenerator ($ routes, $ context); $ url = $ generateur-> generate ('foo_placeholder_route', array ('id' => 123,));
Le premier argument de la produire méthode est le nom de la route, et le deuxième argument est le tableau qui peut contenir des paramètres s'il s'agit de la route paramétrée. Le code ci-dessus devrait générer le /basic_routes.php/foo/123 URL.
Charger des itinéraires à partir du fichier YAML
Dans la section précédente, nous avons construit nos itinéraires personnalisés en utilisant le Route et RouteCollection objets. En fait, le Routage composant vous propose différentes manières d'instancier les itinéraires. Vous pouvez choisir parmi différents chargeurs comme YamlFileLoader, XmlFileLoader, et PhpFileLoader.
Dans cette section, nous allons passer en revue les YamlFileLoader chargeur pour voir comment charger les routes à partir du fichier YAML.
Le fichier YAML Routes
Allez-y et créez le routes.yaml fichier avec le contenu suivant.
foo_route: chemin: / foo par défaut: contrôleur: 'FooController :: indexAction' foo_placeholder_route: chemin: / foo / id par défaut: contrôleur: 'FooController :: loadAction' exigences: id: '[0-9] + '
Un exemple de fichier
Ensuite, allez-y et faites le load_routes_from_yaml.php fichier avec le contenu suivant.
load ('routes.yaml'); // Objet RequestContext Init $ context = new RequestContext (); $ context-> fromRequest (Request :: createFromGlobals ()); // Init UrlMatcher object $ matcher = new UrlMatcher ($ routes, $ context); // Trouver la route actuelle $ parameters = $ matcher-> match ($ context-> getPathInfo ()); // Comment générer une URL de référencement $ generator = new UrlGenerator ($ routes, $ context); $ url = $ generateur-> generate ('foo_placeholder_route', array ('id' => 123,)); écho '
'; print_r ($ paramètres); echo 'URL générée:'. $ url; sortie;  catch (ResourceNotFoundException $ e) echo $ e-> getMessage (); 
La seule chose qui soit différente dans ce cas est la façon dont nous initialisons les itinéraires!
$ fileLocator = new FileLocator (array (__ DIR__)); $ loader = new YamlFileLoader ($ fileLocator); $ routes = $ loader-> load ('routes.yaml');
Nous avons utilisé le YamlFileLoader chargeur pour charger les itinéraires de la routes.yaml fichier au lieu de l’initialiser directement dans le PHP lui-même. En dehors de cela, tout est identique et devrait produire les mêmes résultats que celui de basic_routes.php fichier.
Le routeur tout-en-un
Enfin, dans cette section, nous allons passer en revue les Routeur classe, qui vous permet de configurer rapidement le routage avec moins de lignes de code.
Allez-y et faites le all_in_one_router.php fichier avec le contenu suivant.
fromRequest (Request :: createFromGlobals ()); $ routeur = nouveau routeur (nouveau YamlFileLoader ($ fileLocator), 'routes.yaml', array ('cache_dir' => __DIR __. '/ cache'), $ requestContext); // Trouver la route actuelle $ parameters = $ router-> match ($ requestContext-> getPathInfo ()); // Comment générer une URL de référencement $ routes = $ router-> getRouteCollection (); $ generator = new UrlGenerator ($ routes, $ requestContext); $ url = $ generateur-> generate ('foo_placeholder_route', array ('id' => 123,)); écho '
'; print_r ($ paramètres); echo 'URL générée:'. $ url; sortie;  catch (ResourceNotFoundException $ e) echo $ e-> getMessage (); 
Tout est à peu près la même chose, sauf que nous avons instancié le Routeur objet avec les dépendances nécessaires.
$ routeur = nouveau routeur (nouveau YamlFileLoader ($ fileLocator), 'routes.yaml', array ('cache_dir' => __DIR __. '/ cache'), $ requestContext);
Avec cela en place, vous pouvez immédiatement utiliser le rencontre méthode de l'objet routeur pour le mappage de route.
$ parameters = $ routeur-> match ($ requestContext-> getPathInfo ());
En outre, vous devrez utiliser le getRouteCollection méthode de l'objet Router pour récupérer des itinéraires.
$ routes = $ routeur-> getRouteCollection ();
Conclusion
Allez-y et explorez les autres options disponibles dans la composante Routage. J'aimerais connaître votre opinion.!
Aujourd'hui, nous avons exploré le composant de routage Symfony, qui facilite grandement la mise en œuvre du routage dans les applications PHP. En cours de route, nous avons créé une poignée d’exemples pour illustrer divers aspects de la composante Routage.. 
J'espère que vous avez apprécié cet article et n'hésitez pas à poster vos impressions en utilisant le flux ci-dessous!




		
			
	   
	




Code