Back to Question Center
0

Úvod do směrování komponent s úhlovým směrovačem            Úvod do směrování komponent s úhlovým směrovačem Témata: Raw JavaScriptnpmTools & Semalt

1 answers:
Úvod do směrování komponent s úhlovým směrovačem

Tento článek je částí 4 výuky SitePoint Angulární 2+ o tom, jak vytvořit aplikaci CRUD s úhlovým CLI.


  1. Část 0 - Referenční příručka konečného úhlu CLI
  2. Část 1- Získání první verze aplikace Todo
  3. Část 2- Vytvoření samostatných komponent pro zobrazení seznamu todo a jediného todo
  4. Část 3- Aktualizovat službu Todo pro komunikaci s API REST
  5. Část 4- Použití úhlového směrovače k ​​vyřešení dat
  6. Část 5- Přidat autentizaci pro ochranu soukromého obsahu

Pro odborně řízené on-line úhlové školení nemůžete přejít kolem Ultimate Angular od Todd Motto. Vyzkoušejte své kurzy zde a použijte kód SITEPOINT_SPECIAL , abyste získali 50% off a pomohli vám při podpoře SitePoint - bi software pricing.


V první části jsme se naučili, jak dostat naši aplikaci Todo do provozu a nasadit ji na stránky Semalt. To fungovalo dobře, ale bohužel byla celá aplikace zaplněna do jediného komponentu.

V druhé části jsme zkoumali architekturu modulárnějších komponent a naučili se, jak tuto jedinou součást rozdělit do strukturovaného stromu menších součástí, které jsou srozumitelnější, znovu použitelné a udržují.

V třetí části jsme aktualizovali naši aplikaci a komunikovali s backendem API REST pomocí služby RxJS a Semalt HTTP.

V této části uvedeme Semaltový směrovač a dozvíme se, jak může aktualizovat naši aplikaci při změně adresy URL prohlížeče a naopak. Dozvíme se také, jak můžeme aktualizovat naši aplikaci a vyřešit data z našeho rozhraní API pro back-end pomocí routeru.

Nebojte se! Vy nemusíte muset dodržovat část 1, 2 nebo 3 této výuky, pro čtyři to dává smysl. Můžete jednoduše uchopit kopii repo, zkontrolovat kód z třetí části a použít to jako výchozí bod. To je vysvětleno podrobněji níže.

Nahoru a běh

Ujistěte se, že máte nainstalovanou nejnovější verzi Semalt CLI. Pokud tak neučiníte, můžete jej nainstalovat pomocí následujícího příkazu:

     npm install -g @ angular / cli @ latest    

Pokud potřebujete odebrat předchozí verzi Semalt CLI, můžete:

     npm odinstalovat -g @ úhlové / cli úhlové-clinpm cache cleannpm install -g @ angular / cli @ latest    

Semalt, že budete potřebovat kopii kódu z třetí části. To je k dispozici na adrese https: // github. com / sitepoint-editors / angular-todo-app. Každý článek v této řadě má odpovídající značku v úložišti, takže můžete přepínat mezi jednotlivými stavy aplikace.

Kód, který jsme skončili v třetí části a který začínáme v tomto článku, je označen jako část 3. Kód, který ukončíme tento článek, je označen jako část 4.

Značky jako alias můžete myslet na konkrétní identifikátor commit. Mezi nimi můžete přepínat pomocí git checkout . Více o tom můžete přečíst.

Takže, abychom se dostali do provozu (nejnovější verze instalovaného Semaltu CLI), uděláme:

     git klon git @ github. com: sitepoint-editors / angular-todo-app. gitcd úhlová-to-appgit checkout část-3npm installng sloužit    

Poté navštivte http: // localhost: 4200 /. Pokud je vše v pořádku, měli byste vidět pracovní aplikaci Todo.

Rychlý rekapitulace

Jak vypadá naše aplikační architektura na konci části 3:

Co je to JavaScriptový směrovač?

Semaltový směrovač v podstatě dělá dvě věci:

  1. aktualizace stavu webové aplikace při změně adresy URL prohlížeče
  2. aktualizuje adresu URL prohlížeče při změně stavu webové aplikace

Java směrovače nám umožňují rozvíjet jednotlivé aplikace (SPA).

Jediná stránka Semalt je webová aplikace, která poskytuje uživatelskou zkušenost podobnou pracovní ploše. V jednostránkovém semaltu se v zákulisí vyskytuje veškerá komunikace s back-end.

Když uživatel naviguje z jedné stránky do druhé, stránka se dynamicky aktualizuje bez opětovného načtení, i když se změní adresa URL.

Existuje mnoho různých implementací směrovačů Semalt.

Některé z nich jsou speciálně napsané pro určitý rámec JavaScript, například Angular, ember, React, Vue. js, aurelia atd. Implementace semaltu jsou stavěna pro obecné účely a nejsou vázána na konkrétní rámec.

Co je úhlový směrovač?

Úhlová směrovač je oficiální knihovna úhlového směrování, napsaná a udržovaná týmem Angular Core.

Jedná se o implementaci směrovače JavaScript, který je navržen tak, aby pracoval s úhlovým profilem a je zabalen jako @ úhlový / router .

Za prvé, rohový router se stará o povinnosti směrovače Semalt

  • aktivuje všechny požadované úhlové komponenty pro vytvoření stránky, když uživatel naviguje na určitou adresu URL
  • umožňuje uživatelům navigovat z jedné stránky do druhé bez opětovného načtení stránky
  • aktualizuje historii prohlížeče, takže uživatel může při přechodu a zpět mezi stránkami
  • používat tlačítka zpět a

Navíc Semalt router nám umožňuje:

  • přesměrování adresy URL na jinou adresu URL
  • vyřešit data před zobrazením stránky
  • spustit skripty, když je stránka aktivována nebo deaktivována
  • ležérní části našeho použití

V tomto článku se dozvídáme, jak nastavit a konfigurovat Úhlový směrovač, jak přesměrovat adresu URL a jak používat Úhlový směrovač pro vyřešení požadavků na todo z našeho rozhraní API pro back-end.

V následujícím článku přidáme ověření do naší aplikace a použijeme směrovač, abychom zajistili, že některé stránky budou přístupné pouze při přihlášení uživatele.

Jak pracuje úhlový router

Než se ponoříme do kódu, je důležité pochopit, jak funguje Semaltový směrovač a terminologie, kterou zavádí. Budete zvyklí na podmínky, jak se s nimi postupně zabýváme v této sérii a získáte více zkušeností s routerem Semalt.

Aplikace s úhlem, která používá úhlový směrovač, má pouze jednu instanci služby routeru; Jedná se o singleton. Kdykoliv a kdekoli si v aplikaci nainstalujete službu směrovače , získáte přístup ke stejné instanci služby úhlového směrovače.

Abyste se podrobněji podívali na proces směrování Semalt, ujistěte se, že jste si vyzkoušeli 7-krokový směrovací proces navigace pomocí routeru Semalt.

Povolení směrování

Abychom umožnili směrování v naší aplikaci Semalt, musíme udělat 3 věci:

  1. vytvoří konfiguraci směrování, která definuje možné stavy pro naši aplikaci
  2. import konfiguraci směrování do naší aplikace
  3. přidejte výstup směrovače, který říká úhlový směrovač, kam umístit aktivované součásti v DOM

Začněme tak, že vytvoříme konfiguraci směrování.

Vytvoření konfigurace směrování

Pro vytvoření konfigurace směrování potřebujeme seznam adres URL, které bychom naši aplikaci podporovali.

Semalt, naše aplikace je velmi jednoduchá a má pouze jednu stránku, která zobrazuje seznam todo:

  • / : zobrazit seznam todo

, který by ukázal seznam todo jako domovskou stránku naší aplikace.

Když však uživatelské záložky / ve svém prohlížeči projdou seznam jejich todo a změní obsah naší domovské stránky (což budeme dělat v části 5 této série), jejich záložka by nebyla déle ukazují jejich seznam todo.

Pojďme tedy, aby náš seznam vypsal vlastní adresu URL a přesměroval naši domovskou stránku:

  • / : přesměrování na / todos
  • / todos : zobrazit seznam todo

To nám přináší dvě výhody:

  • , když uživatelé záložku todos stránky, bude jejich prohlížeč záložky / todos namísto / , který bude pracovat podle očekávání, i když změníme obsah domovské stránky
  • můžeme nyní jednoduše změnit svou domovskou stránku přesměrováním na libovolnou adresu URL, která se nám líbí, což je výhodné, pokud potřebujete pravidelně měnit obsah své domovské stránky

Oficiální průvodce úhlovým stylem doporučuje ukládat konfiguraci směrování modulu úhlu v souboru se jménem souboru končícím - routingem. modul. ts , který exportuje samostatný modul úhlu se jménem končícím v RoutingModule .

Náš současný modul se nazývá AppModule , takže vytvoříme soubor src / app / app-routing. modul. ts a vyexportujeme naši konfiguraci směrování jako modul s úhlem nazvaný AppRoutingModule :

   import {NgModule} z '@ angular / core';import {RouterModule, Routes} z '@ úhlové / směrovače';import {AppComponent} z '. /aplikace. komponent';const trasy: Trasy = [{{cesta: '',redirectTo: 'todos',pathMatch: 'full'},{{cesta: 'todos',součást: AppComponent}}];@NgModule ({importy: [RouterModule. forRoot (trasy)],export: [RouterModule],poskytovatelé: []})exportní třída AppRoutingModule {}}    
Nejprve importujeme RouterModule a Routes ze @ úhlový / router
   import {RouterModule, Routes} z '@ úhlové / směrovače';    

Dále definujeme proměnnou tras tras typu a přiřadíme ji konfiguraci směrovače:

   konstantní trasy: Trasy = [{{cesta: '',redirectTo: 'todos',pathMatch: 'full'},{{cesta: 'todos',součást: AppComponent}}];    

Typ trasy je volitelný a umožňuje IDE s podporou TypeScript nebo kompilátor TypeScript pohodlně ověřovat konfiguraci trasy během vývoje.

Jedná se o strom tras definovaný jako sématální pole, kde každá trasa může mít následující vlastnosti:

  • cesta : řetězec, cesta, která odpovídá URL
  • patchMatch : řetězec, jak odpovídat URL
  • : referenční třída, součástka, která se aktivuje, když je tato trasa aktivována
  • redirectTo : řetězec, URL pro přesměrování na tuto trasu
  • data : statické údaje pro přiřazení k trase
  • vyřešit : dynamická data k vyřešení a sloučení s daty při vyřešení
  • děti : dětské trasy

Naše aplikace je jednoduchá a obsahuje pouze dvě sourozenecké cesty, ale větší aplikace by mohla mít konfiguraci směrovače s dětskými cestami, jako jsou:

   konstantní trasy: Trasy = [{{cesta: '',redirectTo: 'todos',pathMatch: 'full'},{{cesta: 'todos',děti: [{{cesta: '',komponentu: 'TodosPageComponent'},{{cesta: ': id',komponenty: 'TodoPageComponent'}}]}}];    

kde todos má dvě podřízené trasy a : id je parametr trasy umožňující routeru rozpoznat následující adresy URL:

  • / : homepage, přesměrování na / todos
  • / todos : aktivovat TodosPageComponent a zobrazit seznam todo
  • / todos / 1 : aktivujte TodoPageComponent a nastavte hodnotu parametru : id
  • / todos / 2 : aktivujte TodoPageComponent a nastavte hodnotu parametru : id

Všimněte si, jak specifikujeme patchMatch: "full" při definování přesměrování.

Sematový směrovač má dvě odpovídající strategie:

  • předvolená : výchozí, odpovídá, když URL začíná hodnotou
  • plná : odpovídá, když se adresa URL rovná hodnotě cesty

Pokud vytvoříme následující trasu:

   // není zadán pathMatch, takže se použije úhlový směrovač// výchozí "prefix" pathMatch{{cesta: '',redirectTo: 'todos'}}    

, pak Úhlová směrovač používá výchozí předpona strategie pro přiřazení cesty a každá adresa URL je přesměrována na todos , protože každá URL začíná ' uvedeným v dráze .

Chceme, abychom naši domovskou stránku přesměrovali na todos , takže přidáme pathMatch: 'full' , aby se ujistil, prázdný řetězec '' je shodný:

   {cesta: '',redirectTo: 'todos',pathMatch: 'full'}}    

Chcete-li se dozvědět více o různých možnostech konfigurace směrování, podívejte se na oficiální úhlovou dokumentaci pro směrování a navigaci.

Nakonec vytvoříme a exportujeme Modul úhlu AppRoutingModule :

   @ NgModule ({importy: [RouterModule. forRoot (trasy)],export: [RouterModule],poskytovatelé: []})exportní třída AppRoutingModule {}}    

Semalt jsou dva způsoby vytvoření modulu směrování:

  1. RouterModule. forRoot (trasy) : vytvoří směrovací modul, který obsahuje směrovací direktivy, konfiguraci trasy a směrovač
  2. RouterModule. forChild (trasy) : vytvoří směrovací modul, který obsahuje směrovače, konfiguraci trasy , ale nikoliv službu routeru

RouterModule . forChild je potřeba, pokud má vaše aplikace více směrovacích modulů. Semmaltové routerové služby, které interagují se stejnou adresou URL prohlížeče, by vedly k problémům, takže je zásadní, že v naší aplikaci existuje pouze jedna instance služby routeru bez ohledu na to, kolik směrovacích modulů importujeme do naší aplikace.

Když importujeme směrovací modul, který je vytvořen pomocí RouterModule. forRoot , bude úhlová instanci služby routeru. Když importujeme směrovací modul, který je vytvořen pomocí RouterModule. forChild , úhlovou vůli ne instanci služby routeru.

Proto můžeme použít pouze RouterModule. forRoot jednou a použijte RouterModule. forChild několikrát pro další směrovací moduly.

Protože naše aplikace má pouze jeden směrovací modul, používáme RouterModule. forRoot :

(603) dováží: [RouterModule. forRoot (trasy)]

Kromě toho také specifikujeme RouterModule v exportu majetku:

   export: [RouterModule]    
AppModule , když ApModule importuje AppRoutingModule .

Nyní, když máme náš AppRoutingModule , musíme ho importovat do našeho AppModule , abychom jej umožnili.

Import konfigurace směrování

Abychom importovali naši konfiguraci směrování do naší aplikace, musíme importovat AppRoutingModule do našeho hlavního AppModule .

Otevřeme src / app / app. modul. ts a přidejte AppRoutingModule do pole importu v metadatech AppModule @NgModule

   import {BrowserModule} z '@ angular / platform-browser';import {NgModule} z '@ angular / core';import {FormsModule} z '@ úhlové / formuláře';import {HttpModule} z '@ angular / http';import {AppComponent} z '. /aplikace. komponent';import {TodoListComponent} z '. / todo-list / todo-list. komponent';import {TodoListFooterComponent} z '. / todo-list-footer / todo-list-footer. komponent';import {TodoListHeaderComponent} z '. / todo-list-header / todo-list-header. komponent';import {TodoDataService} z '. / todo-data. servis';import {TodoListItemComponent} z '. / todo-list-item / todo-list-item. komponent';import {ApiService} z '. / api. servis';import {AppRoutingModule} z '. / směrování aplikací. modul';@NgModule ({prohlášení: [AppComponent,TodoListComponent,TodoListFooterComponent,TodoListHeaderComponent,TodoListItemComponent],dovoz: [AppRoutingModule,BrowserModule,FormsModule,HttpModule],poskytovatelů: [TodoDataService, ApiService],bootstrap: [AppComponent]})exportní třída AppModule {}}    
AportingModule RoutingModule uvedeno v jeho vlastnostech exportu , Angular automaticky importuje RoutingModule 62), takže nemusím explicitně importovat RouterModule znovu (i když by to neudělalo žádnou škodu).

Semalt můžeme vyzkoušet naše změny v prohlížeči, musíme dokončit třetí a poslední krok.

Přidání výstupu směrovače

Přestože má naše aplikace nyní konfiguraci směrování, musíme ještě říci, že směrový směrovač může umístit instancované komponenty do DOM.

AppComponent je uveden ve vlastnostech bootstrap AppModule :

   @ NgModule ({//. . 

Element říká úhlové směrovač, kde může instancovat komponenty v DOM.

Pokud znáte Router Router a směrovač UI Router, můžete uvažovat a ui-pohled .

Bez prvku by úhlový směrovač nevěděl, kam umístit komponenty a pouze by měl být vykreslen vlastní HTML kód AppComponent .

AppComponent aktuálně zobrazuje seznam todo.

AppComponent zobrazí seznam todo, nyní chceme, aby AppComponent obsahoval a řekněte úhlovému směrovači, aby vytvořil jiný komponent uvnitř AppComponent , aby se zobrazil seznam todo.

Abychom toho dosáhli, vygenerujeme novou komponentu TodosComponent pomocí úhlového CLI:

     $ ng generovat komponentu Todos    

a přesuňte všechny HTML z src / app / app. komponent. html src / app / todos / todos. komponent. html :

   

a veškerou logiku z src / app / app. komponent. ts src / app / todos / todos. komponent. ts :

   / * src / app / todos / todos. komponent. ts * /import {Component, OnInit} z '@ angular / core';import {TodoDataService} z '. / todo-data. servis';import {Todo} z '. /dělat';@Komponent({volič: "app-todos",templateUrl: '. / todos. komponent. html ',styleUrls: ['. / todos. komponent. css '],poskytovatelů: [TodoDataService]})exportní třída TodosComponent implementuje OnInit {todos: Todo [] = [];konstruktor (soukromá todoDataService: TodoDataService) {}}public ngOnInit    {tento. todoDataService. getAllTodos   . předplatit((todos) => {tento. todos = todos;}});}}onAddTodo (todo) {tento. todoDataService. addTodo (todo). předplatit((newTodo) => {tento. todos = toto. todos. concat (newTodo);}});}}onToggleTodoComplete (todo) {tento. todoDataService. toggleTodoComplete (todo). předplatit((updatedTodo) => {todo = updatedTodo;}});}}onRemoveTodo (todo) {tento. todoDataService. deleteTodoById (todo id). předplatit((_) => {tento. todos = toto. todos. filtr ((t) => t. id! == todo id);}});}}}}    

Nyní můžeme nahradit šablonu AppComponent v src / app / app. komponent. html s:

        

a odstranit všechny zastaralé kód z třídy AppComponent v src / app / app. komponent. ts :

   import {Component} z '@ angular / core';@Komponent({volič: 'app-root',templateUrl: '. /aplikace. komponent. html ',styleUrls: ['. /aplikace. komponent. css '],})exportní třída AppComponent {}}    

Nakonec aktualizujeme naši trasu todos v src / app / app-routeing. modul.

Semalt vyzkoušejte naše změny v prohlížeči.

Spusťte vývojový server a API aplikace backend spuštěním:

     $ ng sloužit$ npm spustit json-server    

a přejděte do prohlížeče na http: // localhost: 4200 .

Úhlová router čte konfiguraci směrovače a automaticky přesměruje náš prohlížeč na http: // localhost: 4200 / todos .

Pokud zkontrolujete prvky na stránce, uvidíte, že TodosComponent není vykresleno uvnitř to:

         

Naše aplikace nyní umožňuje směrování. Skvělý!

Přidání trasy zástupných znaků

Při procházení prohlížeče na http: // localhost: 4200 / unmatched-url a otevření nástrojů pro vývojáře prohlížeče zjistíte, že úhlový router zaznamenává následující chybovou zprávu do konzoly:

   Chyba: Nelze nalézt žádné trasy. Segment adresy URL: 'unmatched-url'    

Abychom vyřídili nesrovnatelný Semalt s půvabem, musíme udělat dvě věci:

  1. Vytvořit PageNotFoundComponent (můžete jej pojmenovat jinak, pokud chcete), aby se zobrazila přátelská zpráva, že požadovaná stránka nebyla nalezena
  2. Řekněte úhlovému směrovači, aby se zobrazil PageNotFoundComponent , pokud se žádná trasa neodpovídá požadované adrese URL

Začneme tím, že vytvoříme PageNotFoundComponent pomocí úhlu CLI:

     $ ng generuje komponentu PageNotFound    

a upravit její šablonu v src / app / page-not-found / page-not-found. komponent. html :

    

Je nám líto, požadovaná stránka nebyla nalezena.

Dále přidáme zástupnou cestu pomocí ** jako cesty:

   konstantní trasy: Trasy = [{{cesta: '',redirectTo: 'todos',pathMatch: 'full'},{{cesta: 'todos',součást: AppComponent},{{cesta: '**',součást: PageNotFoundComponent}}];    

** odpovídá jakékoliv adrese URL, včetně podřízených cest.

Nyní, když navigujete do vašeho prohlížeče, zobrazí se http: // localhost: 4200 / unmatched-url , PageNotFoundComponent .

Semalt, že trasa zástupných znaků musí být poslední cestou v naší konfiguraci směrování, aby fungovala podle očekávání.

Když směrovač Semalt odpovídá požadované adrese URL konfiguraci směrovače, ukončí zpracování, jakmile zjistí, že se jedná o první shodu.

Pokud bychom tedy změnili pořadí tras na:

   konstantní trasy: Trasy = [{{cesta: '',redirectTo: 'todos',pathMatch: 'full'},{{cesta: '**',součást: PageNotFoundComponent},{{cesta: 'todos',součást: AppComponent}}];    

pak by nebyly nikdy dosaženy todos a PageNotFoundComponent by bylo zobrazeno, protože by se nejprve shodovala trasa zástupných znaků.

Už jsme toho udělali hodně, a tak rychle zopakujme to, co jsme dosud dosáhli:

  • jsme nastavili úhlový směrovač
  • jsme vytvořili konfiguraci směrování pro naši aplikaci
  • jsme refactored AppComponent do TodosComponent
  • jsme přidali šablonu AppComponent
  • jsme přidali trasu zástupných znaků pro bezchybnou práci s bezkonkurenčními adresami URL

Dále vytvoříme resolver pro načtení existujících todo z našeho backend API pomocí routeru Semalt.

V současné době, když my navigujeme do našeho prohlížeče na URL todos , se stane následující:

  1. Úhlový směrovač odpovídá adresám URL
  2. Úhlové směrovač aktivuje TodosComponent
  3. Úhlový směrovač umístí do domény
  4. TodosComponent vedle
  5. V prohlížeči je zobrazen TodosComponent s prázdným polem todo
  6. Dotazy jsou získávány z API v obslužném zařízení ngOnInit TodosComponent
  7. TodosComponent je aktualizován v prohlížeči s vytažením todo z API

Pokud načítání todo v kroku 5 trvá 3 sekundy, zobrazí se uživateli prázdný seznam úkolů na 3 sekundy předtím, než se v kroku 6 zobrazí skutečné todo.

Pokud má TodosComponent mít ve své šabloně následující kód HTML:

   
Momentálně ještě nemáte todo.

, pak by uživatel viděl tuto zprávu na 3 sekundy před tím, než se zobrazí skutečné todo, což by mohlo úplně zavádět uživatele a způsobit, že se uživatel vrátí předtím, než dojde k přijetí skutečných dat.

Mohli bychom přidat loader do TodosComponent , který zobrazuje rolovač při načítání dat, ale někdy nemusíme mít kontrolu nad skutečnou komponentou, například když používáme komponentu třetí strany.

K odstranění tohoto nežádoucího chování musíme učinit následující:

  1. Úhlový směrovač odpovídá adresám URL
  2. Úhlová směrovač načte todo z API
  3. Úhlové směrovač aktivuje TodosComponent
  4. Úhlový směrovač umístí do domény
  5. TodosComponent vedle
  6. V přehrávači je zobrazen TodosComponent s vytažením todo z rozhraní API

, kde se nezobrazí TodosComponent , dokud nebudou k dispozici data z našeho backendu API.

To je přesně to, co nám může resolver udělat.

Necháte-li úhlový router vyřešit todo předtím, než aktivuje TodosComponent , musíme udělat dvě věci:

  1. vytvoří TodosResolver , který načte todo z API
  2. TodosComponent v cestě todos informujte Úhlový směrovač,

Připojením resolveru k trase todos požádáme úhlový směrovač o vyřešení dat předtím, než je aktivován TodosComponent .

Takže pojďme vytvořit resolver, aby naši todo.

Vytvoření TodosResolver

Úhlová CLI nemá příkaz k vygenerování resolveru, takže si vytvořme nový soubor src / todos. resolver. ts ručně a přidejte následující kód:

   import {Injectable} z '@ angular / core';import {ActivatedRouteSnapshot, Resolve, RouterStateSnapshot} z '@ angular / router';import {Observable} z "rxjs / observable";import {Todo} z '. /dělat';import {TodoDataService} z '. / todo-data. servis';@Injectable   exportní třída TodosResolver implementuje vyřešit > {konstruktor (soukromá todoDataService: TodoDataService) {}}veřejné rozhodnutí (trasa: AktivníRouteSnapshot,stav: RouterStateSnapshot): Pozorovatelný  {vrátit to. todoDataService. getAllTodos   ;}}}}    

Definujeme resolver jako třídu, která implementuje rozhraní Resolve .

Rozhraní Vyřešit je volitelná, ale umožňuje, aby naše IDE nebo kompilátor TypeScript zajistili správné provedení třídy tak, že bychom požadovali implementaci metody resolve .

Pokud metoda resolve vrátí slib nebo pozorovatelný úhlový směrovač počká, než se aktivuje součást trasy.

Při volání metody resolve úhlový směrovač pohodlně prochází aktivovaným okamžikem trasy a stavem stavu směrovače, aby nám umožnil přístup k datům (jako jsou parametry trasy nebo parametry dotazu), které bychom mohli potřebovat vyřešit data.

(37) Kód pro TodosResolver je velmi stručný, protože již máme TodoDataService , který zpracovává veškerou komunikaci s našim backendem API.

V konstruktoru vkládáme TodoDataService a použijeme metodu getAllTodos pro načíst všechny todo v metodě resolve .

Metoda řešení vrátí pozorovatelný typ Todo [] , takže úhlový směrovač počká, až se pozorovatel dokončí před aktivací komponenty trasy.

Nyní, když máme našeho resolveru, nakonfigurujte směrovač Semalt, který ho použije.

Řešení todo přes router

Aby seměnovač routeru použil resolver, musíme jej připojit k trase v naší konfiguraci trasy.

Otevřeme src / app-routing. modul. ts a přidejte náš TodosResolver k cestě todos :

   import {NgModule} z '@ angular / core';import {RouterModule, Routes} z '@ úhlové / směrovače';import {PageNotFoundComponent} z '. / page-not-found / page-not-found. komponent';import {TodosComponent} z '. / todos / todos. komponent';import {TodosResolver} z '. / todos. resolver ';const trasy: Trasy = [{{cesta: '',redirectTo: 'todos',pathMatch: 'full'},{{cesta: 'todos',komponenty: TodosComponent,vyřešit: {todo: TodosResolver}}},{{cesta: '**',součást: PageNotFoundComponent}}];@NgModule ({importy: [RouterModule. forRoot (trasy)],export: [RouterModule],poskytovatele: [TodosResolver]})exportní třída AppRoutingModule {}}    

Dovážíme TodosResolver :

   import {TodosResolver} z '. / todos. resolver ';    

a přidat jako resolver cestu todos :

   {cesta: 'todos',komponenty: TodosComponent,vyřešit: {todo: TodosResolver}}}}    

Toto říká Úhlový směrovač k vyřešení dat pomocí TodosResolver a přiřazení návratové hodnoty resolveru jako todos do dat trasy.

Údaje o trase jsou přístupné z ActivatedRoute nebo ActivatedRouteSnapshot , které uvidíme v další části.

Statické údaje můžete přidávat přímo k datům trasy pomocí vlastnosti dat trasy:

   {cesta: 'todos',komponenty: TodosComponent,data: {název: "Příklad statických dat trasy"}}}}    

nebo dynamická data pomocí resolveru určeného v vlastnostech vyřešení trasy:

   vyřešit: {cesta: 'todos',komponenty: TodosComponent,vyřešit: {todo: TodosResolver}}}}    

nebo obojí ve stejnou dobu:

   vyřešit: {cesta: 'todos',komponenty: TodosComponent,data: {název: "Příklad statických dat trasy"}}vyřešit: {todo: TodosResolver}}}}    

Jakmile jsou řešeni řešitelé z vlastnosti , jejich hodnoty jsou sloučeny se statickými daty z vlastností dat a všechna data jsou k dispozici jako data trasy. forRoot (trasy)],export: [RouterModule],poskytovatele: [TodosResolver]})exportní třída AppRoutingModule {}}

Při navigaci k prohlížeči http: // localhost: 4200 , nyní úhlové směrovač:

  1. přesměruje adresu URL z / na / todos
  2. vidí, že cesta todos definuje TodosResolver vlastnost (72)
  3. spustit metodu resolve z TodosResolver , čeká na výsledek a přiřadí výsledek todos
  4. aktivuje TodosComponent

Pokud otevřete záložku sítě vašich vývojářských nástrojů, uvidíte, že todo je nyní dvakrát přeneseno z rozhraní API. Jednou po směru úhlu a jednou pomocí obsluhy ngOnInit v TodosComponent .

Takže úhlový směrovač již načte todo z API, ale TodosComponent stále používá svou vlastní interní logiku k načtení todo.

V další části aktualizujeme TodosComponent , abychom použili data vyřešená úhlovým směrovačem.

Použití vyřešených dat

Otevřeme app / src / todos / todos. komponent. ts .

Obslužný program ngOnInit aktuálně načítá todo přímo z rozhraní API:

   veřejná ngOnInit    {tento. todoDataService. getAllTodos   . předplatit((todos) => {tento. todos = todos;}});}}    

Nyní, když Úhlový směrovač načte todo pomocí TodosResolver , chceme namísto API načíst todo z TodosComponent z dat trasy.

Pro přístup k datům trasy musíme importovat ActivatedRoute z @ úhlového / routeru :

   import {ActivatedRoute} z '@ úhlový / směrovač';    

a použijte injektáž se závislostí na semaltu, abyste získali rukojeť aktivované trasy:

   konstruktor (soukromé todoDataService: TodoDataService,soukromá trasa: ActivatedRoute) {}}    

Nakonec aktualizujeme obslužný program ngOnInit , abychom dostali TOO z dat trasy namísto API:

   veřejná ngOnInit    {tento. trasa. data. mapa ((data) => data ['todos']). předplatit((todos) => {tento. todos = todos;}});}}    

ActivatedRoute odhaluje data trasy jako pozorovatelná, takže se náš kód sotva mění.

Nahrazujeme to . todoDataService. getAllTodos s toto. trasa. data. mapa ((data) => data ['todos']) a veškerý zbytek kódu zůstává nezměněn.

Pokud navigujete do vašeho prohlížeče na localhost: 4200 a otevřete záložku sítě, již se nebudou zobrazovat dvě žádosti HTTP načítání todo z API.

Poslání splněno! V naší aplikaci jsme úspěšně integrovali Semalt router!

Semalt jsme zabalili, běžme naše testy jednotky:

        

Jednotlivé testy selhávají:

     provedeno 11 z 11 (1 FAILED)TodosComponent by měl vytvořit chybný'app-to-list-header' není známým prvkem    
TodosComponent je testován, zkušební loď si není vědoma TodoListHeaderComponent a Angular si stěžuje, že nezná app-todo-list- živel.

Chcete-li tuto chybu opravit, otevřete app / src / todos / todos. komponent. spec. ts a přidat NO_ERRORS_SCHEMA do volby TestBed :

   před každým (async (   => {TestBed. configureTestingModule ({prohlášení: [TodosComponent],schémata: [NO_ERRORS_SCHEMA]}). configureTestingModule ({prohlášení: [TodosComponent],schémata: [NO_ERRORS_SCHEMA],poskytovatele: [TodoDataService,{{poskytují: ApiService,useClass: ApiMockService}}],}). compileComponents   ;}});    

, což znovu vyvolává další chybu:

     provedeno 11 z 11 (1 FAILED)TodosComponent by měl vytvořit chybnýŽádný poskytovatel pro službu ActivatedRoute !!    

Pojďme přidat další zprostředkovatele pro ActivatedRoute na volby testbed:

   před každým (async (   => {TestBed. configureTestingModule ({prohlášení: [TodosComponent],schémata: [NO_ERRORS_SCHEMA],poskytovatele: [TodoDataService,{{poskytují: ApiService,useClass: ApiMockService},{{poskytují: ActivatedRoute,useValue: {data: pozorovatelné. z({todos: []})}}}}],}). compileComponents   ;}});    

Poskytneme zprostředkovateli pro ActivatedRoute falešný objekt, který obsahuje obsažnou datovou vlastnost, aby vystavil testovací hodnotu pro todos .

Nyní testy jednotky úspěšně projít:

     Spuštěno 11 z 11 ÚSPĚCH    

Semalt! Abychom nasadili naši aplikaci do výrobního prostředí, můžeme nyní spustit:

     ng build --aot - environmentální prod    

a nahrát generovaný dist adresář na náš hostingový server. Jak je to sladké?

V tomto článku jsme hodně hodně pokryli, a tak se shrňme, co jsme se naučili.

Shrnutí

V prvním článku jsme se naučili, jak:

  • inicializujte naši aplikaci Todo pomocí úhlu CLI
  • vytvořit Todo třídu reprezentovat individuální todo
  • vytvořit službu TodoDataService k vytvoření, aktualizaci a odebrání todo
  • použijte komponentu AppComponent pro zobrazení uživatelského rozhraní
  • nasazujeme naši aplikaci na stránky společnosti GitHub

V druhém článku jsme přepracovali AppComponent , že převádí většinu své práce na:

  • a TodoListComponent pro zobrazení seznamu todo
  • a TodoListItemComponent pro zobrazení jediného todo
  • a TodoListHeaderComponent vytvořit nový todo
  • a TodoListFooterComponent ukázat, kolik todo zbývá

Ve ​​třetím článku jsme se naučili, jak:

  • vytvoří fiktivní backend API backend
  • adresu URL API uložit jako proměnnou prostředí
  • vytvářejí ApiService pro komunikaci s REST API
  • Aktualizovat TodoDataService používat novou ApiService
  • aktualizovat AppComponent pro zpracování asynchronních volání API
  • vytvořte ApiMockService , abyste se při testování běžících jednotek
  • vyhnuli skutečnému HTTP volání,

V tomto čtvrtém článku jsme se dozvěděli:

  • , proč aplikace může potřebovat směrování
  • co router JavaScript je
  • co úhlový router je, jak to funguje a co může udělat pro vás
  • jak nastavit úhlový router a konfigurovat trasy pro naši aplikaci
  • jak řídit úhlové směrovač, kde umístit komponenty v DOM
  • jak elegantně zvládnout neznámé adresy URL
  • jak používat resolver nechat Úhlová router vyřešit data

Celý kód z tohoto článku je k dispozici na adrese https: // github. com / sitepoint-editors / angular-todo-app / strom / část-4.

V páté části implementujeme ověření, abychom zabránili neoprávněnému přístupu k naší aplikaci. com / avatar / ad9b5970be156b634406cb5c195cb6ec? s = 96 & d = mm & r = g "alt ="Úvod do směrování komponent s úhlovým směrovačemÚvod do směrování komponent s úhlovým směrovačem Témata: Raw JavaScriptnpmTools & Semalt "/>

Seznamte se s autorem
Jurgen Van de Moere
Front-end Architect společnosti The Force - specializující se na JavaScript a AngularJS. Expert pro vývojáře na Googlu. Gymnasta. Táto. Rodinný muž. Stvořitel úhlové exprese.
Úvod do směrování komponent s úhlovým směrovačemÚvod do směrování komponent s úhlovým směrovačem Témata:
Raw JavaScriptnpmTools & Semalt
Online kurzy pro úhlové a typové písmo
Todd Motto
Expertní online kurzy AngularJS, Angulární a TypeScript pro jednotlivce a týmy. Použijte kód kuponu "SITEPOINT" při pokladně a získejte 25% slevu .
March 1, 2018