I det här inlägget visar vi dig hur du använder Mongoose för dina MongoDB-distributioner för att skapa en mer rak, schemabaserad lösning för att modellera din applikationsdata.
Vad är Mongoose?
Mongoose är en "elegant MongoDB-objektmodellering för Node.js ". Om du har använt MongoDB tidigare och provat grundläggande databasoperationer kanske du har märkt att MongoDB är "schemalöst". När du funderar på att implementera en mer strukturerad databas och vill utnyttja kraften i MongoDB, är Mongoose en av ODM (O bject D ata M apping) lösningar.
För att snabbt demonstrera, kör du ett insert-kommando i en samling med namnet användare så här:
db.users.insert({ name : 'Arvind', gender : 'male'});
Och direkt efter det kan du köra:
db.users.insert({ name : 'Arvind', gender : 'male', password : '!@#$'});
och MongoDB kommer aldrig att klaga på variationen i antalet kolumner (nyckel-värdepar). Det här är väldigt flexibelt. Men när du vill hålla din data mer organiserad och strukturerad, skulle du behöva behålla det i din serverkod, skriva validering och se till att inget irrelevant lagras i en samling. Det är här Mongoose gör livet enkelt.
"Mongoose tillhandahåller en enkel, schemabaserad lösning för att modellera dina applikationsdata och inkluderar inbyggd typcasting, validering, frågebyggnad, affärslogikkrokar och mer , ur lådan.”
Installera Node.js &MongoDB
För att använda Mongoose måste vi ha Node.js installerat. Du hittar information här.
Börja utveckla
Låt oss först skapa en liten lekplats där vi kan ha kul. Skapa en ny mapp med namnet myMongooseApp och öppna terminal/prompt här och kör:
npm init
Detta hjälper oss att initiera ett nytt nodprojekt. Fyll den efter behov. Därefter installerar vi Mongoose som ett beroende av vårt projekt. Kör:
npm install mongoose --save-dev
Starta sedan MongoDB-tjänsten genom att köra:
mongod
Skapa sedan en ny fil med namnet index.js i roten och öppna den sedan i din favoritredigerare. Lägg till koden nedan:
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.');
});
Här kräver vi att Mongoose-paketet ansluter till databasen och initierar anslutningen. Namnet på vår databas är myTestDB.
Kör sedan:
node index.js
Du bör nu se det anslutna meddelandet. Du kan också använda ett nodpaket som heter nodemon för att automatiskt starta om nodservern vid ändringar.
Nu är vår sandlåda redo att spelas!
Mangustscheman
Scheman är som skelett, bara benen för hur din datainsamling kommer att se ut. Om du har att göra med en samling användare skulle ditt schema se ut ungefär så här:
Name - String Age - Number Gender - String Date of Birth - Date
Om du har att göra med en samling produkter kommer ditt schema att se ut ungefär så här:
SKU - String Name - String Price - Number InStock - Boolean Quantity - Number
Du kan se driften. När vår data skyddas med ett schema som detta minskar möjligheten att lagra skräpdata drastiskt.
Nu när vi har en förståelse för scheman, låt oss försöka bygga ett användarschema med Mongoose. Tillbaka till index.js och lägg till koden nedan:
var Schema = mongoose.Schema;
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
});
Hitta grundläggande användarrelaterade fält och deras schematyper här.
Närnäst skapar vi en modell från schemat. Lägg till:
var User = mongoose.model('User', userSchema);
Det är allt, vår användarmodell är klar! Vi kommer att använda detta som vårt basschema för att infoga användare i databasen. På så sätt vet vi att varje dokument i en användarsamling kommer att ha fälten listade i schemat. Låt oss skapa en ny användarinstans och spara den i DB. Lägg till:
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 );
});
Du bör se något sånt här:
Saved : { __v: 0,
name: 'Arvind',
age: 99,
DOB: Fri Jan 01 1915 00:00:00 GMT+0530 (IST),
isAlive: true,
_id: 536a4866dba434390d728216 }
Inga krångel, inga problem. Enkelt och lätt API för att interagera med modeller.
Låt oss säga att vi vill att varje modell ska ha en metod som heter isYounger. Den här metoden kommer att returnera sant om åldern är mindre än 50 och falsk om den är högre. Vi kan göra detta genom att fråga databasen för den aktuella användaren, sedan kontrollera villkoret och returnera sant eller falskt.
Men vad händer om vi vill implementera den här metoden på alla modeller av användarschema? Så här gör vi i 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());
På rad 21 lägger vi till metoddefinitionen och resultatet på rad 39 blir falskt. Det här är ett enkelt och praktiskt sätt att lägga till metoder till ditt schema, vilket gör det mer objektorienterat.
Om du har ett lösenordsfält kan du lägga till en metod som encryptPassword(), för att kryptera lösenord och comparePassword(), för att jämföra lösenorden vid inloggning med själva userSchema. Du kan läsa mer om lösenordsautentisering här.
Out-of-the-box Mongoose ger också några alternativ när schemat skapas. Om du till exempel tittar på schemadeklarationen nedan, skickar vi alternativet strict:false:
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
}, {strict : false});
Det strikta alternativet är sant som standard och det tillåter inte att nyckel-värdeparen "icke-schema" sparas. Till exempel kommer detta att sparas:
var arvind = new User({
name : 'Arvind',
age : 99,
DOB : '01/01/1915',
isAlive : true
});
Eftersom:
var arvind = new User({
name : 'Arvind',
age : 99,
DOB : '01/01/1915',
isAlive : true,
bucketList : [{...}, {...}, {...} ]
});
Allt ovanstående kommer att sparas minus bucketList-arrayen eftersom det inte deklarerades som en del av schemat. Så ingen klient som använder dina tjänster kommer att kunna dumpa ogiltiga data i dina samlingar.
Ett annat coolt alternativ är kollektionen. Om du inte vill att ditt modellnamn ska vara detsamma som samlingens namn kan du skicka namnet som ett alternativ som:
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
}, {collection : 'appusers'});
Du kan hitta en lista över andra alternativ här.
Med Mongoose kan du också lägga till händelser till dina scheman som förspara eller efterspara, där du kan utföra valideringar, bearbeta data eller köra andra frågor i respektive händelse. Dessa metoder kallas Middlewares.
Ett enkelt exempel kan vara en parallell mellanprogramvara som:
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);
});
Du kan läsa mer om mellanprogram här. I vårt nästa inlägg kommer vi att prata mer om att använda Yeoman för att automatiskt generera byggnadsställningar för dina MongoDB-projekt.
Tack för att du läser. Kommentera.
@arvindr21