Introduzione a Mongoose per MongoDB

di Nick Karnik

Mongoose è una libreria di modellazione dei dati degli oggetti (ODM) per MongoDB e Node.js. Gestisce le relazioni tra i dati, fornisce la convalida dello schema e viene utilizzato per tradurre tra gli oggetti in codice e la rappresentazione di tali oggetti in MongoDB.

MongoDB è un database di documenti NoSQL senza schema., Significa che è possibile memorizzare documenti JSON al suo interno e la struttura di questi documenti può variare in quanto non viene applicata come i database SQL. Questo è uno dei vantaggi dell’utilizzo di NoSQL in quanto accelera lo sviluppo di applicazioni e riduce la complessità delle distribuzioni.

Di seguito è riportato un esempio di come i dati vengono memorizzati nel database Mongo vs SQL:

Terminologie

Collezioni

‘Collezioni’ in Mongo sono equivalenti alle tabelle nei database relazionali. Possono contenere più documenti JSON.

Documenti

‘Documenti’ sono equivalenti a record o righe di dati in SQL. Mentre una riga SQL può fare riferimento ai dati in altre tabelle, i documenti Mongo di solito lo combinano in un documento.

Campi

‘Campi’ o attributi sono simili alle colonne di una tabella SQL.

Schema

Mentre Mongo è senza schema, SQL definisce uno schema tramite la definizione della tabella., Uno ‘schema ‘ di mangusta è una struttura di dati del documento (o forma del documento) che viene applicata tramite il livello dell’applicazione.

Modelli

‘Modelli’ sono costruttori di ordine superiore che prendono uno schema e creano un’istanza di un documento equivalente a record in un database relazionale.

Guida introduttiva

Installazione Mongo

Prima di iniziare, impostiamo Mongo., È possibile scegliere una delle seguenti opzioni (stiamo usando l’opzione #1 di questo articolo):

1. Scaricare il MongoDB versione per il tuo Sistema Operativo dal database del Sito web e seguire le loro istruzioni per l’installazione
2. Creare gratuitamente un sandbox sottoscrizione del database su mLab
3. Installazione di Mongo utilizzando la finestra Mobile se si preferisce utilizzare la finestra mobile

proviamo a passare attraverso alcuni dei principi fondamentali di Mangusta mediante l’attuazione di un modello che rappresenta i dati di semplificare la rubrica.

Sto usando Visual Studio Code, Node 8.9 e NPM 5.6., Accendi il tuo IDE preferito, crea un progetto vuoto e iniziamo! Useremo la sintassi ES6 limitata nel nodo, quindi non configureremo Babel.

NPM Install

andiamo nella cartella del progetto e inizializzare il nostro progetto

npm init -y

installiamo Mangusta e un validazione biblioteca con il seguente comando:

npm install mongoose validator

L’installazione di comando installa l’ultima versione delle librerie. La sintassi Mangusta in questo articolo è specifica per Mangusta v5 e oltre.,

Connessione al database

Creare un file ./src/database.js sotto la radice del progetto.

Successivamente, aggiungeremo una classe semplice con un metodo che si connette al database.

La stringa di connessione varia in base all’installazione.

La chiamata require(‘mongoose’) sopra restituisce un oggetto Singleton. Significa che la prima volta che chiami require(‘mongoose’), sta creando un’istanza della classe Mongoose e la restituisce., Nelle chiamate successive, restituirà la stessa istanza creata e restituita la prima volta a causa di come funziona l’importazione/esportazione del modulo in ES6.

allo stesso modo, abbiamo trasformato il nostro Database di classe in un singleton, restituendo un’istanza della classe nel module.exports istruzione, perché abbiamo solo bisogno di una singola connessione al database.,

ES6 rende molto facile per noi creare un modello singleton (singola istanza) a causa di come funziona il caricatore del modulo memorizzando nella cache la risposta di un file importato in precedenza.

Schema Mongoose vs. Model

Un modello Mongoose è un wrapper sullo schema Mongoose. Uno schema Mangusta definisce la struttura del documento, i valori predefiniti, i validatori, ecc., mentre un modello Mangusta fornisce un’interfaccia al database per la creazione, l’interrogazione, l’aggiornamento, l’eliminazione di record, ecc.

La creazione di un modello di mangusta comprende principalmente tre parti:

1., Riferimento Mongoose

let mongoose = require('mongoose')

Questo riferimento sarà lo stesso di quello restituito quando ci siamo connessi al database, il che significa che le definizioni dello schema e del modello non dovranno connettersi esplicitamente al database.

2. Definizione dello schema

Uno schema definisce le proprietà del documento attraverso un oggetto in cui il nome della chiave corrisponde al nome della proprietà nella raccolta.,

let emailSchema = new mongoose.Schema({ email: String})

Qui definiamo una proprietà chiamata email con una stringa di tipo schema che si associa a un validatore interno che verrà attivato quando il modello viene salvato nel database. Fallirà se il tipo di dati del valore non è un tipo di stringa.

I seguenti Tipi di Schema sono consentiti:

• Array
• Boolean
• Buffer
• Data
• Misto (A generico / flessibile tipo di dati)
• Numero
• Oggetto
• String

Misto e ObjectId sono definiti in require(‘mongoose’).Schema.Types.

3., Esportazione di un modello

Dobbiamo chiamare il costruttore del modello sull’istanza Mongoose e passargli il nome della raccolta e un riferimento alla definizione dello schema.

module.exports = mongoose.model('Email', emailSchema)

Combiniamo il codice precedente in./src/models/email.js per definire il contenuto di un modello di posta elettronica di base:

Una definizione dello schema dovrebbe essere semplice, ma la sua complessità è solitamente basata sui requisiti dell’applicazione. Gli schemi possono essere riutilizzati e possono contenere anche diversi schemi figlio. Nell’esempio precedente, il valore della proprietà email è un tipo di valore semplice., Tuttavia, può anche essere un tipo di oggetto con proprietà aggiuntive su di esso.

Possiamo creare un’istanza del modello che abbiamo definito sopra e popolarla usando la seguente sintassi:

let EmailModel = require('./email')let msg = new EmailModel({ email: '[email protected]'})

Miglioriamo lo schema Email per rendere la proprietà email un campo obbligatorio univoco e convertire il valore in minuscolo prima di salvarlo. Possiamo anche aggiungere una funzione di convalida che garantirà che il valore sia un indirizzo email valido. Faremo riferimento e utilizzare la libreria di validatore installata in precedenza.,

Operazioni di base

Mangusta ha un’API flessibile e fornisce molti modi per eseguire un’attività. Non ci concentreremo sulle variazioni perché questo è fuori portata per questo articolo, ma ricorda che la maggior parte delle operazioni può essere eseguita in più di un modo sintatticamente o tramite l’architettura dell’applicazione.,

Creare Record

creiamo un’istanza della e-mail il modello e salvarlo nel database:

Il risultato è un documento che viene restituito dopo un salva:

{ _id: 5a78fe3e2f44ba8f85a2409a, email: '[email protected]', __v: 0 }

I seguenti campi vengono restituiti (campi interni sono preceduti da un carattere di sottolineatura):

1. _id campo è auto-generato da Mongo ed è una chiave primaria della collezione. Il suo valore è un identificatore univoco per il documento.
2. Viene restituito il valore del campo email., Si noti che è a casing inferiore perché abbiamo specificato l’attributo lowercase:true nello schema.
3. __v è la proprietà versionKey impostata su ogni documento quando creato per la prima volta da Mongoose. Il suo valore contiene la revisione interna del documento.

Se si tenta di ripetere l’operazione di salvataggio di cui sopra, si otterrà un errore perché abbiamo specificato che il campo e-mail deve essere univoco.

Fetch Record

Proviamo a recuperare il record che abbiamo salvato nel database in precedenza., La classe modello espone diversi metodi statici e di istanza per eseguire operazioni sul database. Ora cercheremo di trovare il record che abbiamo creato in precedenza utilizzando il metodo find e passare l’e-mail come termine di ricerca.

EmailModel .find({ email: '[email protected]' // search query }) .then(doc => { console.log(doc) }) .catch(err => { console.error(err) })

Il documento restituito sarà simile a quello visualizzato quando abbiamo creato il record:

{ _id: 5a78fe3e2f44ba8f85a2409a, email: '[email protected]', __v: 0 }

Aggiorna il record

Modifichiamo il record precedente cambiando l’indirizzo email e aggiungendo un altro campo ad esso, il tutto in una singola operazione., Per motivi di prestazioni, Mongoose non restituirà il documento aggiornato, quindi dobbiamo passare un parametro aggiuntivo per richiederlo:

Il documento restituito conterrà l’email aggiornata:

{ _id: 5a78fe3e2f44ba8f85a2409a, email: '[email protected]', __v: 0 }

Elimina record

Useremo la chiamatafindOneAndRemove per eliminare un record., Restituisce il documento originale che è stato rimosso:

Helper

Abbiamo esaminato alcune delle funzionalità di base sopra note come operazioni CRUD (Create, Read, Update, Delete), ma Mongoose offre anche la possibilità di configurare diversi tipi di metodi e proprietà helper. Questi possono essere utilizzati per semplificare ulteriormente il lavoro con i dati.

Creiamo uno schema utente in./src/models/user.js con i campifirstName elastName:

Proprietà virtuale

Una proprietà virtuale non viene mantenuta nel database., Possiamo aggiungerlo al nostro schema come helper per ottenere e impostare valori.

creare una proprietà virtuale chiamato fullName che può essere utilizzato per impostare i valori su firstName e lastName e li recupero come un valore combinato durante la lettura:

Callback per ottenere e impostare necessario utilizzare la parola chiave function come abbiamo bisogno di accedere al modello tramite il this parola chiave. L’utilizzo delle funzioni fat arrow cambierà a cosa si riferiscethis.,

Ora, siamo in grado di impostare firstName e lastName assegnando un valore fullName:

Il codice di cui sopra verrà restituito il seguente:

{ _id: 5a7a4248550ebb9fafd898cf, firstName: 'Thomas', lastName: 'Anderson' } Thomas Anderson

Metodi di Istanza

E ‘ possibile creare metodi di supporto per lo schema e l’accesso tramite il modello di istanza. Questi metodi avranno accesso all’oggetto modello e possono essere utilizzati in modo abbastanza creativo. Ad esempio, potremmo creare un metodo per trovare tutte le persone che hanno lo stesso nome dell’istanza corrente.,

In questo esempio, creiamo una funzione per restituire le iniziali per l’utente corrente. Aggiungiamo un metodo di supporto personalizzato chiamatogetInitials allo schema:

userSchema.methods.getInitials = function() { return this.firstName + this.lastName}

Questo metodo sarà accessibile tramite un’istanza del modello:

Metodi statici

Simile ai metodi di istanza, possiamo creare metodi statici sullo schema., Creiamo un metodo per recuperare tutti gli utenti nel database:

ChiamaregetUsers sulla classe Model restituirà tutti gli utenti nel database:

UserModel.getUsers() .then(docs => { console.log(docs) }) .catch(err => { console.error(err) })

L’aggiunta di metodi di istanza e statici è un buon approccio per implementare un’interfaccia per le interazioni del database su collezioni e record.

Middleware

Middleware sono funzioni che vengono eseguite in fasi specifiche di una pipeline., Mongoose supporta i middleware per le seguenti operazioni:

• Aggregato
• Documento
• Modello
• Query

Per esempio, i modelli hanno pre e post funzioni che prendono due parametri:

1. Tipo di evento (‘init’, ‘convalida’, ‘salva’, ‘elimina’)
2. Un callback che viene eseguito con questo riferimento il modello di istanza

proviamo con un esempio con l’aggiunta di due campi denominati createdAt e updatedAt per il nostro schema:

Quando model.save() si chiama, c’è un pre(‘save’, …) e post(‘save’, …) evento che viene attivato. Per il secondo parametro, è possibile passare una funzione che viene chiamata quando l’evento viene attivato. Queste funzioni portano un parametro alla funzione successiva nella catena middleware.,

aggiungiamo un pre-salva gancio e impostare i valori di createdAt e updatedAt:

creare e salvare il nostro modello:

Si dovrebbe vedere i valori per createdAt e updatedAt quando il record viene creato è stampato:

Plugins

Supponiamo che si desidera tenere traccia di quando un record è stata creata e aggiornata su ogni raccolta nel nostro database. Invece di ripetere il processo di cui sopra, possiamo creare un plugin e applicarlo a ogni schema.,

Creiamo un file./src/model/plugins/timestamp.js e replichiamo la funzionalità di cui sopra come modulo riutilizzabile:

Per utilizzare questo plugin, lo passiamo semplicemente agli schemi a cui dovrebbe essere data questa funzionalità:

Costruzione di query

Mongoose ha un’API molto ricca che gestisce molte operazioni complesse supportate da MongoDB. Considera una query in cui possiamo creare in modo incrementale componenti di query.,

In questo esempio, stiamo andando:

1. Trovare tutti gli utenti
2. Saltare le prime 100 record
3. Limitare i risultati a 10 record
4. Ordinare i risultati per nome campo
5. Selezionare il nome
6. Eseguire la query

Chiusura

Abbiamo appena scalfito la superficie di esplorare alcune delle funzionalità di Mangusta. Si tratta di una ricca libreria piena di funzioni utili e potenti che lo rendono una gioia per lavorare con i modelli di dati nel livello di applicazione.,

Mentre è possibile interagire con Mongo direttamente utilizzando il driver Mongo, Mongoose semplificherà tale interazione consentendo di modellare le relazioni tra i dati e convalidarli facilmente.

Curiosità: Mangusta è stato creato da Valeri Karpov che è un ingegnere incredibilmente talentuoso! Ha coniato il termine Pila MEDIA.

Se questo articolo è stato utile, ??? e seguimi su Twitter.