In dit bericht laten we u zien hoe u Mongoose kunt gebruiken voor uw MongoDB-implementaties om een eenvoudigere, op schema's gebaseerde oplossing te creëren voor het modelleren van uw app-gegevens.
Wat is mangoest?
Mongoose is een "elegante MongoDB-objectmodellering voor Node.js “. Als je eerder MongoDB hebt gebruikt en basisdatabasebewerkingen hebt geprobeerd, is het je misschien opgevallen dat MongoDB 'schemaloos' is. Wanneer u een meer gestructureerde database wilt implementeren en de kracht van MongoDB wilt benutten, is Mongoose een van de ODM (O bject D bij M apping) oplossingen.
Om snel te demonstreren, voer je een insert-opdracht uit in een verzameling met de naam gebruikers als volgt:
db.users.insert({ name : 'Arvind', gender : 'male'});
En direct daarna kun je het volgende uitvoeren:
db.users.insert({ name : 'Arvind', gender : 'male', password : '!@#$'});
en MongoDB zal nooit klagen over de variatie in het aantal kolommen (sleutel-waarde-paren). Dit is erg flexibel. Maar als u uw gegevens meer georganiseerd en gestructureerd wilt houden, moet u dat in uw servercode handhaven, validatie schrijven, en ervoor zorgen dat niets irrelevants wordt opgeslagen in een verzameling. Dit is waar Mongoose het leven gemakkelijk maakt.
"Mongoose biedt een eenvoudige, op schema's gebaseerde oplossing voor het modelleren van uw toepassingsgegevens en omvat ingebouwde typecasting, validatie, het bouwen van query's, zakelijke logica-haken en meer , uit de doos.”
Installeer Node.js &MongoDB
Om Mongoose te gebruiken, moeten we Node.js hebben geïnstalleerd. Informatie vind je hier.
Begin met ontwikkelen
Laten we eerst een kleine speeltuin maken waar we plezier kunnen hebben. Maak een nieuwe map met de naam myMongooseApp en open terminal/prompt hier en voer het volgende uit:
npm init
Dit zal ons helpen bij het initialiseren van een nieuw knooppuntproject. Vul het naar behoefte bij. Vervolgens zullen we Mongoose installeren als een afhankelijkheid van ons project. Uitvoeren:
npm install mongoose --save-dev
Start vervolgens de MongoDB-service door het volgende uit te voeren:
mongod
Maak vervolgens een nieuw bestand met de naam index.js in de root en open het in je favoriete editor. Voeg de onderstaande code toe:
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 hebben we het Mongoose-pakket nodig om verbinding te maken met de database en de verbinding te initialiseren. De naam van onze database is myTestDB.
Voer dan uit:
node index.js
Je zou nu het gekoppelde bericht moeten zien. U kunt ook een node-pakket met de naam nodemon gebruiken om de node-server automatisch opnieuw op te starten bij wijzigingen.
Nu is onze sandbox klaar om te spelen!
Mangoestschema's
Schema's zijn als skeletten, de basis van hoe uw gegevensverzameling eruit zal zien. Als u te maken heeft met een verzameling gebruikers, ziet uw schema er ongeveer zo uit:
Name - String Age - Number Gender - String Date of Birth - Date
Als je te maken hebt met een verzameling producten, ziet je schema er ongeveer zo uit:
SKU - String Name - String Price - Number InStock - Boolean Quantity - Number
Je kunt de afwijking zien. Wanneer onze gegevens worden bewaakt met een schema als dit, wordt de mogelijkheid om afvalgegevens op te slaan drastisch verminderd.
Nu we schema's begrijpen, gaan we proberen een gebruikersschema te maken met Mongoose. Ga terug naar index.js en voeg de onderstaande code toe:
var Schema = mongoose.Schema;
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
});
Hier vindt u standaard gebruikersgerelateerde velden en hun schematypen.
Vervolgens maken we een model van het schema. Toevoegen:
var User = mongoose.model('User', userSchema);
Dat is alles, ons gebruikersmodel is klaar! We gebruiken dit als ons basisschema om gebruikers in de database in te voegen. Op deze manier weten we dat elk document in een gebruikersverzameling de velden heeft die in het schema worden vermeld. Laten we een nieuwe gebruikersinstantie maken en deze opslaan in DB. Toevoegen:
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 );
});
Je zou zoiets als dit moeten zien:
Saved : { __v: 0,
name: 'Arvind',
age: 99,
DOB: Fri Jan 01 1915 00:00:00 GMT+0530 (IST),
isAlive: true,
_id: 536a4866dba434390d728216 }
Geen gedoe, geen problemen. Eenvoudige en gemakkelijke API om met modellen te communiceren.
Stel dat we willen dat elk model een methode heeft met de naam isYounger. Deze methode retourneert true als de leeftijd kleiner is dan 50, en false als de leeftijd groter is. We kunnen dit doen door de database op te vragen voor de huidige gebruiker, vervolgens de conditionering te controleren en waar of onwaar terug te geven.
Maar wat als we deze methode willen implementeren in alle modellen van het gebruikersschema? Dit is hoe we het doen 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());
Op regel 21 voegen we de methodedefinitie toe, en het resultaat op regel 39 zal onwaar zijn. Dit is een eenvoudige, handige manier om methoden aan uw schema toe te voegen, waardoor het meer objectgeoriënteerd wordt.
Als je een wachtwoordveld hebt, kun je een methode zoals encryptPassword() toevoegen om het wachtwoord te versleutelen en ComparePassword(), om de wachtwoorden bij het inloggen te vergelijken met het userSchema zelf. U kunt hier meer lezen over wachtwoordverificatie.
Out-of-the-box Mongoose biedt ook een paar opties wanneer het schema wordt gemaakt. Als u bijvoorbeeld de onderstaande schemadeclaratie bekijkt, geven we een optie strict:false:
door
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
}, {strict : false});
De strikte optie is standaard true en staat niet toe dat de 'niet-schema' sleutel-waardeparen worden opgeslagen. Dit wordt bijvoorbeeld opgeslagen:
var arvind = new User({
name : 'Arvind',
age : 99,
DOB : '01/01/1915',
isAlive : true
});
Overwegende hetgeen volgt:
var arvind = new User({
name : 'Arvind',
age : 99,
DOB : '01/01/1915',
isAlive : true,
bucketList : [{...}, {...}, {...} ]
});
Al het bovenstaande wordt opgeslagen minus de bucketList-array omdat het niet is gedeclareerd als onderdeel van het schema. Geen enkele klant die uw diensten gebruikt, kan dus ongeldige gegevens in uw verzamelingen dumpen.
Een andere leuke optie is de collectie. Als u niet wilt dat uw modelnaam hetzelfde is als de naam van de collectie, kunt u de naam doorgeven als een optie zoals:
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
}, {collection : 'appusers'});
Je kunt hier een lijst met andere opties vinden.
Met Mongoose kunt u ook gebeurtenissen aan uw schema's toevoegen, zoals pre-save of post save, waar u validaties kunt uitvoeren, gegevens kunt verwerken of andere query's kunt uitvoeren in de respectievelijke gebeurtenissen. Deze methoden worden Middlewares genoemd.
Een eenvoudig voorbeeld kan een parallelle middleware zijn zoals:
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);
});
Je kunt hier meer lezen over middleware. In ons volgende bericht zullen we meer hebben over het gebruik van Yeoman om automatisch steigers te genereren voor uw MongoDB-projecten.
Bedankt voor het lezen. Reageer.
@arvindr21