W tym poście pokażemy, jak używać Mongoose do wdrożeń MongoDB, aby stworzyć bardziej proste, oparte na schemacie rozwiązanie do modelowania danych aplikacji.
Co to jest mangusta?
Mongoose to „eleganckie modelowanie obiektów MongoDB dla Node.js “. Jeśli wcześniej korzystałeś z MongoDB i próbowałeś podstawowych operacji na bazach danych, być może zauważyłeś, że MongoDB jest „bez schematu”. Jeśli chcesz wdrożyć bardziej ustrukturyzowaną bazę danych i chcesz wykorzystać moc MongoDB, Mongoose jest jednym z ODM (O obiekt D ata M aplikacji) rozwiązania.
Aby szybko zademonstrować, uruchamiasz polecenie wstawiania do kolekcji o nazwie użytkownicy w następujący sposób:
db.users.insert({ name : 'Arvind', gender : 'male'});
A zaraz potem możesz uruchomić:
db.users.insert({ name : 'Arvind', gender : 'male', password : '!@#$'});
i MongoDB nigdy nie będzie narzekać na różnice w liczbie kolumn (par klucz-wartość). To jest bardzo elastyczne. Ale jeśli chcesz, aby Twoje dane były bardziej zorganizowane i ustrukturyzowane, musisz zachować to w kodzie serwera, pisząc walidację, upewniając się, że nic nieistotnego nie jest przechowywane w kolekcji. Tutaj Mongoose ułatwia życie.
„Mongoose zapewnia proste, oparte na schemacie rozwiązanie do modelowania danych aplikacji i zawiera wbudowane rzutowanie typów, walidację, tworzenie zapytań, zaczepy logiki biznesowej i nie tylko , po wyjęciu z pudełka”.
Zainstaluj Node.js i MongoDB
Aby korzystać z Mongoose, musimy mieć zainstalowany Node.js. Informacje znajdziesz tutaj.
Rozpocznij programowanie
Najpierw stwórzmy mały plac zabaw, na którym będziemy się dobrze bawić. Utwórz nowy folder o nazwie myMongooseApp i otwórz terminal/monit tutaj i uruchom:
npm init
Pomoże nam to w zainicjowaniu nowego projektu węzła. Uzupełnij zgodnie z wymaganiami. Następnie zainstalujemy Mongoose jako zależność od naszego projektu. Uruchom:
npm install mongoose --save-dev
Następnie uruchom usługę MongoDB, uruchamiając:
mongod
Następnie utwórz nowy plik o nazwie index.js w katalogu głównym, a następnie otwórz go w swoim ulubionym edytorze. Dodaj poniższy kod:
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.');
});
Tutaj potrzebujemy pakietu Mongoose, aby połączyć się z bazą danych i zainicjować połączenie. Nazwa naszej bazy danych to myTestDB.
Następnie uruchom:
node index.js
Powinieneś teraz zobaczyć połączoną wiadomość. Możesz także użyć pakietu węzłów o nazwie nodemon do automatycznego restartowania serwera węzłów po zmianach.
Teraz nasza piaskownica jest gotowa do gry!
Schematy mongusty
Schematy są jak szkielety, szkielety tego, jak będzie wyglądać Twoje zbieranie danych. Jeśli masz do czynienia z kolekcją użytkowników, Twój schemat będzie wyglądał mniej więcej tak:
Name - String Age - Number Gender - String Date of Birth - Date
Jeśli masz do czynienia z kolekcją produktów, Twój schemat będzie wyglądał mniej więcej tak:
SKU - String Name - String Price - Number InStock - Boolean Quantity - Number
Widać dryf. Gdy nasze dane są chronione za pomocą takiego schematu, możliwość przechowywania danych śmieci drastycznie się zmniejsza.
Teraz, gdy znamy już schematy, spróbujmy zbudować schemat użytkownika za pomocą Mongoose. Wróć do index.js i dodaj poniższy kod:
var Schema = mongoose.Schema;
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
});
Tutaj znajdziesz podstawowe pola związane z użytkownikami i ich typy schematów.
Następnie utworzymy model ze schematu. Dodaj:
var User = mongoose.model('User', userSchema);
To wszystko, nasz model użytkownika jest gotowy! Użyjemy tego jako naszego podstawowego schematu do wstawiania użytkowników do bazy danych. W ten sposób wiemy, że każdy dokument w kolekcji użytkownika będzie miał pola wymienione w schemacie. Stwórzmy nową instancję użytkownika i zapiszmy ją w DB. Dodaj:
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 );
});
Powinieneś zobaczyć coś takiego:
Saved : { __v: 0,
name: 'Arvind',
age: 99,
DOB: Fri Jan 01 1915 00:00:00 GMT+0530 (IST),
isAlive: true,
_id: 536a4866dba434390d728216 }
Bez kłopotów, bez problemów. Prosty i łatwy interfejs API do interakcji z modelami.
Powiedzmy, że chcemy, aby każdy model miał metodę o nazwie isYounger. Ta metoda zwróci prawdę, jeśli wiek jest mniejszy niż 50, a fałsz, jeśli wiek jest większy. Możemy to zrobić, wysyłając zapytanie do bazy danych dla bieżącego użytkownika, a następnie sprawdzając warunkowanie i zwracanie prawdy lub fałszu.
A co, jeśli chcemy zaimplementować tę metodę do wszystkich modeli schematu użytkownika? Tak to robimy w 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());
W linii 21 dodajemy definicję metody, a wynik w linii 39 będzie fałszywy. Jest to prosty i wygodny sposób na dodawanie metod do schematu, dzięki czemu jest on bardziej zorientowany obiektowo.
Jeśli masz pole hasła, możesz dodać metodę, taką jak encryptPassword(), aby zaszyfrować hasło i ComparePassword(), aby porównać hasła podczas logowania do samego userSchema. Możesz przeczytać więcej o uwierzytelnianiu hasłem tutaj.
Niestandardowe rozwiązanie Mongoose udostępnia również kilka opcji podczas tworzenia schematu. Na przykład, jeśli spojrzysz na poniższą deklarację schematu, przekazujemy opcję strict:false:
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
}, {strict : false});
Opcja strict jest domyślnie ustawiona na true i nie pozwala na zapisywanie par klucz-wartość „nie będących schematem”. Na przykład zostanie to zapisane:
var arvind = new User({
name : 'Arvind',
age : 99,
DOB : '01/01/1915',
isAlive : true
});
Zważywszy, że:
var arvind = new User({
name : 'Arvind',
age : 99,
DOB : '01/01/1915',
isAlive : true,
bucketList : [{...}, {...}, {...} ]
});
Wszystkie powyższe zostaną zapisane bez tablicy bucketList, ponieważ nie zostały zadeklarowane jako część schematu. Tak więc żaden klient, który korzysta z twoich usług, nie będzie w stanie zrzucić nieprawidłowych danych do twoich kolekcji.
Kolejną fajną opcją jest kolekcja. Jeśli nie chcesz, aby nazwa Twojego modelu była taka sama jak nazwa kolekcji, możesz podać nazwę jako opcję, na przykład:
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
}, {collection : 'appusers'});
Listę innych opcji znajdziesz tutaj.
Dzięki Mongoose możesz również dodawać zdarzenia do swoich schematów, takie jak przed zapisywaniem lub po zapisaniu, gdzie możesz przeprowadzać walidacje, przetwarzać dane lub uruchamiać inne zapytania w odpowiednich zdarzeniach. Te metody są nazywane Middleware.
Prostym przykładem może być równoległe oprogramowanie pośredniczące, takie jak:
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);
});
Więcej informacji o oprogramowaniu pośredniczącym znajdziesz tutaj. W naszym następnym poście porozmawiamy więcej o używaniu Yeoman do automatycznego generowania rusztowań dla projektów MongoDB.
Dziękuje za przeczytanie. Komentuj.
@arvindr21
