In der vorherigen
Lektion haben wir etwas über den MongoDB-Treiber erfahren.
Das ermöglicht es unserer Knotenanwendung, mit einem MongoDB-Server zu kommunizieren
und Dokumente vom MongoDB-Server zu speichern und abzurufen.
Wir haben auch gesehen, dass der MongoDB-Treiber uns
viele Methoden zur Verfügung stellt, die es uns ermöglichen, Sammlungen innerhalb einer Datenbank
zu erstellen, Dokumente zu den Sammlungen hinzuzufügen
und dann verschiedene Operationen an den Dokumenten innerhalb einer Sammlung durchzuführen.
Jetzt, wenn die Dokumente in der Datenbank gespeichert sind,
legt der MongoDB-Treiber selbst keine Struktur auf die Dokumente.
Wenn wir eine spezifische Struktur für die Dokumente haben und diese Struktur durchsetzen müssen,
dann müssen wir das Mongoose-Knotenmodul verwenden, das es uns ermöglicht,
ein Schema und eine Struktur für unsere Dokumente zu definieren, die in unserer MongoDB-Datenbank gespeichert sind,
und die Struktur strikt durchsetzt.
Schauen wir uns weitere Details in dieser Vorlesung und die Übungen an, die dieser Vorlesung folgen.
Wie wir bereits gelernt haben,
speichert MongoDB Daten in Sammlungen in einer Datenbank.
Diese Sammlungen bestehen aus einer Sammlung von Dokumenten.
Die Dokumente selbst, die in
einer MongoDB-Datenbank gespeichert sind, haben keine spezifische Struktur, die dem Dokument auferlegt wird.
Jedes Dokument kann in jeder Sammlung gespeichert werden.
MongoDB verlässt sich auf den Entwickler, um die Struktur der Dokumente durchzusetzen,
und überträgt dem Entwickler die volle Verantwortung, sicherzustellen, dass Dokumente
der richtigen Struktur in den verschiedenen Sammlungen hinzugefügt und gepflegt werden.
Nun, es ist sehr einfach, das zu verletzen.
Zum Beispiel, obwohl Sie mit der Annahme beginnen,
dass eine bestimmte Verbindung Dokumente einer bestimmten Struktur haben wird,
können Sie leicht Dokumente einfügen, die nicht unbedingt mit der Struktur übereinstimmen.
Wenn Sie sehr besonders sind, dass die Struktur der Dokumente in
einer Sammlung immer eine bestimmte Struktur hat
und immer den spezifischen Satz von Feldern hat,
dann wird MongoDB selbst nicht auferlegt, dass auch
der Knoten MongoDB-Treiber, den wir in der vorherigen Lektion gesehen haben, nicht.
Dies ist, wo wir eine formellere Möglichkeit benötigen,
Struktur auf die Dokumente aufzuzwingen, die in einer Sammlung in einer MongoDB-Datenbank gespeichert sind.
Hier kommt das Mongoose-Knotenmodul zu unserer Hilfe.
Das Mongoose-Knotenmodul erlegt
eine standardisierte Struktur für die Dokumente, die in einer bestimmten Sammlung gespeichert sind.
Deshalb hören wir oft Leute, die sich auf das Mungo ODM beziehen.
Das ODM selbst wird von einigen Personen so interpretiert, dass es
Objektdatenmodell oder manchmal als Objektdokumentzuordnung bezeichnet wird,
oder einige Leute bezeichnen es als ORM oder Objekt-Relational-Mapping.
Nun, wenn wir über relationale Datenbanken sprechen, die viel mehr für relationale Datenbanken gilt,
aber dann mit SQL-Datenbanken brauchten wir explizit das Objekt zum
relationalen Mapping, um zwischen der Datenbank und unserer Anwendung selbst platziert zu werden.
Denn innerhalb der Anwendung würden wir uns
Objekte ansehen, aber ihre Speicherung in einer SQL-Datenbank wird in Form von Datensätzen vorliegen,
und daher benötigen Sie eine explizite Zuordnung.
Wie wir mit der NoSQL-Datenbank gesehen haben,
war dies nicht explizit erforderlich.
Aber wenn Sie Ihre Dokumente, die in einer Sammlung gespeichert sind, Struktur auferlegen müssen,
dann ist die Verwendung von Mongoose, um diese Struktur aufzuzwingen, sehr nützlich.
Die Art und Weise, wie Mongoose umgeht, die
Struktur der Dokumente aufzuzwingen, ist durch die Verwendung von Schema.
Schema, definiert die Struktur ihrer Dokumente.
Lassen Sie uns darüber etwas ausführlicher sprechen.
Also, was genau ist Mungo Schema,
und was bringt es auf den Tisch?
Mungo Schema, impliziert eine Struktur auf
den Daten, die in einem Dokument in Ihrer Datenbank gespeichert ist.
Es definiert also alle Felder Ihres Dokuments
und gibt auch die Typen der Felder an
und kann uns auch
zusätzliche Funktionen zur Verfügung stellen, die die Validierung dieser Felder ermöglichen können.
So sind zum Beispiel die verschiedenen Schematypen, die in Mongoose unterstützt werden: String,
Number, Date, Puffer, Boolean,
Mixed, Objekt-ID und Array.
Insbesondere werden wir uns String-Nummer,
und ein Datum, und Boolean in der folgenden Übung zu suchen.
Wir werden einige der anderen in späteren Übungen betrachten.
Beachten Sie insbesondere die Verwendung des Array-Schematyps.
Ein Array-Schema-Typ ermöglicht es Ihnen,
ein Array von Unterdokumenten innerhalb des Dokuments zu erstellen.
Ich werde in kurzer Zeit darüber reden.
Nachdem Sie ein Schema definiert haben,
wird das Schema dann in Mongoose verwendet, um eine Modellfunktion
zu erstellen. Dadurch können Sie die Struktur für Ihre Dokumente in der Datenbank definieren.
Schemas selbst können Verschachtelung haben.
Das bedeutet, dass Sie Unterdokument haben können, die in einem Dokument eingeschlossen sind.
Die Unterdokumente werden in der Regel
entweder durch die Angabe eines zusätzlichen Schemas aufgenommen
und dann eines der Felder des Schemas so definiert, dass es sich nicht um den Typ des anderen Schemas handelt.
Oder Sie können sogar ein Array eines
anderen Schematyps innerhalb eines zweiten Schemas verwenden, das Sie definieren.
Schauen wir uns ein Beispiel an, um einige davon genauer zu klären.
Dieses Beispiel stammt aus der Übung, die Sie direkt nach dieser Vorlesung durchführen werden.
Bevor ich über Schemas und Modelle in Mongoose sprechen kann,
lasst uns verstehen, warum wir das brauchen.
Wenn Sie den vorherigen eckigen oder
ionischen oder den nativen Skript-Kurs genommen haben,
haben Sie gesehen, dass wir
verschiedene Daten darstellen, die wir in unseren Anwendungen in Form von JSON-Strings verwenden.
In unserer Anwendung definieren wir also eine Sammlung, die als Gerichte bezeichnet wird.
In einer Geschirrsammlung
enthält jedes Gericht einen bestimmten Satz von Eigenschaften, die in Form einer JSON-Zeichenfolge definiert sind,
wie Sie in diesem Beispiel sehen.
Also, das Geschirr ist eine Reihe von Gerichttyp,
und jedes Gericht selbst wird einen Namen,
ein Bild, eine Kategorie,
ein Etikett und so weiter enthalten.
Außerdem
würden Sie innerhalb des Dish-Dokuments selbst Kommentare haben, die als ein Array von wieder gespeichert werden, -
JSON-Dokumenten, die bestimmte Felder Schritt enthalten.
So
enthält jeder Kommentar zum Beispiel einen Bewertungskommentar und ein Datumsfeld, wie Sie in diesem Beispiel sehen.
So sehen Sie, dass es eine klare Struktur zu
jedem Dokument gibt, die ein Gericht definiert, das in unserer Datenbank gespeichert ist.
Mehrere Gerichte werden offensichtlich in Form einer Sammlung in unserer Datenbank gespeichert,
und könnten zusammen gruppiert und als eine Reihe von
Gerichten an unsere Client-Anwendung gesendet werden verwendet werden.
Nun, da wir verstanden haben, wie das definiert ist,
wie bezieht sich das jetzt auf das Mungo Schema und das Modell, das wir in Mongoose definieren?
Notieren Sie sich nun die Struktur eines typischen Gerichtes hier.
Dies könnte also leicht in ein MongoDB-Dokument in einer Sammlung abgebildet werden,
vielleicht die Geschirrsammlung genannt.
Wir sehen also, dass das Dokument selbst eine klare Struktur hat.
Nun, wie spiegeln wir dies in einem Schema in unserer Mongoose-Anwendung?
Wie Sie in der Übung erfahren werden,
werden wir sehen, dass wir Schemas in Mungo definieren würden.
So ist das Schema hier als Mongoose-Schema definiert.
Als Beispiel wird hier ein CommentSchema dargestellt.
Das CommentSchema
enthält, wie Sie sehen können, drei verschiedene Felder: die Bewertung, den Kommentar
und das Autorenfeld
sowie hier Zeitstempel. Mit
den Zeitstempeln können Sie zwei verschiedene Felder im
Dokument haben: das erstellte Feld und das aktualisierte Feld bei.
Beide Zeitstempel sind Zeitstempel, die in Form einer ISO-Datumszeichenfolge im Dokument gespeichert werden.
Nun wäre die Bewertung selbst ein ganzzahliger Wert.
Also, in Mongoose Terminologie,
wird es als eine Zahl gespeichert werden,
der Typ wäre eine Zahl.
Sie können sogar den Minimal- und den Maximalwert angeben.
Sie können auch angeben, dass dieses Feld erforderlich ist.
Das bedeutet, dass jedes Dokument des Kommentartyps ein Bewertungsfeld enthalten sollte.
In ähnlicher Weise können Sie auch ein Kommentarfeld definieren,
das vom Typ String ist.
Also, offensichtlich ist ein Kommentar nichts anderes als eine Zeichenfolge, die einige Informationen enthält,
und dies kann auch als ein erforderliches Feld definiert werden,
was bedeutet, dass jedes Dokument einen Kommentar enthalten sollte,
und auch ein Autorenfeld,
das auch vom Typ String ist.
Sie sehen das also, indem Sie dieses Schema in diesem Format definieren.
Wie wir in der Diskussion ein wenig früher gelernt,
Schema wird durch die Verwendung der verschiedenen Typen definiert, die wir in unserer Mongoose-Anwendung haben.
Also, im Schema, wieder,
sehen Sie hier drei verschiedene Felder,
Bewertung, Kommentar und Autor,
und jedes von denen hat einen bestimmten Typ gegeben,
und dann, ob dies erforderlich ist oder nicht.
So erzwingen Sie eine strenge Struktur
auf die Kommentardokumente, die in Ihrer Anwendung gespeichert werden.
Nun, da wir ein Kommentarschema definiert haben, können wir dann,
wie Sie am Beispiel der Art von Daten bemerkt haben, die wir in unserer Anwendung benötigen,
ein Gericht Dokument selbst haben.
Das Gericht Dokument enthält verschiedene Felder.
Hier, in der Übung,
werden wir zuerst nur zwei Felder in das Gericht Dokument einführen,
den Namen und die Beschreibung.
In der nächsten Lektion
werden wir die verbleibenden Felder für das DishSchema vorstellen.
Nun, also
ist der Name, wie in diesem Fall, vom Typ string.
Wir können auch angeben, dass dies ein Pflichtfeld ist,
was bedeutet, dass jedes Dokument das Namensfeld enthalten sollte.
Wir können auch angeben, dass das Namensfeld eindeutig ist,
was bedeutet, dass keine zwei Dokumente genau den gleichen Namenswert im Dokument haben können.
Dadurch wird sichergestellt, dass jedes Dokument
ein eindeutiges Namensfeld enthält und ein Beschreibungsfeld,
das wiederum vom Typ String ist,
aber auch bei Bedarf angegeben wird.
Nun, wie wir in dem Beispiel gesehen haben,
enthält ein Dish-Dokument mehrere Kommentare, die innerhalb des Dokuments eingeschlossen sind.
Nun, in Mongoose, wird dies durch die Verwendung von Unterdokumenten unterstützt.
Wenn Sie also ein Schema früher definieren,
also haben wir hier bereits ein CommentSchema definiert,
können Sie auch ein Feld in ein anderes Schema definieren, das Sie definieren und
dann angeben, dass dieses Feld
vom Typ des vorherigen Schemas sein wird, das Sie definiert haben.
Also, in diesem Fall,
das Kommentarfeld, definiere ich es als ein Array,
so dass Sie die Verwendung eines Array-Typs in Ihrem Schema sehen, den Sie hier definieren,
und dann Array des CommentSchema-Typs.
Also, dies ist ein Array von Kommentaren, die in jedem Gericht Dokument enthalten werden.
So können Sie
mehr als ein Kommentar-Unterdokument in einem Gericht Dokument eingeschlossen haben. Wenn wir
also die Struktur so definieren, können wir
die entsprechende JSON-String-Struktur unterstützen, die wir
für ein Dish-Dokument definiert haben oder die wir im Beispiel zuvor gesehen haben.
Nun, sobald wir das Schema definieren,
um dies in unserer Anwendung
zu nutzen, müssen wir ein Modell aus diesem Schema erstellen, das wir gerade definiert haben.
In unserer Anwendung
definieren wir also ein Mongoose-Modell und geben an, dass das Modell
vom Typ DishSchema in diesem Beispiel entfernt ist.
Nicht nur das, Sie geben dem Modell hier auch einen Namen.
Also, wenn Sie dem Modell hier einen Namen geben,
geben wir den Namen als Gericht an.
Nun, wenn Sie dieses Gericht Modell in
unserer Knotenanwendung verwenden, in der wir Mongoose verwenden,
dann wird dies umgewandelt und in eine Sammlung in meiner MongoDB-Datenbank abgebildet.
Die Kollektion selbst wird als Gerichte bezeichnet.
Also, Mongoose weiß automatisch, dass, wenn Sie hier einen Namen angeben,
es automatisch den Plural dieses
Namens konstruiert und dann der Sammlung den Namen gibt. Dies
ist der Plural des Modellnamens, den Sie in diesem Beispiel angeben.
Also, wenn ich hier Gericht sage,
dann wird Mongoose dies automatisch in
die Geschirr-Sammlung in der MongoDB-Datenbank abbilden.
Woher weiß es, wie man diesen singulären Namen in einen Plural umwandelt?
Mungo verfügt automatisch über einen eingebauten Mechanismus, der
es ermöglicht, die Plurale von englischen Standardwörtern zu konstruieren.
Also, wenn Sie Gericht sagen,
wird es Geschirr konstruieren.
Wenn Sie Führer sagen, wird es den Plural von ihm als Führer konstruieren, und so weiter.
Dies ist also bereits in das Mongoose-Knotenmodul integriert.
Deshalb wird
Mongoose, wenn ich dies als Gerichtenmodelltyp spezifiziere, die Geschirrsammlung in meiner MongoDB-Datenbank konstruieren,
und dann wird diese
Geschirrsammlung die verschiedenen Dokumente des Gerichttyps dort speichern.
Sobald wir das erstellt haben, in der Regel,
wenn wir Modelle in unserer Anwendung deklarieren,
würden wir sie in einem Unterordner namens models speichern, nur der Einfachheit halber.
Sie müssen das nicht tun,
aber nur um Ihre Anwendung zu organisieren,
würden wir diese normalerweise in einem Ordner namens models speichern.
Dann würden das Schema und das Modell
in einer Datei wie dieser definiert werden, wie Sie im Beispiel hier sehen, das
heißt dishes.js, und dann würde dies exportiert werden, weil es sich um ein Knotenmodul handelt.
Dies wird aus dieser Datei exportiert, so dass es in die Knotenanwendung aufgenommen
werden kann, wo wir
dieses Schema und das Modell verwenden, das wir gerade hier definiert haben.
Mit diesem schnellen Verständnis von Schema und Modell und
seiner Verwendung bei der Definition der Struktur für ein Dokument, das wir in einer MongoDB speichern,
gehen wir zurück und verstehen ein wenig mehr darüber, was Mongoose für uns bietet.
Darüber hinaus ermöglicht uns Mongoose, die Verbindung mit dem MongoDB-Server herzustellen.
Mongoose nutzen intern
den MongoDB-Treiber, den wir in der vorherigen Übung verwendet hatten.
Also, Mongoose hängt vom MongoDB-Treiber ab,
was bedeutet, dass
Sie von Ihrer Mongoose-basierten Knotenanwendung alle Methoden verwenden können, die bereits
vom MongoDB-Treiber verfügbar sind, auch wenn Sie dies wünschen,
aber Mongoose selbst hat eine eigene Sammlung von Methoden, die wir Verwendung von, um mit der MongoDB-Datenbank zu interagieren,
wie wir in der folgenden Übung sehen werden.
Lassen Sie mich Ihnen kurz zeigen, wie wir eine Verbindung zur Datenbank herstellen würden,
und Sie werden dies in der folgenden Übung tun.
So, wie wir die URL im Falle
der MongoDB-Knotenanwendung in der früheren Lektion deklariert
haben, werden wir immer noch die URL für unsere Anwendung deklarieren.
Dann werden wir die Mongoose Connect-Methode verwenden
und die URL für die Mongoose Connect-Methode liefern,
und dies wird die Verbindung mit der Datenbank herstellen.
Mit diesem schnellen Verständnis von Mongoose und welche Rolle Mongoose
bei der Unterstützung von strukturiertem Einfügen
, Speichern und Abrufen von Dokumenten aus unserer MongoDB spielt,
lassen Sie uns zu der Übung übergehen, wo wir
einige praktische Erfahrungen mit dem Mongoose-Modul bekommen.