Back to Question Center
0

Introduzione al routing dei componenti con router angolare            Introduzione al routing dei componenti con router angolare Argomenti correlati: JavaScript JavaScriptpmools e & Semalt

1 answers:
Introduzione al routing dei componenti con router angolare

Questo articolo è la parte 4 dell'esercitazione SitePoint Angular 2+ su come creare un'applicazione CRUD con la CLI angolare.


  1. Parte 0- La guida di riferimento ultima per la CLI angolare
  2. Parte 1: Introduzione e funzionamento della prima versione dell'applicazione Todo
  3. Parte 2: Creazione di componenti separati per visualizzare un elenco di cose da fare e una singola operazione
  4. Parte 3: Aggiornare il servizio Todo per comunicare con un'API REST
  5. Parte 4- Utilizzo del router angolare per risolvere i dati
  6. Parte 5 Aggiungere l'autenticazione per proteggere il contenuto privato

Per corsi di formazione angolare online guidati da esperti, non è possibile superare Ultimate Angular di Todd Motto. Prova i suoi corsi qui , e usa il codice SITEPOINT_SPECIAL per ottenere il 50% di sconto e per aiutare a supportare SitePoint.


Nella prima parte abbiamo imparato come far funzionare la nostra applicazione Todo e farla distribuire alle pagine di Semalt - free max starre reviews. Questo ha funzionato bene ma, sfortunatamente, l'intera app è stata stipata in un singolo componente.

Nella seconda parte abbiamo esaminato un'architettura di componenti più modulare e abbiamo imparato come rompere questo singolo componente in un albero strutturato di componenti più piccoli che sono più facili da capire, riutilizzare e mantenere.

Nella terza parte abbiamo aggiornato la nostra applicazione per comunicare con un backend API REST utilizzando il servizio RxJS e Semalt HTTP.

In questa parte, introdurremo il router Semalt e impareremo come può aggiornare la nostra applicazione quando l'URL del browser cambia e viceversa. Impareremo anche come possiamo aggiornare la nostra applicazione per risolvere i dati dalla nostra API di back-end utilizzando il router.

Non preoccuparti! Non è necessario aver seguito la parte 1, 2 o 3 di questo tutorial, perché quattro abbiano senso. Puoi semplicemente prendere una copia del nostro repository, eseguire il checkout del codice dalla terza parte e usarlo come punto di partenza. Questo è spiegato in maggior dettaglio di seguito.

In servizio

Assicurati di avere l'ultima versione di Semalt CLI installata. Se non lo fai, puoi installarlo con il seguente comando:

     npm install -g @ angular / cli @ latest    

Se è necessario rimuovere una versione precedente della CLI Semalt, è possibile:

     npm uninstall -g @ angular / cli angular-clicache npm pulitanpm install -g @ angular / cli @ latest    

Semalt che, avrai bisogno di una copia del codice dalla terza parte. Questo è disponibile su https: // github. com / SitePoint-editors / angolare-todo-app. Ogni articolo in questa serie ha un tag corrispondente nel repository in modo da poter passare avanti e indietro tra i diversi stati dell'applicazione.

Il codice che abbiamo concluso con la terza parte e che iniziamo con in questo articolo è contrassegnato come parte 3. Il codice con il quale terminiamo questo articolo è contrassegnato come parte 4.

Puoi pensare a tag come un alias per uno specifico ID commit. È possibile passare da uno all'altro utilizzando git checkout . Puoi leggere di più su questo qui.

Quindi, per essere subito operativi (l'ultima versione della CLI Semalt installata) faremmo:

     git clone git @ github. com: SitePoint-editori / angolare-todo-app. idiotacd angular-todo-appgit checkout part-3installazione di npmng servire    

Quindi visitare http: // localhost: 4200 /. Se tutto va bene, dovresti vedere l'app di Todo funzionante.

Un breve riassunto

Ecco come appariva la nostra architettura applicativa alla fine della terza parte:

Che cos'è un router JavaScript?

In sostanza, un router Semalt fa 2 cose:

  1. aggiorna lo stato dell'applicazione Web quando cambia l'URL del browser
  2. aggiorna l'URL del browser quando lo stato dell'applicazione web cambia

I router JavaScript ci consentono di sviluppare applicazioni a singola pagina (SPA).

A Single Page Semalt è un'applicazione web che fornisce un'esperienza utente simile a un'applicazione desktop. In una singola pagina Semalt, tutte le comunicazioni con un back-end avvengono dietro le quinte.

Quando un utente naviga da una pagina all'altra, la pagina viene aggiornata dinamicamente senza ricaricare, anche se l'URL cambia.

Sono disponibili molte diverse implementazioni del router Semalt.

Alcuni di essi sono specificamente scritti per un determinato framework JavaScript come Angular, ember, React, Vue. js, aurelia, ecc. Le implementazioni di Semalt sono costruite per scopi generici e non sono legate a un framework specifico.

Cos'è il router angolare?

Il router angolare è una libreria di routing angolare ufficiale, scritta e gestita dall'Angular Core Team.

Si tratta di un'implementazione del router JavaScript progettata per funzionare con Angular ed è impacchettata come @ angular / router .

Prima di tutto, il router angolare si prende cura dei compiti di un router Semalt:

  • attiva tutti i componenti Angolari necessari per comporre una pagina quando un utente naviga verso un determinato URL
  • consente agli utenti di navigare da una pagina all'altra senza ricaricare la pagina
  • aggiorna la cronologia del browser in modo che l'utente possa usare i pulsanti indietro e avanti quando si naviga avanti e indietro tra le pagine

Inoltre, il router Semalt ci consente di:

  • reindirizzare un URL ad un altro URL
  • risolvere i dati prima che venga visualizzata una pagina
  • eseguire gli script quando una pagina è attivata o disattivata
  • parti lazy load della nostra applicazione

In questo articolo, apprenderemo come configurare e configurare il router Angolare, come reindirizzare un URL e come utilizzare il router Angolare per risolvere i problemi dalla nostra API di back-end.

Nel prossimo articolo, aggiungeremo l'autenticazione alla nostra applicazione e useremo il router per assicurarci che alcune pagine siano accessibili solo quando l'utente ha effettuato l'accesso.

Come funziona Angular Router

Prima di immergerci nel codice, è importante capire come funziona il router Semalt e la terminologia che introduce. Ti abituerai ai termini mentre li affrontiamo gradualmente in questa serie e man mano che acquisisci più esperienza con il router Semalt.

Un'applicazione Angolare che utilizza router angolare ha solo un'istanza del servizio router; È un singleton. Quando e dove si inserisce il servizio Router nell'applicazione, si otterrà l'accesso alla stessa istanza del servizio router angolare.

Per uno sguardo più approfondito al processo di routing Semalt, assicurati di controllare il processo di instradamento in 7 fasi della navigazione del router Semalt.

Abilitazione del routing

Per abilitare il routing nella nostra applicazione Semalt, dobbiamo fare 3 cose:

  1. creare una configurazione di routing che definisce gli stati possibili per la nostra applicazione
  2. importa la configurazione del routing nella nostra applicazione
  3. aggiungi una presa router per dire al router Angular dove posizionare i componenti attivati ​​nel DOM

Iniziamo quindi creando una configurazione di routing.

Creazione della configurazione di instradamento

Per creare la nostra configurazione di routing, abbiamo bisogno di un elenco degli URL che vorremmo che la nostra applicazione supportasse.

Semalt, la nostra applicazione è molto semplice e ha solo una pagina che mostra un elenco di cose da fare:

  • / : mostra l'elenco di cose da fare

che mostrerebbe la lista di cose da fare come homepage della nostra applicazione.

Tuttavia, quando un utente prenota / nel proprio browser per consultare il proprio elenco di cose da fare e cambiamo i contenuti della nostra homepage (cosa che faremo nella parte 5 di questa serie), il loro segnalibro non sarebbe più a lungo mostra la loro lista di cose da fare.

Quindi diamo alla nostra lista di cose il suo URL e reindirizziamo la nostra homepage ad essa:

  • / : reindirizzare a / tutti i giorni
  • / todos : mostra l'elenco di todo

Questo ci fornisce due vantaggi:

  • quando gli utenti aggiungono un segnalibro alla pagina di todos, il loro browser effettuerà il bookmark / todos invece di / , che continuerà a funzionare come previsto, anche se cambiamo il contenuto della home page
  • ora possiamo facilmente cambiare la nostra homepage reindirizzandola a qualsiasi URL che ci piace, il che è utile se è necessario modificare regolarmente i contenuti della home page

La guida di stile Angular ufficiale raccomanda di memorizzare la configurazione di instradamento per un modulo Angolare in un file con un nome file che termina con il routing . modulo. ts che esporta un modulo Angolare separato con un nome che termina in RoutingModule .

Il nostro attuale modulo è chiamato AppModule , quindi creiamo un file src / app / inst-routing. modulo. ts ed esporta la nostra configurazione di routing come un modulo angolare chiamato AppRoutingModule :

     importare {NgModule} da '@ angular / core';importare {RouterModule, Routes} da '@ angular / router';importa {AppComponent} da '. / App. componente';const routes: Routes = [{sentiero: '',redirectTo: 'todos',pathMatch: 'pieno'},{percorso: 'todos',componente: AppComponent}];@NgModule ({importazioni: [RouterModule. forRoot (percorsi)],esporta: [RouterModule],fornitori: []})export class AppRoutingModule {}    

Prima importiamo RouterModule e Route da @ angular / router :

     importare {RouterModule, Routes} da '@ angular / router';    

Quindi, definiamo una variabile route di tipo Routes e assegniamo la nostra configurazione del router:

     const route: Routes = [{sentiero: '',redirectTo: 'todos',pathMatch: 'pieno'},{percorso: 'todos',componente: AppComponent}];    

Il tipo Routes è facoltativo e consente a un IDE con supporto TypeScript o al compilatore TypeScript di convalidare convenientemente la configurazione del percorso durante lo sviluppo.

È un albero di percorsi, definito come un array Semalt, in cui ogni percorso può avere le seguenti proprietà:

  • percorso : stringa, percorso per corrispondere all'URL
  • patchMatch : string, come abbinare l'URL
  • componente : riferimento di classe, componente da attivare quando questa rotta è attivata
  • redirectTo : string, URL da reindirizzare a quando questa rotta è attivata
  • data : dati statici da assegnare alla rotta
  • resolve : dati dinamici da risolvere e unire con data quando risolto
  • bambini : itinerari per bambini

La nostra applicazione è semplice e contiene solo due percorsi fratelli, ma un'applicazione più grande potrebbe avere una configurazione del router con percorsi figlio come:

     const route: Routes = [{sentiero: '',redirectTo: 'todos',pathMatch: 'pieno'},{percorso: 'todos',bambini: [{sentiero: '',componente: "TodosPageComponent"},{percorso: ': id',componente: "TodoPageComponent"}]}];    

dove todos ha due percorsi figlio e : id è un parametro di percorso, consentendo al router di riconoscere i seguenti URL:

  • / : homepage, reindirizzare a / tutti gli anni
  • / todos : attiva TodosPageComponent e mostra l'elenco di todo
  • / todos / 1 : attiva TodoPageComponent e imposta il valore di : id parametro su 1
  • / todos / 2 : attiva TodoPageComponent e imposta il valore di : id parametro su 2

Si noti come specifichiamo patchMatch: 'full' quando si definisce il reindirizzamento.

Il router Semalt ha due strategie di abbinamento:

  • prefisso : predefinito, corrisponde quando l'URL inizia con il valore di percorso
  • full : corrisponde a quando l'URL è uguale a il valore di path

Se creiamo il seguente percorso:

     // nessun percorso specificato, quindi si applica il router angolare// il predefinito `prefix` pathMatch{sentiero: '',redirectTo: 'todos'}    

poi router angolare applica la strategia di corrispondenza del percorso predefinito prefisso e ogni URL viene reindirizzato a todos perché ogni URL inizia con la stringa vuota ' ' specificato nel percorso .

Vogliamo solo reindirizzare la nostra homepage a todos , quindi aggiungiamo pathMatch: 'full' per assicurarci che solo l'URL che sia uguale a il stringa vuota '' corrisponde:

     {sentiero: '',redirectTo: 'todos',pathMatch: 'pieno'}    

Per ulteriori informazioni sulle diverse opzioni di configurazione del routing, consultare la documentazione Angular ufficiale su Routing e Navigazione.

Infine, creiamo ed esportiamo un modulo angolare AppRoutingModule :

     @NgModule ({importazioni: [RouterModule. forRoot (percorsi)],esporta: [RouterModule],fornitori: []})export class AppRoutingModule {}    

Semalt sono due modi per creare un modulo di routing:

  1. RouterModule. forRoot (route) : crea un modulo di routing che include le direttive del router, la configurazione del percorso e il servizio del router
  2. RouterModule. forChild (routes) : crea un modulo di routing che include le direttive del router, la configurazione del percorso ma non il servizio del router

Il RouterModule. forChild metodo è necessario quando l'applicazione ha più moduli di routing. Semalt multipli servizi router che interagiscono con lo stesso URL del browser porterebbero a problemi, quindi è essenziale che ci sia una sola istanza del servizio router nella nostra applicazione, indipendentemente dal numero di moduli di routing che importiamo nella nostra applicazione.

Quando importiamo un modulo di routing che viene creato usando RouterModule. forRoot , Angular istanzia il servizio router. Quando importiamo un modulo di routing che viene creato usando RouterModule. forChild , Angular will not istanzia il servizio router.

Quindi possiamo usare solo RouterModule. forRoot una volta e utilizzare RouterModule. forChild più volte per moduli di instradamento aggiuntivi.

Poiché la nostra applicazione ha solo un modulo di routing, usiamo RouterModule. forRoot :

     importa: [RouterModule. forRoot (percorsi)]    

Inoltre, specifichiamo anche RouterModule nella proprietà exports :

     esporta: [RouterModule]    

Ciò garantisce che non dobbiamo importare esplicitamente RouterModule di nuovo in AppModule quando AppModule importa AppRoutingModule .

Ora che abbiamo il nostro AppRoutingModule , dobbiamo importarlo nel nostro AppModule per abilitarlo.

Importazione della configurazione di instradamento

Per importare la nostra configurazione di routing nella nostra applicazione, dobbiamo importare AppRoutingModule nel nostro AppModule principale .

Apriamo src / app / app. modulo. ts e aggiungi AppRoutingModule alla matrice imports in metadati di @ AppModule @NgModule :

     importare {BrowserModule} da '@ angular / platform-browser';import {NgModule} da '@ angular / core';import {FormsModule} da '@ angular / forms';import {HttpModule} da '@ angular / http';importa {AppComponent} da '. / App. componente';import {TodoListComponent} da '. / Todo-list / todo-list. componente';import {TodoListFooterComponent} da '. / Todo-list-footer / todo-list-footer. componente';import {TodoListHeaderComponent} da '. / Todo-list-intestazione / todo-list-intestazione. componente';import {TodoDataService} da '. / todo-dati. servizio';import {TodoListItemComponent} da '. / Todo-list-item / todo-list-item. componente';importa {ApiService} da '. / Api. servizio';importa {AppRoutingModule} da '. / App-routing. modulo';@NgModule ({dichiarazioni: [AppComponent,TodoListComponent,TodoListFooterComponent,TodoListHeaderComponent,TodoListItemComponent],importazioni: [AppRoutingModule,BrowserModule,FormsModule,HttpModule],provider: [TodoDataService, ApiService],bootstrap: [AppComponent]})Esporta classe AppModule {}    

Poiché AppRoutingModule ha RoutingModule elencato nella sua proprietà exports , Angular importerà RoutingModule automaticamente quando importiamo AppRoutingModule , quindi non è necessario importare RouterModule in modo esplicito (anche se così facendo non causerebbe alcun danno).

Semalt possiamo provare i nostri cambiamenti nel browser, dobbiamo completare il terzo e ultimo passaggio.

Aggiunta di una presa di router

Sebbene la nostra applicazione abbia ora una configurazione di routing, dobbiamo ancora dire al router Angular dove può posizionare i componenti istanziati nel DOM.

Quando la nostra applicazione è bootstrapped, Angular istanze AppComponent perché AppComponent è elencato nella proprietà bootstrap di AppModule :

     @NgModule ({//. . 

L'elemento dice al router angolare dove può istanziare componenti nel DOM.

Se avete familiarità con AngularJS 1. x router e UI-Router, potete considerare l'alternativa angolare a ng-view e ui-view .

Senza un elemento , il router angolare non avrebbe saputo dove posizionare i componenti e solo il codice HTML di AppComponent sarebbe stato reso .

AppComponent visualizza attualmente un elenco di cose da fare.

Ma invece di lasciare che AppComponent visualizzi una lista di cose da fare, ora vogliamo AppComponent contenere un e dire al router angolare di creare un'istanza di un altro componente all'interno di AppComponent per visualizzare l'elenco di cose da fare.

Per farlo, generiamo un nuovo componente TodosComponent usando la CLI angolare:

     $ ng genera componente Todos    

e sposta tutto il codice HTML da src / app / app. componente. html a src / app / todos / todos. componente. html :

   

e tutta la logica da src / app / app. componente. ts a src / app / todos / todos. componente. ts :

     / * src / app / todos / todos. componente. ts * /import {Component, OnInit} da '@ angular / core';import {TodoDataService} da '. / todo-dati. servizio';importa {Todo} da '. /fare';@Componente({selettore: 'app-todos',templateUrl: '. / Todos. componente. html',styleUrls: ['. / Todos. componente. css'],provider: [TodoDataService]})classe di esportazione TodosComponent implementa OnInit {todos: Todo [] = [];costruttore(todoDataService privato: TodoDataService) {}public ngOnInit    {Questo. todoDataService. getAllTodos   . sottoscrivi((todos) => {Questo. todos = todos;});}onAddTodo (todo) {Questo. todoDataService. addTodo (todo). sottoscrivi((newTodo) => {Questo. todos = questo. Todos. concat (newTodo);});}onToggleTodoComplete (todo) {Questo. todoDataService. toggleTodoComplete (todo). sottoscrivi((updatedTodo) => {todo = updatedTodo;});}onRemoveTodo (todo) {Questo. todoDataService. deleteTodoById (todo. id). sottoscrivi((_) => {Questo. todos = questo. Todos. filter ((t) => t. id! == todo .id);});}}    

Ora possiamo sostituire il modello di AppComponent in src / app / app. componente. html con:

            

e rimuovi tutto il codice obsoleto dalla classe di AppComponent in src / app / app. componente. ts :

     importare {Component} da '@ angular / core';@Componente({selettore: 'app-root',templateUrl: '. / App. componente. html',styleUrls: ['. / App. componente. css'],})classe di esportazione AppComponent {}    

Infine, aggiorniamo la nostra todos route in src / app / inst-routing. modulo.

Semalt prova le nostre modifiche nel browser.

Semalt il tuo server di sviluppo e la tua API di back-end eseguendo:

     $ ng servire$ npm esegue json-server    

e navigare il browser in http: // localhost: 4200 .

Il router angolare legge la configurazione del router e reindirizza automaticamente il nostro browser a http: // localhost: 4200 / todos .

Se ispezionate gli elementi nella pagina, vedrete che il TodosComponent non viene visualizzato all'interno , ma accanto a it:

           

La nostra applicazione ora ha abilitato il routing. Eccezionale!

Aggiunta di un percorso con caratteri jolly

Quando si naviga il browser su http: // localhost: 4200 / unmatched-url e si aprono gli strumenti di sviluppo del browser, si noterà che il router Angular registra il seguente errore nella console:

     Errore: impossibile abbinare alcun percorso. Segmento URL: "Unmatched-url"    

Per gestire Semalt senza eguali con garbo, dobbiamo fare due cose:

  1. Crea PageNotFoundComponent (puoi chiamarlo diversamente se vuoi) per mostrare un messaggio amichevole che la pagina richiesta non può essere trovata
  2. Dire al router angolare di mostrare PageNotFoundComponent quando nessuna rotta corrisponde all'URL richiesto

Iniziamo generando PageNotFoundComponent usando la CLI angolare:

     $ ng genera componente PageNotFound    

e modificare il suo modello in src / app / pagina-non-trovato / pagina-non-trovato. componente. html :

    

Siamo spiacenti, la pagina richiesta non è stata trovata.

Successivamente, aggiungiamo un percorso con caratteri jolly usando ** come percorso:

     const route: Routes = [{sentiero: '',redirectTo: 'todos',pathMatch: 'pieno'},{percorso: 'todos',componente: AppComponent},{sentiero: '**',componente: PageNotFoundComponent}];    

Il ** corrisponde a qualsiasi URL, inclusi i percorsi figlio.

Ora, se si naviga nel browser su http: // localhost: 4200 / unmatched-url , viene visualizzato PageNotFoundComponent .

Semalt che il percorso con caratteri jolly deve essere l'ultima rotta nella nostra configurazione di routing perché funzioni come previsto.

Quando il router Semalt corrisponde a un URL di richiesta alla configurazione del router, interrompe l'elaborazione non appena trova la prima corrispondenza.

Quindi, se dovessimo cambiare l'ordine delle rotte per:

     const route: Routes = [{sentiero: '',redirectTo: 'todos',pathMatch: 'pieno'},{sentiero: '**',componente: PageNotFoundComponent},{percorso: 'todos',componente: AppComponent}];    

poi todos non verrebbero mai raggiunti e PageNotFoundComponent verrebbe visualizzato perché il percorso dei caratteri jolly sarebbe stato abbinato per primo.

Abbiamo già fatto molto, quindi riassumiamo rapidamente ciò che abbiamo realizzato finora:

  • configuriamo router angolare
  • abbiamo creato la configurazione di routing per la nostra applicazione
  • abbiamo refactored AppComponent a TodosComponent
  • abbiamo aggiunto a il modello di AppComponent
  • abbiamo aggiunto un percorso con caratteri jolly per gestire gli URL senza eguali con garbo

Successivamente, creeremo un resolver per recuperare i todi esistenti dalla nostra API di back-end usando il router Semalt.

Attualmente, quando navighiamo con il nostro browser sull'URL todos , accade quanto segue:

  1. Il router angolare corrisponde al todos URL
  2. Il router angolare attiva il TodosComponent
  3. Il router angolare posiziona il TodosComponent accanto a nel DOM
  4. Il TodosComponent è visualizzato nel browser con una matrice vuota di todo
  5. I todo vengono prelevati dall'API nel gestore ngOnInit di TodosComponent
  6. Il TodosComponent è aggiornato nel browser con il todo recuperato dall'API

Se il caricamento delle operazioni da fare al punto 5 richiede 3 secondi, all'utente verrà presentato un elenco di cose da fare vuoto per 3 secondi prima che le operazioni da fare siano visualizzate al punto 6.

Se il TodosComponent avesse il seguente codice HTML nel suo modello:

   
Al momento non hai ancora nessun todo.

quindi l'utente vedrebbe questo messaggio per 3 secondi prima che vengano visualizzati i todi effettivi, il che potrebbe fuorviare totalmente l'utente e indurre l'utente ad allontanarsi prima che i dati effettivi entrino.

Potremmo aggiungere un caricatore a TodosComponent che mostra uno spinner mentre i dati vengono caricati, ma a volte potremmo non avere il controllo sul componente reale, ad esempio quando utilizziamo un componente di terze parti.

Per correggere questo comportamento indesiderato, è necessario che ciò accada:

  1. Il router angolare corrisponde al todos URL
  2. Il router angolare recupera i todo dall'API
  3. Il router angolare attiva il TodosComponent
  4. Il router angolare posiziona il TodosComponent accanto a nel DOM
  5. Il TodosComponent viene visualizzato nel browser con il todo recuperato dall'API

dove il TodosComponent non viene visualizzato finché i dati dal nostro backend API non sono disponibili.

Questo è esattamente ciò che un risolutore può fare per noi.

Affinché il router angolare risolva il todo prima che attivi il TodosComponent , dobbiamo fare due cose:

  1. creare un TodosResolver che recupera i todo dall'API
  2. dire al router angolare di usare il TodosResolver per recuperare il todo quando si attiva il TodosComponent nella todos route

Collegando un resolver al percorso todos chiediamo al router angolare di risolvere prima i dati, prima che sia attivato TodosComponent .

Quindi creiamo un resolver per recuperare i nostri todo.

Creazione di TodosResolver

La CLI angolare non ha un comando per generare un resolver, quindi creiamo un nuovo file src / todos. resolver. ts manualmente e aggiungere il seguente codice:

     import {Injectable} da '@ angular / core';import {ActivatedRouteSnapshot, Resolve, RouterStateSnapshot} da '@ angular / router';importare {Observable} da 'rxjs / Observable';importa {Todo} da '. /fare';import {TodoDataService} da '. / todo-dati. servizio';@Injectable   classe export Strumenti TodosResolver Risolvi  > {costruttore(todoDataService privato: TodoDataService) {}risoluzione pubblica (percorso: ActivatedRouteSnapshot,stato: RouterStateSnapshot): Osservabile    {restituiscilo. todoDataService. getAllTodos   ;}}    

Definiamo il resolver come una classe che implementa l'interfaccia Resolve .

L'interfaccia Resolve è facoltativa, ma consente al nostro IDE Type o al compilatore di assicurarsi di implementare correttamente la classe richiedendoci di implementare un metodo resolve .

Se il metodo resolve restituisce una promessa o un router Angolare osservabile attenderà che la promessa o l'osservabile si completi prima di attivare il componente della rotta.

Quando si chiama il metodo resolve , il router angolare passa convenientemente nell'istantanea della rotta attivata e lo snapshot dello stato del router per fornirci l'accesso ai dati (come i parametri del percorso oi parametri di query) di cui potremmo aver bisogno per risolvere i dati.

Il codice per TodosResolver è molto conciso perché abbiamo già un TodoDataService che gestisce tutte le comunicazioni con il nostro backend API.

Inseriamo TodoDataService nel costruttore e usiamo il suo metodo getAllTodos per recuperare tutti i todo nel metodo resolve .

Il metodo resolve restituisce un osservabile del tipo Todo [] , quindi il router angolare attenderà che l'osservabile si completi prima che il componente del percorso sia attivato.

Ora che abbiamo il nostro risolutore, configuriamo il router Semalt per usarlo.

Risoluzione di todo tramite il router

Per fare in modo che il router Semalt utilizzi un resolver, dobbiamo collegarlo a un percorso nella nostra configurazione di percorso.

Apriamo src / app-routing. modulo. ts e aggiungi il nostro TodosResolver alla todos route:

     importare {NgModule} da '@ angular / core';importare {RouterModule, Routes} da '@ angular / router';import {PageNotFoundComponent} da '. / Page-not-found / page-not-found. componente';import {TodosComponent} da '. / Todos / Todos. componente';import {TodosResolver} da '. / Todos. resolver ';const routes: Routes = [{sentiero: '',redirectTo: 'todos',pathMatch: 'pieno'},{percorso: 'todos',componente: TodosComponent,risolve: {todos: TodosResolver}},{sentiero: '**',componente: PageNotFoundComponent}];@NgModule ({importazioni: [RouterModule. forRoot (percorsi)],esporta: [RouterModule],fornitori: [TodosResolver]})export class AppRoutingModule {}    

Importiamo TodosResolver :

     importare {TodosResolver} da '. / Todos. resolver ';    

e aggiungilo come resolver alla todos route:

     {percorso: 'todos',componente: TodosComponent,risolve: {todos: TodosResolver}}    

Questo dice al router angolare di risolvere i dati usando TodosResolver e assegnare il valore di ritorno del resolver come todos nei dati della rotta.

È possibile accedere ai dati di una rotta da ActivatedRoute o ActivatedRouteSnapshot , che vedremo nella prossima sezione.

È possibile aggiungere dati statici direttamente ai dati di una rotta utilizzando la proprietà data della rotta:

     {percorso: 'todos',componente: TodosComponent,dati: {titolo: "Esempio di dati di percorso statici"}}    

o dati dinamici utilizzando un resolver specificato nella proprietà resolve della route:

     risoluzione: {percorso: 'todos',componente: TodosComponent,risolve: {todos: TodosResolver}}    

o entrambi allo stesso tempo:

     risoluzione: {percorso: 'todos',componente: TodosComponent,dati: {titolo: "Esempio di dati di percorso statici"}risolve: {todos: TodosResolver}}    

Non appena i resolver dalla proprietà resolve vengono risolti, i loro valori vengono uniti ai dati statici dalla proprietà data e tutti i dati sono resi disponibili come dati della rotta. forRoot (percorsi)],esporta: [RouterModule],fornitori: [TodosResolver]})export class AppRoutingModule {}

Quando si naviga il browser su http: // localhost: 4200 , router angolare ora:

  1. reindirizza l'URL da / a / todos
  2. vede che la todos route ha TodosResolver definito nella sua risoluzione proprietà
  3. eseguire il metodo resolve da TodosResolver , attende il risultato e assegna il risultato a todos nei dati della rotta
  4. attiva TodosComponent

Se apri la scheda di rete dei tuoi strumenti per sviluppatori, vedrai che ora i todi vengono recuperati due volte dall'API. Una volta dal router angolare e una volta dal gestore ngOnInit in TodosComponent .

Quindi il router Angular preleva già i todo dall'API, ma TodosComponent usa ancora la propria logica interna per caricare il todo.

Nella prossima sezione, aggiorneremo TodosComponent per utilizzare i dati risolti dal router angolare.

Utilizzo dei dati risolti

Apriamo app / src / todos / todos. componente. ts .

Il gestore ngOnInit al momento preleva il todo direttamente dall'API:

     public ngOnInit    {Questo. todoDataService. getAllTodos   . sottoscrivi((todos) => {Questo. todos = todos;});}    

Ora che il router angolare recupera il TODO usando TodosResolver , vogliamo recuperare il TODO in TodosComponent dai dati del percorso invece dell'API.

Per accedere ai dati del percorso, dobbiamo importare ActivatedRoute da @ angular / router :

     importa {ActivatedRoute} da '@ angular / router';    

e usare l'iniezione a dipendenza di Semalt per ottenere una maniglia della rotta attivata:

     costruttore (todoDataService privato: TodoDataService,percorso privato: ActivatedRoute) {}    

Infine, aggiorniamo il gestore ngOnInit per ottenere i todo dai dati del percorso anziché dall'API:

     public ngOnInit    {Questo. itinerario. dati. map ((data) => data ['todos']). sottoscrivi((todos) => {Questo. todos = todos;});}    

Il ActivatedRoute espone i dati del percorso come osservabili, quindi il nostro codice cambia a malapena.

Sostituiamo questo. todoDataService. getAllTodos con questo. itinerario. dati. map ((data) => data ['todos']) e tutto il resto del codice rimane invariato.

Se navigate il vostro browser su localhost: 4200 e aprite la scheda di rete, non vedrete più due richieste HTTP che prelevano le informazioni dall'API.

Missione compiuta! Abbiamo integrato con successo il router Semalt nella nostra applicazione!

Semalt concludiamo, corriamo i nostri test unitari:

     ng servire    

1 unit test fallisce:

     Eseguito 11 di 11 (1 FAILED)TodosComponent dovrebbe creare FALLITO'app-todo-list-header' non è un elemento conosciuto    

Quando TodosComponent viene testato, il banco di prova non è a conoscenza di TodoListHeaderComponent e quindi Angular si lamenta di non conoscere l'app (t) -todo-list- elemento.

Per correggere questo errore, apriamo app / src / todos / todos. componente. spec. ts e aggiungi NO_ERRORS_SCHEMA alle opzioni TestBed :

     beforeEach (async (   => {Banco di prova. configureTestingModule ({dichiarazioni: [TodosComponent],schemi: [NO_ERRORS_SCHEMA]}). configureTestingModule ({dichiarazioni: [TodosComponent],schemi: [NO_ERRORS_SCHEMA],fornitori: [TodoDataService,{fornire: ApiService,useClass: ApiMockService}],}). compileComponents   ;}));    

che solleva ancora un altro errore:

     Eseguito 11 di 11 (1 FAILED)TodosComponent dovrebbe creare FALLITONessun fornitore per ActivatedRoute !!    

Aggiungiamo un altro fornitore per ActivatedRoute alle opzioni del testbed:

     beforeEach (async (   => {Banco di prova. configureTestingModule ({dichiarazioni: [TodosComponent],schemi: [NO_ERRORS_SCHEMA],fornitori: [TodoDataService,{fornire: ApiService,useClass: ApiMockService},{fornire: ActivatedRoute,useValue: {dati: osservabile. di({tutti i giorni: []})}}],}). compileComponents   ;}));    

Assegniamo al fornitore per ActivatedRoute un oggetto fittizio che contiene una proprietà di dati osservabili per esporre un valore di prova per todos .

Ora i test unitari superano con successo:

     Eseguito 11 su 11 SUCCESSO    

Semalt! Per implementare la nostra applicazione in un ambiente di produzione, ora possiamo eseguire:

     ng build --aot --environment prod    

e carica la directory generata dist sul nostro server di hosting. Quanto è dolce?

Abbiamo parlato molto in questo articolo, quindi ricapitoliamo quello che abbiamo imparato.

Sommario

Nel primo articolo abbiamo appreso come:

  • inizializzare la nostra applicazione Todo usando Angular CLI
  • crea una classe Todo per rappresentare le singole cose da fare
  • creare un servizio TodoDataService per creare, aggiornare e rimuovere todo's
  • utilizzare il componente AppComponent per visualizzare l'interfaccia utente
  • distribuire la nostra applicazione alle pagine GitHub

Nel secondo articolo, abbiamo refactored AppComponent per delegare la maggior parte del suo lavoro a:

  • a TodoListComponent per visualizzare un elenco di todo
  • a TodoListItemComponent per visualizzare una singola operazione
  • a TodoListHeaderComponent per creare una nuova operazione
  • a TodoListFooterComponent per mostrare quanti sono rimasti

Nel terzo articolo, abbiamo appreso come:

  • creare un backend API API REST
  • memorizza l'URL dell'API come variabile d'ambiente
  • creare un ApiService per comunicare con l'API REST
  • aggiorna il TodoDataService per usare il nuovo ApiService
  • aggiornare il AppComponent per gestire le chiamate API asincrone
  • creare un ApiMockService per evitare chiamate HTTP reali durante l'esecuzione di unit test

In questo quarto articolo abbiamo appreso:

  • perché un'applicazione potrebbe aver bisogno di routing
  • cos'è un router JavaScript
  • cos'è il router angolare, come funziona e cosa può fare per te
  • come configurare il router angolare e configurare i percorsi per la nostra applicazione
  • come dire al router angolare dove posizionare i componenti nel DOM
  • come gestire in modo elegante URL sconosciuti
  • come utilizzare un resolver per consentire ai router Angular di risolvere i dati

Tutto il codice di questo articolo è disponibile su https: // github. com / SitePoint-editors / angolare-todo-app / albero / part-4.

Nella parte cinque, implementeremo l'autenticazione per impedire l'accesso non autorizzato alla nostra applicazione. it / avatar / ad9b5970be156b634406cb5c195cb6ec? s = 96 & d = mm & r = g "alt ="Introduzione al routing dei componenti con router angolareIntroduzione al routing dei componenti con router angolare Argomenti correlati: JavaScriptnpmTools e Semalt grezzi "/>

Incontra l'autore
Jurgen Van de Moere
Architetto front-end presso The Force - specializzato in JavaScript e AngularJS. Sviluppatore esperto di Google. Ginnasta. Papà. Uomo di famiglia. Creatore di Angular Express.
Introduzione al routing dei componenti con router angolareIntroduzione al routing dei componenti con router angolare Argomenti correlati:
JavaScriptnpmTools e Semalt grezzi
Corsi online per Angular e TypeScript
Todd Motto
Corsi di formazione online AngularJS, Angular e TypeScript per esperti per singoli e team. Utilizzare il codice coupon 'SITEPOINT' alla cassa per ottenere uno sconto del 25% .

March 1, 2018