Wie wir aus dem vorherigen Vortrag in dieser Lektion verstanden haben,
besteht unser Ziel in dieser Lektion darin,
den bereits entwickelten REST-API-Server
zusammen mit dem Zugriff auf die MongoDB-Datenbank zu integrieren.
Wir beginnen also mit dem REST-API-Server
, den wir in der allerersten Lektion in diesem Modul erstellt
haben, und nachdem wir gelernt haben, wie wir von
unserer Knotenanwendung mit Mongoose zum MongoDB-Server interagieren,
werden wir unseren REST API-Server weiter entwickeln, um
den gesamten Pfad zwischen der Clientanforderung, die in den Server kommt,
bis zur entsprechenden Datenbankoperation, die ausgeführt werden soll,
und dann das Erstellen und Senden der Antwort an diesen Client von unserer Server-Site.
Um zu beginnen,
gehen Sie natürlich zuerst zu dem Verwirrungsserver-Ordner, den wir bereits in
der ersten Übung dieses Moduls in der REST-API-Lektion erstellt haben
, und dann
haben wir im Verwirrungsordner bereits den REST-API-Server aufgebaut.
Nun, was wir tun würden, ist,
die Modelle zu leihen, die wir in der vorherigen Übung entwickelt haben,
die Datei dishes.js, die wir in der vorherigen Übung entwickelt, in
das Verwirrungsserver-Projekt kopiert haben,
und auch Bluebird Mongoose installieren,
und ein anderes Modul namens Mongoose Währung, zu unserem Projekt.
Also, wenn wir zu unserem Knoten JS-Ordner gehen,
gehen wir zuerst in den Knoten Mongoose Ordner,
und wir sehen, dass
wir im Unterordner des Knotens Mongoose Ordner die Datei dishes.js haben.
Ich werde nur den Models-Ordner kopieren
und dann zum Verwirrungsserver-Ordner gehen
und dann einfach den Models-Ordner darin durchstechen.
Also, sobald wir das tun,
dann ist die Datei dishes.js, die das Schema und das Modell für das Geschirr Dokument enthält,
in unseren REST API-Server integriert.
Um dies zu nutzen,
müssen wir natürlich das Mongoose-Knotenmodul
und ein neues Knotenmodul, das als Mongoose-Währung bezeichnet wird, in unser Projekt installieren.
Gehen Sie also zum Terminal im Confusion-Server-Projekt,
stellen Sie sicher, dass sich Ihr Terminal oder das Befehlsfenster
im Confusion-Server-Projekt befindet, in dem Sie die REST-API früher entwickeln,
und lassen Sie uns in diesem Projekt installieren.
Also, wir tun npm installieren Mongoose,
und dann, ein neues Knotenmodul als Mongoose Währung genannt.
Das Mungo Währungsknotenmodul,
und in anderen Schema-Typ zu unserer Mungo Anwendung gesehen,
so dass die Mungo selbst,
hat sicherlich bereits integrierte Schema-Typen.
Wir haben die Verwendung der Zahl, der
Zeichenfolge und der Boolean, und das Array gesehen.
Jetzt fügt die Mungo Währung zur Unterstützung der Währung hinzu.
Warum sollten wir diese Währungsunterstützung brauchen?
So dass Mongoose Währungsmodul fügt einen neuen Typ als Währungstyp genannt,
die uns ermöglicht, einen Währungswert zu speichern.
Da unser Gericht einen Preis enthalten
wird, werde ich deshalb hier das Mongoose-Währungsmodul verwenden.
Nun, die Übung hier,
werden wir die Verwendung des Mongoose-Währungsmoduls veranschaulichen,
Sie können mehr Details über das Mongoose-Währungsknotenmodul lesen, auch
in der Dokumentation, dass ein Link zu dem in den zusätzlichen Ressourcen zur Verfügung gestellt wird.
Also, jetzt, da wir diese Knotenmodule installiert haben,
Mongoose und Mongoose Währung,
lassen Sie uns zu unserer Anwendung gehen und es einrichten, um mit dem MongoDB-Server zu kommunizieren. Stellen
Sie nun sicher, dass Ihr MongoDB-Server betriebsbereit ist.
Hier sehen Sie, dass
mein MongoDB-Server in einem anderen Terminal Tab auf meinem Computer läuft.
Wenn Sie es auf einem Windows-Computer ausführen,
stellen Sie sicher, dass es in einem anderen Befehl Fenster Ihres Windows-Computers ausgeführt wird. Wenn wir
zu unserer Anwendung im Editor gehen,
werden wir zuerst mit der Datei app.js beginnen.
Jetzt in der Datei app.js,
hier haben wir unsere Express-Anwendung früher aufgebaut.
Aber jetzt ist diese zusätzliche Suck-Negation nicht mit dem Back-End-MongoDB-Server verbunden.
Wir werden das Mongoose-Modul nutzen,
um die Verbindung mit dem Server herzustellen.
Also, hier reingehen,
werde ich das Mungo Modul hier hinzufügen.
Also sagen wir: „Const Mongoose braucht Mungo.“
Und dann auch, da wir über den Models-Ordner kopiert haben,
der die Gerichte Datei enthält,
die das Geschirr Schema und das Modell deklariert.
Also, lassen Sie mich das Geschirr importieren.
Also, wir werden sagen, „erforderlich.Slash Modelle Gerichte.“
Also, sobald wir das abgeschlossen haben,
müssen wir jetzt natürlich die Verbindung mit dem Server herstellen.
Also, richten Sie
URL mongodb// localhost7017/Verwirrung,
genau wie wir es mit der Mungo Übung getan haben,
und dann werden wir sagen,
„Const connect, Mongos connect URL“.
Dies ist also genau der gleiche Code, den wir in der vorherigen Übung verwendet haben.
Dann stellen wir die Verbindung her.
Also, wir werden sagen, „connect“ und dann sagen wir,
„DB tun es Konsolenprotokoll.“
Sprich: „Richtig mit dem Server verbunden“.
Und wir werden auch den Fehler hier behandeln.
Wir werden einfach ein Konsolenprotokoll des Fehlers hier machen, das war's.
Dadurch wird die Verbindung zum Server aus unserer Datei app.js hergestellt.
Also, sobald wir die Verbindung zum Server hergestellt
haben, öffnen wir die Datei dishes.js von unseren Modellen.
Jetzt, in der Datei dishes.js,
um
das Knotenmodul zu verwenden, das wir gerade installiert haben.
Also sagen wir: „Erfordert Mungo Währung“ und sagen:
„Lade den Typ und Mungo.“
Also, was das tun wird, ist, diesen neuen Währungstyp in Mongoose zu laden.
Danach können wir sagen const,
Währung Mongoose Typen Währung.
Das war's. Also, dieser neue Typ,
der Währungstyp wird in Mungo hinzugefügt und das wird in einem neuen Typ namens
Währung hinzufügen und dann werde ich
diese konstante Währung als die Mungo Typen Währung deklarieren.
Damit ich dies bei der Definition des Schemas in meiner Anwendung nutzen kann.
Nun, in diesem Fall
bleibt das gemeinsame Schema genau das gleiche wie zuvor, aber
das Dish-Schema, wie Sie sich aus der Datei db.json erinnern.
Wenn Sie sich die Struktur eines Geschirrdokuments ansehen,
sehen Sie, dass das Dokument den Namen und das Bild enthält, das, wie Sie hier sehen, eine Zeichenfolge,
eine Kategorie, ein Etikett,
ein Preis ist, der hier ein String-Typ ist.
Aber wir werden dies als Währungstyp deklarieren,
ein Feature, das, wie Sie erwarten, ist eine boolesche Variable,
und eine Beschreibung, die eine Zeichenfolge ist und dann Kommentare
, die nichts anderes als ein Array von Kommentaren Typ ist.
Nun, was wir jetzt tun werden, ist, das Dish-Schema zu erweitern, um
all diese verschiedenen Eigenschaften oder verschiedene Felder in meinem json-Dokument zu unterstützen.
Also haben wir schon den Namen.
So haben wir bereits die Beschreibung an Ort und Stelle.
Also müssen wir in den nächsten paar dort hinzufügen, haben wir bereits die Kommentare,
das Array von Kommentaren des Kommentarschematyps gibt.
Also werden wir in den nächsten paar hinzufügen.
Der nächste, den wir hinzufügen werden, ist der Bildtyp
,
der vom Typ String sein würde und
wir sagen, erforderlich wahr.
Dies fügt also den Bildtyp hinzu.
Die nächste, die ich hinzufügen werde, ist Kategorie,
die auch der String-Typ ist.
Die nächste ist die Bezeichnung,
die auch dieser String-Typ ist.
Da alle diese vom gleichen Typ sind und benötigt werden,
kopiere ich sie hier rein.
Dann
würde ich für das Label sagen, dass dies nicht erforderlich ist, aber
stattdessen kann ich auch einen Standardwert angeben, wenn ich möchte.
So kann ich einen Standardwert wie diesen angeben.
Der Standardwert ist eine leere Zeichenfolge.
Also, wenn ich nicht erforderlich spezifiziere, kann ich hier einfach einen Standardwert angeben.
Nun, das nächste Feld, das ich einführen werde, ist das Preisfeld.
Das Preisfeld Ich deklariere den Typ als Währung.
Erinnern Sie sich, dass wir den Währungstyp früher
hier deklariert hatten, indem wir zuerst
das Währungsmodul Mongoose und dann den Währungstyp deklarieren.
Also, so würden Sie den Währungstyp in unserer Anwendung verwenden.
Also werden wir sagen, Preisart Währung und
erforderlich ist wahr und dann kann ich auch den Mindestwert angeben, der Null wäre.
Dann ist das nächste Feld
das Featured Feld, das vom Typ Boolean sein würde,
und der Standardwert ist false.
Also, wenn mein Dokument das fehlt,
dann wird der Standardwert hier in das Dokument eingefügt.
Beachten Sie also, dass ich nun
das Schema-Schema erweitert habe, indem ich den Bildtyp, die Kategorie, das
Etikett, den Preis und die Funktion hinzufüge, um
die Struktur des Dokumentbeispiels, das ich Ihnen gerade gezeigt habe, übereinstimmte.
Also jetzt, mein Geschirr Schema ist alles bereit, verwendet zu werden.
Also, lasst uns jetzt anfangen, an meinem Router zu arbeiten.
Also, wo ist der Router?
Sie erinnern sich, dass der Router, der die REST-API-Endpunkte für die Schrägschrägschalen,
REST-API-Endpunkt und
Schrägschrägschüssel-ID-Endpunkt unterstützt, im Dish Router ist.
Also, wir werden zu Gericht router.jsfile gehen und dann werden wir das Gericht router.js Datei erweitern.
Also, im Dish Router zusammen mit Express und BodyParser,
werde ich jetzt Mongoose einschließen.
Also werden wir sagen, erfordern Mungo und
dann werden wir Gerichte Modell benötigen.
Wo ist das Geschirr Modell?
Es ist drin. /Modelle/Geschirr.
Also ist es da drin.
Beachten Sie also, dass wir uns im Ordner des Routers befinden,
also müssen Sie eine Ebene nach oben gehen und dann in
den Ordner des Modells gehen und dann ist die Datei dishes.js genau dort.
Das ist es, was wir hier importieren.
Jetzt kann ich meinen Dish Router aktualisieren, um
mit dem MongoDB-Server mit
Mongoose interagieren zu können und wir haben das Geschirr Modell bereits in meinen Geschirrrouter importiert.
Also, es ist Zeit für mich zu gehen und alle Methoden hier zu aktualisieren.
Also für den Teller Router,
der Schrägstrich, was bedeutet, dass der Schrägstrich Geschirr Endpunkt.
Ich werde das alles von hier entfernen, stattdessen
werde ich alle verschiedenen Endpunkte explizit deklarieren.
Um Post setzen und löschen zu lassen, werde ich jeden von ihnen unabhängig behandeln.
Also in der Get-Methode
werde ich das ausschneiden und dann in der Get-Methode, was muss ich tun?
Daran erinnern, dass wir Methode von Mongoose definiert hatten, die uns erlaubt, alle Gerichte zu finden.
Wenn Sie also eine Get-Operation auf dem Schrägschrägschüssel-Endpunkt durchführen,
erwarten Sie, dass alle Gerichte
an den Client als Antwort auf die Get-Anfrage zurückgegeben werden.
Also werde ich zum Geschirr gehen und dann die Suchoperation durchführen.
Jetzt sehen Sie, dass
ich von meinem Express-Server auf meine MongoDB zugreife.
Also, wird eine Suche machen und in der Suche werde ich jetzt die Anfrage behandeln.
Also kann ich sagen, Gerichte finden,
da das ein Versprechen zurückgeben wird,
dann kann ich das hier drinnen regeln.
Also, ich werde sagen Gericht und so, wenn das Versprechen richtig aufgelöst wird,
werde ich es in der dann bekommen und so werde ich sagen Gericht und dann werden wir res
Statuscode behandeln 200 und dann sagen wir
res set Header Inhaltstyp.
Da wir den Wert als JSON zurückgeben werden,
setzen wir das auf Anwendung json.
Okay, das wird eine Reihe von Gerichten zurückgeben.
Also kann ich einfach Gerichte sagen und dann sagen wir res.json.
Also wird die res.json als Eingabe in json-Zeichenfolge nehmen
und sie dann an meinen Client zurücksenden.
Also, wenn Sie res.json aufrufen und den Wert angeben und dann wird es einfach
den Parameter nehmen, den Sie hier geben, und dann senden Sie ihn als JSON-Antwort zurück.
Es wird dieses Geschirr in den Text
der Antwortnachricht geben und dann an den Server zurücksenden.
Jetzt können wir den Fehler
hier behandeln, indem wir nächsten Fehler sagen.
Wir können auch einen Catch-Fehler nur aus Gründen der vollständigen tun.
Ich werde hier nur beides einführen,
damit beide als solches behandelt werden.
Wenn also ein Fehler zurückgegeben wird
, wird der Fehler einfach an
den allgemeinen Fehlerbehandler für meine Anwendung übergeben
und sich darum kümmern, wie mit dem Fehler umzugehen ist.
Also werden wir es dahin schicken.
Sie sehen also, wie ich die Suchoperation verwende und dann die Anfrage hier durchführe.
Nun, für den Beitrag,
wie Sie bereits erwartet hätten,
werde ich dishes.create tun,
weil wir hier ein neues Gericht erstellen werden.
Also, erinnern Sie sich, dass wir bereits gesehen haben, dass die Gerichte die
Methodenverwendung früher erstellen und denken Sie daran, dass der Body
Parser bereits alles analysiert hätte, was sich im Körper der Nachricht befindet und es
auf die Körpereigenschaft der Anfrage geladen hat.
Also, ich werde nur den Anforderungskörper nehmen und ihn dann als Parameter für meine
dishes.create-Methode analysieren und den Rückgabewert behandeln.
Also, dann sagen wir, und das würde
ein Gericht zurückgeben und wir werden das hier drinnen erledigen.
Also werden wir sagen, wenn das Geschirr richtig zurückkehren und wenn Gerichte richtig geschrieben, wird es sagen.
Okay, lasst uns eine console.log für unsere eigene Verwendung machen.
Auf der Server-Seite werden wir hier ein console.log sagen „Dish Created“ Gericht machen.
Lassen Sie uns das Gericht in die Konsole einloggen und dann sagen wir diese beiden Ruhestatus-Code.
Wir kopieren einfach diesen Code und fügen ihn dort ein und in diesem Fall
geben wir das Gericht zurück.
Das Gericht, das hier als Parameter hereingekommen ist und dann
den Kunden mit diesem Wert auf der Client-Seite umgehen lassen,
was auch immer in der Schüssel zurückgegeben wird.
Nun, auch sie werden in
diesem hier und dann den Fang hinzufügen.
So behandeln wir die Post.
Für die PUT, weil PUT nicht erlaubt ist,
so werden wir es als solche verlassen.
Für DELETE werden wir alle Gerichte löschen.
Also sagen wir: „Gerichte.Entfernen.“
Dies ist im Wesentlichen eine gefährliche Operation.
So entfernen Sie alle Gerichte vom
Server und so werden wir sagen,
„Gerichte.Entfernen Sie dann“ und die „dann“ wird eine Antwort zu bekommen.
Also werden wir einfach sagen, „resp hier“ und die Art und Weise, wie wir mit
dieser Antwort umgehen würden, ist einfach, diesen Wert zu nehmen und ihn dann an den Client zurückzugeben.
Also werden wir sagen, „Res.StatusCode 200 Inhaltstyp Anwendung json“, und
dann senden wir einfach die Antwort zurück an den Client und wir werden den Fehler
wie zuvor behandeln.
Das ist der DELETE-Vorgang.
Sie sehen also, dass wir jetzt die GET,
POST, PUT und die DELETE-Operation machen.
Jetzt werden wir das gleiche mit dem Endpunkt /dishid fortsetzen.
Also in diesem Fall
sind wir speziell Motiv, ein bestimmtes Gericht zu bekommen.
Wir werden diesen spezifischen Wert zurückgeben.
Also in der GET,
was wir tun, ist, dass wir sagen „dishes.findById.
Die FindById ist also eine Methode, die sowohl vom MongoDB-Treiber als auch vom MongoDB-Treiber zur Verfügung steht.
Also sagen wir:“ Req.params.dishid.“
Daran erinnern, dass wir bereits wissen, dass die Schale ID in der params Eigenschaft vorhanden ist.
Sie haben bereits früher davon erfahren.
Also werde ich sagen, „findById (req.params.dishid)“ und
dann und das andere.
Also werde ich das dann und sonst von
dort kopieren und dann runter zum DishRouter kommen und
das dann einfach hier einfügen.
Also sagen wir, "res.StatusCode200
Anwendung json.res.jsondish und dann die Fehlerbehandlung.
Für den POST werden wir natürlich nicht den Beitrag für einen /dishid-Endpunkt behandeln.
Also werden wir es als solche verlassen.
Für PUT werden wir
ein bestimmtes Gericht aktualisieren, das durch seine Schalen-ID identifiziert wird.
Dies ist also, wo wir dishes.findByIdandUpdate verwenden.
Dies ist also die Methode, die wir verwenden werden,
findByIdanduUpdate und dies nimmt als erster Parameter
req.params.dishid und der zweite Wert ist
der Satz und das Update
wird im Hauptteil der Nachricht sein.
Also werde ich das einfach aus
dem Req-Körper abrufen und dann auch die andere Flagge, die ich haben werde.
Also wird sagen, „new: true“, so dass diese FindById-Methode
das aktualisierte Gericht als JSON-Zeichenfolge in der Antwort zurückgibt.
Also, das ist, was ich hier bekommen werde, und wenn dieser Wert kommt,
werde ich einfach das Gericht nehmen und
dann einfach das Gericht an die Kundenseite zurückgeben.
Also werde ich res.jason (Gericht) sagen und dann werden wir den Fehler entsprechend behandeln.
Endlich für die DELETE.
Für die DELETE wieder
ist die entsprechende Methode, die wir verwenden werden, die Mongo-Methode namens FindByIdAndRemove.
So können Sie sehen, dass wir diese Methode namens
findByIdAndRemove und diese findByIdAndRemove haben,
wird req.params.dishid nehmen, weil das das Gericht ist, das wir zu entfernen versuchen.
Dann, wenn dies gelöscht wird,
so genau wie wir dies hier behandelt haben,
also werde ich nur diesen Code aus den Gerichten zu kopieren.Entfernen.
Ist das Gleiche, was ich auch hier tun werde.
Also FindByIdAndRemove und welche Antwort ich bekomme,
werde ich es an meinen Client zurückgeben.
Damit haben wir den DishRouter aktualisiert.
Lassen Sie uns alle Änderungen speichern, die wir
bisher gemacht haben, und dann gehen wir und starten unseren Server und sehen dann, was er tut.
Gehen Sie also zum Terminal oder zum Befehlsfenster, starten Sie den Server.
Also werde ich sagen „npm start“ und der Server ist jetzt einsatzbereit.
Wir werden den Postboten benutzen, um mit diesem Server zu kommunizieren.
Gehen wir also zum Postboten und führen dann bestimmte Operationen durch.
Hier siehst du meinen Postboten hier rauf und rennt.
Lassen Sie mich also eine GET-Operation auf dem localhost machen: 3000/Gerichte.
Wenn Sie also eine GET-Operation ausführen, wie Sie sehen,
wird eine leere Zeichenfolge zurückgegeben.
Meine Datenbank ist jetzt leer, so dass ich nichts dort habe.
Also werde ich nur eine leere Zeichenfolge zurückgegeben werden.
Lassen Sie uns ein Gericht posten.
Also, wenn Sie ein Gericht veröffentlichen,
offensichtlich im Körper,
werden Sie ein Gericht umschließen und der Körper wird auf den Anwendungs-JSON-Typ eingestellt.
Nun, um ein Gericht zu posten,
habe ich Ihnen bereits die Datei db.json in den Übungsressourcen gegeben.
Öffnen Sie einfach die Datei db.json und kopieren Sie dann das erste Gericht von
dort und dann fügen wir es hier ein und posten Sie das Gericht.
Also, lassen Sie mich zur Datei db.jason gehen.
Lassen Sie mich das allererste Gericht von hier kopieren.
Also werde ich nur
das ganze Gericht den ganzen Weg bis dorthin kopieren und dann werde ich dieses Gericht posten.
Dies enthält viele der Felder, die wir hier bereits haben.
Lassen Sie uns dieses Gericht auf dem Server posten und sehen, was passiert.
Also komm zurück zum Postboten.
Hier, in den Formulardaten,
im Körper, lassen Sie mich das Gericht an Ort und Stelle einfügen.
Also, wir haben die vollständigen Details des Gerichts dort.
Lassen Sie uns dieses Gericht auf den Server POSTEN.
Dann, sobald das Gericht auf dem Server veröffentlicht wurde,
sehen Sie, dass der Postman hat,
lassen Sie mich dies einfach verkleinern,
und dann sehen Sie unten, dass dieses spezielle Gericht
von meinem Server in die Datenbank, in die MongoDB-Datenbank gepostet wurde.
Sie sehen also, dass der zurückgegebene Wert
hier zeigt, wann das Gericht in diesen Server eingefügt wurde.
Sie haben also die CreateDat und UpdateDat hinzugefügt.
Sie sehen, dass alle verbleibenden Felder dort gespeichert sind.
Beachten Sie insbesondere, wie der Preiswert dort gespeichert wird.
Auf diese Weise speichert die Währung den Preiswert.
Wenn Sie also den Rückgabewert erhalten,
müssen Sie dies auf Ihrer Clientseite entsprechend interpretieren, was das bedeutet.
Beachten Sie auch, dass die ID zu meinem Gericht hinzugefügt wurde und für jeden Kommentar selbst,
da jeder der Kommentare selbst ein Unterdokument ist.
Sie werden die UpdateDat und CreateDat hinzugefügt,
und die ID für jeden der Kommentare werden ebenfalls automatisch von meiner Datenbank hinzugefügt.
Da gehst du. Nun
wurde dieses Gericht meiner Datenbank hinzugefügt.
Lassen Sie uns erneut die GET-Operation durchführen,
und offensichtlich
sollte der Server an diesem Punkt das eine bestimmte Gericht zurückgeben, das hinzugefügt wurde.
So wird es hier eine Reihe von Gerichten zurückgeben,
so wie Sie sehen können, gibt es eine Reihe von Gerichten zurück.
Natürlich enthält dieses Array nur ein Gericht
oder dieses spezielle Gericht wurde hierher zurückgegeben.
So weit, so gut.
Also, lasst uns einen PUT auf das Geschirr machen und sehen, was passiert.
Wenn Sie eine PUT tun, offensichtlich, es sagt,
„PUT-Operation nicht auf Geschirr unterstützt“, wie wir erwarten.
Lassen Sie uns ein DELETE machen.
Wenn Sie eine DELETE-Operation ausführen,
gibt es diese Antwort zurück, die besagt:
„N ist gleich eins“, okay,
eine bedeutet, dass es ein Gericht gelöscht hat.
Lassen Sie uns jetzt wieder eine GET-Operation durchführen,
und dann würden Sie sehen, dass mein Geschirr leer ist, wie wir erwartet haben.
Sie sehen also, dass die
Operationen GET, PUT, POST und DELETE korrekt funktionieren.
Nun, lassen Sie mich das Gericht wieder
auf den Server posten, weil ich ein Gericht im Server haben möchte.
Also, lassen Sie mich dieses Gericht POSTEN,
und Sie würden feststellen, dass sich die ID jetzt geändert hat.
Also, lassen Sie mich diese ID auswählen,
und dann werden wir ein GET mit der ID an Ort und Stelle tun.
Wenn Sie ein GET mit der ID durchführen,
sehen Sie, dass es dieses spezifische Gericht wie erwartet zurückgibt.
Gehen wir zum Terminal und sehen, was
auf dem Terminal oder Ihrem Befehlsfenster gedruckt wird. Wenn Sie
also zum Terminal oder zu Ihrem Befehlsfenster gehen,
sehen Sie, dass es all diese Dinge im Befehlsfenster ausdruckt.
Also, als wir die erste GET-Operation gemacht haben,
heißt es, GET /Gerichte.
Also, das ist wieder,
Morgan macht diese Arbeit für Sie, es druckt aus,
verfolgt diese Informationen und es sagt,
dass Gericht erstellt wurde und dann diese spezielle Gericht Information gedruckt wurde,
und dann sagt es POST/Gerichte, GET /Gerichte,
und dann, wenn Sie einen PUT gemacht haben, gab es eine 403
dort zurück und du hast wieder Gerichte erstellt und so weiter.
Sie sehen also, dass Ihr Server tatsächlich die ganze Arbeit macht,
und diese Dinge werden wie erwartet in Ihre MongoDB-Datenbank eingefügt.
Nun, zurück zum Postboten,
lassen Sie uns einen POST über das Geschirr machen.
Dies wird auf der Serverseite nicht unterstützt,
daher sollte Ihr Server sagen:
„POST-Operation wird auf diesem bestimmten Endpunkt nicht unterstützt“, wie Sie es vielleicht erwarten.
Lassen Sie uns eine PUT-Operation machen.
Wenn Sie eine PUT-Operation ausführen,
was ich in der PUT-Operation tun werde, ist, dass ich
das Etikett dort ersetzen werde.
Also, in meinem Körper der Nachricht. Denken Sie
daran, dass, wenn Sie sich die Datei db.json ansehen,
das Label dafür neu wäre,
und daher werde ich dieses Label in heiß ändern.
Da dies in Json sein muss,
so beschriften Sie auch in Anführungszeichen Json Label hot,
und dann lassen Sie uns einen PUT auf diesem bestimmten Endpunkt machen.
Der PUT-Vorgang war erfolgreich,
und Sie sehen, dass, wenn der PUT-Vorgang ausgeführt wurde,
dann würden Sie feststellen, dass die Beschriftung jetzt von neu zu heiß hier geändert wurde,
und beachten Sie insbesondere den
CreateDat-Wert und den UpdateDat-Wert.
Beachten Sie also, dass dieser Datensatz
zu diesem Zeitpunkt erstellt wurde und ein wenig später aktualisiert wurde.
Also, das Update wurde durch die PUT-Operation durchgeführt, die ich gerade
an diesem bestimmten Gericht durchgeführt habe.
Lassen Sie uns das Gericht löschen.
Das ist erlaubt. Also, wir werden das Gericht löschen,
und dann wird das Gericht gelöscht und der Wert wird zurückgegeben.
Wenn Sie nun eine GET-Operation auf dem
Endpunkt der Gerichte durchführen, werden Sie sehen, dass dies eine leere zurückgibt.
So haben Sie es gerade geschafft, das Gericht aus unserer Datenbank zu löschen.
Was ich tun werde, ist
eine GET-Operation an einem nicht vorhandenen Gericht durchzuführen und zu sehen, was passiert.
Wenn ich eine GET-Operation auf nicht vorhandenem Gericht durchführe,
gibt es null zurück, da dieses Gericht nicht existiert.
Es gibt also einen Nullwert zurück, der besagt, dass das Gericht nicht existiert.
Lassen Sie mich nun eine GET-Operation für eine Nicht-ObjectID ausführen und sehen, was passiert.
Es kehrt zurück, wie Sie sehen.
Lassen Sie mich eine Vorschau darauf.
Also, es heißt: „Die Umwandlung in ObjectID ist für den Wert hier am Pfad fehlgeschlagen.“
Also, ich werde offensichtlich sein, dass dies keine
gültige ObjectID ist, also habe ich es gerade geschafft, einen Teil davon zu löschen
und dann den Vorgang auszuführen, so dass es einen Fehler gibt, der besagt,
so dass Sie sehen, dass es 500 interne Serverfehler gibt.
Der Server konnte dies nicht verarbeiten und dann diesen Wert hier zurückgeben.
Es heißt also: „Nein,
das ist nicht erlaubt.“
Also, weil das keine gültige ObjectID ist.
So werden auch Fehler entsprechend behandelt, wie Sie hier sehen.
Also, lassen Sie mich noch einmal, machen Sie eine GET-Operation auf dem Geschirr,
und Ihr Server läuft immer noch,
und es wird hier einen leeren Wert zurückgeben.
So haben wir gesehen, wie wir
unseren REST API-Server geändert haben, um mit dem MongoDB-Server interagieren zu können.
Wir haben jetzt einen vollwertigen REST-API-Server, der in der Lage ist,
verschiedene Operationen
auf den Daten zu speichern, abzurufen und auszuführen, die auf meinem MongoDB-Server gespeichert sind.
Damit schließen wir diese Übung ab.
In dieser Übung
haben wir gesehen, wie wir in der Lage sind, mit unserem REST-API-Server
und wiederum mit dem MongoDB-Server zu interagieren,
und dann nutzen wir den MongoDB-Server, um Daten vom Server zu speichern und abzurufen.
Sie können mit
Mongoose von unserer Express-Anwendung aus mit dem MongoDB-Server interagieren.
Dies ist ein guter Zeitpunkt für Sie, ein GIT Commit mit der Meldung
„Express REST API with Mongoose Part One“ durchzuführen.