In questo post, ti mostreremo come utilizzare Mongoose per le distribuzioni di MongoDB per creare una soluzione più semplice e basata su schemi per modellare i dati delle tue applicazioni.
Cos'è la mangusta?
Mongoose è una "elegante modellazione di oggetti MongoDB per Node.js “. Se hai già utilizzato MongoDB e provato le operazioni di base del database, potresti aver notato che MongoDB è "senza schema". Quando stai cercando di implementare un database più strutturato e vuoi sfruttare la potenza di MongoDB, Mongoose è uno degli ODM (O oggetto D ata M apping) soluzioni.
Per dimostrare rapidamente, esegui un comando di inserimento in una raccolta denominata utenti in questo modo:
db.users.insert({ name : 'Arvind', gender : 'male'});
E subito dopo, puoi eseguire:
db.users.insert({ name : 'Arvind', gender : 'male', password : '!@#$'});
e MongoDB non si lamenteranno mai della variazione del numero di colonne (coppie chiave-valore). Questo è molto flessibile. Ma quando vuoi mantenere i tuoi dati più organizzati e strutturati, dovresti mantenerli nel codice del tuo server, scrivendo la convalida, assicurandoti che nulla di irrilevante sia archiviato in una raccolta. È qui che Mongoose semplifica la vita.
"Mongoose fornisce una soluzione semplice e basata su schemi per modellare i dati dell'applicazione e include typecasting, convalida, creazione di query, hook di business logic e altro ancora , fuori dagli schemi."
Installa Node.js e MongoDB
Per utilizzare Mongoose, è necessario che Node.js sia installato. Puoi trovare informazioni qui.
Inizia a sviluppare
Per prima cosa, creiamo un piccolo parco giochi dove possiamo divertirci. Crea una nuova cartella denominata myMongooseApp e apri il terminale/prompt qui ed esegui:
npm init
Questo ci aiuterà nell'inizializzazione di un nuovo progetto di nodo. Riempilo come richiesto. Successivamente, installeremo Mongoose come dipendenza dal nostro progetto. Corri:
npm install mongoose --save-dev
Quindi, avvia il servizio MongoDB eseguendo:
mongod
Quindi, crea un nuovo file chiamato index.js alla radice e poi aprilo nel tuo editor preferito. Aggiungi il codice seguente:
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.');
});
Qui è necessario che il pacchetto Mongoose si connetta al database e inizializzi la connessione. Il nome del nostro database è myTestDB.
Quindi, esegui:
node index.js
Ora dovresti vedere il messaggio connesso. Puoi anche utilizzare un pacchetto di nodi denominato nodemon per riavviare automaticamente il server del nodo in caso di modifiche.
Ora, la nostra sandbox è pronta per giocare!
Schemi Mangusta
Gli schemi sono come scheletri, le ossa nude di come apparirà la tua raccolta di dati. Se hai a che fare con una raccolta di utenti, il tuo schema sarebbe simile a questo:
Name - String Age - Number Gender - String Date of Birth - Date
Se hai a che fare con una raccolta di prodotti, il tuo schema sarà simile a questo:
SKU - String Name - String Price - Number InStock - Boolean Quantity - Number
Puoi vedere la deriva. Quando i nostri dati sono protetti con uno schema come questo, la possibilità di archiviare dati spazzatura si riduce drasticamente.
Ora che abbiamo una comprensione degli schemi, proviamo a creare uno schema utente usando Mongoose. Torna a index.js e aggiungi il codice seguente:
var Schema = mongoose.Schema;
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
});
Trova i campi di base relativi all'utente e i relativi tipi di schema qui.
Successivamente, creeremo un modello dallo schema. Aggiungi:
var User = mongoose.model('User', userSchema);
Ecco fatto, il nostro modello utente è pronto! Lo useremo come schema di base per inserire gli utenti nel database. In questo modo, sappiamo che ogni documento in una raccolta utente avrà i campi elencati nello schema. Creiamo una nuova istanza utente e la salviamo su DB. Aggiungi:
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 );
});
Dovresti vedere qualcosa del genere:
Saved : { __v: 0,
name: 'Arvind',
age: 99,
DOB: Fri Jan 01 1915 00:00:00 GMT+0530 (IST),
isAlive: true,
_id: 536a4866dba434390d728216 }
Nessuna seccatura, nessun problema. API semplice e facile per interagire con i modelli.
Diciamo che vogliamo che ogni modello abbia un metodo chiamato isYounger. Questo metodo restituirà true se l'età è inferiore a 50 anni e false se maggiore. Possiamo farlo interrogando il database per l'utente corrente, quindi controllando il condizionamento e restituendo true o false.
E se volessimo implementare questo metodo su tutti i modelli di User schema? Ecco come lo facciamo 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());
Alla riga 21, aggiungiamo la definizione del metodo e il risultato alla riga 39 sarà falso. Questo è un modo semplice e pratico per aggiungere metodi al tuo schema, rendendolo più orientato agli oggetti.
Nel caso in cui tu abbia un campo password, puoi aggiungere un metodo come encryptPassword(), per crittografare la password e comparePassword(), per confrontare le password al login con userSchema stesso. Puoi leggere ulteriori informazioni sull'autenticazione della password qui.
Mongoose pronto all'uso fornisce anche alcune opzioni quando viene creato lo schema. Ad esempio, se dai un'occhiata alla dichiarazione dello schema seguente, stiamo passando un'opzione strict:false:
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
}, {strict : false});
L'opzione strict è true per impostazione predefinita e non consente il salvataggio delle coppie chiave-valore "non schema". Ad esempio, questo verrà salvato:
var arvind = new User({
name : 'Arvind',
age : 99,
DOB : '01/01/1915',
isAlive : true
});
Considerando che:
var arvind = new User({
name : 'Arvind',
age : 99,
DOB : '01/01/1915',
isAlive : true,
bucketList : [{...}, {...}, {...} ]
});
Tutto quanto sopra verrà salvato meno l'array bucketList perché non è stato dichiarato come parte dello schema. Pertanto, nessun cliente che consuma i tuoi servizi sarà in grado di scaricare dati non validi nelle tue raccolte.
Un'altra opzione interessante è la raccolta. Se non vuoi che il nome del tuo modello sia uguale al nome della collezione, puoi passare il nome come un'opzione come:
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
}, {collection : 'appusers'});
Puoi trovare un elenco di altre opzioni qui.
Con Mongoose, puoi anche aggiungere eventi ai tuoi schemi come pre-salvataggio o post-salvataggio, dove puoi eseguire convalide, elaborare dati o eseguire altre query nei rispettivi eventi. Questi metodi sono chiamati Middleware.
Un semplice esempio può essere un middleware parallelo come:
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);
});
Puoi leggere di più sui middleware qui. Nel nostro prossimo post parleremo di più sull'utilizzo di Yeoman per generare automaticamente lo scaffolding per i tuoi progetti MongoDB.
Grazie per aver letto. Commenta.
@arvindr21
