I dette indlæg viser vi dig, hvordan du bruger Mongoose til dine MongoDB implementeringer for at skabe en mere ligetil, skemabaseret løsning til modellering af dine applikationsdata.
Hvad er Mongoose?
Mongoose er en "elegant MongoDB-objektmodellering for Node.js “. Hvis du har brugt MongoDB før og prøvet grundlæggende databaseoperationer, har du måske bemærket, at MongoDB er "skemaløs". Når du ønsker at implementere en mere struktureret database og ønsker at udnytte kraften i MongoDB, er Mongoose en af ODM'erne (O bject D ata M apping) løsninger.
For hurtigt at demonstrere, kører du en indsæt-kommando i en samling med navnet brugere som denne:
db.users.insert({ name : 'Arvind', gender : 'male'});
Og lige efter det kan du køre:
db.users.insert({ name : 'Arvind', gender : 'male', password : '!@#$'});
og MongoDB vil aldrig klage over variationen i antallet af kolonner (nøgle-værdi-par). Dette er meget fleksibelt. Men når du ønsker at holde dine data mere organiserede og strukturerede, skal du vedligeholde det i din serverkode, skrive validering og sikre dig, at intet irrelevant er gemt i en samling. Det er her, Mongoose gør livet nemt.
"Mongoose giver en ligetil, skemabaseret løsning til modellering af dine applikationsdata og inkluderer indbygget typecasting, validering, forespørgselsopbygning, forretningslogikhooks og mere , ud af kassen.”
Installer Node.js &MongoDB
For at bruge Mongoose skal vi have Node.js installeret. Du kan finde info her.
Begynd at udvikle
Lad os først skabe en lille legeplads, hvor vi kan have det sjovt. Opret en ny mappe ved navn myMongooseApp og åbn terminal/prompt her og kør:
npm init
Dette vil hjælpe os med at initialisere et nyt nodeprojekt. Fyld den op efter behov. Dernæst installerer vi Mongoose som en afhængighed af vores projekt. Kør:
npm install mongoose --save-dev
Start derefter MongoDB-tjenesten ved at køre:
mongod
Opret derefter en ny fil med navnet index.js ved roden og åbn den derefter i dit yndlingsredigeringsprogram. Tilføj nedenstående kode:
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.');
});
Her kræver vi, at Mongoose-pakken forbinder til databasen og initialiserer forbindelsen. Navnet på vores database er myTestDB.
Kør derefter:
node index.js
Du skulle nu kunne se den tilsluttede meddelelse. Du kan også bruge en nodepakke ved navn nodemon til automatisk at genstarte nodeserveren ved ændringer.
Nu er vores sandkasse klar til at spille!
Mangoose-skemaer
Skemaer er som skeletter, de blotte knogler for, hvordan din dataindsamling vil se ud. Hvis du har at gøre med en samling af brugere, vil dit skema se nogenlunde sådan ud:
Name - String Age - Number Gender - String Date of Birth - Date
Hvis du har at gøre med en samling af produkter, vil dit skema se nogenlunde således ud:
SKU - String Name - String Price - Number InStock - Boolean Quantity - Number
Du kan se afdriften. Når vores data er beskyttet med et skema som dette, reduceres muligheden for at gemme skraldedata drastisk.
Nu hvor vi har fået en forståelse af skemaer, lad os prøve at bygge et brugerskema ved hjælp af Mongoose. Tilbage til index.js og tilføj nedenstående kode:
var Schema = mongoose.Schema;
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
});
Find grundlæggende brugerrelaterede felter og deres skematyper her.
Derefter opretter vi en model ud fra skemaet. Tilføj:
var User = mongoose.model('User', userSchema);
Det er det, vores brugermodel er klar! Vi bruger dette som vores basisskema til at indsætte brugere i databasen. På denne måde ved vi, at hvert dokument i en brugersamling vil have felterne anført på skemaet. Lad os oprette en ny brugerinstans og gemme den i DB. Tilføj:
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 noget som dette:
Saved : { __v: 0,
name: 'Arvind',
age: 99,
DOB: Fri Jan 01 1915 00:00:00 GMT+0530 (IST),
isAlive: true,
_id: 536a4866dba434390d728216 }
Ingen besvær, ingen problemer. Enkel og nem API til at interagere med modeller.
Lad os sige, at vi ønsker, at hver model skal have en metode, der hedder isYounger. Denne metode vil returnere sand, hvis alderen er mindre end 50, og falsk, hvis den er større. Vi kan gøre dette ved at forespørge databasen for den aktuelle bruger og derefter kontrollere konditioneringen og returnere sand eller falsk.
Men hvad nu hvis vi ønsker at implementere denne metode til alle modeller af brugerskema? Sådan gør vi det 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å linje 21 tilføjer vi metodedefinitionen, og resultatet på linje 39 vil være falsk. Dette er en enkel, praktisk måde at tilføje metoder til dit skema, hvilket gør det mere objektorienteret.
Hvis du har et kodeordsfelt, kan du tilføje en metode som encryptPassword(), for at kryptere adgangskode og comparePassword(), for at sammenligne adgangskoderne ved login med selve userSchema. Du kan læse mere om adgangskodegodkendelse her.
Out-of-the-box Mongoose giver også et par muligheder, når skemaet oprettes. Hvis du f.eks. tager et kig på nedenstående skemaerklæring, sender vi en mulighed strict:false:
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
}, {strict : false});
Den strenge indstilling er som standard sand, og den tillader ikke, at nøgleværdiparrene 'ikke-skema' gemmes. For eksempel vil dette blive gemt:
var arvind = new User({
name : 'Arvind',
age : 99,
DOB : '01/01/1915',
isAlive : true
});
Hvorimod:
var arvind = new User({
name : 'Arvind',
age : 99,
DOB : '01/01/1915',
isAlive : true,
bucketList : [{...}, {...}, {...} ]
});
Alt ovenstående vil blive gemt minus bucketList-arrayet, fordi det ikke blev erklæret som en del af skemaet. Så ingen klient, der bruger dine tjenester, vil være i stand til at dumpe ugyldige data ind i dine samlinger.
En anden cool mulighed er kollektionen. Hvis du ikke ønsker, at dit modelnavn skal være det samme som samlingens navn, kan du videregive navnet som en mulighed som:
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
}, {collection : 'appusers'});
Du kan finde en liste over andre muligheder her.
Med Mongoose kan du også tilføje hændelser til dine skemaer som pre-save eller post save, hvor du kan udføre valideringer, behandle data eller køre andre forespørgsler i de respektive hændelser. Disse metoder kaldes Middlewares.
Et simpelt eksempel kan være en parallel middleware 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æse mere om middleware her. I vores næste indlæg vil vi tale mere om at bruge Yeoman til automatisk at generere stilladser til dine MongoDB-projekter.
Tak fordi du læste med. Kommenter.
@arvindr21