ExpressJS - Datenbank

Wir erhalten weiterhin Anfragen, speichern diese jedoch nirgendwo. Wir benötigen eine Datenbank, um die Daten zu speichern. Dazu nutzen wir die aufgerufene NoSQL-DatenbankMongoDB.

Folgen Sie diesem Link, um Mongo zu installieren und zu lesen .

Um Mongo mit Express verwenden zu können, benötigen wir eine Client-API für den Knoten. Es gibt mehrere Möglichkeiten für uns, aber für dieses Tutorial bleiben wir beim Mungo . Mungo wird verwendet fürdocument Modelingim Knoten für MongoDB. Für die Dokumentmodellierung erstellen wir eineModel (ähnlich wie ein class in dokumentenorientierter Programmierung), und dann produzieren wir documents mit diesem Modell (wie wir erstellen documents of a classin OOP). Alle unsere Verarbeitung wird auf diesen "Dokumenten" durchgeführt, und schließlich werden wir diese Dokumente in unsere Datenbank schreiben.

Mungo einrichten

Nachdem Sie Mongo installiert haben, lassen Sie uns Mongoose genauso installieren, wie wir unsere anderen Knotenpakete installiert haben.

npm install --save mongoose

Bevor wir Mungo verwenden, müssen wir eine Datenbank mit der Mongo-Shell erstellen. Um eine neue Datenbank zu erstellen, öffnen Sie Ihr Terminal und geben Sie "mongo" ein. Eine Mongo-Shell wird gestartet. Geben Sie den folgenden Code ein:

use my_db

Eine neue Datenbank wird für Sie erstellt. Wenn Sie die Mongo-Shell öffnen, wird standardmäßig die Datenbank "getestet", und Sie müssen mit demselben Befehl wie oben zu Ihrer Datenbank wechseln.

Um Mungo zu benutzen, benötigen wir es in unserem index.js Datei und verbinden Sie sich dann mit dem mongodb Dienst läuft weiter mongodb://localhost.

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/my_db');

Jetzt ist unsere App mit unserer Datenbank verbunden. Lassen Sie uns ein neues Modell erstellen. Dieses Modell dient als Sammlung in unserer Datenbank. Verwenden Sie zum Erstellen eines neuen Modells den folgenden Code, bevor Sie eine Route definieren:

var personSchema = mongoose.Schema({
   name: String,
   age: Number,
   nationality: String
});
var Person = mongoose.model("Person", personSchema);

Der obige Code definiert das Schema für eine Person und wird zum Erstellen eines Mungo-Modus verwendet Person.

Dokumente speichern

Jetzt erstellen wir ein neues HTML-Formular. Mit diesem Formular können Sie die Details einer Person abrufen und in unserer Datenbank speichern. Erstellen Sie zum Erstellen des Formulars eine neue Ansichtsdatei mit dem Namenperson.pug im Ansichtenverzeichnis mit folgendem Inhalt -

html
head
   title Person
   body
      form(action = "/person", method = "POST")
      div
         label(for = "name") Name: 
         input(name = "name")
      br
      div
         label(for = "age") Age: 
         input(name = "age")
      br
      div
         label(for = "nationality") Nationality: 
         input(name = "nationality")
      br
      button(type = "submit") Create new person

Fügen Sie auch a hinzu new get route im index.js um dieses Dokument zu rendern -

app.get('/person', function(req, res){
   res.render('person');
});

Gehe zu "localhost:3000/person"um zu überprüfen, ob das Formular die richtige Ausgabe anzeigt. Beachten Sie, dass dies nur die Benutzeroberfläche ist und noch nicht funktioniert. Der folgende Screenshot zeigt, wie das Formular angezeigt wird -

Wir werden nun einen Post-Route-Handler unter definieren '/person' welches diese Anfrage behandeln wird

app.post('/person', function(req, res){
   var personInfo = req.body; //Get the parsed information
   
   if(!personInfo.name || !personInfo.age || !personInfo.nationality){
      res.render('show_message', {
         message: "Sorry, you provided worng info", type: "error"});
   } else {
      var newPerson = new Person({
         name: personInfo.name,
         age: personInfo.age,
         nationality: personInfo.nationality
      });
		
      newPerson.save(function(err, Person){
         if(err)
            res.render('show_message', {message: "Database error", type: "error"});
         else
            res.render('show_message', {
               message: "New person added", type: "success", person: personInfo});
      });
   }
});

Wenn wir im obigen Code ein leeres Feld erhalten oder kein Feld erhalten, senden wir eine Fehlerantwort. Wenn wir jedoch ein wohlgeformtes Dokument erhalten, erstellen wir einnewPerson Dokument aus dem Personenmodell und speichern Sie es mit dem in unserer Datenbank newPerson.save()Funktion. Dies ist in Mongoose definiert und akzeptiert einen Rückruf als Argument. Dieser Rückruf hat zwei Argumente - Fehler und Antwort. Diese Argumente rendern dieshow_message Aussicht.

Um die Antwort von dieser Route anzuzeigen, müssen wir auch eine erstellen show_messageAussicht. Erstellen Sie eine neue Ansicht mit dem folgenden Code:

html
   head
      title Person
   body
      if(type == "error")
         h3(style = "color:red") #{message}
      else
         h3 New person, 
            name: #{person.name}, 
            age: #{person.age} and 
            nationality: #{person.nationality} added!

Wir erhalten die folgende Antwort nach erfolgreicher Übermittlung der form(show_message.pug) - -

Wir haben jetzt eine Schnittstelle zu erstellen persons.

Dokumente abrufen

Mungo bietet viele Funktionen zum Abrufen von Dokumenten, wir werden uns auf drei davon konzentrieren. Alle diese Funktionen verwenden auch einen Rückruf als letzten Parameter, und genau wie die Speicherfunktion sind ihre Argumente Fehler und Antwort. Die drei Funktionen sind wie folgt:

Model.find (Bedingungen, Rückruf)

Diese Funktion findet alle Dokumente, die mit den Feldern im Bedingungsobjekt übereinstimmen. Dieselben in Mongo verwendeten Operatoren arbeiten auch in Mungos. Zum Beispiel,

Person.find(function(err, response){
   console.log(response);
});

Dadurch werden alle Dokumente aus der Sammlung der Person abgerufen.

Person.find({name: "Ayush", age: 20}, 
   function(err, response){
      console.log(response);
});

Dadurch werden alle Dokumente abgerufen, bei denen der Feldname "Ayush" und das Alter 20 Jahre beträgt.

Wir können auch Projektionen bereitstellen, die wir benötigen, dh die Felder, die wir benötigen. Zum Beispiel, wenn wir nur die wollennames von Menschen, deren nationalityist "indisch" , wir benutzen -

Person.find({nationality: "Indian"}, "name", function(err, response){
   console.log(response);
});

Model.findOne (Bedingungen, Rückruf)

Diese Funktion ruft immer ein einzelnes, relevantestes Dokument ab. Es hat genau die gleichen Argumente wieModel.find().

Model.findById (ID, Rückruf)

Diese Funktion übernimmt die _id(definiert von mongo) als erstes Argument, eine optionale Projektionszeichenfolge und ein Rückruf zur Verarbeitung der Antwort. Zum Beispiel,

Person.findById("507f1f77bcf86cd799439011", function(err, response){
   console.log(response);
});

Lassen Sie uns nun eine Route erstellen, um alle Personendatensätze anzuzeigen -

var express = require('express');
var app = express();

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/my_db');

var personSchema = mongoose.Schema({
   name: String,
   age: Number,
   nationality: String
});

var Person = mongoose.model("Person", personSchema);

app.get('/people', function(req, res){
   Person.find(function(err, response){
      res.json(response);
   });
});

app.listen(3000);

Dokumente aktualisieren

Mongoose bietet 3 Funktionen zum Aktualisieren von Dokumenten. Die Funktionen werden nachfolgend beschrieben -

Model.update (Zustand, Updates, Rückruf)

Diese Funktion nimmt eine Bedingung und aktualisiert ein Objekt als Eingabe und wendet die Änderungen auf alle Dokumente an, die den Bedingungen in der Sammlung entsprechen. Mit dem folgenden Code wird beispielsweise die Nationalität "Amerikaner" in allen Personendokumenten aktualisiert.

Person.update({age: 25}, {nationality: "American"}, function(err, response){
   console.log(response);
});

Model.findOneAndUpdate (Bedingung, Aktualisierungen, Rückruf)

Es findet ein Dokument basierend auf der Abfrage und aktualisiert es gemäß dem zweiten Argument. Es wird auch ein Rückruf als letztes Argument verwendet. Lassen Sie uns das folgende Beispiel ausführen, um die Funktion zu verstehen

Person.findOneAndUpdate({name: "Ayush"}, {age: 40}, function(err, response) {
   console.log(response);
});

Model.findByIdAndUpdate (ID, Updates, Rückruf)

Diese Funktion aktualisiert ein einzelnes Dokument, das durch seine ID identifiziert wird. Zum Beispiel,

Person.findByIdAndUpdate("507f1f77bcf86cd799439011", {name: "James"}, 
   function(err, response){
      console.log(response);
});

Lassen Sie uns nun eine Route erstellen, um Personen zu aktualisieren. Dies wird einPUT Route mit der ID als Parameter und Details in der Nutzlast.

var express = require('express');
var app = express();

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/my_db');

var personSchema = mongoose.Schema({
   name: String,
   age: Number,
   nationality: String
});

var Person = mongoose.model("Person", personSchema);

app.put('/people/:id', function(req, res){
   Person.findByIdAndUpdate(req.params.id, req.body, function(err, response){
      if(err) res.json({message: "Error in updating person with id " + req.params.id});
      res.json(response);
   });
});

app.listen(3000);

Geben Sie zum Testen dieser Route Folgendes in Ihr Terminal ein (ersetzen Sie die ID durch eine ID aus Ihrem erstellten people) -

curl -X PUT --data "name = James&age = 20&nationality = American
"http://localhost:3000/people/507f1f77bcf86cd799439011

Dadurch wird das Dokument, das der in der Route angegebenen ID zugeordnet ist, mit den oben genannten Details aktualisiert.

Dokumente löschen

Wir haben abgedeckt Create, Read und UpdateJetzt werden wir sehen, wie man Mungo gewohnt ist DeleteUnterlagen. Wir haben hier 3 Funktionen, genau wie beim Update.

Model.remove (Bedingung, [Rückruf])

Diese Funktion verwendet ein Bedingungsobjekt als Eingabe und entfernt alle Dokumente, die den Bedingungen entsprechen. Wenn wir beispielsweise alle Personen im Alter von 20 Jahren entfernen müssen, verwenden Sie die folgende Syntax:

Person.remove({age:20});

Model.findOneAndRemove (Bedingung, [Rückruf])

Diese Funktion entfernt a single, relevantestes Dokument nach Bedingungsobjekt. Lassen Sie uns den folgenden Code ausführen, um dasselbe zu verstehen.

Person.findOneAndRemove({name: "Ayush"});

Model.findByIdAndRemove (id, [Rückruf])

Diese Funktion entfernt ein einzelnes Dokument, das durch seine ID identifiziert wird. Zum Beispiel,

Person.findByIdAndRemove("507f1f77bcf86cd799439011");

Lassen Sie uns nun eine Route erstellen, um Personen aus unserer Datenbank zu löschen.

var express = require('express');
var app = express();

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/my_db');

var personSchema = mongoose.Schema({
   name: String,
   age: Number,
   nationality: String
});

var Person = mongoose.model("Person", personSchema);

app.delete('/people/:id', function(req, res){
   Person.findByIdAndRemove(req.params.id, function(err, response){
      if(err) res.json({message: "Error in deleting record id " + req.params.id});
      else res.json({message: "Person with id " + req.params.id + " removed."});
   });
});

app.listen(3000);

Verwenden Sie den folgenden Curl-Befehl, um die Ausgabe zu überprüfen:

curl -X DELETE http://localhost:3000/people/507f1f77bcf86cd799439011

Dadurch wird die Person mit der angegebenen ID entfernt, die die folgende Nachricht erstellt:

{message: "Person with id 507f1f77bcf86cd799439011 removed."}

Dies fasst zusammen, wie wir einfache CRUD-Anwendungen mit MongoDB, Mongoose und Express erstellen können. Lesen Sie die API-Dokumente, um Mongoose weiter zu erkunden .