Nella lezione precedente,
abbiamo imparato a conoscere il driver MongoDB.
Ciò consente alla nostra applicazione nodo di comunicare con un server MongoDB,
e anche memorizzare e recuperare documenti dal server MongoDB.
Abbiamo anche visto che il driver MongoDB ci fornisce
molti metodi che ci consentono di creare raccolte all'interno di un database,
aggiungere documenti alle raccolte
e quindi eseguire varie operazioni sui documenti all'interno di una raccolta.
Ora, quando i documenti sono memorizzati nel database,
il driver MongoDB stesso non impone alcuna struttura ai documenti.
Se abbiamo bisogno di avere una struttura specifica per i documenti e applicare quella struttura,
allora abbiamo bisogno di fare uso del modulo nodo Mongoose che ci permette di definire
uno schema e una struttura per i nostri documenti che sono memorizzati nel nostro database MongoDB,
e applica rigorosamente la struttura.
Diamo un'occhiata a maggiori dettagli in questa lezione e agli esercizi che seguono questa lezione.
Come abbiamo già imparato,
MongoDB memorizza i dati in raccolte in un database.
Queste raccolte sono costituite da una raccolta di documenti.
I documenti stessi memorizzati in
un database MongoDB non hanno alcuna struttura specifica imposta al documento.
Qualsiasi documento può essere memorizzato in qualsiasi raccolta.
MongoDB si affida allo sviluppatore per far rispettare la struttura sui documenti,
e dà la piena responsabilità allo sviluppatore di assicurarsi che i documenti
della struttura corretta vengano aggiunti e mantenuti nelle varie collezioni.
Ora, è molto facile violare questo.
Ad esempio, anche se si potrebbe iniziare con il presupposto
che una particolare connessione avrà documenti di una determinata struttura,
è possibile inserire facilmente documenti che non necessariamente sono conformi alla struttura.
Se sei molto particolare che la struttura dei documenti in
una raccolta abbia sempre una struttura specificata
e avrai sempre il set specifico di campi,
allora lo stesso MongoDB non impone che nemmeno
il driver MongoDB nodo che abbiamo visto nella lezione precedente.
Questo è dove avremo bisogno di un modo più formale di imporre
la struttura sui documenti che sono memorizzati in una raccolta in un database MongoDB.
Questo è dove il modulo nodo Mangusta viene in nostro aiuto.
Il modulo nodo Mangoose impone
una struttura standardizzata per i documenti memorizzati in una particolare raccolta.
Quindi, questo è il motivo per cui sentiamo spesso persone che si riferiscono a questo come l'ODM di Mangusta.
L' ODM stesso viene interpretato da alcune persone per indicare
Object Data Model o talvolta indicato come Object Document Mapping,
o alcune persone si riferiscono ad esso come ORM o Object Relational Mapping.
Ora, quando parliamo di relazionale che si applica molto di più ai database relazionali,
ma poi con i database SQL avevamo bisogno esplicitamente dell'oggetto
alla mappatura relazionale da inserire tra il database e la nostra applicazione stessa.
Perché all'interno dell'applicazione staremmo guardando
gli oggetti ma la loro memorizzazione in un database SQL sarà sotto forma di record,
e quindi è necessario un mapping esplicito.
Come abbiamo visto con il database NoSQL,
questo non era esplicitamente richiesto.
Ma se hai bisogno di imporre una struttura sui tuoi documenti che sono memorizzati in una raccolta
allora l'uso di Mangusta per imporre questa struttura è molto, molto utile.
Il modo in cui Mongoose va in giro
imponendo struttura sui documenti è attraverso l'uso di schema.
Schema, definisce la struttura dei loro documenti.
Parliamo di questo in modo un po 'più dettagliato.
Quindi, cos'è esattamente lo schema di mangusta
e cosa porta al tavolo?
Schema mangusta, implica una struttura
sui dati memorizzati in un documento nel database.
Quindi, definisce tutti i campi del documento,
e specifica anche i tipi dei campi,
e anche in grado di fornirci
funzionalità aggiuntive che possono abilitare la convalida su questi campi.
Quindi, ad esempio, i vari tipi di schema supportati in Mongoose includono: String,
Number, Date, Buffer, Boolean,
Mixed, ID oggetto e Array.
In particolare vedremo il numero di stringa,
e una data, e booleano nell'esercizio che segue.
Vedremo alcuni degli altri negli esercizi successivi.
In particolare, si noti l'uso del tipo di schema di array.
Quindi, un tipo di schema di array consentirebbe di
creare una matrice di documenti secondari all'interno del documento.
Ne parlerò tra un po'.
Una volta definito uno schema,
lo schema viene utilizzato in Mongoose per creare una funzione del modello,
ed è ciò che consente di definire la struttura per i documenti nel database.
Gli schemi stessi possono avere nidificazione.
Quindi, il che significa che è possibile avere documenti secondari che sono racchiusi all'interno di un documento.
I documenti secondari in genere vengono ospitati
specificando uno schema aggiuntivo
e quindi definendo uno dei campi dello schema per essere fuori dal tipo dell'altro schema.
Oppure puoi anche andare con una matrice di un
altro tipo di schema all'interno di un secondo schema che definisci.
Diamo un'occhiata a un esempio per chiarire alcuni di questi in modo più dettagliato.
Questo esempio sarà tratto dall'esercizio che farai subito dopo questa lezione.
Prima di poter parlare di schemi e modelli in Mongoose,
cerchiamo di capire perché ne avremmo bisogno.
Se hai preso il precedente angolare,
o lo ionico, o il corso di script nativo,
hai visto che rappresentiamo
vari dati che usiamo nelle nostre applicazioni sotto forma di stringhe JSON.
Quindi, nella nostra applicazione definiamo una collezione chiamata come piatti.
In una raccolta di piatti,
ogni piatto conterrà un certo insieme di proprietà definite sotto forma di stringa JSON,
come si vede in questo esempio qui.
Quindi, i piatti sono una matrice di tipo piatto,
e ogni piatto stesso conterrà un nome,
un'immagine, una categoria
, un'etichetta e così via.
Inoltre, all'interno del documento piatto stesso,
avresti commenti che vengono memorizzati come una matrice di
documenti JSON che contengono campi specifici step.
Quindi, ogni commento, ad esempio,
contiene un autore commento di valutazione e un campo data, come si vede in questo esempio qui.
Quindi, si vede che c'è una struttura chiara per
ogni documento che definisce un piatto che è memorizzato nel nostro database.
Più piatti ovviamente saranno conservati sotto forma di una raccolta nel nostro database,
e potrebbero essere raggruppati insieme e inviati come una serie di
piatti alla nostra applicazione cliente da utilizzare.
Ora che abbiamo capito come questo è definito, ora,
come si riferisce allo schema Mongoose e al modello che definiamo in Mongoose?
Ora, nota la struttura di un tipico documento piatto qui.
Quindi, questo potrebbe essere facilmente mappato in un documento MongoDB in una raccolta,
forse chiamato collezione di piatti.
Quindi, vediamo che c'è una struttura chiara al documento stesso.
Ora, come facciamo a rispecchiare questo in uno schema nella nostra applicazione Mongoose?
Come imparerete nell'esercizio,
vedremo che definiremmo schemi in Mangusta.
Quindi lo schema è definito come uno schema Mongoose qui.
Ad esempio, un CommentSchema è mostrato qui.
Il CommentSchema, come puoi vedere,
contiene tre campi diversi: la valutazione, il commento
e il campo autore,
e anche i timestamp qui.
I timestamp consentono di avere due campi diversi nel
documento: il campo creato a e il campo aggiornato a,
entrambi i quali sono timestamp memorizzati sotto forma di una stringa di data ISO nel documento.
Ora, la valutazione stessa sarebbe un valore intero.
Quindi, nella terminologia di
Mangusta, verrà memorizzato come numero,
il tipo sarebbe un numero.
È anche possibile specificare il valore minimo e massimo.
È inoltre possibile specificare che questo particolare campo è obbligatorio, quindi, il
che significa che ogni documento del tipo di commento deve contenere un campo di valutazione.
Allo stesso modo, è anche possibile definire un campo di commento,
che è della stringa di tipo.
Quindi, ovviamente, un commento non è altro che una stringa che contiene alcune informazioni,
e questo può anche essere definito come un campo obbligatorio, il
che significa che ogni documento dovrebbe contenere un commento,
e anche un campo autore,
che è anche della stringa di tipo.
Quindi, si vede che definendo questo schema in questo formato.
Come abbiamo imparato nella discussione un po 'prima,
schema è definito utilizzando i vari tipi che abbiamo nella nostra applicazione Mongoose.
Quindi, nello schema, ancora una volta,
si vedono tre campi diversi qui,
valutazione, commento e autore qui,
e ognuno dei quali ha un tipo specifico dato,
e quindi se questo è richiesto o meno.
Quindi, in tal modo, stai imponendo una struttura rigorosa
sui documenti di commento che verranno archiviati nella tua applicazione.
Ora che abbiamo definito uno schema di commento, possiamo quindi,
come avete notato dall'esempio del tipo di dati che abbiamo bisogno nella nostra applicazione,
abbiamo un documento piatto stesso.
Il documento piatto contiene vari campi.
Qui, nell'esercizio,
introdurremo solo due campi nel documento piatto,
il nome e la descrizione.
Nella prossima lezione,
introdurremo i campi rimanenti per il DishSchema.
Ora, quindi il nome,
come in questo caso,
è della stringa di tipo.
Possiamo anche specificare che questo è un campo obbligatorio,
il che significa che ogni documento dovrebbe contenere il campo nome.
Possiamo anche specificare che il campo nome è univoco, il
che significa che nessun documento può avere esattamente lo stesso valore del nome nel documento.
Quindi, questo assicura che ogni documento avrà
un campo nome univoco in esso e un campo di descrizione,
che è di nuovo della stringa di tipo,
ma anche specificato come richiesto.
Ora, come abbiamo visto nell'esempio,
un documento piatto contiene più commenti racchiusi all'interno del documento.
Ora, in Mongoose, questo è supportato attraverso l'uso di sottodocumenti.
Quindi, se si definisce uno schema in precedenza,
così per esempio, abbiamo già definito un CommentSchema qui,
è anche possibile definire un campo in un altro schema
che si definisce e quindi specificare che tale campo sarà
del tipo dello schema precedente che avete definito.
Quindi, in questo caso,
il campo dei commenti, lo sto definendo come un array,
quindi vedi l'uso di un tipo di array nello schema che stai definendo qui,
e quindi array del tipo CommentSchema.
Quindi, questa è una serie di commenti che saranno inclusi in ogni documento piatto.
Quindi, in tal modo, è possibile avere
più di un documento secondario di commento racchiuso all'interno di un documento piatto.
Quindi, definendo la struttura in questo modo ci permette di supportare
la corrispondente struttura stringa JSON che abbiamo definito
per un documento piatto o che abbiamo visto nell'esempio precedente.
Ora, una volta definito lo schema,
per fare uso di questo nella nostra applicazione,
abbiamo bisogno di creare un modello da quello schema che abbiamo appena definito.
Quindi, all'interno della nostra applicazione,
definiremo un modello Mongoose e specificare che il modello
è fuori dal tipo dishSchema in questo esempio.
Non solo, darai anche un nome al modello qui.
Quindi, quando si dà un nome al modello qui,
stiamo specificando il nome come piatto.
Ora, quando si utilizza questo modello piatto nella
nostra applicazione nodo in cui stiamo facendo uso di Mongoose,
allora questo sarà trasformato e mappato in una raccolta nel mio database MongoDB.
La collezione stessa sarà nominata come piatti.
Quindi, Mongoose sa automaticamente che quando si specifica un nome qui,
costruirà automaticamente il plurale
di quel nome e quindi darà alla raccolta il nome,
che è il plurale del nome del modello specificato in questo esempio.
Quindi, quando dico piatto qui,
Mongoose automaticamente lo mapperà
nella raccolta di piatti nel database MongoDB.
Come fa a sapere come convertire questo nome singolare in un plurale?
Mongoose ha automaticamente un meccanismo integrato che gli
permette di costruire i plurali di parole inglesi standard.
Quindi, se dici piatto,
costruirà piatti.
Se dici leader, costruirà il plurale di esso come leader, e così via.
Quindi, questo è già integrato nel modulo nodo Mongoose.
Quindi, questo è il motivo per cui quando lo specifico come tipo di modello di piatto,
Mongoose costruirà la collezione di piatti nel mio database MongoDB,
e quindi quella raccolta di piatti memorizzerà
i vari documenti del tipo di piatto lì dentro.
Una volta che abbiamo creato che, in genere,
quando dichiariamo modelli nella nostra applicazione,
vorremmo memorizzarli in una sottocartella denominata modelli, solo per comodità.
Non è necessario farlo,
ma solo per organizzare l'applicazione,
normalmente lo memorizzeremmo in una cartella denominata modelli.
Quindi lo schema e il modello sarebbero
definiti in un file come questo come si vede nell'esempio qui,
questo chiamato dishes.js, e quindi questo verrebbe esportato perché questo è un modulo nodo.
Questo verrà esportato da questo file in modo che possa essere incluso nell'applicazione nodo,
dove faremo uso di
questo schema e del modello che abbiamo appena definito qui.
Con questa rapida comprensione dello schema e del modello e il
suo uso nella definizione della struttura di un documento che memorizziamo in un MongoDB,
torniamo indietro e capiamo un po 'di più su ciò che Mongoose ci fornisce.
Inoltre, Mongoose ci permette di stabilire la connessione con il server MongoDB.
Mangusta utilizza internamente
il driver MongoDB che avevamo usato nell'esercizio precedente.
Quindi, Mongoose dipende dal driver MongoDB, quindi,
il che significa che dall'applicazione del nodo basata su Mongoose,
è possibile utilizzare tutti i metodi che sono già
disponibili dal driver MongoDB anche se si sceglie di farlo,
ma Mongoose stesso ha una propria raccolta di metodi che
possiamo rendere uso di per interagire con il database MongoDB,
come vedremo nell'esercizio che segue.
Permettetemi di mostrarvi brevemente come stabilire una connessione al database,
e lo farete nell'esercizio che segue.
Quindi, proprio come abbiamo dichiarato l'URL nel caso
dell'applicazione nodo MongoDB nella lezione precedente,
continueremo a dichiarare l'URL per la nostra applicazione.
Quindi useremo il metodo di connessione Mongoose
e fornire l'URL per il metodo di connessione Mongoose,
e questo stabilirà la connessione al database.
Con questa rapida comprensione di Mongoose e quale ruolo
gioca Mongoose nel supportare l'inserimento strutturato
, l'archiviazione e il recupero di documenti dal nostro MongoDB,
passiamo all'esercizio in cui
otterremo qualche esperienza pratica usando il modulo Mongoose.