Richten Sie das Routing in PHP-Anwendungen mit der Symfony Routing-Komponente ein

Heute gehen wir die Symfony Routing-Komponente durch, mit der Sie das Routing in Ihren PHP-Anwendungen einrichten können.

Was ist die Symfony Routing-Komponente??

Die Symfony Routing-Komponente ist eine sehr beliebte Routing-Komponente, die von verschiedenen Frameworks angepasst wird und viel Flexibilität bietet, wenn Sie in Ihrer PHP-Anwendung Routen einrichten möchten.

Wenn Sie eine benutzerdefinierte PHP-Anwendung erstellt haben und nach einer funktionsreichen Routing-Bibliothek suchen, ist die Symfony Routing-Komponente mehr als einen Blick wert. Außerdem können Sie Routen für Ihre Anwendung im YAML-Format definieren.

Beginnend mit der Installation und Konfiguration gehen wir anhand realer Beispiele vor, um die verschiedenen Optionen der Komponente für die Routenkonfiguration zu demonstrieren. In diesem Artikel erfahren Sie:

• Installation und Konfiguration
• So richten Sie grundlegende Routen ein
• So laden Sie Routen aus der YAML-Datei
• So verwenden Sie den All-in-One-Router
  

Installation und Konfiguration

In diesem Abschnitt werden wir die Bibliotheken installieren, die zum Einrichten des Routings in Ihren PHP-Anwendungen erforderlich sind. Ich gehe davon aus, dass Sie Composer in Ihrem System installiert haben, da wir es benötigen, um die erforderlichen Bibliotheken zu installieren, die auf Packagist verfügbar sind.

Nachdem Sie Composer installiert haben, installieren Sie die Kernkomponente Routing mithilfe des folgenden Befehls.

$ composer erfordert Symfony / Routing

Obwohl die Routing-Komponente selbst ausreicht, um umfassende Routing-Funktionen in Ihrer Anwendung bereitzustellen, werden wir einige weitere Komponenten installieren, um unser Leben zu vereinfachen und die vorhandenen Kern-Routing-Funktionen zu erweitern.

Zunächst beginnen wir mit der Installation der HttpFoundation-Komponente, die einen objektorientierten Wrapper für globale PHP-Variablen und antwortbezogene Funktionen bereitstellt. Es stellt sicher, dass Sie nicht auf globale Variablen wie zugreifen müssen $ _GET, $ _POST und dergleichen direkt.

$ composer benötigt eine symfony / http-foundation

Wenn Sie als nächstes Ihre Anwendungsrouten in der YAML-Datei anstelle des PHP-Codes definieren möchten, ist dies die YAML-Komponente, die Sie bei der Konvertierung von YAML-Strings in PHP-Arrays und umgekehrt unterstützt.

$ composer erfordert symfony / yaml

Schließlich installieren wir die Config-Komponente, die mehrere Dienstprogrammklassen zum Initialisieren und Behandeln von Konfigurationswerten enthält, die in den verschiedenen Dateitypen definiert sind, wie YAML, INI, XML usw. In unserem Fall verwenden wir sie zum Laden von Routen aus der YAML-Datei.

$ composer benötigt symfony / config

Das ist also der Installationsteil, aber wie soll man es verwenden? In der Tat ist es nur eine Frage der Einbeziehung der autoload.php Datei, die von Composer in Ihrer Anwendung erstellt wurde, wie im folgenden Snippet gezeigt.

Grundrouten einrichten

Im vorherigen Abschnitt haben wir die erforderlichen Routing-Komponenten installiert. Jetzt können Sie das Routing in Ihrer PHP-Anwendung sofort einrichten.

Lasst uns fortfahren und das erstellen basic_routes.php Datei mit folgendem Inhalt.

 'FooController')); // Init-Route mit dynamischen Platzhaltern $ foo_placeholder_route = neue Route ('/ foo / id'), array ('controller' => 'FooController', 'method' => 'load'), array ('id' => '[0-9] +')); // Route-Objekt (e) zum RouteCollection-Objekt hinzufügen $ routes = new RouteCollection (); $ routes-> add ('foo_route', $ foo_route); $ routes-> add ('foo_placeholder_route', $ foo_placeholder_route); // Init RequestContext-Objekt $ context = new RequestContext (); $ context-> fromRequest (Request :: createFromGlobals ()); // Init UrlMatcher-Objekt $ matcher = neuer UrlMatcher ($ routes, $ context); // Finde die aktuelle Route $ parameters = $ matcher-> match ($ context-> getPathInfo ()); // So generieren Sie eine SEO-URL $ generator = new UrlGenerator ($ routes, $ context); $ url = $ generator-> generate ('foo_placeholder_route', array ('id' => 123,)); Echo '
'; print_r ($ parameters); echo 'Generierte URL:'. $ url; Ausfahrt;  catch (ResourceNotFoundException $ e) echo $ e-> getMessage (); 
Das Einrichten des Routings mit der Symfony Routing-Komponente durchläuft normalerweise eine Reihe von Schritten, wie unten aufgeführt.
 
Initialisieren Sie die Route Objekt für jede Ihrer Anwendungsrouten.
 
Füge alle Hinzu Route Objekte an die RouteCollection Objekt.
 
Initialisieren Sie die RequestContext Objekt, das die aktuellen Anforderungskontextinformationen enthält.
 
Initialisieren Sie die UrlMatcher Objekt durch Übergeben der RouteCollection Objekt und die RequestContext Objekt.
 
Initialisieren Sie das Routenobjekt für verschiedene Routen
Gehen wir weiter und definieren ein ziemlich grundlegendes Element foo Route.
$ foo_route = neue Route ('/ foo', Array ('Controller' => 'FooController'));
Das erste Argument der Route Der Konstruktor ist der URI-Pfad. Das zweite Argument ist das Array mit benutzerdefinierten Attributen, das Sie zurückgeben möchten, wenn diese bestimmte Route abgeglichen wird. Normalerweise ist dies eine Kombination aus Controller und Methode, die Sie anrufen möchten, wenn diese Route angefordert wird.
Als Nächstes betrachten wir die parametrisierte Route.
$ foo_placeholder_route = neue Route ('/ foo / id'), Array ('Controller' => 'FooController', 'Methode' => 'load'), Array ('id' => '[0-9] + '));
Die obige Route kann mit URIs übereinstimmen foo / 1, foo / 123 und ähnlich. Bitte beachten Sie, dass wir das eingeschränkt haben Ich würde Parameter nur auf numerische Werte, und daher nicht mit URIs wie übereinstimmen Foo / Bar seit der Ich würde Parameter wird als String bereitgestellt.
Fügen Sie alle Routenobjekte zum RouteCollection-Objekt hinzu
Der nächste Schritt ist das Hinzufügen von Routenobjekten, die wir im vorherigen Abschnitt initialisiert haben RouteCollection Objekt.
$ routes = new RouteCollection (); $ routes-> add ('foo_route', $ foo_route); $ routes-> add ('foo_placeholder_route', $ foo_placeholder_route);
Wie Sie sehen, ist es ziemlich unkompliziert, da Sie nur die hinzufügen Methode der RouteCollection Objekt zum Hinzufügen von Routenobjekten. Das erste Argument der hinzufügen method ist der Name der Route und das zweite Argument ist das Routenobjekt selbst.
Initialisieren Sie die RequestContext Objekt
Als nächstes müssen wir das initialisieren RequestContext Objekt, das die aktuellen Anforderungskontextinformationen enthält. Wir benötigen dieses Objekt, wenn wir das initialisieren UrlMatcher Objekt, wie wir es gleich durchgehen werden.
$ context = new RequestContext (); $ context-> fromRequest (Request :: createFromGlobals ());
Initialisieren Sie die UrlMatcher Objekt
Zum Schluss müssen wir das initialisieren UrlMatcher Objekt zusammen mit Routen und Kontextinformationen.
// Init UrlMatcher-Objekt $ matcher = neuer UrlMatcher ($ routes, $ context);
Jetzt haben wir alles, was wir mit unseren Routen vergleichen könnten.
So passen Sie Routen an
Es ist das Spiel Methode der UrlMatcher Objekt, mit dem Sie jede Route mit einer Reihe vordefinierter Routen abgleichen können.
Das Spiel Die Methode nimmt den URI als erstes Argument und versucht, ihn mit vordefinierten Routen abzugleichen. Wenn die Route gefunden wird, werden die dieser Route zugeordneten benutzerdefinierten Attribute zurückgegeben. Andererseits wirft es das ResourceNotFoundException Ausnahme, wenn dem aktuellen URI keine Route zugeordnet ist.
$ parameters = $ matcher-> match ($ context-> getPathInfo ());
In unserem Fall haben wir die aktuelle URI bereitgestellt, indem Sie sie von der Datenbank abrufen $ context Objekt. Wenn Sie also auf die URL http: //your-domain/basic_routes.php/foo zugreifen, wird die $ context-> getPathInfo () kehrt zurück foo, und wir haben bereits eine Route für die festgelegt foo URI, also sollte uns folgendes zurückgegeben werden.
Array ([Controller] => FooController [_route] => foo_route)
Lassen Sie uns nun die parametrisierte Route testen, indem Sie auf die URL http: //your-domain/basic_routes.php/foo/123 zugreifen.
Array ([Controller] => FooController [Methode] => Laden [ID] => 123 [_Route] => Foo_placeholder_route)
Es hat funktioniert, wenn man das sehen kann Ich würde Parameter ist an den entsprechenden Wert gebunden 123.
Lassen Sie uns als Nächstes versuchen, auf eine nicht vorhandene Route wie http: //Ihre-Domäne/Basic_routes.php/unknown-route zuzugreifen, und die folgende Meldung sollte angezeigt werden.
Keine Routen gefunden für "/ unknown-route".
So finden Sie Routen mit der Spiel Methode.
Abgesehen davon können Sie auch die Routing Komponente zum Erstellen von Links in Ihrer Anwendung. Unter der Voraussetzung RouteCollection und RequestContext Objekte, die UrlGenerator ermöglicht das Erstellen von Links für bestimmte Routen.
$ generator = neuer UrlGenerator ($ routes, $ context); $ url = $ generator-> generate ('foo_placeholder_route', array ('id' => 123,));
Das erste Argument der generieren method ist der Routenname, und das zweite Argument ist das Array, das Parameter enthalten kann, wenn es sich um die parametrisierte Route handelt. Der obige Code sollte das generieren /basic_routes.php/foo/123 URL.
Routen aus der YAML-Datei laden
Im vorherigen Abschnitt haben wir unsere benutzerdefinierten Routen mithilfe von erstellt Route und RouteCollection Objekte. In der Tat die Routing Die Komponente bietet verschiedene Möglichkeiten, um Routen zu instanziieren. Sie können aus verschiedenen Ladern wählen YamlFileLoader, XmlFileLoader, und PhpFileLoader.
In diesem Abschnitt gehen wir durch YamlFileLoader loader, um zu sehen, wie Routen aus der YAML-Datei geladen werden.
Die Routen-YAML-Datei
Mach weiter und erstelle das routen.yaml Datei mit folgendem Inhalt.
foo_route: Pfad: / foo Standardwerte: Controller: 'FooController :: indexAction' foo_placeholder_route: Pfad: / foo / id Standardwerte: Controller: 'FooController :: loadAction' Anforderungen: id: '[0-9] + '
Eine Beispieldatei
Als nächstes machen Sie die load_routes_from_yaml.php Datei mit folgendem Inhalt.
load ('routes.yaml'); // Init RequestContext-Objekt $ context = new RequestContext (); $ context-> fromRequest (Request :: createFromGlobals ()); // Init UrlMatcher-Objekt $ matcher = neuer UrlMatcher ($ routes, $ context); // Finde die aktuelle Route $ parameters = $ matcher-> match ($ context-> getPathInfo ()); // So generieren Sie eine SEO-URL $ generator = new UrlGenerator ($ routes, $ context); $ url = $ generator-> generate ('foo_placeholder_route', array ('id' => 123,)); Echo '
'; print_r ($ parameters); echo 'Generierte URL:'. $ url; Ausfahrt;  catch (ResourceNotFoundException $ e) echo $ e-> getMessage (); 
Das einzige, was in diesem Fall anders ist, ist die Art und Weise, wie wir Routen initialisieren!
$ fileLocator = neuer FileLocator (Array (__ DIR__)); $ loader = neuer YamlFileLoader ($ fileLocator); $ routes = $ loader-> load ('routes.yaml');
Wir haben die verwendet YamlFileLoader Loader zum Laden von Routen aus dem routen.yaml Datei statt direkt in PHP zu initialisieren. Abgesehen davon ist alles gleich und sollte zu den gleichen Ergebnissen führen wie das basic_routes.php Datei.
Der All-in-One-Router
Zum Schluss gehen wir in diesem Abschnitt durch Router Klasse, mit der Sie das Routing mit weniger Codezeilen schnell einrichten können.
Mach weiter und mach das all_in_one_router.php Datei mit folgendem Inhalt.
fromRequest (Request :: createFromGlobals ()); $ router = neuer Router (neuer YamlFileLoader ($ fileLocator), 'routes.yaml', Array ('cache_dir' => __DIR __ '/ cache'), $ requestContext); // Finde die aktuelle Route $ parameters = $ router-> match ($ requestContext-> getPathInfo ()); // So generieren Sie eine SEO-URL $ routes = $ router-> getRouteCollection (); $ generator = neuer UrlGenerator ($ routes, $ requestContext); $ url = $ generator-> generate ('foo_placeholder_route', array ('id' => 123,)); Echo '
'; print_r ($ parameters); echo 'Generierte URL:'. $ url; Ausfahrt;  catch (ResourceNotFoundException $ e) echo $ e-> getMessage (); 
Alles ist ziemlich gleich, außer dass wir das instanziiert haben Router Objekt mit den notwendigen Abhängigkeiten.
$ router = neuer Router (neuer YamlFileLoader ($ fileLocator), 'routes.yaml', Array ('cache_dir' => __DIR __ '/ cache'), $ requestContext);
Damit können Sie sofort die Spiel Methode des Router-Objekts zur Routenzuordnung.
$ parameters = $ router-> match ($ requestContext-> getPathInfo ());
Sie müssen auch das verwenden getRouteCollection Methode des Router-Objekts zum Abrufen von Routen.
$ routes = $ router-> getRouteCollection ();
Fazit
Machen Sie sich mit den anderen in der Routing-Komponente verfügbaren Optionen vertraut - ich würde gerne Ihre Gedanken hören!
Heute haben wir uns mit der Symfony Routing-Komponente beschäftigt, die die Implementierung von Routing in PHP-Anwendungen zum Kinderspiel macht. Dabei haben wir einige Beispiele erstellt, um verschiedene Aspekte der Routing-Komponente zu veranschaulichen. 
Ich hoffe, dass Ihnen dieser Artikel gefallen hat, und Sie können Ihre Gedanken mit dem untenstehenden Feed posten!




		
			
	   
	




Code