Konfigurera routing i PHP-program Använda Symfony Routing Component

Idag går vi igenom komponenten Symfony Routing, som gör att du kan konfigurera routing i dina PHP-applikationer.

Vad är Symfony Routing Component?

Symfony Routing Component är en mycket populär routing komponent som anpassas av flera ramar och ger mycket flexibilitet om du vill skapa rutor i din PHP-applikation.

Om du har byggt en anpassad PHP-applikation och letar efter ett funktionsrikt routing-bibliotek, är Symfony Routing Component mer än en värt att se. Det låter dig också definiera rutter för din ansökan i YAML-formatet.

Från och med installationen och konfigurationen går vi igenom exemplar i verkligheten för att visa en rad olika alternativ som komponenten har för rutekonfiguration. I den här artikeln lär du dig:

• installation och konfiguration
• hur man ställer in grundläggande linjer
• hur man laddar rutter från YAML-filen
• hur man använder all-in-one-routern
  

Installation och konfiguration

I det här avsnittet ska vi installera de bibliotek som krävs för att konfigurera routing i dina PHP-applikationer. Jag antar att du har installerat Composer i ditt system, eftersom vi behöver det för att installera de nödvändiga bibliotek som finns på Packagist.

När du har installerat Composer, fortsätt och installera core Routing-komponenten med följande kommando.

$ komponent kräver symfoni / routing

Även om routing-komponenten i sig är tillräcklig för att tillhandahålla omfattande routingsfunktioner i din ansökan, kommer vi att fortsätta och installera några andra komponenter också för att göra vårt liv enklare och berika den befintliga core routingfunktionaliteten.

Till att börja med kommer vi att fortsätta och installera komponenten HttpFoundation, som ger ett objektorienterat omslag för PHP-globala variabler och responsrelaterade funktioner. Det gör att du inte behöver tillgång till globala variabler som $ _GET, $ _POST och liknande direkt.

$ komponent kräver symfony / http-foundation

Om du vill definiera dina applikationsvägar i YAML-filen istället för PHP-koden är det YAML-komponenten som kommer till räddning, eftersom det hjälper dig att konvertera YAML-strängar till PHP-arrayer och vice versa.

$ komponist kräver symfoni / yaml

Slutligen installerar vi Config-komponenten, som ger flera verktygsklasser att initiera och hantera konfigurationsvärden som definieras i olika typer av filer som YAML, INI, XML, etc. I vårt fall använder vi det för att ladda vägar från YAML-filen.

$ komponent kräver symfony / config

Så det är installationsdelen, men hur ska du använda den? Faktum är att det bara handlar om att inkludera autoload.php fil skapad av kompositören i din ansökan, som visas i följande kod.

Konfigurera grundläggande rutter

I det föregående avsnittet gick vi igenom installationen av nödvändiga routing-komponenter. Nu är du redo att konfigurera routing i din PHP-applikation direkt.

Låt oss fortsätta och skapa basic_routes.php fil med följande innehåll.

 "FooController")); // Init-rutt med dynamiska platshållare $ foo_placeholder_route = Ny rutt ('/ foo / id', array ('controller' => 'FooController', 'method' => 'load' '[0-9] +')); // Lägg till Ruttobjekt (er) till RouteCollection-objekt $ routes = Ny RouteCollection (); $ routes-> lägg till ('foo_route', $ foo_route); $ routes-> lägg till ('foo_placeholder_route', $ foo_placeholder_route); // Init RequestContext objekt $ context = new RequestContext (); $ Sammanhangs> fromRequest (Request :: createFromGlobals ()); // Init UrlMatcher objekt $ matcher = ny UrlMatcher ($ rutter, $ kontext); // Hitta den aktuella rutten $ parameters = $ matcher-> match ($ context-> getPathInfo ()); // Hur genererar en SEO URL $ generator = ny UrlGenerator ($ rutter, $ context); $ url = $ generator-> generera ('foo_placeholder_route', array ('id' => 123,)); eko "
'; print_r ($ parametrar); echo 'Genererad URL:'. $ Url; utgång;  fånga (ResourceNotFoundException $ e) echo $ e-> getMessage (); 
Konfigurering av routning med hjälp av Symfony Routing-komponenten går vanligen genom en rad steg som anges nedan.
 
Initiera Rutt objekt för var och en av dina ansökningsvägar.
 
Lägg till alla Rutt objekt till RouteCollection objekt.
 
Initiera RequestContext objekt som innehåller den aktuella begäran om sammanhangsinformation.
 
Initiera UrlMatcher objekt genom att passera RouteCollection objekt och RequestContext objekt.
 
Initiera ruttobjektet för olika rutter
Låt oss gå vidare och definiera en ganska grundläggande foo rutt.
$ foo_route = ny rutt ('/ foo', array ('controller' => 'FooController'));
Det första argumentet från Rutt konstruktorn är URI-sökvägen, och det andra argumentet är en rad anpassade attribut som du vill återvända när den här vägen matchas. Vanligtvis skulle det vara en kombination av den kontroller och metod som du vill ringa när den här vägen begärs.
Låt oss nu titta på den parametrerade rutten.
$ foo_placeholder_route = ny rutt ('/ foo / id', array ('controller' => 'FooController', 'method' => 'ladda'), array ('id' => '[0-9] + '));
Ovanstående rutt kan matcha URI: er som foo / 1, foo / 123 och liknande. Observera att vi har begränsat Id parameter till numeriska värden bara, och det kommer därför inte att matcha URI-filer som Foo bar sedan Id parametern tillhandahålls som en sträng.
Lägg till alla ruttobjekt till RouteCollection-objektet
Nästa steg är att lägga till rutobjekt som vi har initierat i föregående avsnitt till RouteCollection objekt.
$ routes = ny RouteCollection (); $ routes-> lägg till ('foo_route', $ foo_route); $ routes-> lägg till ('foo_placeholder_route', $ foo_placeholder_route);
Som du kan se är det ganska enkelt eftersom du bara behöver använda Lägg till metod för RouteCollection motsätta sig att lägga till ruttobjekt. Det första argumentet från Lägg till Metoden är namnet på rutten, och det andra argumentet är själva rutinobjektet.
Initiera RequestContext Objekt
Därefter måste vi initiera RequestContext objekt som innehåller den aktuella förfrågningstextinformationen. Vi behöver detta objekt när vi initierar UrlMatcher objekt som vi kommer att gå igenom det på ett ögonblick.
$ context = new RequestContext (); $ Sammanhangs> fromRequest (Request :: createFromGlobals ());
Initiera UrlMatcher Objekt
Slutligen måste vi initiera UrlMatcher objekt tillsammans med rutter och kontextinformation.
// Init UrlMatcher objekt $ matcher = ny UrlMatcher ($ rutter, $ kontext);
Nu har vi allt vi kan matcha våra vägar mot.
Hur man matchar rutter
Det är match metod för UrlMatcher objekt som låter dig matcha vilken rutt som helst mot en uppsättning fördefinierade rutter.
De match Metoden tar URI som första argument och försöker matcha det mot fördefinierade rutter. Om rutten hittas returnerar den anpassade attribut som är associerade med den rutten. Å andra sidan kastar den ResourceNotFoundException undantag om det inte finns någon rutt som är associerad med den aktuella URI.
$ parametrar = $ matcher-> match ($ context-> getPathInfo ());
I vårt fall har vi gett den aktuella URI-enheten genom att hämta den från $ sammanhang objekt. Så, om du använder http: //your-domain/basic_routes.php/foo URL $ Sammanhangs> getPathInfo () avkastning foo, och vi har redan definierat en rutt för foo URI, så det borde returnera oss följande.
Array ([controller] => FooController [_route] => foo_route)
Nu, låt oss fortsätta och testa den parametrerade rutten genom att öppna http: //your-domain/basic_routes.php/foo/123 URL.
Array ([controller] => FooController [method] => ladda [id] => 123 [_route] => foo_placeholder_route)
Det fungerade om du kan se att id parametern är bunden med lämpligt värde 123.
Låt oss sedan försöka få tillgång till en existerande väg som http: //your-domain/basic_routes.php/unknown-route, och du borde se följande meddelande.
Inga rutter hittades för "/ okänd rutt".
Så det är så du kan hitta rutter med hjälp av match metod.
Bortsett från detta kan du också använda routing komponent för att generera länkar i din ansökan. Försedd RouteCollection och RequestContext objekt, UrlGenerator låter dig bygga länkar för specifika rutter.
$ generator = ny UrlGenerator ($ rutter, $ kontext); $ url = $ generator-> generera ('foo_placeholder_route', array ('id' => 123,));
Det första argumentet från generera Metoden är rutens namn och det andra argumentet är den matris som kan innehålla parametrar om det är den parametrerade rutten. Ovanstående kod ska generera /basic_routes.php/foo/123 URL.
Ladda rutor från YAML-filen
I det föregående avsnittet byggde vi våra anpassade rutter med hjälp av Rutt och RouteCollection objekt. Faktum är att routing Komponenten erbjuder olika sätt att välja mellan för att omedelbara vägar. Du kan välja bland olika lastare som YamlFileLoader, XmlFileLoader, och PhpFileLoader.
I det här avsnittet går vi igenom YamlFileLoader lastare för att se hur man laddar rutter från YAML-filen.
Rutterna YAML-filen
Gå vidare och skapa routes.yaml fil med följande innehåll.
foo_route: path: / foo default: controller: 'FooController :: indexAction' foo_placeholder_route: sökväg: / foo / id standard: controller: 'FooController :: loadAction' krav: id: '[0-9] +'
En exempelfil
Fortsätt sedan och gör load_routes_from_yaml.php fil med följande innehåll.
belastning ( 'routes.yaml'); // Init RequestContext objekt $ context = new RequestContext (); $ Sammanhangs> fromRequest (Request :: createFromGlobals ()); // Init UrlMatcher objekt $ matcher = ny UrlMatcher ($ rutter, $ kontext); // Hitta den aktuella rutten $ parameters = $ matcher-> match ($ context-> getPathInfo ()); // Hur genererar en SEO URL $ generator = ny UrlGenerator ($ rutter, $ context); $ url = $ generator-> generera ('foo_placeholder_route', array ('id' => 123,)); eko "
'; print_r ($ parametrar); echo 'Genererad URL:'. $ Url; utgång;  fånga (ResourceNotFoundException $ e) echo $ e-> getMessage (); 
Det enda som är annorlunda i detta fall är hur vi initierar rutter!
$ fileLocator = ny FileLocator (array (__ DIR__)); $ loader = ny YamlFileLoader ($ fileLocator); $ routes = $ loader-> load ('routes.yaml');
Vi har använt YamlFileLoader lastare att lasta vägar från routes.yaml fil istället för att initiera den direkt i själva PHP. Bortsett från det är allt detsamma och borde det producera samma resultat som den basic_routes.php fil.
Allt-i-ett-routern
Slutligen i det här avsnittet går vi igenom router klassen, som gör att du snabbt kan konfigurera routing med färre linjer kod.
Fortsätt och gör all_in_one_router.php fil med följande innehåll.
fromRequest (Request :: createFromGlobals ()); $ router = ny router (ny YamlFileLoader ($ fileLocator), 'routes.yaml', array ('cache_dir' => __DIR __. '/ cache'), $ requestContext); // Hitta den aktuella rutten $ parameters = $ router-> match ($ requestContext-> getPathInfo ()); // Hur man genererar en SEO URL $ routes = $ router-> getRouteCollection (); $ generator = ny UrlGenerator ($ rutter, $ requestContext); $ url = $ generator-> generera ('foo_placeholder_route', array ('id' => 123,)); eko "
'; print_r ($ parametrar); echo 'Genererad URL:'. $ Url; utgång;  fånga (ResourceNotFoundException $ e) echo $ e-> getMessage (); 
Allt är ungefär detsamma, förutom att vi har instanserat router objekt tillsammans med nödvändiga beroenden.
$ router = ny router (ny YamlFileLoader ($ fileLocator), 'routes.yaml', array ('cache_dir' => __DIR __. '/ cache'), $ requestContext);
Med det på plats kan du genast använda match Metod för routerns objekt för rutekartläggning.
$ parametrar = $ router-> match ($ requestContext-> getPathInfo ());
Du måste också använda getRouteCollection Metoden för routerns objekt att hämta rutter.
$ routes = $ router-> getRouteCollection ();
Slutsats
Gå vidare och utforska de andra alternativen som finns i routing-komponenten-jag skulle gärna höra dina tankar!
Idag utforskade vi komponenten Symfony Routing, vilket gör genomförandet av routing i PHP-applikationer en bris. Under tiden skapade vi en handfull exempel för att visa olika aspekter av Routing-komponenten. 
Jag hoppas att du har haft den här artikeln, och gärna skicka dina tankar med hjälp av flödet nedan!




		
			
	   
	




Koda