[MUSIC]
Ora che abbiamo compreso l'API REST ed espresso il supporto per
l'API REST, passiamo all'esercizio successivo.
Dove vedremo come svilupperemo l'API REST
utilizzando il supporto fornito da express.
E anche, l'uso di router express, che
ci consente di organizzare il nostro codice in un modo che è più adatto
quando è necessario supportare un gran numero di endpoint API REST.
Per iniziare, continuando con la cartella node-express
abbiamo lavorato sul server web basato su express.
Al prompt, installiamo body-parser,
quindi per farlo, digita npm install body-parser —save.
E stiamo usando la versione 1.18.3 di
corpo-parser in questo corso qui.
Ora, una volta che abbiamo installato corpo-parser, quindi andare nel nostro codice.
In index.js5,
lasciami richiedere BodyParser, quindi
diremo const BodyParser
richiede body parser.
E poi ogni volta che hai bisogno di usare un middleware,
dirai, app.use (BodyParser.JSON).
Quindi questo ci permette di analizzare il corpo del messaggio di richiesta,
che è formattato in formato JSON.
Una volta che abbiamo completato questo, allora iniziamo
a costruire il supporto API REST per l'endpoint /dish.
Utilizzando i
metodi app.all, app.get, put, post e delete sono supportati da express.
Quindi, per farlo, lasciami iniziare dicendo
app.all, e i primi parametri
che app.all prende è l'endpoint.
Quindi in questo caso, sto specificando l'endpoint di/dishes.
E poi il secondo parametro è la funzione di callback,
req, res, next, i tre parametri qui.
E all'interno di questa funzione di callback, gestiremo la richiesta in arrivo.
Quindi diremo, quando arriva una richiesta, per tutte le richieste.
Quindi, quando diciamo app.all, indipendentemente dal metodo invocato,
get, put, post o delete, per l'endpoint API REST /dish,
questo codice verrà eseguito prima di default qui.
Quindi diremo res StatusCode è 200 e
poi Res.SetHeader e
diciamo Content-Type testo.
Invieremo testo normale ora, invece di testo HTML.
Questo dovrebbe essere sufficiente per gli endpoint API REST.
Successivamente, invieremo i dati sotto forma di JSON una volta che
siamo in grado di recuperare i dati dal database.
Così che arriverà in uno degli esercizi successivi.
Per il momento, invieremo semplicemente le risposte in chiaro al cliente.
Ora, dopo questi due, il middleware qui non è ancora completato.
Quindi chiameremo la prossima funzione qui, quindi il prossimo come vedi si riferisce a questo prossimo.
Quindi, quando chiami il prossimo, ciò che significa è che continuerà a cercare
ulteriori specifiche qui sotto,
che corrisponderanno a questo endpoint piatti.
Quindi questo sarebbe fatto per tutte le richieste, ottenere, mettere,
postare e cancellare, sui piatti, e continuerà a quello successivo.
Quindi qui, supponiamo di ottenere una richiesta get
sui piatti, il che significa che ora,
se otteniamo una richiesta get su piatti,
prima questo verrà eseguito, e
poi il req e res saranno trasmessi
a questa seconda chiamata qui.
Quindi in questo caso, non avrò più bisogno del prossimo,
perché non ho intenzione di chiamare più in basso.
Completerò la gestione proprio all'interno di questo metodo qui stesso.
Quindi, se modifichiamo il req o res all'interno di questo codice,
allora quando chiami il prossimo, quell'oggetto modificato
verrà passato come parametro a questo.
Quindi, se hai emesso una richiesta get su piatti, quindi questo è ciò che verrà
eseguito subito dopo questo, quindi questo prossimo farà passare.
E poi qui, si nota che abbiamo modificato l'oggetto res qui.
E la modifica porterà come parametro di input a questa funzione qui.
Quindi all'interno di questa funzione get, possiamo dire, per esempio, al momento,
ho semplicemente intenzione di inviare un semplice messaggio, diremo,
invierà tutti i piatti a voi.
Più tardi, quando recuperiamo le informazioni piatti dal database
dopo aver appreso su MongoDB, allora questa funzione restituirà
quei dati JSON al client, dal momento che è in una richiesta get qui.
Ora, nel corso precedente, avevamo usato il server JSON e
il server JSON stava già fornendo tutti questi per noi.
Ora stai vedendo come costruiresti
un real server che elaborerà la richiesta in arrivo.
E quindi generare una risposta appropriata e
inviarla di nuovo a voi in risposta alla richiesta ricevuta dal lato client.
E questo è dove l'utente espresso, come vediamo qui, è utile.
Così abbiamo gestito ottenere,
cerchiamo di gestire post anche su piatti qui.
E ancora, i parametri sarebbero (req, res,
next), e quella funzione che viene invocata sarà qui.
Ora, quando viene ricevuta la richiesta get, perché qui, stai chiamando rest.end.
Quindi quella fine è la gestione della richiesta get e non attiva la risposta
da inviare o la risposta da inviare al client a questo punto.
Ora, se ricevi una richiesta di post sui piatti, di nuovo, questo intero codice verrà eseguito.
E poi, a causa di questo prossimo, che cadrà in questa chiamata di funzione qui.
E poi il codice qui, verrà eseguito, quindi quando si riceve un
post La richiesta di post proveniente dal server porterà alcune informazioni
nel corpo del messaggio sotto forma di dati JSON.
Vedranno qual è la forma dei dati JSON quando
guardiamo più tardi quando testiamo punto finale usando post net.
Ti mostrerò ciò che conterrà il corpo del messaggio di richiesta di post.
Ma a questo punto, quello che farò è
estrarre le informazioni dal corpo.
E così qui quando usiamo il parser corpo, ciò che accade è che per
la richiesta in arrivo, il corpo della richiesta in arrivo verrà analizzato e
quindi aggiunto nell'oggetto req come req.body.
Quindi il req.body ti darà accesso a tutto ciò che è all'interno di quel corpo
del messaggio.
Quindi, quando invio la richiesta,
aggiungerò informazioni al
corpo della richiesta sotto forma di una stringa JSON che
contiene un nome e una descrizione.
Quindi ho intenzione di estrarre queste due informazioni e
poi stamparle e poi rispedirle al client nel messaggio di risposta.
Quindi posso dire, req.body e poi nome.
E così l'aspettativa è che quando il client invia il messaggio post,
il corpo del messaggio post conterrà una stringa JSON,
che conterrà anche la proprietà name nella stringa JSON.
Quindi req.body.name plus e
questo è dove includerò
con i dettagli: + req.body.description.
Quindi qualunque cosa contenga la stringa JSON nel req.body, ma la
stringa JSON verrà analizzata in un oggetto JavaScript e
aggiunta all'oggetto richiesta come corpo di proprietà.
L' oggetto JavaScript punta a tutto ciò che
è entrato come stringa JSON nel corpo del messaggio di richiesta.
Ecco perché sono in grado di analizzare la proprietà del nome, la proprietà della descrizione,,
puoi avere la proprietà del prezzo, la proprietà dell'immagine e tutto questo.
Quindi, se hai seguito il corso precedente, hai visto la struttura di un
oggetto piatto, sotto forma di una stringa JSON o l'oggetto JavaScript lì.
Quindi, il nome e la descrizione ti sembrano familiari.
Quindi è esattamente quello che sto usando qui.
In questo momento sto solo estraendo il nome e la descrizione dal corpo e
poi lo rimando al cliente in questo corpo.
Quindi sto solo costruendo questo messaggio di risposta qui usando le informazioni
dal corpo del messaggio di richiesta e quindi inviandolo al client.
In questo modo posso confermare che il server sta ricevendo tutto ciò che sto inviando
nel corpo del messaggio.
Quindi questa è la richiesta di post.
Ora, per dirla, fammi solo copiare questo, e poi incollarlo qui.
E poi per mettere su quel piatto endpoint,
perché mettere sul piatto endpoint non ha senso.
Un post significa che stai postando un nuovo piatto ai server.
Un punto finale messo sui piatti non ha senso,
quindi ecco quello che ho intenzione di fare è
risponderò con l'
operazione PUT messaggio non supportata su/dish.
Inoltre, lo farò anche, Includere un codice di stato di 403.
403 significa che il loro funzionamento non è supportato.
Quindi, se si guarda indietro alla tabella dei codici di risposta HTTP,
si vedrà il codice corrispondente 403 ciò che rappresenta lì.
Quindi questo è quello che sto usando per post.
Per eliminare, ho intenzione di copiare
questo e per eliminare ho intenzione di,
Basta analizzare questo, e poi diremo, Eliminando tutti i piatti.
Quindi, quando si invia una richiesta di eliminazione su quell'endpoint /dish.
Viene interpretato nel senso che
il cliente vuole eliminare tutte le informazioni sui piatti sul lato server.
Ora, questa è un'operazione pericolosa, quindi
assicurati di non consentire agli utenti partner di farlo.
Quindi in seguito, quando studiamo l'autenticazione,
vedremo come possiamo controllare questa operazione solo agli utenti privilegiati.
Ma ancora, come vedi, questa è un'operazione pericolosa, quindi tienilo a mente.
Così ora si vede che nell'endpoint piatti, abbiamo ottenere, mettere,
postare ed eliminare il supporto.
Supportiamo anche questo sull'endpoint dishID: dishID.
Quindi ho intenzione di copiare i metodi get, put, post ed eliminare da qui,
e poi li chiama tutti anche per essere supportati su
dishes/: dishID.
Quindi questo è per il get, e lo copiamo e
pubblichiamo, mettiamo e cancelliamo.
Come gestiamo ognuno di questi?
Quindi, per ottenere, se ottengo una richiesta su dishes/dishID,
quello che vorrei fare è estrarre questo parametro e
quindi inviarlo nuovamente nella richiesta, nel messaggio di risposta.
Quindi diremo, manderemo,
dettagli del piatto.
Ora quale piatto?
Queste informazioni si trovano nel parametro.
Quindi questo valore del parametro può recuperare da
req.params.dishId.
Quindi questo dishId, come vedi, il nome che usi qui dovrebbe corrispondere a questo valore qui.
Quindi, se vedi semplicemente ID qui,
questo dovrebbe anche corrispondere al SID dato qui.
Quindi il nome stesso non significa nulla, tranne che questo nome del parametro e
questo dovrebbe corrispondere tra loro, in modo da poter recuperare le informazioni correttamente.
Quindi diremo, invia i parametri del piatto dishId e
poi ti diremo.
Quindi in questo modo sappiamo che il server sta ottenendo il parametro piatto..
Quindi se dico /piatti/23 ci diverse risposte
invieranno i dettagli del piatto 23 a voi e così via.
Così vedremo come funziona quando usiamo post per testare questo server.
Ora per la posta.
Per post, questo metodo non sarà supportato,
quindi ho intenzione di copiare questa parte.
non ha senso fare un post su un ID piatto specifico,
perché non stai cercando di aggiungere un nuovo piatto.
Ma si desidera modificare, e la modifica viene eseguita utilizzando l'operazione put.
Quindi diremo, operazione POST non supportata su/dishes.
E poi ho intenzione di aggiungere in.
Req.params.dishID.
Quindi questo invierà indietro dicendo post non supportato su
piatti/23 nel messaggio di risposta.
Ora, per PUT, Per PUT, diremo,
res.end e diciamo Will, aggiorna il piatto.
Req.params.dishID.
O meglio, lo faremo in questo modo.
Prima scriverò, Quindi
res.write può essere utilizzato per aggiungere una riga al messaggio di risposta.
Quindi diremo di aggiornare il piatto.
E diremo req.params.dishid.
E poiché questa è un'operazione PUT, e se il corpo contiene la stringa JSON,
che contiene i dettagli del piatto,
posso estrarre la stringa JSON perché stiamo usando il parser body.
Quindi diremo
aggiornerà il piatto:.
Quale piatto?
req.body.name.
In piu'.
Con dettagli,
req.body.description.
Ora, quando aggiorniamo il piatto, voglio aggiungere una, Nuova linea lì.
Quindi dirò '/n' lì.
Quindi, quando fai un PUT, stai inviando indietro le informazioni su quale ID piatto
stai aggiornando e anche i dettagli che stai aggiornando.
Il nome e la descrizione,
che dovrebbero essere nel corpo del messaggio PUT lì.
Per eliminare, Si dirà Eliminazione piatto, e req.params.dishID.
E così per eliminare, questa è l'operazione che verrà eseguita.
Così si vede che ora abbiamo le
operazioni get, put, post, ed delete sui piatti/dishID, endpoint, e
anche le operazioni get, put, post sul/dish, endpoint.
Quindi ora salviamo le modifiche.
E riavvia il nostro server.
Avviare il server dicendo npm start.
Andiamo ora al postino e inviamo alcune richieste a questo server e
vediamo cosa restituisce.
Lasciatemi prima emettere un get a host locale 3.000 e vedere cosa restituisce.
Quindi, quando si invia una richiesta per ottenere l'host locale 3.000,
sta ancora restituendo la pagina HTML iniziale dell'indice,
perché la gestione dei file statici è ancora a posto.
Ora lasciami inviare una richiesta get a localhost: 3000/piatti, e questo,
come ti aspetti, invierà una risposta dicendo che ti invieremo tutti i piatti.
Ora, inviamo una richiesta POST a localhost: 3000/piatti.
Quindi questo è dove puoi cambiare i vari metodi che vuoi eseguire.
Ma quando si invia un post,
si desidera includere alcuni dettagli nel corpo del messaggio perché
c'è qualcuno che si aspetta di inviare informazioni nel corpo del messaggio.
Quindi clicca sul corpo qui e clicca su crudo qui.
E poi, per il testo, lo selezioni in JSON, quindi
usa l'applicazione JSON.
Quindi il tipo di contenuto sarebbe Application/JSON
nella richiesta che invii.
Quindi, poiché questo è un oggetto JSON, quindi
tra parentesi graffe, dirò nome.
Semplicemente scriverò il test
e la descrizione.
Alcune informazioni standard qui, quindi vedi che questa è una stringa JSON che
contiene due proprietà, nome e descrizione e i valori corrispondenti.
Quindi cerchiamo di inviare una richiesta di post al server.
Quando si invia una richiesta di post al server, come si vede,
nella risposta si dice aggiungerà il piatto: dettagli settimana di prova: descrizione.
Quindi, come puoi vedere, le due informazioni vengono estratte dal corpo
di quel JSON richiesto [INUDIBLE] e quindi incluse nella risposta.
Mandiamo una richiesta di put ai piatti.
Quando invii una richiesta put ai piatti, come vedi,
dice l'operazione PUT non supportata su/dish e guarda lo stato qui.
Dice Stato: 403 Proibito.
Quindi questa operazione non è consentita su questo endpoint.
Facciamo un'operazione DELETE sui piatti.
Quando si DELETE operazione sui piatti,
allora si noterà che si dice l'eliminazione di tutti i piatti.
Quindi questa è la risposta che si ottiene indietro.
Quindi vedi che il post get, put ed
delete sull'endpoint /dish funziona come ti aspetti.
Ora facciamo un get sui piatti /23.
Quindi 23 qui è il parametro,
l'ID del piatto che si desidera ottenere.
Quindi, quando si invia una richiesta a che il server risponderà,
invierà i dettagli del piatto: 23 a voi.
Quindi si vede che il parametro è stato estratto dal messaggio di richiesta e
quindi incluso nel messaggio di risposta.
Facciamo un post su questo.
E come sai, POST non è consentito su questo endpoint, ed
è per questo che ottieni uno stato 403 Proibito su questo.
Facciamo un'operazione PUT su questo.
Quindi, per l'operazione PUT, si nota che il corpo lo contiene ancora.
Quindi in POST, quando digiti un valore qui,
questo verrà mantenuto e può essere incluso in altre richieste che stai inviando.
Quindi, quando si invia una richiesta PUT sull'endpoint, piatti/23.
Quindi si nota che dice aggiornare il piatto, 23.
Aggiornerà il piatto, il nome del piatto,
con i dettagli, la descrizione del piatto qui.
E poi, facciamo un'operazione di eliminazione su quell'endpoint e
poi dice, d cancellazione piatto: 23.
Quindi questi endpoint sono tutti supportati come vedi in questo esempio qui.
Quindi abbiamo fatto ottenere PUT, POSRT, ed eliminare le operazioni sia sull'endpoint /dish che
anche sull'endpoint /dishes/ l'endpoint id del piatto.
Così, si vede come abbiamo implementato il supporto endpoint API REST per
un set di endpoint API REST.
Ora, con questo, completiamo la prima parte di questo esercizio.
Quindi, qui abbiamo visto come possiamo usare express per costruire e
implementare l'endpoint API REST per i piatti.
Ora, questo è un buon momento per
fare un commit git con il messaggio Express Simple REST.
Secondo il terminale inizierò il, Server.
Verificare che tre degli elementi siano stati modificati.
Quindi, git add, git commit -m,
Express Simple REST, E controlla il set.
Quindi, come puoi vedere, usando Express puoi facilmente implementare il supporto per l'API REST.
E come puoi vedere da questo elenco, costruisci l'app get, PUT
, POST ed elimina i metodi per tutti gli endpoint API REST come questo.
Ora immagina di avere un migliaio di endpoint API REST
e devi costruire qualcosa del genere.
Il tuo file index.js esploderà con così tanti endpoint API REST diversi.
E ognuno viene gestito usando il proprio app.get,
app.put, app.delete e app.post.
Ora Wxpress supporta un modo di suddividere questo lavoro in più,
molte applicazioni Express,
che poi possono essere combinate insieme per formare l'applicazione complessiva, Express.
Questo è dove faremo uso di Express Router
per essere in grado di costruire una mini applicazione Express.
E poi, all'interno di un file Express Router,
supporteremo l'endpoint API REST per un gruppo di parti API REST.
Ad esempio, per i piatti e i piatti dishId,
possono essere tutti supportati in un unico file.
Allo stesso modo, nell'assegnazione, supporterai un
endpoint API REST chiamato promozioni e promozioni/: promoID.
E poi, supporterai un'altra API REST e
per leader/leader, e/leader: leaderID.
Così ognuno di questi gruppi può essere implementato separatamente come molte
applicazioni Express utilizzando Express Router.
Quindi questo è ciò che vi illustrerò per
l'endpoint piatti nella prossima parte di questo esercizio.
Quindi, per farlo, ci rendiamo conto che se mettiamo tutti i file in una singola cartella,
allora di nuovo la struttura delle cartelle sembrerà disordinata.
Quindi la mia preferenza è creare una cartella qui denominata route.
E questa cartella route conterrà tutti i router che ho intenzione di
progettare utilizzando il Router Express.
Quindi nella cartella route, creerò un nuovo file chiamato
dishRouter.js.
E questo file dishRouter.js conterrà
l'implementazione della gestione dell'endpoint API REST per
/dish e/dishes:endpoint DishID.
Ora come facciamo a utilizzare Express Router?
Vediamo come possiamo usarlo.
Ora Express Router viene insieme a Express, quindi non abbiamo bisogno di installare ancora
un altro modulo Node.
Invece, possiamo lavorare con Express che abbiamo già installato.
Quindi, per farlo, a quel prompt, digita, const express
= require ('express');.
Quindi noti che, poiché questa è una mini-applicazione,
abbiamo ancora bisogno di esprimere anche in questo file dishRouter.js.
E dalla vostra conoscenza dei moduli Node, una volta definito un nuovo file,
che diventa il proprio modulo Node.
E questo modulo Node può quindi essere importato in index.js.
Così si vede la connessione già tra il modo in cui possiamo ristrutturare la nostra
applicazione in più file utilizzando i moduli Node.
Quindi imposteremo richiedono Express, quindi diremo const
BodyParser require ('corpo-parser').
Quindi abbiamo già installato BodyParser nei passaggi precedenti dell'esercizio,
quindi possiamo usarlo.
Ora per usare un router Express,
lasciami dichiarare const DishRouter = Express.r
E su express, supporta questa interfaccia router, quindi
diremo semplicemente Express.Router e questo dichiarerà DishRouter come router Express.
Quindi in molte applicazioni Express,
un'intuizione qui posso gestire quel codice relativo a DishRouter qui.
Quindi, una volta che dichiaro di questo un router Express, allora posso dire DishRouter.
E poi su DishRouter, supporta un metodo chiamato metodo route,
che può prendere in un endpoint come parametro.
Quindi vorrei semplicemente dichiarare questo endpoint un/.
Ora, ti stai chiedendo, non dovrebbero essere piatti?
Vedrai molto presto che ho bisogno di montare questo
router Express nel mio file index.js.
Quindi nel mio file index.js, monterò questo router espresso nell'endpoint /dish.
Montaggio di un router espresso, ancora una volta,
un altro concetto che voglio che tu capisca.
Ancora una volta, ve lo illustrerò in breve tempo.
Ora, DishRouter.Route significa che utilizzando questo approccio,
stiamo dichiarando l'endpoint in una singola posizione.
Per cui è possibile concatenare tutti ottenere, PUT, POST,
eliminare i metodi già fare questo router piatto.
Ora, quando guardi index.js,, guarda il modo in cui abbiamo implicato questo.
Quindi abbiamo app.all e dopo/piatti, app.get/piatti e/dishes.
Ora, se hai fatto un errore, e la loro istruzione
app.post/dish invece se digiti semplicemente /dish, allora cosa succede?
L' operazione POST non sarà supportata sui piatti, ma
sarà supportata sull'endpoint /dish.
Per evitare questo problema, il router express supporta questo punto finale del percorso.
Sul punto finale del percorso,
è sufficiente specificare il punto finale su cui funzionerà questo router.
E poi, il metodo get put part delete, questo semplicemente incatenato in quello.
Quindi sarà un gruppo di implementazioni di metodi tutti insieme.
Quindi questo è il motivo per cui usano un router Express.
Quindi viene fornito con un paio di
supporto molto utile per assicurarsi che la tua implementazione sia corretta.
Quindi ora che lo faremo come router piatto,
quello che farò è rimuoverò questa cosa da qui.
Ora, che i piatti IDN punto, lo lascerò
a te come esercizio nel tuo primo incarico
, ma l'endpoint piatti, ho intenzione di tagliare questo, fino a tutti.
Ho intenzione di tagliare questo da index.js5 e di
spostarlo in DishRouter qui.
Ora, quando lo sposto in DishRouter, non ho più bisogno di questa app.all.
Lo concatenerò semplicemente nel percorso, quindi dirò semplicemente .all e
poi non ho più bisogno di questa definizione del punto finale lì.
Questo è tutto. Quindi
dirà .all e poi diremo req, res, il prossimo.
E questo, tutto funziona su questo particolare endpoint
già specificato qui.
Ora, non solo, possiamo concatenare i metodi rimanenti.
Ecco perché vedi che ho rimosso il punto e virgola da qui.
Ho intenzione di eliminare questa app e quindi allegarla a quella.
Così viene anche cambiato nel percorso, e quindi posso rimuovere
questa parte, la gestione rimarrà esattamente la stessa di prima.
Quindi allo stesso modo, rimuoverò l'app lì.
E poi di nuovo, cancellalo dal post.
E la stessa cosa.
Per mettere, E
per cancellare, Stessa cosa.
Quindi nota che non ci sono punti e virgola qui, qui o
qui, ma l'ultimo, l'eliminazione, avrà il punto e virgola in posizione.
Quindi questo gruppo è una singola unità implementata utilizzando
il router piatto su questo particolare router, e tutti questi sono incatenati insieme.
E anche, naturalmente, con delete, ho bisogno di rimuovere questo punto finale.
Questo è tutto, vedi, struttura pulita del codice qui. In
modo che essenzialmente, finisca per implementare DishRouter, giusto,
ricorda, questo DishRouter è definito all'interno del file dishRouter.js.
Ora, ho bisogno di esportare questo da questo modulo nodo.
Quindi, per esportare questo, andrò in fondo qui e
dirò module.exports e
dire, DishRouter.
Questo è tutto.
Quindi ora, il mio DishRouter sta esportando tutto ciò di cui ho bisogno.
Ora, stai guardando questo e dicendo, che dire del piatto Colon.
Fara' parte del tuo primo incarico.
Non solo, implementerai
anche due endpoint API REST aggiuntivi, le promozioni e i leader.
Ma questo ti mostra già la struttura di
come appare un'implementazione di router Express del supporto API res.
Quindi questo è per DishRouter.Route.
E un'ultima cosa prima di dimenticare,
dovremmo dire DishRouter.use (BodyParser.JSON ()).
Ora, una volta completata l'implementazione del DishRouter,
possiamo ora andare nel file index.js.
Poiché questo DishRouter è un altro modulo nodo, un modulo nodo fine tuttavia.
Quindi abbiamo bisogno di importare questo nella nostra applicazione.
Quindi proprio qui, ho intenzione di importare const
DishRouter è uguale a richiedere.
Ora, poiché questo è un modulo nodo basato su file,
dirò. /Routes/DishRouter.
E una volta che li ho dichiarati lì, allora scendo nel codice qui.
E proprio lì, dico app.use.
E monto il router su un endpoint.
Quindi, come faccio a montare il router?
Il primo parametro qui, specificherò piatti barra.
E il secondo parametro, specificare DishRouter.
E questo è tutto.
Quindi ciò significa che nella mia applicazione espressa,
qualsiasi richiesta che arriva a quell'endpoint di piatti barra sarà gestita da DishRouter,
e questo sarà fatto dal codice che è presente qui,
perché abbiamo detto percorso DishRouter, e quindi notare che questo dice barra,
quindi il che significa che questo è montato al punto finale dei piatti della barra.
Ecco perché tutto ciò che arriva attraverso piatti di taglio verrà inviato a questo e
sarà gestito da questo.
Un grande suggerimento per pensare a come implementare
quel punto finale dell'id piatto del colon.
Userai comunque lo stesso file dishRouter.js per implementare anche il supporto per
questo, /dishes/:punto finale dishID.
E' un altro grande suggerimento per te, ok?
Con queste modifiche, salviamo le modifiche che abbiamo fatto
alla nostra applicazione e poi riavviare il nostro server e
poi dare un'occhiata a come il nostro server sta andando a fare il suo lavoro.
Andando al terminale, fammi riavviare quel server digitando npm start.
E una volta che il server è attivo e funzionante, andrò al postino e
invierò richieste dal postino a questo server.
Andando al postino, ora so che il mio server supporta solo
il punto finale piatti, ho implementato la parte ID piatto di esso.
Quindi lasciami inviare una richiesta di ottenere ai piatti di accoglienza locali e
vedrai che funziona esattamente come prima.
Ora, se hai fatto una richiesta precedente nel post, puoi semplicemente fare clic su quello e
quindi inviare nuovamente quella richiesta.
Put operazione non funziona, post operazione, Funziona come vedi lì.
E poi facciamo in modo che l'operazione di cancellazione sui piatti.
E dice di cancellare tutti i piatti come previsto.
Quindi questa è l'implementazione del supporto API resto utilizzando il router express.
Con questo, completiamo la seconda metà di questo esercizio.
Questo è un buon momento per voi per fare un commento get con il router di messaggio espresso.
Ora che abbiamo completato questo esercizio in cui abbiamo visto come Express può
essere utilizzato per supportare l'implementazione del supporto del punto finale Res API sul nostro server,
e anche l'uso del router Express,
è il momento di passare alla prima assegnazione che segue questa lezione.
[ MUSIC]