In diesem Beitrag zeigen wir Ihnen, wie Sie Mongoose für Ihre MongoDB-Bereitstellungen verwenden, um eine einfachere, schemabasierte Lösung für die Modellierung Ihrer Anwendungsdaten zu erstellen.
P>Was ist Mongoose?
Mongoose ist eine „elegante MongoDB-Objektmodellierung für Node.js “. Wenn Sie MongoDB schon einmal verwendet und grundlegende Datenbankoperationen ausprobiert haben, ist Ihnen vielleicht aufgefallen, dass MongoDB „schemalos“ ist. Wenn Sie eine strukturiertere Datenbank implementieren und die Leistungsfähigkeit von MongoDB nutzen möchten, ist Mongoose eines der ODM (O Objekt D ata M apping) Lösungen.
Um es schnell zu demonstrieren, führen Sie einen Befehl zum Einfügen in eine Sammlung mit dem Namen Benutzer wie folgt aus:
db.users.insert({ name : 'Arvind', gender : 'male'});
Und direkt danach können Sie Folgendes ausführen:
db.users.insert({ name : 'Arvind', gender : 'male', password : '!@#$'});
und MongoDB wird sich niemals über die Variation in der Anzahl der Spalten (Schlüssel-Wert-Paare) beschweren. Dies ist sehr flexibel. Wenn Sie Ihre Daten jedoch organisierter und strukturierter halten möchten, müssen Sie dies in Ihrem Servercode beibehalten, eine Validierung schreiben und sicherstellen, dass nichts Irrelevantes in einer Sammlung gespeichert wird. Hier macht Mongoose das Leben einfach.
„Mongoose bietet eine geradlinige, schemabasierte Lösung zur Modellierung Ihrer Anwendungsdaten und umfasst integrierte Typumwandlung, Validierung, Abfrageerstellung, Geschäftslogik-Hooks und mehr , sofort einsatzbereit.“
Installieren Sie Node.js und MongoDB
Um Mongoose zu verwenden, muss Node.js installiert sein. Informationen finden Sie hier.
Beginnen Sie mit der Entwicklung
Erstellen wir zuerst einen kleinen Spielplatz, auf dem wir Spaß haben können. Erstellen Sie einen neuen Ordner namens myMongooseApp und öffnen Sie hier das Terminal/die Eingabeaufforderung und führen Sie Folgendes aus:
npm init
Dies hilft uns bei der Initialisierung eines neuen Node-Projekts. Füllen Sie es nach Bedarf auf. Als Nächstes installieren wir Mongoose als Abhängigkeit von unserem Projekt. Ausführen:
npm install mongoose --save-dev
Starten Sie dann den MongoDB-Dienst, indem Sie Folgendes ausführen:
mongod
Erstellen Sie als Nächstes eine neue Datei namens index.js im Stammverzeichnis und öffnen Sie sie dann in Ihrem bevorzugten Editor. Fügen Sie den folgenden Code hinzu:
var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/myTestDB');
var db = mongoose.connection;
db.on('error', function (err) {
console.log('connection error', err);
});
db.once('open', function () {
console.log('connected.');
});
Hier benötigen wir das Mongoose-Paket, um eine Verbindung zur Datenbank herzustellen und die Verbindung zu initialisieren. Der Name unserer Datenbank ist myTestDB.
Führen Sie dann Folgendes aus:
node index.js
Du solltest jetzt die verbundene Nachricht sehen. Sie können auch ein Node-Paket namens nodemon verwenden, um den Node-Server bei Änderungen automatisch neu zu starten.
Jetzt ist unsere Sandbox spielbereit!
Mongoose-Schemata
Schemata sind wie Skelette, die nackten Knochen dafür, wie Ihre Datensammlung aussehen wird. Wenn Sie es mit einer Sammlung von Benutzern zu tun haben, würde Ihr Schema in etwa so aussehen:
Name - String Age - Number Gender - String Date of Birth - Date
Wenn Sie es mit einer Sammlung von Produkten zu tun haben, sieht Ihr Schema etwa so aus:
SKU - String Name - String Price - Number InStock - Boolean Quantity - Number
Sie können die Abweichung sehen. Wenn unsere Daten mit einem solchen Schema geschützt werden, reduziert sich die Wahrscheinlichkeit, Datenmüll zu speichern, drastisch.
Nun, da wir ein Verständnis von Schemas haben, wollen wir versuchen, ein Benutzerschema mit Mongoose zu erstellen. Kehren Sie zu index.js zurück und fügen Sie den folgenden Code hinzu:
var Schema = mongoose.Schema;
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
});
Hier finden Sie grundlegende nutzerbezogene Felder und ihre Schematypen.
Als Nächstes erstellen wir ein Modell aus dem Schema. Hinzufügen:
var User = mongoose.model('User', userSchema);
Das ist es, unser Benutzermodell ist fertig! Wir verwenden dies als unser Basisschema, um Benutzer in die Datenbank einzufügen. Auf diese Weise wissen wir, dass jedes Dokument in einer Benutzersammlung die im Schema aufgeführten Felder enthält. Lassen Sie uns eine neue Benutzerinstanz erstellen und in DB speichern. Hinzufügen:
var arvind = new User({
name : 'Arvind',
age : 99,
DOB : '01/01/1915',
isAlive : true
});
arvind.save(function (err, data) {
if (err) console.log(err);
else console.log('Saved : ', data );
});
Sie sollten so etwas sehen:
Saved : { __v: 0,
name: 'Arvind',
age: 99,
DOB: Fri Jan 01 1915 00:00:00 GMT+0530 (IST),
isAlive: true,
_id: 536a4866dba434390d728216 }
Kein Ärger, keine Probleme. Einfache und einfache API zur Interaktion mit Modellen.
Nehmen wir an, wir möchten, dass jedes Modell eine Methode namens isYounger hat. Diese Methode gibt „true“ zurück, wenn das Alter unter 50 liegt, und „false“, wenn es darüber liegt. Wir können dies tun, indem wir die Datenbank nach dem aktuellen Benutzer abfragen, dann die Bedingung prüfen und wahr oder falsch zurückgeben.
Aber was ist, wenn wir diese Methode für alle Modelle des Benutzerschemas implementieren möchten? So machen wir es in Mongoose:
var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/myTestDB');
var db = mongoose.connection;
db.on('error', function (err) {
console.log('connection error', err);
});
db.once('open', function () {
console.log('connected.');
});
var Schema = mongoose.Schema;
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
});
userSchema.methods.isYounger = function () {
return this.model('User').age < 50 ? true : false;
}
var User = mongoose.model('User', userSchema);
var arvind = new User({
name : 'Arvind',
age : 99,
DOB : '01/01/1915',
isAlive : true
});
arvind.save(function (err, data) {
if (err) console.log(err);
else console.log('Saved ', data );
});
console.log('isYounger : ',arvind.isYounger());
In Zeile 21 fügen wir die Methodendefinition hinzu und das Ergebnis in Zeile 39 ist falsch. Dies ist eine einfache und praktische Möglichkeit, Ihrem Schema Methoden hinzuzufügen, um es objektorientierter zu machen.
Falls Sie ein Passwortfeld haben, können Sie eine Methode wie encryptPassword() hinzufügen, um das Passwort zu verschlüsseln, und ComparePassword(), um die Passwörter bei der Anmeldung mit dem Benutzerschema selbst zu vergleichen. Hier können Sie mehr über die Passwort-Authentifizierung lesen.
Mongoose bietet standardmäßig einige Optionen, wenn das Schema erstellt wird. Wenn Sie sich beispielsweise die folgende Schemadeklaration ansehen, übergeben wir eine Option strict:false:
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
}, {strict : false});
Die Option strict ist standardmäßig wahr und lässt nicht zu, dass die Schlüssel-Wert-Paare „Nicht-Schema“ gespeichert werden. Dies wird beispielsweise gespeichert:
var arvind = new User({
name : 'Arvind',
age : 99,
DOB : '01/01/1915',
isAlive : true
});
Wobei:
var arvind = new User({
name : 'Arvind',
age : 99,
DOB : '01/01/1915',
isAlive : true,
bucketList : [{...}, {...}, {...} ]
});
Alles Obige wird abzüglich des BucketList-Arrays gespeichert, da es nicht als Teil des Schemas deklariert wurde. Daher kann kein Kunde, der Ihre Dienste nutzt, ungültige Daten in Ihre Sammlungen ablegen.
Eine weitere coole Option ist die Sammlung. Wenn Sie nicht möchten, dass Ihr Modellname mit dem Sammlungsnamen identisch ist, können Sie den Namen als Option übergeben, z. B.:
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
}, {collection : 'appusers'});
Eine Liste mit weiteren Optionen finden Sie hier.
Mit Mongoose können Sie Ihren Schemas auch Ereignisse wie Pre-Save oder Post-Save hinzufügen, wo Sie Validierungen durchführen, Daten verarbeiten oder andere Abfragen in den jeweiligen Ereignissen ausführen können. Diese Methoden werden als Middlewares bezeichnet.
Ein einfaches Beispiel kann eine parallele Middleware sein wie:
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
})
schema.pre('save', true, function (next, done) {
// calling next kicks off the next middleware in parallel
next();
doAsync(done);
});
Hier können Sie mehr über Middleware lesen. In unserem nächsten Beitrag werden wir mehr über die Verwendung von Yeoman zum automatischen Generieren von Gerüsten für Ihre MongoDB-Projekte sprechen.
Danke fürs Lesen. Kommentieren Sie.
@arvindr21
