Nachdem wir nun über den Knoten MongoDB-Treiber, das Knotenmodul, gelernt haben, mit
dem unsere Knotenanwendung
mit einem MongoDB-Server interagieren kann,
werden wir in dieser Übung das Knotenmodul verwenden und die verschiedenen Methoden verwenden,
die vom Knotenmodul unterstützt werden, um eine Einführung mit unserem MongoDB-Server.
Um zu beginnen, gehen Sie zu
dem NodeJS-Ordner, den Sie verwendet haben, um alle Ihre Beispiele zu speichern,
und erstellen Sie dort einen neuen Ordner namens node-mongo.
In diesem Ordner werden wir
die NodeJS-Anwendung entwickeln, die mit unserem MongoDB-Server interagiert. Stellen
Sie nun sicher, dass Ihr MongoDB-Server einsatzbereit ist.
In der vorherigen Übung haben wir bereits gesehen, wie unser MongoDB-Server gestartet werden kann.
Also, halten Sie den MongoDB-Server auf und laufen und
gehen Sie in einem anderen Terminalfenster oder Terminal-Tab oder Befehlsfenster zu dem node-mongo-Ordner, den Sie gerade
erstellt haben, und initialisieren Sie hier eine Knotenanwendung.
Also, lassen Sie mich npm init eingeben und wir
werden die Anwendung als Node-Mongo und Version,
Beschreibung Node MongoDB Beispiel,
und der Einstiegspunkt,
und der Autor, genau wie wir in den vorherigen Übungen ausgefüllt haben.
Sobald die Datei package.json initialisiert wurde,
öffnen Sie diese im Editor Ihrer Wahl.
Gehen Sie nun in die package.json-Datei,
lassen Sie mich ein anderes Skript hier einführen, genau wie wir es früher getan haben, also
sagen wir „start“: „node index“ und speichern Sie die Änderungen.
Gehen wir zurück zum Terminal,
lassen Sie uns das MongoDB-Knotenmodul installieren.
Geben Sie also npm install mongodb @3 .0.10 —save ein.
Wir werden auch das Assert-Knoten-Modul installieren, also
sagen wir npm install assert @1 .4.1 —save.
Das assert-Modul ermöglicht es uns, die Behauptung zu verwenden, um auf
Wahrheit oder falsche Werte in unserer Anwendung zu überprüfen,
und Sie werden sehen, wie ich es später verwende.
Nun, da wir diese Knotenmodule installiert haben,
lassen Sie uns unsere Knotenanwendung erstellen, die mit dem MongoDB-Server interagiert.
Gehen Sie zurück zum Editor
,
erstellen Sie im Projektordner eine Datei namens index.js,
und hier werden wir
die Knotenanwendung erstellen, die mit unserem MongoDB-Server interagiert.
Also, in dieser Anwendung,
lassen Sie uns const Mongoclient,
und dann werden sie sagen,
erfordern (`mongodb`), das MongoDB-Knotenmodul, das wir bereits installiert haben,
und dann würde dies uns mit
dem MongoClient liefern, der uns ermöglicht, eine Verbindung mit dem MongoDB-Server herzustellen.
Benötigen Sie auch das Assert-Modul.
Nun, um eine Verbindung mit dem MongoDB-Server zu starten,
lassen Sie uns einen konstanten Namen URL erstellen, die die URL sein wird, auf die der MongoDB-Server
zugegriffen werden kann und der Babyzugriff dies ist,
indem man mongodb: //localhost: 27017/ sagt. Daran
erinnern, dass dies die Portnummer ist, an der Ihr MongoDB-Server
läuft 27017 const dbname=,
und dann werden sie sagen wir ConFusion.
Erinnern Sie sich, dass wir
die ConFusion-Datenbank in unserem MongoDB-Server in der vorherigen Übung erstellt haben
, so dass wir auf die ConFusion-Datenbank zugreifen, die wir zuvor erstellt haben.
Nun, um auf den Server zuzugreifen, sagen wir MongoClient.connect.
Die Verbindungsmethode ermöglicht es uns, von unserem MongoDB-Server aus eine Verbindung mit dem MongoClient herzustellen,
und dann werden wir sagen, dass dies die URL als ersten Parameter nimmt,
die URL des MongoDB-Servers als ersten Parameter.
Der zweite Parameter ist eine Callback-Funktion.
Die Callback-Funktion hat also zwei Parameter, den Fehlerwert
und den Client, mit dem wir dann
eine Verbindung zu unserer Datenbank herstellen und dann verschiedene Operationen ausführen können.
Also, innerhalb dieser Callback-Funktion,
das erste, was wir tun werden, ist zu überprüfen, um sicherzustellen, dass der Fehler nicht null ist.
Also, die Assert wird überprüfen, ob Fehler gleich null ist,
so dass die assert-Funktion es uns ermöglicht, verschiedene Prüfungen auf Werten durchzuführen.
Also, wir überprüfen, um sicherzustellen, dass der Fehler nicht ist,
wenn er nicht null ist,
dann bedeutet das, dass es einen Fehler gibt und so werden wir den Fehler auf dem Bildschirm anzeigen.
Also, das ist die Verwendung der assert-Funktion hier.
Nun, wenn das nicht passiert,
dann bedeutet das, dass wir richtig mit dem Server verbunden sind,
also sagen wir `richtig mit dem Server`
const db= client.db (dbname), um sich mit der Datenbank zu verbinden,
dann können wir sagen const collection db. ,
so dass die Datenbank uns verschiedene Methoden zur Verfügung stellt, die es uns ermöglichen,
mit dem Server zu interagieren, so sagen wir db.collection (`dishes`) Also,
wir werden versuchen, auf die Gerichte Sammlung innerhalb dieser Datenbank zuzugreifen.
Nun, das nächste, was wir versuchen werden, ist
collection.insertone, also werden wir versuchen, ein Objekt in die Sammlung einzufügen,
und dieses Objekt wäre mit
dem Namen und der Beschreibung, „test“.
Also, diese Sammlung bietet diese Methode namens InserTone,
die es uns ermöglicht, ein Dokument in diese Sammlung einfügen,
und das Dokument ist das erste Argument für diese Methode hier.
Das zweite Argument für die Methode ist eine Callback-Funktion,
und die Callback-Funktion nimmt zwei Parameter, Fehler und Ergebnis.
Also, innerhalb dieser Callback-Funktion,
wenn das Ergebnis erhalten wird,
dann sind wir in der Lage, auf die Sammlung zuzugreifen und dann weitere Operationen auszuführen.
Also, hier, das erste, was wir tun werden, ist zu überprüfen, um sicherzustellen, dass der Fehler nicht null ist.
Also, wir werden dort eine Behauptung machen,
und dann können wir hier sagen, „After Insert“.
Also, nachdem wir einfügen, dann sehen wir, dass wir
den Ergebniswert erhalten, der dort zurückgegeben wird, also dieses Ergebnis.
Dieses Ergebnis wird auch
diese OPS-Eigenschaft liefern, die besagt, wie viele Operationen gerade erfolgreich ausgeführt wurden.
Also, das ist es, was ich drucken werde.
Also, es wird sagen, die eingefügte Nummer ist eins.
Also, was bedeutet, dass dieses bestimmte Dokument in die Datenbank eingefügt wurde.
Also, das werden wir hier bestätigen.
Dann, danach, werden wir eine andere Option durchführen,
eine Operation für die Sammlung, und sagen wir,
Sammlung finden, und wir werden versuchen, nach allen Datensätzen in der Sammlung zu suchen.
Also, hier werden wir eine leere JSON-Zeichenfolge oder entsprechende Ebene JavaScript-Objekt liefern.
Also, es wird nach allem suchen, was in der Sammlung ist,
und dann, das uns zur Verfügung stellen.
Dann kann dies in ein Array von JSON-Objekten konvertiert werden.
Deshalb rufen wir das toArray auf,
und dies nimmt eine Callback-Funktion als Parameter.
Der erste Parameter ist natürlich der Fehlerwert, also
überprüfen wir erneut, um sicherzustellen, dass der Fehler nicht null ist.
Dann werden wir sagen, console.log gefunden,
und dann drucken Sie alles, was gefunden wurde,
und wir sagen console.log.
Der zweite Parameter hier, docs, gibt also
alle Dokumente aus dieser Sammlung zurück
, die den Kriterien entsprechen, die Sie hier angeben.
Da dies leer ist,
bedeutet dies, dass alle Dokumente in der Sammlung an uns zurückgesendet werden.
Sie können hier einen Filter angeben, der
besagt, dass name gleich einem Wert ist,
und dann werden nur die Dokumente abgerufen, die diesem Wert entsprechen.
Also hier, lassen Sie mich einfach die Dokumente hier ausdrucken,
um anzuzeigen, dass dieses Element
in die Sammlung eingefügt wurde und dann abgerufen wird,
und dann drucken wir es einfach aus, nur um sicherzustellen, dass das Dokument, das wir gerade
in der vorherigen Operation eingefügt haben, tatsächlich in der Sammlung ist,
und so drucken wir das hier aus.
Nun danach werden wir
hier die DropCollection-Methode verwenden.
Daher wird die DropCollection die angegebene Sammlung hier löschen.
Also, wir sagen DropCollection Gerichte,
also werde ich nur die Geschirr Sammlung aus meiner Datenbank entfernen.
Also, ich werde nur die Datenbank bereinigen und
sie dann mit einer leeren Datenbank belassen, so dass wir auf
die nächste Übung gehen können, wo wir wieder
ähnliche Arten von Operationen ausführen können, um dies zu überprüfen.
Dieser nimmt als zweiter Parameter
eine Callback-Funktion, die entweder einen Fehler oder ein Ergebnis zurückgibt.
In diesem werden wir überprüfen und sicherstellen, dass die Behauptung nicht null ist,
und dann werden wir sagen, client.close.
So werden wir die Verbindung zur Datenbank vor Ort schließen.
Mit diesem einfachen Satz von Methoden ermöglichen wir uns, mit unserem Server zu interagieren,
und es zeigt uns auch, wie wir mit dem Server kommunizieren können, indem wir die
Methoden verwenden, die über dieses MongoDB-Knotenmodul oder den MongoDB-Treiber verfügbar sind.
Also, hier sehen Sie, dass wir zuerst eine Einfügeoperation durchführen.
Beachten Sie dann nach der Einfügeoperation, dass
wir die zweite Operation innerhalb der Callback-Funktion ausführen.
Dies stellt sicher, dass dieser Vorgang abgeschlossen wurde, bevor Sie den nächsten ausführen.
Dies ist also ein zweiter Aufruf, der innerhalb der ersten Callback-Funktion
und dann entsprechend darin eingeschlossen ist.
Wir rufen die Methoden wieder hier und drinnen auf.
Sie sehen also, dass es eine Verschachtelung dieser Anrufe gibt,
eine innerhalb der anderen.
Beachten Sie die Struktur, weil ich zurückkommen werde, um
etwas darüber in einer der späteren Übungen zu erklären.
Also, beachten Sie, dass die Verschachtelung dieser Anrufe ineinander.
Lassen Sie uns die Änderungen speichern
und dann sehen, was diese Anwendung tut, wenn wir sie ausführen. Wenn Sie
wieder zum Terminal gehen,
stellen Sie sicher, dass Ihr MongoDB-Server einsatzbereit
ist und läuft. Wenn er ausgeführt wird, wird er viele Protokollmeldungen auf der Konsole ausdrucken.
Wir können diese Log-Meldungen vorerst ignorieren.
Lassen Sie uns die Knotenanwendung ausführen.
Also, wir werden sagen, npm start,
und wenn die Knotenanwendung ausgeführt wird,
bemerken Sie, was Knotenanwendung tut.
So heißt es, richtig mit dem Server verbunden, After Insert,
dann zeigt es, dass
dieses bestimmte Dokument in unsere MongoDB eingefügt wurde und insbesondere der Knoten,
die ID hier angegeben.
Beachten Sie also, dass dies nicht besagt, dass dies eine Objekt-ID ist.
Diese ID wird automatisch
vom Knoten Mongo-Treiber in ihr Dokument eingefügt, wenn
Sie versuchen, sie hier in den MongoDB-Server einzufügen.
Dieses Format ist genau das gleiche wie die Objekt-ID, die wir gesehen haben.
Danach führten wir eine Findoperation durch.
Also, das wird gefunden,
und dann druckt es diesen Artikel hier aus.
Beachten Sie, dass
wir aus der vorherigen Übung in einem früheren Dokument, das wir in der vorherigen Übung eingefügt hatten, übrig geblieben waren.
Also, das ist immer noch in der Sammlung hier zu sehen,
und das neue Dokument, das wir gerade hier eingefügt haben.
Dieses Dokument ist direkt darunter zu sehen,
aber beachten Sie, dass diese beiden zwei verschiedene IDs haben.
Diese ID stimmt mit der ID des Dokuments überein, das wir gerade eingefügt haben.
Also, das ist übrig von der vorherigen Übung.
Danach lassen wir natürlich die Sammlung fallen, so dass
diese ganze Reihe von Dokumenten und die Geschirrsammlung aus unserer Datenbank entfernt werden.
Also, jetzt wird unsere Datenbank sauber und leer sein.
Das zeigt Ihnen also, wie wir
den MongoDB-Treiber verwenden können, um von unserer Knotenanwendung mit dem Server zu kommunizieren.
Jetzt, da wir unsere Anwendung haben,
lassen Sie mich eine.gitignore
hier einführen und dann Knotenmodule in die.gitignore setzen,
und Sie verstehen schnell, warum ich das tue.
Dann werden wir zurück gehen und das Git-Repository initialisieren und dann ein Git-Commit machen.
Gehen Sie zurück zum Terminal,
lassen Sie mich das Git-Repository initialisieren,
und dann überprüfen Sie den Git-Status und Sie sehen, dass es einige nicht festgeschriebene Dateien gibt.
Also lassen Sie mich sie einchecken und dann ein Git-Commit mit der Nachricht tun,
Node MongoDB Beispiel eins.
Dies ist der Teil einer der Übung,
also überprüfen wir einfach die Elemente in unser Git-Repository.
Damit ist diese Übung abgeschlossen.
In dieser Übung haben wir gesehen, wie wir das Knotenmodul,
den MongoDB-Treiber installieren, dann
konnten wir mit unserem MongoDB-Server aus
unserer Knotenanwendung mit den Methoden kommunizieren, die vom MongoDB-Treiber bereitgestellt werden.
Wir werden diese Übung im nächsten Teil
der Übung fortsetzen, wo wir ein paar weitere Methoden des MongoDB-Treibers erforschen werden.