1
00:00:00,000 --> 00:00:04,528
[MUSIC]

2
00:00:04,528 --> 00:00:09,392
Ora che abbiamo compreso l'API REST ed espresso il supporto per

3
00:00:09,392 --> 00:00:13,293
l'API REST, passiamo all'esercizio successivo.

4
00:00:13,293 --> 00:00:17,168
Dove vedremo come svilupperemo l'API REST

5
00:00:17,168 --> 00:00:19,972
utilizzando il supporto fornito da express.

6
00:00:19,972 --> 00:00:23,110
E anche, l'uso di router express, che

7
00:00:23,110 --> 00:00:28,110
ci consente di organizzare il nostro codice in un modo che è più adatto

8
00:00:28,110 --> 00:00:33,231
quando è necessario supportare un gran numero di endpoint API REST.

9
00:00:35,080 --> 00:00:39,965
Per iniziare, continuando con la cartella node-express

10
00:00:39,965 --> 00:00:44,565
abbiamo lavorato sul server web basato su express.

11
00:00:44,565 --> 00:00:50,546
Al prompt, installiamo body-parser,

12
00:00:50,546 --> 00:00:57,729
quindi per farlo, digita npm install body-parser —save.

13
00:00:57,729 --> 00:01:02,674
E stiamo usando la versione 1.18.3 di

14
00:01:02,674 --> 00:01:06,689
corpo-parser in questo corso qui.

15
00:01:06,689 --> 00:01:12,151
Ora, una volta che abbiamo installato corpo-parser, quindi andare nel nostro codice.

16
00:01:12,151 --> 00:01:16,476
In index.js5,

17
00:01:16,476 --> 00:01:22,723
lasciami richiedere BodyParser, quindi

18
00:01:22,723 --> 00:01:28,492
diremo const BodyParser

19
00:01:28,492 --> 00:01:33,553
richiede body parser.

20
00:01:33,553 --> 00:01:39,891
E poi ogni volta che hai bisogno di usare un middleware,

21
00:01:39,891 --> 00:01:46,558
dirai, app.use (BodyParser.JSON).

22
00:01:46,558 --> 00:01:51,782
Quindi questo ci permette di analizzare il corpo del messaggio di richiesta,

23
00:01:51,782 --> 00:01:54,989
che è formattato in formato JSON.

24
00:01:57,466 --> 00:02:03,374
Una volta che abbiamo completato questo, allora iniziamo

25
00:02:03,374 --> 00:02:08,678
a costruire il supporto API REST per l'endpoint /dish.

26
00:02:08,678 --> 00:02:12,797
Utilizzando i

27
00:02:12,797 --> 00:02:16,339
metodi app.all, app.get, put, post e delete sono supportati da express.

28
00:02:16,339 --> 00:02:21,692
Quindi, per farlo, lasciami iniziare dicendo

29
00:02:21,692 --> 00:02:26,725
app.all, e i primi parametri

30
00:02:26,725 --> 00:02:31,937
che app.all prende è l'endpoint.

31
00:02:31,937 --> 00:02:36,360
Quindi in questo caso, sto specificando l'endpoint di/dishes.

32
00:02:36,360 --> 00:02:43,560
E poi il secondo parametro è la funzione di callback,

33
00:02:43,560 --> 00:02:49,564
req, res, next, i tre parametri qui.

34
00:02:49,564 --> 00:02:56,518
E all'interno di questa funzione di callback, gestiremo la richiesta in arrivo.

35
00:02:56,518 --> 00:03:01,740
Quindi diremo, quando arriva una richiesta, per tutte le richieste.

36
00:03:01,740 --> 00:03:06,993
Quindi, quando diciamo app.all, indipendentemente dal metodo invocato,

37
00:03:06,993 --> 00:03:12,864
get, put, post o delete, per l'endpoint API REST /dish,

38
00:03:12,864 --> 00:03:17,190
questo codice verrà eseguito prima di default qui.

39
00:03:17,190 --> 00:03:26,376
Quindi diremo res StatusCode è 200 e

40
00:03:26,376 --> 00:03:31,889
poi Res.SetHeader e

41
00:03:31,889 --> 00:03:39,248
diciamo Content-Type testo.

42
00:03:39,248 --> 00:03:44,290
Invieremo testo normale ora, invece di testo HTML.

43
00:03:44,290 --> 00:03:47,575
Questo dovrebbe essere sufficiente per gli endpoint API REST.

44
00:03:47,575 --> 00:03:52,420
Successivamente, invieremo i dati sotto forma di JSON una volta che

45
00:03:52,420 --> 00:03:54,640
siamo in grado di recuperare i dati dal database.

46
00:03:54,640 --> 00:03:57,340
Così che arriverà in uno degli esercizi successivi.

47
00:03:57,340 --> 00:04:04,389
Per il momento, invieremo semplicemente le risposte in chiaro al cliente.

48
00:04:04,389 --> 00:04:10,785
Ora, dopo questi due, il middleware qui non è ancora completato.

49
00:04:10,785 --> 00:04:17,590
Quindi chiameremo la prossima funzione qui, quindi il prossimo come vedi si riferisce a questo prossimo.

50
00:04:17,590 --> 00:04:24,954
Quindi, quando chiami il prossimo, ciò che significa è che continuerà a cercare

51
00:04:24,954 --> 00:04:29,665
ulteriori specifiche qui sotto,

52
00:04:29,665 --> 00:04:33,790
che corrisponderanno a questo endpoint piatti.

53
00:04:33,790 --> 00:04:38,282
Quindi questo sarebbe fatto per tutte le richieste, ottenere, mettere,

54
00:04:38,282 --> 00:04:42,712
postare e cancellare, sui piatti, e continuerà a quello successivo.

55
00:04:42,712 --> 00:04:48,436
Quindi qui, supponiamo di ottenere una richiesta get

56
00:04:48,436 --> 00:04:53,792
sui piatti, il che significa che ora,

57
00:04:53,792 --> 00:04:58,961
se otteniamo una richiesta get su piatti,

58
00:04:58,961 --> 00:05:04,133
prima questo verrà eseguito, e

59
00:05:04,133 --> 00:05:09,304
poi il req e res saranno trasmessi

60
00:05:09,304 --> 00:05:13,760
a questa seconda chiamata qui.

61
00:05:13,760 --> 00:05:17,481
Quindi in questo caso, non avrò più bisogno del prossimo,

62
00:05:17,481 --> 00:05:21,335
perché non ho intenzione di chiamare più in basso.

63
00:05:21,335 --> 00:05:26,444
Completerò la gestione proprio all'interno di questo metodo qui stesso.

64
00:05:26,444 --> 00:05:31,337
Quindi, se modifichiamo il req o res all'interno di questo codice,

65
00:05:31,337 --> 00:05:36,607
allora quando chiami il prossimo, quell'oggetto modificato

66
00:05:36,607 --> 00:05:41,130
verrà passato come parametro a questo.

67
00:05:41,130 --> 00:05:45,698
Quindi, se hai emesso una richiesta get su piatti, quindi questo è ciò che verrà

68
00:05:45,698 --> 00:05:50,202
eseguito subito dopo questo, quindi questo prossimo farà passare.

69
00:05:50,202 --> 00:05:55,836
E poi qui, si nota che abbiamo modificato l'oggetto res qui.

70
00:05:55,836 --> 00:06:02,770
E la modifica porterà come parametro di input a questa funzione qui.

71
00:06:03,940 --> 00:06:09,380
Quindi all'interno di questa funzione get, possiamo dire, per esempio, al momento,

72
00:06:09,380 --> 00:06:15,197
ho semplicemente intenzione di inviare un semplice messaggio, diremo,

73
00:06:15,197 --> 00:06:20,170
invierà tutti i piatti a voi.

74
00:06:20,170 --> 00:06:25,650
Più tardi, quando recuperiamo le informazioni piatti dal database

75
00:06:25,650 --> 00:06:31,036
dopo aver appreso su MongoDB, allora questa funzione restituirà

76
00:06:31,036 --> 00:06:36,534
quei dati JSON al client, dal momento che è in una richiesta get qui.

77
00:06:36,534 --> 00:06:40,566
Ora, nel corso precedente, avevamo usato il server JSON e

78
00:06:40,566 --> 00:06:44,457
il server JSON stava già fornendo tutti questi per noi.

79
00:06:44,457 --> 00:06:46,965
Ora stai vedendo come costruiresti

80
00:06:46,965 --> 00:06:50,268
un real server che elaborerà la richiesta in arrivo.

81
00:06:50,268 --> 00:06:53,139
E quindi generare una risposta appropriata e

82
00:06:53,139 --> 00:06:57,857
inviarla di nuovo a voi in risposta alla richiesta ricevuta dal lato client.

83
00:06:57,857 --> 00:07:02,611
E questo è dove l'utente espresso, come vediamo qui, è utile.

84
00:07:02,611 --> 00:07:06,971
Così abbiamo gestito ottenere,

85
00:07:06,971 --> 00:07:14,387
cerchiamo di gestire post anche su piatti qui.

86
00:07:16,120 --> 00:07:21,064
E ancora, i parametri sarebbero (req, res,

87
00:07:21,064 --> 00:07:26,722
next), e quella funzione che viene invocata sarà qui.

88
00:07:26,722 --> 00:07:31,606
Ora, quando viene ricevuta la richiesta get, perché qui, stai chiamando rest.end.

89
00:07:31,606 --> 00:07:36,982
Quindi quella fine è la gestione della richiesta get e non attiva la risposta

90
00:07:36,982 --> 00:07:42,130
da inviare o la risposta da inviare al client a questo punto.

91
00:07:42,130 --> 00:07:47,050
Ora, se ricevi una richiesta di post sui piatti, di nuovo, questo intero codice verrà eseguito.

92
00:07:47,050 --> 00:07:52,859
E poi, a causa di questo prossimo, che cadrà in questa chiamata di funzione qui.

93
00:07:52,859 --> 00:07:57,000
E poi il codice qui, verrà eseguito, quindi quando si riceve un

94
00:07:59,610 --> 00:08:04,820
post La richiesta di post proveniente dal server porterà alcune informazioni

95
00:08:04,820 --> 00:08:08,710
nel corpo del messaggio sotto forma di dati JSON.

96
00:08:08,710 --> 00:08:13,650
Vedranno qual è la forma dei dati JSON quando

97
00:08:13,650 --> 00:08:18,910
guardiamo più tardi quando testiamo punto finale usando post net.

98
00:08:18,910 --> 00:08:24,700
Ti mostrerò ciò che conterrà il corpo del messaggio di richiesta di post.

99
00:08:24,700 --> 00:08:27,710
Ma a questo punto, quello che farò è

100
00:08:27,710 --> 00:08:33,420
estrarre le informazioni dal corpo.

101
00:08:33,420 --> 00:08:38,545
E così qui quando usiamo il parser corpo, ciò che accade è che per

102
00:08:38,545 --> 00:08:44,541
la richiesta in arrivo, il corpo della richiesta in arrivo verrà analizzato e

103
00:08:44,541 --> 00:08:48,237
quindi aggiunto nell'oggetto req come req.body.

104
00:08:48,237 --> 00:08:52,843
Quindi il req.body ti darà accesso a tutto ciò che è all'interno di quel corpo

105
00:08:52,843 --> 00:08:54,050
del messaggio.

106
00:08:54,050 --> 00:08:58,642
Quindi, quando invio la richiesta,

107
00:08:58,642 --> 00:09:04,339
aggiungerò informazioni al

108
00:09:04,339 --> 00:09:10,034
corpo della richiesta sotto forma di una stringa JSON che

109
00:09:10,034 --> 00:09:15,570
contiene un nome e una descrizione.

110
00:09:15,570 --> 00:09:20,081
Quindi ho intenzione di estrarre queste due informazioni e

111
00:09:20,081 --> 00:09:26,080
poi stamparle e poi rispedirle al client nel messaggio di risposta.

112
00:09:26,080 --> 00:09:32,840
Quindi posso dire, req.body e poi nome.

113
00:09:32,840 --> 00:09:38,298
E così l'aspettativa è che quando il client invia il messaggio post,

114
00:09:38,298 --> 00:09:42,183
il corpo del messaggio post conterrà una stringa JSON,

115
00:09:42,183 --> 00:09:47,108
che conterrà anche la proprietà name nella stringa JSON.

116
00:09:47,108 --> 00:09:52,646
Quindi req.body.name plus e

117
00:09:52,646 --> 00:09:57,952
questo è dove includerò

118
00:09:57,952 --> 00:10:06,970
con i dettagli: + req.body.description.

119
00:10:06,970 --> 00:10:11,654
Quindi qualunque cosa contenga la stringa JSON nel req.body, ma la

120
00:10:11,654 --> 00:10:15,963
stringa JSON verrà analizzata in un oggetto JavaScript e

121
00:10:15,963 --> 00:10:19,909
aggiunta all'oggetto richiesta come corpo di proprietà.

122
00:10:19,909 --> 00:10:22,971
L' oggetto JavaScript punta a tutto ciò che

123
00:10:22,971 --> 00:10:27,440
è entrato come stringa JSON nel corpo del messaggio di richiesta.

124
00:10:27,440 --> 00:10:31,750
Ecco perché sono in grado di analizzare la proprietà del nome, la proprietà della descrizione,,

125
00:10:31,750 --> 00:10:38,000
puoi avere la proprietà del prezzo, la proprietà dell'immagine e tutto questo.

126
00:10:38,000 --> 00:10:42,260
Quindi, se hai seguito il corso precedente, hai visto la struttura di un

127
00:10:42,260 --> 00:10:48,850
oggetto piatto, sotto forma di una stringa JSON o l'oggetto JavaScript lì.

128
00:10:48,850 --> 00:10:52,920
Quindi, il nome e la descrizione ti sembrano familiari.

129
00:10:52,920 --> 00:10:55,400
Quindi è esattamente quello che sto usando qui.

130
00:10:55,400 --> 00:11:00,823
In questo momento sto solo estraendo il nome e la descrizione dal corpo e

131
00:11:00,823 --> 00:11:04,220
poi lo rimando al cliente in questo corpo.

132
00:11:04,220 --> 00:11:09,460
Quindi sto solo costruendo questo messaggio di risposta qui usando le informazioni

133
00:11:09,460 --> 00:11:13,150
dal corpo del messaggio di richiesta e quindi inviandolo al client.

134
00:11:13,150 --> 00:11:17,830
In questo modo posso confermare che il server sta ricevendo tutto ciò che sto inviando

135
00:11:17,830 --> 00:11:19,930
nel corpo del messaggio.

136
00:11:19,930 --> 00:11:21,820
Quindi questa è la richiesta di post.

137
00:11:23,390 --> 00:11:30,620
Ora, per dirla, fammi solo copiare questo, e poi incollarlo qui.

138
00:11:30,620 --> 00:11:35,360
E poi per mettere su quel piatto endpoint,

139
00:11:35,360 --> 00:11:39,100
perché mettere sul piatto endpoint non ha senso.

140
00:11:39,100 --> 00:11:44,440
Un post significa che stai postando un nuovo piatto ai server.

141
00:11:44,440 --> 00:11:50,992
Un punto finale messo sui piatti non ha senso,

142
00:11:50,992 --> 00:11:55,516
quindi ecco quello che ho intenzione di fare è

143
00:11:55,516 --> 00:12:00,664
risponderò con l'

144
00:12:00,664 --> 00:12:06,660
operazione PUT messaggio non supportata su/dish.

145
00:12:06,660 --> 00:12:14,790
Inoltre, lo farò anche, Includere un codice di stato di 403.

146
00:12:14,790 --> 00:12:19,987
403 significa che il loro funzionamento non è supportato.

147
00:12:19,987 --> 00:12:24,319
Quindi, se si guarda indietro alla tabella dei codici di risposta HTTP,

148
00:12:24,319 --> 00:12:30,600
si vedrà il codice corrispondente 403 ciò che rappresenta lì.

149
00:12:30,600 --> 00:12:34,650
Quindi questo è quello che sto usando per post.

150
00:12:34,650 --> 00:12:39,879
Per eliminare, ho intenzione di copiare

151
00:12:39,879 --> 00:12:44,777
questo e per eliminare ho intenzione di,

152
00:12:47,537 --> 00:12:55,960
Basta analizzare questo, e poi diremo, Eliminando tutti i piatti.

153
00:12:55,960 --> 00:13:02,200
Quindi, quando si invia una richiesta di eliminazione su quell'endpoint /dish.

154
00:13:02,200 --> 00:13:04,900
Viene interpretato nel senso che

155
00:13:04,900 --> 00:13:08,960
il cliente vuole eliminare tutte le informazioni sui piatti sul lato server.

156
00:13:08,960 --> 00:13:11,300
Ora, questa è un'operazione pericolosa, quindi

157
00:13:11,300 --> 00:13:15,540
assicurati di non consentire agli utenti partner di farlo.

158
00:13:15,540 --> 00:13:17,750
Quindi in seguito, quando studiamo l'autenticazione,

159
00:13:17,750 --> 00:13:23,220
vedremo come possiamo controllare questa operazione solo agli utenti privilegiati.

160
00:13:23,220 --> 00:13:28,620
Ma ancora, come vedi, questa è un'operazione pericolosa, quindi tienilo a mente.

161
00:13:28,620 --> 00:13:33,340
Così ora si vede che nell'endpoint piatti, abbiamo ottenere, mettere,

162
00:13:33,340 --> 00:13:35,130
postare ed eliminare il supporto.

163
00:13:35,130 --> 00:13:41,520
Supportiamo anche questo sull'endpoint dishID: dishID.

164
00:13:41,520 --> 00:13:46,280
Quindi ho intenzione di copiare i metodi get, put, post ed eliminare da qui,

165
00:13:48,530 --> 00:13:54,175
e poi li chiama tutti anche per essere supportati su

166
00:13:54,175 --> 00:14:00,360
dishes/: dishID.

167
00:14:00,360 --> 00:14:06,913
Quindi questo è per il get, e lo copiamo e

168
00:14:06,913 --> 00:14:11,480
pubblichiamo, mettiamo e cancelliamo.

169
00:14:11,480 --> 00:14:13,330
Come gestiamo ognuno di questi?

170
00:14:13,330 --> 00:14:19,460
Quindi, per ottenere, se ottengo una richiesta su dishes/dishID,

171
00:14:19,460 --> 00:14:22,750
quello che vorrei fare è estrarre questo parametro e

172
00:14:22,750 --> 00:14:27,000
quindi inviarlo nuovamente nella richiesta, nel messaggio di risposta.

173
00:14:27,000 --> 00:14:29,725
Quindi diremo, manderemo,

174
00:14:39,018 --> 00:14:41,625
dettagli del piatto.

175
00:14:44,584 --> 00:14:46,910
Ora quale piatto?

176
00:14:46,910 --> 00:14:51,570
Queste informazioni si trovano nel parametro.

177
00:14:51,570 --> 00:14:55,335
Quindi questo valore del parametro può recuperare da

178
00:14:55,335 --> 00:15:02,300
req.params.dishId.

179
00:15:02,300 --> 00:15:07,510
Quindi questo dishId, come vedi, il nome che usi qui dovrebbe corrispondere a questo valore qui.

180
00:15:07,510 --> 00:15:09,370
Quindi, se vedi semplicemente ID qui,

181
00:15:09,370 --> 00:15:13,220
questo dovrebbe anche corrispondere al SID dato qui.

182
00:15:13,220 --> 00:15:17,920
Quindi il nome stesso non significa nulla, tranne che questo nome del parametro e

183
00:15:17,920 --> 00:15:23,400
questo dovrebbe corrispondere tra loro, in modo da poter recuperare le informazioni correttamente.

184
00:15:25,090 --> 00:15:30,470
Quindi diremo, invia i parametri del piatto dishId e

185
00:15:30,470 --> 00:15:37,360
poi ti diremo.

186
00:15:37,360 --> 00:15:43,160
Quindi in questo modo sappiamo che il server sta ottenendo il parametro piatto..

187
00:15:43,160 --> 00:15:47,350
Quindi se dico /piatti/23 ci diverse risposte

188
00:15:47,350 --> 00:15:52,350
invieranno i dettagli del piatto 23 a voi e così via.

189
00:15:52,350 --> 00:15:57,632
Così vedremo come funziona quando usiamo post per testare questo server.

190
00:15:57,632 --> 00:15:59,584
Ora per la posta.

191
00:15:59,584 --> 00:16:03,530
Per post, questo metodo non sarà supportato,

192
00:16:03,530 --> 00:16:07,060
quindi ho intenzione di copiare questa parte.

193
00:16:07,060 --> 00:16:12,205
non ha senso fare un post su un ID piatto specifico,

194
00:16:12,205 --> 00:16:16,375
perché non stai cercando di aggiungere un nuovo piatto.

195
00:16:16,375 --> 00:16:21,360
Ma si desidera modificare, e la modifica viene eseguita utilizzando l'operazione put.

196
00:16:21,360 --> 00:16:28,111
Quindi diremo, operazione POST non supportata su/dishes.

197
00:16:33,331 --> 00:16:36,360
E poi ho intenzione di aggiungere in.

198
00:16:39,750 --> 00:16:43,197
Req.params.dishID.

199
00:16:43,197 --> 00:16:47,535
Quindi questo invierà indietro dicendo post non supportato su

200
00:16:47,535 --> 00:16:50,752
piatti/23 nel messaggio di risposta.

201
00:16:50,752 --> 00:16:55,926
Ora, per PUT, Per PUT, diremo,

202
00:16:59,902 --> 00:17:08,799
res.end e diciamo Will, aggiorna il piatto.

203
00:17:13,902 --> 00:17:20,978
Req.params.dishID.

204
00:17:28,915 --> 00:17:31,675
O meglio, lo faremo in questo modo.

205
00:17:33,785 --> 00:17:39,141
Prima scriverò, Quindi

206
00:17:39,141 --> 00:17:45,345
res.write può essere utilizzato per aggiungere una riga al messaggio di risposta.

207
00:17:45,345 --> 00:17:50,077
Quindi diremo di aggiornare il piatto.

208
00:17:50,077 --> 00:17:58,655
E diremo req.params.dishid.

209
00:17:58,655 --> 00:18:06,245
E poiché questa è un'operazione PUT, e se il corpo contiene la stringa JSON,

210
00:18:06,245 --> 00:18:10,277
che contiene i dettagli del piatto,

211
00:18:10,277 --> 00:18:17,310
posso estrarre la stringa JSON perché stiamo usando il parser body.

212
00:18:17,310 --> 00:18:21,649
Quindi diremo

213
00:18:21,649 --> 00:18:26,569
aggiornerà il piatto:.

214
00:18:30,234 --> 00:18:31,924
Quale piatto?

215
00:18:31,924 --> 00:18:34,822
req.body.name.

216
00:18:38,122 --> 00:18:38,657
In piu'.

217
00:18:40,531 --> 00:18:45,701
Con dettagli,

218
00:18:45,701 --> 00:18:55,250
req.body.description.

219
00:18:59,320 --> 00:19:08,800
Ora, quando aggiorniamo il piatto, voglio aggiungere una, Nuova linea lì.

220
00:19:08,800 --> 00:19:11,411
Quindi dirò '/n' lì.

221
00:19:14,500 --> 00:19:19,257
Quindi, quando fai un PUT, stai inviando indietro le informazioni su quale ID piatto

222
00:19:19,257 --> 00:19:22,674
stai aggiornando e anche i dettagli che stai aggiornando.

223
00:19:22,674 --> 00:19:26,997
Il nome e la descrizione,

224
00:19:26,997 --> 00:19:34,318
che dovrebbero essere nel corpo del messaggio PUT lì.

225
00:19:34,318 --> 00:19:41,868
Per eliminare, Si dirà Eliminazione piatto, e req.params.dishID.

226
00:19:41,868 --> 00:19:47,970
E così per eliminare, questa è l'operazione che verrà eseguita.

227
00:19:47,970 --> 00:19:51,607
Così si vede che ora abbiamo le

228
00:19:51,607 --> 00:19:55,838
operazioni get, put, post, ed delete sui piatti/dishID, endpoint, e

229
00:19:55,838 --> 00:20:00,590
anche le operazioni get, put, post sul/dish, endpoint.

230
00:20:00,590 --> 00:20:03,765
Quindi ora salviamo le modifiche.

231
00:20:03,765 --> 00:20:05,387
E riavvia il nostro server.

232
00:20:08,245 --> 00:20:10,643
Avviare il server dicendo npm start.

233
00:20:10,643 --> 00:20:15,611
Andiamo ora al postino e inviamo alcune richieste a questo server e

234
00:20:15,611 --> 00:20:17,270
vediamo cosa restituisce.

235
00:20:17,270 --> 00:20:22,287
Lasciatemi prima emettere un get a host locale 3.000 e vedere cosa restituisce.

236
00:20:22,287 --> 00:20:26,832
Quindi, quando si invia una richiesta per ottenere l'host locale 3.000,

237
00:20:26,832 --> 00:20:30,798
sta ancora restituendo la pagina HTML iniziale dell'indice,

238
00:20:30,798 --> 00:20:35,069
perché la gestione dei file statici è ancora a posto.

239
00:20:35,069 --> 00:20:41,564
Ora lasciami inviare una richiesta get a localhost: 3000/piatti, e questo,

240
00:20:41,564 --> 00:20:48,383
come ti aspetti, invierà una risposta dicendo che ti invieremo tutti i piatti.

241
00:20:48,383 --> 00:20:56,350
Ora, inviamo una richiesta POST a localhost: 3000/piatti.

242
00:20:56,350 --> 00:21:01,200
Quindi questo è dove puoi cambiare i vari metodi che vuoi eseguire.

243
00:21:01,200 --> 00:21:02,880
Ma quando si invia un post,

244
00:21:02,880 --> 00:21:08,570
si desidera includere alcuni dettagli nel corpo del messaggio perché

245
00:21:08,570 --> 00:21:12,920
c'è qualcuno che si aspetta di inviare informazioni nel corpo del messaggio.

246
00:21:12,920 --> 00:21:17,967
Quindi clicca sul corpo qui e clicca su crudo qui.

247
00:21:17,967 --> 00:21:23,395
E poi, per il testo, lo selezioni in JSON, quindi

248
00:21:23,395 --> 00:21:26,377
usa l'applicazione JSON.

249
00:21:26,377 --> 00:21:31,081
Quindi il tipo di contenuto sarebbe Application/JSON

250
00:21:31,081 --> 00:21:34,220
nella richiesta che invii.

251
00:21:34,220 --> 00:21:38,658
Quindi, poiché questo è un oggetto JSON, quindi

252
00:21:38,658 --> 00:21:43,103
tra parentesi graffe, dirò nome.

253
00:21:45,320 --> 00:21:50,727
Semplicemente scriverò il test

254
00:21:50,727 --> 00:21:53,939
e la descrizione.

255
00:22:01,212 --> 00:22:05,760
Alcune informazioni standard qui, quindi vedi che questa è una stringa JSON che

256
00:22:05,760 --> 00:22:10,900
contiene due proprietà, nome e descrizione e i valori corrispondenti.

257
00:22:10,900 --> 00:22:13,858
Quindi cerchiamo di inviare una richiesta di post al server.

258
00:22:13,858 --> 00:22:18,294
Quando si invia una richiesta di post al server, come si vede,

259
00:22:18,294 --> 00:22:24,290
nella risposta si dice aggiungerà il piatto: dettagli settimana di prova: descrizione.

260
00:22:24,290 --> 00:22:30,368
Quindi, come puoi vedere, le due informazioni vengono estratte dal corpo

261
00:22:30,368 --> 00:22:35,772
di quel JSON richiesto [INUDIBLE] e quindi incluse nella risposta.

262
00:22:35,772 --> 00:22:39,459
Mandiamo una richiesta di put ai piatti.

263
00:22:39,459 --> 00:22:43,029
Quando invii una richiesta put ai piatti, come vedi,

264
00:22:43,029 --> 00:22:48,654
dice l'operazione PUT non supportata su/dish e guarda lo stato qui.

265
00:22:48,654 --> 00:22:52,580
Dice Stato: 403 Proibito.

266
00:22:52,580 --> 00:22:57,570
Quindi questa operazione non è consentita su questo endpoint.

267
00:22:57,570 --> 00:23:01,430
Facciamo un'operazione DELETE sui piatti.

268
00:23:01,430 --> 00:23:04,240
Quando si DELETE operazione sui piatti,

269
00:23:04,240 --> 00:23:09,270
allora si noterà che si dice l'eliminazione di tutti i piatti.

270
00:23:09,270 --> 00:23:11,560
Quindi questa è la risposta che si ottiene indietro.

271
00:23:12,920 --> 00:23:15,410
Quindi vedi che il post get, put ed

272
00:23:15,410 --> 00:23:20,610
delete sull'endpoint /dish funziona come ti aspetti.

273
00:23:20,610 --> 00:23:24,507
Ora facciamo un get sui piatti /23.

274
00:23:24,507 --> 00:23:29,017
Quindi 23 qui è il parametro,

275
00:23:29,017 --> 00:23:34,710
l'ID del piatto che si desidera ottenere.

276
00:23:34,710 --> 00:23:38,716
Quindi, quando si invia una richiesta a che il server risponderà,

277
00:23:38,716 --> 00:23:41,878
invierà i dettagli del piatto: 23 a voi.

278
00:23:41,878 --> 00:23:47,421
Quindi si vede che il parametro è stato estratto dal messaggio di richiesta e

279
00:23:47,421 --> 00:23:50,645
quindi incluso nel messaggio di risposta.

280
00:23:50,645 --> 00:23:54,850
Facciamo un post su questo.

281
00:23:54,850 --> 00:23:59,580
E come sai, POST non è consentito su questo endpoint, ed

282
00:23:59,580 --> 00:24:03,450
è per questo che ottieni uno stato 403 Proibito su questo.

283
00:24:03,450 --> 00:24:05,728
Facciamo un'operazione PUT su questo.

284
00:24:05,728 --> 00:24:10,040
Quindi, per l'operazione PUT, si nota che il corpo lo contiene ancora.

285
00:24:10,040 --> 00:24:13,950
Quindi in POST, quando digiti un valore qui,

286
00:24:13,950 --> 00:24:18,720
questo verrà mantenuto e può essere incluso in altre richieste che stai inviando.

287
00:24:18,720 --> 00:24:25,087
Quindi, quando si invia una richiesta PUT sull'endpoint, piatti/23.

288
00:24:25,087 --> 00:24:28,650
Quindi si nota che dice aggiornare il piatto, 23.

289
00:24:28,650 --> 00:24:31,780
Aggiornerà il piatto, il nome del piatto,

290
00:24:31,780 --> 00:24:36,200
con i dettagli, la descrizione del piatto qui.

291
00:24:36,200 --> 00:24:41,130
E poi, facciamo un'operazione di eliminazione su quell'endpoint e

292
00:24:41,130 --> 00:24:45,140
poi dice, d cancellazione piatto: 23.

293
00:24:45,140 --> 00:24:52,210
Quindi questi endpoint sono tutti supportati come vedi in questo esempio qui.

294
00:24:52,210 --> 00:24:58,430
Quindi abbiamo fatto ottenere PUT, POSRT, ed eliminare le operazioni sia sull'endpoint /dish che

295
00:24:58,430 --> 00:25:03,830
anche sull'endpoint /dishes/ l'endpoint id del piatto.

296
00:25:03,830 --> 00:25:08,010
Così, si vede come abbiamo implementato il supporto endpoint API REST per

297
00:25:08,010 --> 00:25:12,730
un set di endpoint API REST.

298
00:25:12,730 --> 00:25:17,405
Ora, con questo, completiamo la prima parte di questo esercizio.

299
00:25:17,405 --> 00:25:22,378
Quindi, qui abbiamo visto come possiamo usare express per costruire e

300
00:25:22,378 --> 00:25:26,755
implementare l'endpoint API REST per i piatti.

301
00:25:26,755 --> 00:25:27,885
Ora, questo è un buon momento per

302
00:25:27,885 --> 00:25:32,895
fare un commit git con il messaggio Express Simple REST.

303
00:25:33,895 --> 00:25:42,361
Secondo il terminale inizierò il, Server.

304
00:25:42,361 --> 00:25:45,845
Verificare che tre degli elementi siano stati modificati.

305
00:25:45,845 --> 00:25:52,527
Quindi, git add, git commit -m,

306
00:25:52,527 --> 00:26:01,750
Express Simple REST, E controlla il set.

307
00:26:01,750 --> 00:26:08,670
Quindi, come puoi vedere, usando Express puoi facilmente implementare il supporto per l'API REST.

308
00:26:08,670 --> 00:26:15,300
E come puoi vedere da questo elenco, costruisci l'app get, PUT

309
00:26:15,300 --> 00:26:21,590
, POST ed elimina i metodi per tutti gli endpoint API REST come questo.

310
00:26:21,590 --> 00:26:24,601
Ora immagina di avere un migliaio di endpoint API REST

311
00:26:24,601 --> 00:26:27,347
e devi costruire qualcosa del genere.

312
00:26:27,347 --> 00:26:33,344
Il tuo file index.js esploderà con così tanti endpoint API REST diversi.

313
00:26:33,344 --> 00:26:37,744
E ognuno viene gestito usando il proprio app.get,

314
00:26:37,744 --> 00:26:41,536
app.put, app.delete e app.post.

315
00:26:41,536 --> 00:26:46,336
Ora Wxpress supporta un modo di suddividere questo lavoro in più,

316
00:26:46,336 --> 00:26:48,442
molte applicazioni Express,

317
00:26:48,442 --> 00:26:54,580
che poi possono essere combinate insieme per formare l'applicazione complessiva, Express.

318
00:26:54,580 --> 00:26:58,260
Questo è dove faremo uso di Express Router

319
00:26:58,260 --> 00:27:01,960
per essere in grado di costruire una mini applicazione Express.

320
00:27:01,960 --> 00:27:06,070
E poi, all'interno di un file Express Router,

321
00:27:06,070 --> 00:27:10,040
supporteremo l'endpoint API REST per un gruppo di parti API REST.

322
00:27:10,040 --> 00:27:13,190
Ad esempio, per i piatti e i piatti dishId,

323
00:27:13,190 --> 00:27:15,598
possono essere tutti supportati in un unico file.

324
00:27:15,598 --> 00:27:20,694
Allo stesso modo, nell'assegnazione, supporterai un

325
00:27:20,694 --> 00:27:25,339
endpoint API REST chiamato promozioni e promozioni/: promoID.

326
00:27:25,339 --> 00:27:29,570
E poi, supporterai un'altra API REST e

327
00:27:29,570 --> 00:27:34,241
per leader/leader, e/leader: leaderID.

328
00:27:34,241 --> 00:27:39,088
Così ognuno di questi gruppi può essere implementato separatamente come molte

329
00:27:39,088 --> 00:27:43,120
applicazioni Express utilizzando Express Router.

330
00:27:43,120 --> 00:27:46,230
Quindi questo è ciò che vi illustrerò per

331
00:27:46,230 --> 00:27:52,150
l'endpoint piatti nella prossima parte di questo esercizio.

332
00:27:52,150 --> 00:27:57,668
Quindi, per farlo, ci rendiamo conto che se mettiamo tutti i file in una singola cartella,

333
00:27:57,668 --> 00:28:01,498
allora di nuovo la struttura delle cartelle sembrerà disordinata.

334
00:28:01,498 --> 00:28:07,731
Quindi la mia preferenza è creare una cartella qui denominata route.

335
00:28:07,731 --> 00:28:12,591
E questa cartella route conterrà tutti i router che ho intenzione di

336
00:28:12,591 --> 00:28:15,450
progettare utilizzando il Router Express.

337
00:28:15,450 --> 00:28:19,465
Quindi nella cartella route, creerò un nuovo file chiamato

338
00:28:19,465 --> 00:28:27,270
dishRouter.js.

339
00:28:27,270 --> 00:28:31,332
E questo file dishRouter.js conterrà

340
00:28:31,332 --> 00:28:36,972
l'implementazione della gestione dell'endpoint API REST per

341
00:28:36,972 --> 00:28:41,281
/dish e/dishes:endpoint DishID.

342
00:28:41,281 --> 00:28:44,626
Ora come facciamo a utilizzare Express Router?

343
00:28:44,626 --> 00:28:46,910
Vediamo come possiamo usarlo.

344
00:28:46,910 --> 00:28:51,050
Ora Express Router viene insieme a Express, quindi non abbiamo bisogno di installare ancora

345
00:28:51,050 --> 00:28:53,130
un altro modulo Node.

346
00:28:53,130 --> 00:28:56,970
Invece, possiamo lavorare con Express che abbiamo già installato.

347
00:28:56,970 --> 00:29:02,308
Quindi, per farlo, a quel prompt, digita, const express

348
00:29:02,308 --> 00:29:07,200
= require ('express');.

349
00:29:07,200 --> 00:29:09,950
Quindi noti che, poiché questa è una mini-applicazione,

350
00:29:09,950 --> 00:29:15,000
abbiamo ancora bisogno di esprimere anche in questo file dishRouter.js.

351
00:29:15,000 --> 00:29:18,495
E dalla vostra conoscenza dei moduli Node, una volta definito un nuovo file,

352
00:29:18,495 --> 00:29:20,251
che diventa il proprio modulo Node.

353
00:29:20,251 --> 00:29:24,708
E questo modulo Node può quindi essere importato in index.js.

354
00:29:24,708 --> 00:29:29,520
Così si vede la connessione già tra il modo in cui possiamo ristrutturare la nostra

355
00:29:29,520 --> 00:29:33,415
applicazione in più file utilizzando i moduli Node.

356
00:29:33,415 --> 00:29:39,525
Quindi imposteremo richiedono Express, quindi diremo const

357
00:29:39,525 --> 00:29:44,830
BodyParser require ('corpo-parser').

358
00:29:44,830 --> 00:29:50,310
Quindi abbiamo già installato BodyParser nei passaggi precedenti dell'esercizio,

359
00:29:50,310 --> 00:29:51,634
quindi possiamo usarlo.

360
00:29:51,634 --> 00:29:55,040
Ora per usare un router Express,

361
00:29:55,040 --> 00:30:00,636
lasciami dichiarare const DishRouter = Express.r

362
00:30:00,636 --> 00:30:05,769
E su express, supporta questa interfaccia router, quindi

363
00:30:05,769 --> 00:30:11,430
diremo semplicemente Express.Router e questo dichiarerà DishRouter come router Express.

364
00:30:11,430 --> 00:30:13,951
Quindi in molte applicazioni Express,

365
00:30:13,951 --> 00:30:18,820
un'intuizione qui posso gestire quel codice relativo a DishRouter qui.

366
00:30:19,830 --> 00:30:26,560
Quindi, una volta che dichiaro di questo un router Express, allora posso dire DishRouter.

367
00:30:28,050 --> 00:30:33,337
E poi su DishRouter, supporta un metodo chiamato metodo route,

368
00:30:33,337 --> 00:30:36,694
che può prendere in un endpoint come parametro.

369
00:30:36,694 --> 00:30:41,330
Quindi vorrei semplicemente dichiarare questo endpoint un/.

370
00:30:41,330 --> 00:30:44,620
Ora, ti stai chiedendo, non dovrebbero essere piatti?

371
00:30:44,620 --> 00:30:49,630
Vedrai molto presto che ho bisogno di montare questo

372
00:30:49,630 --> 00:30:53,140
router Express nel mio file index.js.

373
00:30:53,140 --> 00:31:01,270
Quindi nel mio file index.js, monterò questo router espresso nell'endpoint /dish.

374
00:31:01,270 --> 00:31:03,300
Montaggio di un router espresso, ancora una volta,

375
00:31:03,300 --> 00:31:05,900
un altro concetto che voglio che tu capisca.

376
00:31:05,900 --> 00:31:08,408
Ancora una volta, ve lo illustrerò in breve tempo.

377
00:31:08,408 --> 00:31:13,368
Ora, DishRouter.Route significa che utilizzando questo approccio,

378
00:31:13,368 --> 00:31:17,526
stiamo dichiarando l'endpoint in una singola posizione.

379
00:31:17,526 --> 00:31:21,316
Per cui è possibile concatenare tutti ottenere, PUT, POST,

380
00:31:21,316 --> 00:31:25,219
eliminare i metodi già fare questo router piatto.

381
00:31:25,219 --> 00:31:30,139
Ora, quando guardi index.js,, guarda il modo in cui abbiamo implicato questo.

382
00:31:30,139 --> 00:31:36,029
Quindi abbiamo app.all e dopo/piatti, app.get/piatti e/dishes.

383
00:31:36,029 --> 00:31:40,795
Ora, se hai fatto un errore, e la loro istruzione

384
00:31:40,795 --> 00:31:45,580
app.post/dish invece se digiti semplicemente /dish, allora cosa succede?

385
00:31:45,580 --> 00:31:49,050
L' operazione POST non sarà supportata sui piatti, ma

386
00:31:49,050 --> 00:31:51,730
sarà supportata sull'endpoint /dish.

387
00:31:53,170 --> 00:31:59,220
Per evitare questo problema, il router express supporta questo punto finale del percorso.

388
00:31:59,220 --> 00:32:00,090
Sul punto finale del percorso,

389
00:32:00,090 --> 00:32:05,860
è sufficiente specificare il punto finale su cui funzionerà questo router.

390
00:32:05,860 --> 00:32:10,890
E poi, il metodo get put part delete, questo semplicemente incatenato in quello.

391
00:32:10,890 --> 00:32:16,300
Quindi sarà un gruppo di implementazioni di metodi tutti insieme.

392
00:32:16,300 --> 00:32:20,345
Quindi questo è il motivo per cui usano un router Express.

393
00:32:20,345 --> 00:32:24,185
Quindi viene fornito con un paio di

394
00:32:24,185 --> 00:32:28,525
supporto molto utile per assicurarsi che la tua implementazione sia corretta.

395
00:32:28,525 --> 00:32:32,190
Quindi ora che lo faremo come router piatto,

396
00:32:32,190 --> 00:32:37,920
quello che farò è rimuoverò questa cosa da qui.

397
00:32:37,920 --> 00:32:42,990
Ora, che i piatti IDN punto, lo lascerò

398
00:32:42,990 --> 00:32:47,565
a te come esercizio nel tuo primo incarico

399
00:32:47,565 --> 00:32:54,180
, ma l'endpoint piatti, ho intenzione di tagliare questo, fino a tutti.

400
00:32:54,180 --> 00:32:59,350
Ho intenzione di tagliare questo da index.js5 e di

401
00:32:59,350 --> 00:33:04,580
spostarlo in DishRouter qui.

402
00:33:04,580 --> 00:33:11,887
Ora, quando lo sposto in DishRouter, non ho più bisogno di questa app.all.

403
00:33:11,887 --> 00:33:18,267
Lo concatenerò semplicemente nel percorso, quindi dirò semplicemente .all e

404
00:33:18,267 --> 00:33:24,210
poi non ho più bisogno di questa definizione del punto finale lì.

405
00:33:24,210 --> 00:33:24,900
Questo è tutto. Quindi

406
00:33:24,900 --> 00:33:28,390
dirà .all e poi diremo req, res, il prossimo.

407
00:33:28,390 --> 00:33:31,470
E questo, tutto funziona su questo particolare endpoint

408
00:33:31,470 --> 00:33:33,690
già specificato qui.

409
00:33:33,690 --> 00:33:37,920
Ora, non solo, possiamo concatenare i metodi rimanenti.

410
00:33:37,920 --> 00:33:41,360
Ecco perché vedi che ho rimosso il punto e virgola da qui.

411
00:33:41,360 --> 00:33:46,270
Ho intenzione di eliminare questa app e quindi allegarla a quella.

412
00:33:46,270 --> 00:33:51,600
Così viene anche cambiato nel percorso, e quindi posso rimuovere

413
00:33:53,140 --> 00:33:57,740
questa parte, la gestione rimarrà esattamente la stessa di prima.

414
00:33:57,740 --> 00:34:05,520
Quindi allo stesso modo, rimuoverò l'app lì.

415
00:34:05,520 --> 00:34:10,850
E poi di nuovo, cancellalo dal post.

416
00:34:10,850 --> 00:34:11,865
E la stessa cosa.

417
00:34:17,447 --> 00:34:22,248
Per mettere, E

418
00:34:22,248 --> 00:34:27,360
per cancellare, Stessa cosa.

419
00:34:27,360 --> 00:34:30,800
Quindi nota che non ci sono punti e virgola qui, qui o

420
00:34:30,800 --> 00:34:34,670
qui, ma l'ultimo, l'eliminazione, avrà il punto e virgola in posizione.

421
00:34:34,670 --> 00:34:40,810
Quindi questo gruppo è una singola unità implementata utilizzando

422
00:34:40,810 --> 00:34:45,930
il router piatto su questo particolare router, e tutti questi sono incatenati insieme.

423
00:34:47,640 --> 00:34:52,610
E anche, naturalmente, con delete, ho bisogno di rimuovere questo punto finale.

424
00:34:52,610 --> 00:34:56,626
Questo è tutto, vedi, struttura pulita del codice qui. In

425
00:34:56,626 --> 00:35:02,100
modo che essenzialmente, finisca per implementare DishRouter, giusto,

426
00:35:02,100 --> 00:35:07,700
ricorda, questo DishRouter è definito all'interno del file dishRouter.js.

427
00:35:07,700 --> 00:35:12,870
Ora, ho bisogno di esportare questo da questo modulo nodo.

428
00:35:12,870 --> 00:35:17,500
Quindi, per esportare questo, andrò in fondo qui e

429
00:35:17,500 --> 00:35:22,877
dirò module.exports e

430
00:35:22,877 --> 00:35:26,170
dire, DishRouter.

431
00:35:26,170 --> 00:35:27,030
Questo è tutto.

432
00:35:27,030 --> 00:35:34,920
Quindi ora, il mio DishRouter sta esportando tutto ciò di cui ho bisogno.

433
00:35:34,920 --> 00:35:41,170
Ora, stai guardando questo e dicendo, che dire del piatto Colon.

434
00:35:41,170 --> 00:35:44,302
Fara' parte del tuo primo incarico.

435
00:35:44,302 --> 00:35:47,010
Non solo, implementerai

436
00:35:47,010 --> 00:35:53,000
anche due endpoint API REST aggiuntivi, le promozioni e i leader.

437
00:35:53,000 --> 00:35:57,960
Ma questo ti mostra già la struttura di

438
00:35:57,960 --> 00:36:03,080
come appare un'implementazione di router Express del supporto API res.

439
00:36:03,080 --> 00:36:05,070
Quindi questo è per DishRouter.Route.

440
00:36:05,070 --> 00:36:09,848
E un'ultima cosa prima di dimenticare,

441
00:36:09,848 --> 00:36:18,140
dovremmo dire DishRouter.use (BodyParser.JSON ()).

442
00:36:20,326 --> 00:36:23,852
Ora, una volta completata l'implementazione del DishRouter,

443
00:36:23,852 --> 00:36:26,130
possiamo ora andare nel file index.js.

444
00:36:26,130 --> 00:36:34,020
Poiché questo DishRouter è un altro modulo nodo, un modulo nodo fine tuttavia.

445
00:36:34,020 --> 00:36:38,120
Quindi abbiamo bisogno di importare questo nella nostra applicazione.

446
00:36:38,120 --> 00:36:44,250
Quindi proprio qui, ho intenzione di importare const

447
00:36:46,000 --> 00:36:52,100
DishRouter è uguale a richiedere.

448
00:36:52,100 --> 00:36:56,626
Ora, poiché questo è un modulo nodo basato su file,

449
00:36:56,626 --> 00:37:03,000
dirò. /Routes/DishRouter.

450
00:37:03,000 --> 00:37:09,850
E una volta che li ho dichiarati lì, allora scendo nel codice qui.

451
00:37:09,850 --> 00:37:14,230
E proprio lì, dico app.use.

452
00:37:14,230 --> 00:37:19,130
E monto il router su un endpoint.

453
00:37:19,130 --> 00:37:20,930
Quindi, come faccio a montare il router?

454
00:37:20,930 --> 00:37:25,790
Il primo parametro qui, specificherò piatti barra.

455
00:37:25,790 --> 00:37:29,480
E il secondo parametro, specificare DishRouter.

456
00:37:30,810 --> 00:37:31,830
E questo è tutto.

457
00:37:31,830 --> 00:37:35,080
Quindi ciò significa che nella mia applicazione espressa,

458
00:37:36,205 --> 00:37:41,435
qualsiasi richiesta che arriva a quell'endpoint di piatti barra sarà gestita da DishRouter,

459
00:37:41,435 --> 00:37:45,615
e questo sarà fatto dal codice che è presente qui,

460
00:37:45,615 --> 00:37:50,755
perché abbiamo detto percorso DishRouter, e quindi notare che questo dice barra,

461
00:37:50,755 --> 00:37:54,575
quindi il che significa che questo è montato al punto finale dei piatti della barra.

462
00:37:54,575 --> 00:37:59,378
Ecco perché tutto ciò che arriva attraverso piatti di taglio verrà inviato a questo e

463
00:37:59,378 --> 00:38:00,890
sarà gestito da questo.

464
00:38:02,730 --> 00:38:07,000
Un grande suggerimento per pensare a come implementare

465
00:38:07,000 --> 00:38:11,020
quel punto finale dell'id piatto del colon.

466
00:38:11,020 --> 00:38:16,440
Userai comunque lo stesso file dishRouter.js per implementare anche il supporto per

467
00:38:16,440 --> 00:38:21,670
questo, /dishes/:punto finale dishID.

468
00:38:21,670 --> 00:38:24,580
E' un altro grande suggerimento per te, ok?

469
00:38:24,580 --> 00:38:29,260
Con queste modifiche, salviamo le modifiche che abbiamo fatto

470
00:38:29,260 --> 00:38:33,870
alla nostra applicazione e poi riavviare il nostro server e

471
00:38:33,870 --> 00:38:37,480
poi dare un'occhiata a come il nostro server sta andando a fare il suo lavoro.

472
00:38:38,850 --> 00:38:44,190
Andando al terminale, fammi riavviare quel server digitando npm start.

473
00:38:44,190 --> 00:38:47,340
E una volta che il server è attivo e funzionante, andrò al postino e

474
00:38:47,340 --> 00:38:50,220
invierò richieste dal postino a questo server.

475
00:38:51,220 --> 00:38:57,110
Andando al postino, ora so che il mio server supporta solo

476
00:38:57,110 --> 00:39:01,690
il punto finale piatti, ho implementato la parte ID piatto di esso.

477
00:39:01,690 --> 00:39:05,570
Quindi lasciami inviare una richiesta di ottenere ai piatti di accoglienza locali e

478
00:39:05,570 --> 00:39:08,590
vedrai che funziona esattamente come prima.

479
00:39:08,590 --> 00:39:12,910
Ora, se hai fatto una richiesta precedente nel post, puoi semplicemente fare clic su quello e

480
00:39:12,910 --> 00:39:15,150
quindi inviare nuovamente quella richiesta.

481
00:39:16,940 --> 00:39:26,680
Put operazione non funziona, post operazione, Funziona come vedi lì.

482
00:39:26,680 --> 00:39:32,370
E poi facciamo in modo che l'operazione di cancellazione sui piatti.

483
00:39:32,370 --> 00:39:36,210
E dice di cancellare tutti i piatti come previsto.

484
00:39:36,210 --> 00:39:45,230
Quindi questa è l'implementazione del supporto API resto utilizzando il router express.

485
00:39:45,230 --> 00:39:48,950
Con questo, completiamo la seconda metà di questo esercizio.

486
00:39:48,950 --> 00:39:54,490
Questo è un buon momento per voi per fare un commento get con il router di messaggio espresso.

487
00:39:55,830 --> 00:40:00,896
Ora che abbiamo completato questo esercizio in cui abbiamo visto come Express può

488
00:40:00,896 --> 00:40:06,450
essere utilizzato per supportare l'implementazione del supporto del punto finale Res API sul nostro server,

489
00:40:06,450 --> 00:40:08,900
e anche l'uso del router Express,

490
00:40:08,900 --> 00:40:13,906
è il momento di passare alla prima assegnazione che segue questa lezione.

491
00:40:13,906 --> 00:40:20,030
[ MUSIC]