Ora che abbiamo avuto una rapida panoramica di Mongoose ODM e
come Mongoose porta schemi per strutturare i documenti che memorizziamo nel nostro MongoDB,
diamo un'occhiata a come facciamo uso
del modulo nodo Mongoose e quindi incorporarlo nella nostra applicazione nodo.
Quindi utilizzare Mongoose per comunicare con
il nostro server MongoDB e quindi memorizzare e recuperare
documenti con informazioni sulla struttura nei documenti.
Per iniziare a questo esercizio,
vai in una posizione comoda sul tuo computer.
Quindi, eccomi nella cartella Node JS in cui ho memorizzato
tutti gli esempi di questo corso e poi
creerò una nuova cartella denominata nodo Mongoose.
Questo è dove creeremo l'applicazione nodo utilizzando Mongoose prossimo.
Nel terminale o nella finestra di comando,
passare alla cartella Mongoose nodo e quindi inizializzare un'applicazione nodo lì.
Quindi, lasciami digitare npm init e quindi
inizializzare l'applicazione del nodo e poi chiamerei l'applicazione
come node-mangusta e il punto di ingresso è index.js git history,
parole chiave, autore e licenza e diremo okay.
Una volta creato il file package.json del nodo,
apri il progetto nell'editor di testo a tua scelta.
Quindi, qui ho il mio progetto aperto in Visual Studio.
Lasciami andare nel file package.json e quindi aggiungere
lo script di avvio e poi
diremo indice di avvio del nodo come al solito ogni volta che iniziamo con una nuova applicazione nodo.
Quindi, andando al terminale o alla finestra di comando, installiamo Mongoose.
Quindi, al prompt digitare npm installa Mongoose, salva.
Che al momento è Mongoose 5.1.7.
Quindi, queste sono le versioni che userò in questo corso.
Quindi andando alla mia applicazione nell'editor.
Permettetemi di creare una sottocartella nel progetto chiamato come Models.
Quindi, questo è dove ho intenzione di memorizzare tutti i modelli per la mia applicazione.
Nella cartella dei modelli,
permettetemi di creare un nuovo file denominato dishes.js.
Quindi, questo è dove ho intenzione di creare lo schema e il modello
per i miei piatti documento che ho intenzione di memorizzare,
la collezione di piatti che memorizza i documenti per ogni piatto.
Quindi, proprio lì, fammi importare prima Mangusta.
Quindi, avremo bisogno di Mongoose in questo file e poi dire
const schema è Mongoose schema.
Quindi, creeremo lo schema qui.
Quindi, diremo const DishSchema nuovo schema.
Quindi, questo è dove definisco lo schema per il mio piatto.
All' interno di questo schema, permettetemi di definire i vari valori.
Quindi, dirò nome,
che è il tipo String.
Quindi, questo è il tipo di schema e quindi questo dichiarerei come richiesto.
Quindi, dirò vero.
Quindi, ogni documento avrà il nome come campo obbligatorio lì e poi
dichiarerò anche questo come significato univoco che
nessun documento dovrebbe avere lo stesso campo nome in là.
Quindi, questo è il primo campo nel mio documento.
Quindi, includeremo anche un altro campo chiamato come, descrizione.
La descrizione è della stringa di tipo e richiesto true.
Inoltre, possiamo avere Mongoose inserire automaticamente
timestamp nel nostro modello.
Quindi, proprio lì possiamo semplicemente impostare i timestamp della bandiera: vero.
Quindi, questo aggiungerà automaticamente il creato a e aggiornato a,
due timestamp in ogni documento che è memorizzato
nella nostra applicazione e aggiornerà automaticamente questi valori.
Ogni volta che aggiorniamo il documento e il creato a verrà automaticamente
inizializzato quando il documento è il primo creatore di questo tempo.
Dopo questo, diremo piatti var.
Quindi, dato lo schema,
ora stiamo andando a costruire il modello da questo schema.
Quindi, diremo modello Mangusta e piatto,
e questo sta per essere utilizzando lo schema piatto che abbiamo appena dichiarato in precedenza.
Quindi esporteremo
questo modello da questo file qui.
Quindi, diremo piatti di esportazione del modulo.
Così, ora abbiamo costruito
lo schema Mongoose e il modello corrispondente e il modello è ora esportato da qui.
Quindi, questo può essere importato nella nostra applicazione e utilizzato.
Quindi, all'interno della nostra cartella di progetto,
lasciami creare un nuovo file chiamato index.js.
Nel file index.js,
permettimi prima di richiedere Mongoose,
e poi dopo questo possiamo dire
const Piatti richiedono piatti di modelli.
Perché abbiamo già creato il modello Piatti
nel file piatti modelli lì e quindi lo stiamo richiedendo qui.
Ora, per stabilire la connessione al server Mongo,
diremo const URL mongodb.
Localhost 27017, Confusione.
Quindi, questo database è quello che ci collegheremo dalla nostra applicazione e
poi dopo che possiamo stabilire la connessione dicendo const connect Mongoose.
Mongoose supporta questo metodo di connessione,
che accetta l'URL come primo parametro.
Quindi, una volta stabilito questo,
allora diciamo semplicemente collegare poi.
Si noti che dal momento che stiamo già usando le promesse,
possiamo solo dire connetti poi e poi questo prenderà
una funzione come parametro
e dentro qui possiamo ora connetterci al database.
Così ora una volta stabilita questa connessione,
lasciami fare un registro console
dicendo collegato correttamente al server,
e qui posso creare un nuovo piatto dicendo var
nuovo piatto e poi Piatti e dentro qui posso specificare un documento così sto creando
un nuovo piatto di questo tipo e poi così qui
Specificherò i due campi che sono obbligatori.
Quindi dirò nome,
descrizione e così è come si creerebbe un nuovo piatto e poi una volta creato
un nuovo piatto dal modello diremo semplicemente nuovo piatto salvare.
Il metodo di salvataggio farà sì che questo valore Dish venga
salvato e poi come ci si aspetta restituirà una promessa e
poi qui otterremo il valore Dish come richiamo lì e poi,
posso semplicemente registrare il valore Dish qui e poi diremo
Piatti trovare e così troveremo
tutti i Piatti e poi dire exec.
L' exec si assicurerà che questo venga
eseguito e che restituisca una promessa e in modo che la promessa
venga restituita in modo che possa quindi
concatenare il metodo a quelli rimanenti.
Quindi vedi come sto usando le promesse e poi sto invocando il metodo precedente in modo che questo
trovi tutti i piatti all'interno del mio database,
nella collezione Piatti e quindi me li rende disponibili.
Quindi, quando ottengo i piatti, posso semplicemente consolare il registro dei piatti solo per vedere cosa viene
restituito e questo ovviamente in questa fase dovrebbe
restituire questo singolo piatto che ho inserito nella
mia collezione Piatti e poi diremo di
ritorno Piatti rimuovi con
un oggetto JavaScript vuoto che rimuoverà tutti i piatti
dal database e restituirà la chiusura della
connessione mangusta che chiude la connessione al database.
E cattura qualsiasi errore a questo punto.
Quindi useremo il catch e poi il log della console.
Questo è tutto. Quindi quello che stiamo facendo qui è che stiamo creando il nuovo questo piatto e poi stiamo
salvando il piatto, quindi stiamo trovando tutti i piatti della collezione.
Questo è tutto. Stiamo usando le promesse qui,
quindi abbiamo incatenato tutte le tane qui dentro. Questo è tutto.
Salviamo le modifiche e quindi vedere questa applicazione in esecuzione.
Vai al terminale,
al prompt tipo npm start e
vedrai che la mia applicazione nodo viene eseguita e poi mostra,
prima, che ha creato questo particolare Dish.
Nota in particolare, che questi due campi,
aggiornati e creati a,
questi due timestamp sono stati aggiunti automaticamente
nel Dish qui e così puoi vedere che il creato a e
aggiornato a timestamp sono esattamente gli stessi al momento e
quindi l'ID viene anche aggiunto automaticamente in.
Nella fase successiva stiamo stampando tutti i piatti che sono stati recuperati e così si
può vedere che questo singolo piatto è nella collezione, collezione
Piatti, e questo è ciò che viene stampato sullo schermo qui.
Inizializziamo ora il repository Git e poi impostiamo il file gitignore ottenuto
quindi andando all'editor quindi creiamo il file.gitignore e quindi aggiungiamo
i moduli nodo al file gitignore e salviamo le modifiche e
poi tornando al prompt fammi
digitare git status e vediamo che
abbiamo questi file che non sono stati controllati, quindi diremo
git add e poi git
commit il messaggio Mongoose Part One.
Con questo completiamo questo esercizio.
In questo esercizio abbiamo visto quanto sia facile impostare un'applicazione nodo con
mangusta e connettersi al nostro server MongoDB e quindi interagire con esso.
Ora poiché mangusta si basa sul server MongoDB,
Mongoose può accedere a tutti i vari metodi
supportati dal driver MongoDB anche.