Imposta il routing nelle applicazioni PHP utilizzando il componente di routing di Symfony

Oggi passeremo attraverso il componente Symfony Routing, che ti consente di configurare il routing nelle tue applicazioni PHP.

Qual è il componente di routing di Symfony?

Symfony Routing Component è un componente di routing molto popolare che è adattato da diversi framework e offre molta flessibilità se si desidera impostare percorsi nell'applicazione PHP.

Se hai creato un'applicazione PHP personalizzata e stai cercando una libreria di routing ricca di funzionalità, il componente di instradamento di Symfony è più che degno di attenzione. Permette anche di definire percorsi per la tua applicazione nel formato YAML.

A partire dall'installazione e dalla configurazione, analizzeremo esempi reali per dimostrare una varietà di opzioni che il componente ha per la configurazione del percorso. In questo articolo imparerai:

• installazione e configurazione
• come impostare i percorsi di base
• come caricare rotte dal file YAML
• come utilizzare il router all-in-one
  

Installazione e configurazione

In questa sezione, installeremo le librerie necessarie per configurare il routing nelle tue applicazioni PHP. Presumo che tu abbia installato Composer nel tuo sistema poiché avremo bisogno di installare le librerie necessarie disponibili su Packagist.

Dopo aver installato Composer, andare avanti e installare il componente principale di Routing utilizzando il seguente comando.

$ compositore richiede symfony / routing

Sebbene il componente di instradamento stesso sia sufficiente per fornire funzionalità di routing complete nell'applicazione, andremo avanti e installeremo anche alcuni altri componenti per semplificarci la vita e arricchire la funzionalità di core routing esistente.

Per iniziare, andremo avanti e installeremo il componente HttpFoundation, che fornisce un wrapper orientato agli oggetti per le variabili globali di PHP e le funzioni relative alle risposte. Si assicura che non sia necessario accedere a variabili globali come $ _GET, $ _POST e simili direttamente.

$ compositore richiede symfony / http-foundation

Successivamente, se si desidera definire i percorsi dell'applicazione nel file YAML anziché nel codice PHP, è il componente YAML che viene in soccorso in quanto consente di convertire stringhe YAML in array PHP e viceversa.

$ compositore richiede symfony / yaml

Infine, installeremo il componente Config, che fornisce diverse classi di utilità per inizializzare e gestire i valori di configurazione definiti nei diversi tipi di file come YAML, INI, XML, ecc. Nel nostro caso, lo useremo per caricare le rotte dal file YAML.

$ compositore richiede symfony / config

Quindi questa è la parte di installazione, ma come si dovrebbe utilizzarla? In realtà, è solo questione di includere il autoload.php file creato da Composer nella tua applicazione, come mostrato nello snippet seguente.

Imposta percorsi di base

Nella sezione precedente, abbiamo eseguito l'installazione dei componenti di routing necessari. Ora, sei pronto per impostare il routing nella tua applicazione PHP subito.

Andiamo avanti e creare il basic_routes.php file con il seguente contenuto.

 'FooController')); // Inizializzazione con segnaposto dinamici $ foo_placeholder_route = new Route ('/ foo / id', array ('controller' => 'FooController', 'method' => 'load'), array ('id' => '[0-9] +')); // Aggiungi oggetto / i di instradamento all'oggetto RouteCollection $ routes = new RouteCollection (); $ routes-> add ('foo_route', $ foo_route); $ routes-> add ('foo_placeholder_route', $ foo_placeholder_route); // Init RequestContext object $ context = new RequestContext (); $ Context-> fromRequest (Request :: createFromGlobals ()); // Init UrlMatcher object $ matcher = new UrlMatcher ($ routes, $ context); // Trova il percorso corrente $ parameters = $ matcher-> match ($ context-> getPathInfo ()); // Come generare un URL SEO $ generator = new UrlGenerator ($ routes, $ context); $ url = $ generator-> generate ('foo_placeholder_route', array ('id' => 123,)); eco '
'; print_r ($ parametri); echo 'URL generato:'. $ Url; Uscita;  catch (ResourceNotFoundException $ e) echo $ e-> getMessage (); 
L'impostazione del routing tramite il componente Symfony Routing di solito passa attraverso una serie di passaggi come elencato di seguito.
 
Inizializza il Itinerario oggetto per ciascuna delle tue rotte di applicazione.
 
Aggiungi tutto Itinerario oggetti al RouteCollection oggetto.
 
Inizializza il RequestContext oggetto che contiene le informazioni sul contesto della richiesta corrente.
 
Inizializza il UrlMatcher oggetto passando il RouteCollection oggetto e il RequestContext oggetto.
 
Inizializza l'oggetto di instradamento per percorsi diversi
Andiamo avanti e definiamo una cosa piuttosto elementare foo itinerario.
$ foo_route = new Route ('/ foo', array ('controller' => 'FooController'));
Il primo argomento del Itinerario il costruttore è il percorso URI e il secondo argomento è la matrice di attributi personalizzati che si desidera restituire quando questa particolare rotta è abbinata. In genere, sarebbe una combinazione del controller e del metodo che si desidera chiamare quando viene richiesta questa route.
Quindi, diamo un'occhiata al percorso parametrizzato.
$ foo_placeholder_route = new Route ('/ foo / id', array ('controller' => 'FooController', 'method' => 'load'), array ('id' => '[0-9] + '));
Il percorso sopra può corrispondere agli URI come foo / 1, foo / 123 e simili. Si prega di notare che abbiamo limitato il Id parametro solo ai valori numerici e quindi non corrisponderà agli URI come foo / bar dal momento che Id parametro è fornito come una stringa.
Aggiungi tutti gli oggetti di instradamento all'oggetto RouteCollection
Il prossimo passo è aggiungere oggetti di percorso che abbiamo inizializzato nella sezione precedente al RouteCollection oggetto.
$ routes = new RouteCollection (); $ routes-> add ('foo_route', $ foo_route); $ routes-> add ('foo_placeholder_route', $ foo_placeholder_route);
Come puoi vedere, è piuttosto semplice come devi solo usare il Inserisci metodo del RouteCollection oggetto per aggiungere oggetti di percorso. Il primo argomento del Inserisci metodo è il nome del percorso e il secondo argomento è l'oggetto del percorso stesso.
Inizializza il RequestContext Oggetto
Quindi, dobbiamo inizializzare il RequestContext oggetto, che contiene le informazioni sul contesto della richiesta corrente. Avremo bisogno di questo oggetto quando inizializziamo il UrlMatcher obiettare come lo attraverseremo in un momento.
$ context = new RequestContext (); $ Context-> fromRequest (Request :: createFromGlobals ());
Inizializza il UrlMatcher Oggetto
Infine, abbiamo bisogno di inizializzare il UrlMatcher oggetto insieme a percorsi e informazioni sul contesto.
// Init UrlMatcher object $ matcher = new UrlMatcher ($ routes, $ context);
Ora, abbiamo tutto ciò che potremmo confrontare con i nostri percorsi.
Come abbinare le rotte
È il incontro metodo del UrlMatcher oggetto che consente di abbinare qualsiasi percorso contro un insieme di percorsi predefiniti.
Il incontro il metodo prende l'URI come primo argomento e prova a farlo corrispondere a percorsi predefiniti. Se viene trovata la rotta, restituisce gli attributi personalizzati associati a quella rotta. D'altra parte, lancia il ResourceNotFoundException eccezione se non ci sono percorsi associati con l'URI corrente.
$ parameters = $ matcher-> match ($ context-> getPathInfo ());
Nel nostro caso, abbiamo fornito l'URI corrente recuperandolo dal $ contesto oggetto. Quindi, se stai accedendo all'URL http: //your-domain/basic_routes.php/foo, il $ Al contesto> getPathInfo () ritorna foo, e abbiamo già definito un percorso per il foo URI, quindi dovrebbe restituirci quanto segue.
Array ([controller] => FooController [_route] => foo_route)
Ora, procediamo e testiamo il percorso parametrizzato accedendo all'URL http: //your-domain/basic_routes.php/foo/123.
Array ([controller] => FooController [method] => load [id] => 123 [_route] => foo_placeholder_route)
Ha funzionato se puoi vedere che il id il parametro è associato al valore appropriato 123.
Successivamente, proviamo ad accedere a una route inesistente come http: //your-domain/basic_routes.php/unknown-route e dovresti vedere il seguente messaggio.
Nessuna traccia trovata per "/ unknown-route".
Ecco come puoi trovare percorsi usando il incontro metodo.
Oltre a questo, potresti anche usare il Routing componente per generare collegamenti nella tua applicazione. Fornito RouteCollection e RequestContext oggetti, il UrlGenerator ti consente di creare collegamenti per percorsi specifici.
$ generator = new UrlGenerator ($ routes, $ context); $ url = $ generator-> generate ('foo_placeholder_route', array ('id' => 123,));
Il primo argomento del creare metodo è il nome della route e il secondo argomento è la matrice che può contenere parametri se è la route parametrizzata. Il codice sopra dovrebbe generare il /basic_routes.php/foo/123 URL.
Carica percorsi dal file YAML
Nella sezione precedente, abbiamo creato i nostri percorsi personalizzati usando il Itinerario e RouteCollection oggetti. In effetti, il Routing componente offre diversi modi tra cui scegliere per istanziare percorsi. Puoi scegliere tra vari caricatori come YamlFileLoader, XmlFileLoader, e PhpFileLoader.
In questa sezione, passeremo attraverso il YamlFileLoader loader per vedere come caricare percorsi dal file YAML.
Il file YAML delle rotte
Vai avanti e crea il routes.yaml file con il seguente contenuto.
foo_route: percorso: / foo defaults: controller: 'FooController :: indexAction' foo_placeholder_route: percorso: / foo / id default: controller: 'FooController :: loadAction' requisiti: id: '[0-9] +'
Un file di esempio
Quindi, vai avanti e crea il load_routes_from_yaml.php file con il seguente contenuto.
load ( 'routes.yaml'); // Init RequestContext object $ context = new RequestContext (); $ Context-> fromRequest (Request :: createFromGlobals ()); // Init UrlMatcher object $ matcher = new UrlMatcher ($ routes, $ context); // Trova il percorso corrente $ parameters = $ matcher-> match ($ context-> getPathInfo ()); // Come generare un URL SEO $ generator = new UrlGenerator ($ routes, $ context); $ url = $ generator-> generate ('foo_placeholder_route', array ('id' => 123,)); eco '
'; print_r ($ parametri); echo 'URL generato:'. $ Url; Uscita;  catch (ResourceNotFoundException $ e) echo $ e-> getMessage (); 
L'unica cosa che è diversa in questo caso è il modo in cui inizializziamo i percorsi!
$ fileLocator = new FileLocator (array (__ DIR__)); $ loader = new YamlFileLoader ($ fileLocator); $ routes = $ loader-> load ('routes.yaml');
Abbiamo usato il YamlFileLoader caricatore per caricare rotte dal routes.yaml file invece di inizializzarlo direttamente nel PHP stesso. A parte questo, tutto è lo stesso e dovrebbe produrre gli stessi risultati di quello di basic_routes.php file.
Il router all-in-one
Infine, in questa sezione, esamineremo il Router classe, che consente di impostare il routing rapidamente con meno righe di codice.
Vai avanti e fai il all_in_one_router.php file con il seguente contenuto.
fromRequest (Request :: createFromGlobals ()); $ router = new Router (nuovo YamlFileLoader ($ fileLocator), 'routes.yaml', array ('cache_dir' => __DIR __. '/ cache'), $ requestContext); // Trova il percorso corrente $ parameters = $ router-> match ($ requestContext-> getPathInfo ()); // Come generare un URL SEO $ routes = $ router-> getRouteCollection (); $ generator = new UrlGenerator ($ routes, $ requestContext); $ url = $ generator-> generate ('foo_placeholder_route', array ('id' => 123,)); eco '
'; print_r ($ parametri); echo 'URL generato:'. $ Url; Uscita;  catch (ResourceNotFoundException $ e) echo $ e-> getMessage (); 
Tutto è praticamente lo stesso, tranne che abbiamo istanziato il Router oggetto insieme alle dipendenze necessarie.
$ router = new Router (nuovo YamlFileLoader ($ fileLocator), 'routes.yaml', array ('cache_dir' => __DIR __. '/ cache'), $ requestContext);
Con quello sul posto, potete immediatamente usare il incontro metodo dell'oggetto Router per la mappatura del percorso.
$ parameters = $ router-> match ($ requestContext-> getPathInfo ());
Inoltre, è necessario utilizzare il getRouteCollection metodo dell'oggetto Router per recuperare percorsi.
$ routes = $ router-> getRouteCollection ();
Conclusione
Vai avanti ed esplora le altre opzioni disponibili nel componente Routing: mi piacerebbe sentire i tuoi pensieri!
Oggi abbiamo esplorato il componente Symfony Routing, che semplifica l'implementazione del routing nelle applicazioni PHP. Lungo la strada, abbiamo creato una manciata di esempi per dimostrare vari aspetti del componente Routing. 
Spero che questo articolo ti sia piaciuto e sentiti libero di pubblicare i tuoi pensieri utilizzando il feed di seguito!




		
			
	   
	




Codice