Nun, da wir einen schnellen Überblick über Mongoose ODM hatten und
wie Mongoose Schemas bringt, um die Dokumente zu strukturieren, die wir in unserer MongoDB speichern,
schauen wir uns an, wie wir
das Mongoose Knotenmodul nutzen und es dann in unsere Knotenanwendung integrieren.
Dann verwenden Sie Mongoose, um mit
unserem MongoDB-Server zu kommunizieren und dann
Dokumente mit Strukturinformationen in den Dokumenten zu speichern und abzurufen.
Um mit dieser Übung zu beginnen,
wechseln Sie zu einem geeigneten Speicherort auf Ihrem Computer.
Also, hier bin ich im Node JS-Ordner, in
dem ich alle Beispiele aus diesem Kurs gespeichert habe und dann werde ich
einen neuen Ordner namens Knoten Mongoose erstellen.
Dies ist, wo wir die Knotenanwendung mit Mongoose als nächstes erstellen.
Wechseln Sie im Terminal oder im Befehlsfenster zum Knoten Mongoose Ordner und initialisieren Sie dort eine Knotenanwendung.
Also, lassen Sie mich npm init eingeben und dann
die Knotenanwendung initialisieren und dann würde ich die Anwendung
als Node-mongoose benennen und der Einstiegspunkt ist index.js git history,
Schlüsselwörter, Autor und Lizenz und wir werden sagen, okay.
Sobald Ihre Knotenpackage.json-Datei erstellt wurde,
öffnen Sie das Projekt im Texteditor Ihrer Wahl.
Also, hier habe ich mein Projekt in Visual Studio geöffnet.
Lassen Sie mich in die package.json-Datei gehen und fügen Sie dann
das Startskript hinzu und dann
sagen wir, Startknotenindex wie üblich, wenn wir mit einer neuen Knotenanwendung beginnen.
Dann, wenn wir zum Terminal oder zum Befehlsfenster gehen, installieren wir Mongoose. Geben
Sie also an der Eingabeaufforderung npm install Mongoose ein, speichern Sie.
Was im Moment Mongoose 5.1.7 ist.
Also, das sind die Versionen, die ich in diesem Kurs verwenden werde.
Dann gehe ich zu meiner Bewerbung im Editor.
Lassen Sie mich einen Unterordner im Projekt erstellen, der als Models bezeichnet wird.
Also, hier werde ich alle Modelle für meine Anwendung speichern.
Lassen Sie mich im Models-Ordner eine neue Datei namens dishes.js erstellen.
Also, hier werde ich das Schema und das Modell
für mein Geschirr Dokument erstellen, das ich speichern werde,
die Geschirr Sammlung, die die Dokumente für jedes Geschirr speichert.
Also, genau da, lass mich zuerst Mongoose importieren.
Also, wir benötigen Mongoose in dieser Datei und dann sagen
const Schema ist Mongoose Schema.
Dann erstellen wir das Schema hier.
Also, wir werden sagen const DishSchema neues Schema.
Also, hier definiere ich das Schema für mein Gericht.
Lassen Sie mich innerhalb dieses Schemas die verschiedenen Werte definieren.
Also, ich werde Name sagen,
was der Typ String ist.
Also, das ist der Schema-Typ und dann würde ich dies bei Bedarf deklarieren.
Also, ich sage wahr.
Also, jedes Dokument wird dort den Namen als Pflichtfeld haben und dann
werde ich dies auch als eindeutig deklarieren, was bedeutet, dass
keine zwei Dokumente das gleiche Namensfeld haben sollten.
Also, das ist das erste Feld in meinem Dokument.
Dann werden wir auch ein anderes Feld namens, Beschreibung.
Die Beschreibung ist vom Typ string und erfordert true.
Außerdem können wir Mongoose automatisch
Zeitstempel in unser Modell einfügen lassen.
Also, genau dort können wir einfach die Fahne Zeitstempel aufstellen: true.
Dies fügt automatisch die erstellten und aktualisierten bei,
zwei Zeitstempel in jedes Dokument, das
in unserer Anwendung gespeichert ist, hinzu und aktualisiert diese Werte automatisch.
Wann immer wir das Dokument aktualisieren und die erstellte bei wird automatisch
initialisiert werden, wenn das Dokument zum ersten Ersteller dieser Zeit ist.
Danach werden wir var Gerichte sagen.
Also, angesichts des Schemas,
jetzt werden wir das Modell aus diesem Schema zu konstruieren.
Also, wir werden sagen Mongoose Modell und Gericht,
und dies wird das Gericht Schema verwenden, das wir gerade früher erklärt haben.
Dann werden wir
dieses Modell aus dieser Datei hier exportieren.
Also, wir werden sagen Modul Export Gerichte.
Also, jetzt haben wir
das Mongoose-Schema und das entsprechende Modell konstruiert und das Modell wird jetzt von hier exportiert.
Dies kann also in unsere Anwendung importiert und verwendet werden.
Lassen Sie mich also in unserem Projektordner eine neue Datei namens index.js erstellen.
In der Datei index.js,
lassen Sie mich zuerst Mungo benötigen,
und dann können wir sagen,
const Gerichte erfordern Modelle Gerichte.
Weil wir bereits das Dishes Modell in
den Modellen Geschirr Datei dort erstellt haben und dann brauchen wir es hier.
Nun, um die Verbindung zum Mongo-Server herzustellen,
sagen wir const URL mongodb.
Localhost 27017, ConFusion.
Also, diese Datenbank ist diejenige, mit der wir von unserer Anwendung verbinden und
dann können wir die Verbindung herstellen, indem wir sagen const connect Mongoose.
Mongoose unterstützt diese Connect-Methode,
die die URL als ersten Parameter verwendet.
Also, wenn wir das festgestellt haben,
dann sagen wir einfach verbinden dann.
Beachten Sie, dass, da wir bereits Versprechen verwenden,
wir können einfach sagen, connect dann und dann wird dies
eine Funktion als Parameter nehmen
und im Inneren können wir uns jetzt mit der Datenbank verbinden.
Also jetzt, sobald diese Verbindung hergestellt ist,
lassen Sie mich ein Konsolenprotokoll tun,
das sagt, richtig mit dem Server verbunden ist,
und hier kann ich ein neues Gericht erstellen, indem ich var
new Dish und dann Dishes sage und innen hier kann ich ein Dokument angeben, so dass ich
ein neues Gericht dieser Art und dann so hier in Ich werde
die beiden Felder angeben, die erforderlich sind.
Also werde ich Name,
Beschreibung sagen und so würden Sie ein neues Gericht erstellen und dann, sobald wir
ein neues Dish aus dem Modell erstellen, sagen wir einfach neues Dish save.
Die Speichermethode wird dazu führen, dass dieser Dish-Wert
gespeichert wird und dann, wie Sie erwarten, wird ein Versprechen zurückgeben und
dann hier werden wir den Dish-Wert als Rückruf dort erhalten und dann
kann ich einfach den Dish-Wert hier protokollieren und dann danach sagen
wir Gerichte finden und so werden wir
alle Gerichte und dann sagen exec.
Die exec wird sicherstellen, dass dies
ausgeführt wird und dass es ein Versprechen zurückgibt und so dass das Versprechen
zurückgegeben wird, so dass es dann
die Methode an die verbleibenden verketten kann.
So sehen Sie, wie ich Versprechungen verwende und dann rufe ich die vorherige Methode auf, so dass diese
alle Gerichte in meiner Datenbank findet,
in der Dishes Sammlung und dann macht sie mir verfügbar.
Also, wenn ich die Gerichte bekomme, dann kann ich einfach die Gerichte einloggen, nur um zu sehen, was
zurückgegeben wird, und das sollte offensichtlich in diesem Stadium
dieses einzige Gericht zurückgeben, das ich in
meine Dishes Sammlung eingefügt habe und dann werden wir sagen
zurückkehren Gerichte mit
einem leeren JavaScript-Objekt entfernen , die alle Gerichte aus
der Datenbank entfernen und
Mungo Verbindung schließen, die die Verbindung zur Datenbank schließt.
Und fangen Sie jeden Fehler an diesem Punkt.
Also verwenden wir den Catch und dann das Konsolenprotokoll.
Das war's. Also, was wir hier tun, ist, dass wir das neue dieses Gericht kreieren und dann
retten wir das Gericht, dann finden wir alle Gerichte aus der Sammlung.
Das war's. Wir verwenden hier Versprechen,
also haben wir alle Höhlen hier drin angekettet. Das war's.
Lassen Sie uns die Änderungen speichern und dann sehen, wie diese Anwendung ausgeführt wird.
Gehen Sie in das Terminal, geben Sie
an der Eingabeaufforderung npm start ein und Sie werden
sehen, dass meine Knotenanwendung ausgeführt wird und dann
zuerst zeigt, dass es dieses spezielle Dish erstellt hat.
Beachten Sie insbesondere, dass diese beiden Felder, die
bei aktualisiert und erstellt wurden,
diese beiden Zeitstempel wurden
hier automatisch in das Dish hinzugefügt und so können Sie sehen, dass die erstellten und
aktualisierten Zeitstempel im Moment genau gleich sind und
dann die ID auch automatisch hinzugefügt wird in.
Im nächsten Schritt drucken wir alle Gerichte aus, die abgerufen wurden, und so
können Sie sehen, dass dieses einzige Gericht in der Sammlung ist,
Geschirr Sammlung, und das ist, was auf dem Bildschirm hier gedruckt wird.
Lassen Sie uns jetzt das Git-Repository initialisieren und dann lassen Sie uns die bekommene gitignore Datei einrichten,
so gehen wir zum Editor, dann erstellen wir die.gitignore Datei und fügen dann
Knotenmodule zur gitignore Datei hinzu und speichern Sie die Änderungen und
gehen dann zurück zu der Eingabeaufforderung lassen Sie mich
git status eingeben und wir sehen, dass
wir haben diese Dateien, die nicht eingecheckt wurden, also sagen wir
git add und git
commit der Nachricht Mongoose Part One.
Damit schließen wir diese Übung ab.
In dieser Übung haben wir gesehen, wie einfach es ist, eine Knotenanwendung mit
Mungo einzurichten und sich mit unserem MongoDB-Server zu verbinden und dann mit ihm zu interagieren.
Jetzt, da Mungo auf dem MongoDB-Server aufbaut,
kann Mongoose auf alle verschiedenen Methoden zugreifen
, die auch vom MongoDB-Treiber unterstützt werden.