Mongoose – Node.js + MongoDB mit Mongoose Tutorial

Entwickeln Sie eine Node.js + MongoDB-Anwendung mit Mongoose

In meinem vorherigen Beitrag habe ich gezeigt, wie man vorgeht CRUD (Erstellen, Lesen, Aktualisieren, Löschen) Vorgänge mit Node.js und der MongoDB-API. In diesem Tutorial wird erklärt, wie Sie mit der Mongoose-Anwendung ganz einfach Node.js- und MongoDB-Anwendungen entwickeln können Mongoose-API. In diesem Tutorial wird davon ausgegangen, dass der Leser über Kenntnisse zu Node.js und MongoDB verfügt und weiß, wie die Umgebung für dieses Tutorial eingerichtet wird. Diejenigen, die die grundlegenden Tutorials zu Node.js und MongoDB lesen möchten, lesen bitte die Einführung in Node.js und die Installation von MongoDB unter Windows.

Wenn Sie daran interessiert sind, weitere Updates zu Node.js- und MongoDB-Tutorials zu erhalten, abonnieren Sie uns bitte hier.

Hier finden Sie eine Übersicht über die Abschnitte, die in diesem Tutorial behandelt werden.

Mongoose-API

Mongoose ist eine Mongodb-Objektmodellierungs-API für node.js. Mongoose bietet eine unkomplizierte, schemabasierte Lösung zur Modellierung Ihrer Anwendungsdaten und umfasst integrierte Typumwandlung, Validierung, Abfrageerstellung, Geschäftslogik-Hooks und mehr – sofort einsatzbereit. (Einführung von der Mongoose API-Homepage)

Um die Mongoose-API in der Anwendung node.js zu verwenden, müsste man das Node-Paket für die Mongoose-API mit dem folgenden Befehl herunterladen: npm install mongoose und importieren Sie dann das Mongoose-API-Paket in Ihre node.js-Anwendung, indem Sie den folgenden Befehl verwenden: var mongoose = require('mongoose');

Herstellen einer Verbindung zu MongoDB mithilfe von Mongoose

Der folgende Code stellt eine Verbindung zur MongoDB-Datenbank namens test her, die auf localhost, Port 27017, ausgeführt wird.

var dbHost="mongodb://localhost:27017/test";
mongoose.connect(dbHost);

Nachdem Sie eine Verbindung zur Datenbank hergestellt haben, müssen Sie ein Verbindungsobjekt abrufen. Das Verbindungsobjekt befindet sich zunächst im Status „Ausstehend“ und sobald es in den Status „Offen“ wechselt, können wir mit der Interaktion mit MongoDB fortfahren. Damit dies geschieht, registrieren wir einen Rückruf zum Abhören offen Bei diesem Ereignis wird der folgende Code zum Abhören registriert Fehler Und offen Ereignisse, die von der Verbindung ausgelöst werden.

db.on('error', console.error.bind(console, 'connection error:'));
db.once('open', function(){
  console.log("Connected to DB");
  //do operations which involve interacting with DB.
});

Erstellen Sie Schema und Modell in Mongoose

Wir müssen das Schema des Dokuments erstellen, das wir in der Datenbank speichern möchten. Beim Erstellen des Schemas können wir die Attribute des Dokuments, den Typ des Attributs, zusätzliche Informationen angeben, z. B. ob für das Attribut ein Index erstellt werden muss usw. In unserem Beispiel hätte unser Buchdokument die folgenden Attribute: Name, ISBN, Autor, Seiten. Das Folgende ist das Beispielschema, das ich für dieses Beispiel erstellt habe:

  //Create a schema for Book
  var bookSchema = mongoose.Schema({
    name: String,
    //Also creating index on field isbn
    isbn: {type: String, index: true},
    author: String,
    pages: Number
  });

Mit dem obigen Schema erstellen wir ein Modell. Der API Um ein Modell zu erstellen, akzeptiert es Folgendes: Name des Modells, Name des Schemas, das zum Erstellen der Modellklasse verwendet werden muss, Name der Sammlung und ob die Initialisierung übersprungen werden soll. Nachfolgend finden Sie den Code zum Erstellen eines Buchmodells aus dem Schema:

  //Create a Model by using the schema defined above
  //Optionally one can provide the name of collection where the instances
  //of this model get stored. In this case it is "mongoose_demo". Skipping
  //this value defaults the name of the collection to plural of model name i.e books.
  var Book = mongoose.model('Book', bookSchema, "mongoose_demo");

Sehen wir uns nun an, wie Sie mithilfe des oben erstellten Modells Datensätze einfügen, lesen, aktualisieren und löschen. Im Gegensatz zum vorherigen Beitrag zeige ich Ihnen in diesem Beitrag einige Beispiele für das Einfügen von Datensätzen, das Abfragen von Datensätzen, das Bearbeiten von Datensätzen und das Löschen von Datensätzen.

Einfügen von Daten mit Mongoose

Wir erstellen eine Instanz der Model-Klasse und rufen sie dann auf save Methode auf der Instanz, um die Daten in der Datenbank zu speichern. Beim Aufrufen der save Methode stellen wir auch einen Rückruf bereit, der ausgeführt wird, nachdem die Speichermethode entweder mit einem Fehler oder nach erfolgreichem Einfügen der Daten zurückkehrt. Der folgende Code erstellt zwei Instanzen der Book-Modellklasse und speichert sie in der Datenbank.

  //Instantiating the Model - An instance of Model represents a mongodb document
  var book1 = new Book({
    name:"Mongoose Demo 1",
    isbn: "MNG123",
    author: "Author1,  Author2",
    pages: 123
  });

  //Saving the model instance to the DB
  book1.save(function(err){
    if ( err ) throw err;
    console.log("Book Saved Successfully");
  });

  var book2 = new Book({
    name:"Mongoose Demo 2",
    isbn: "MNG124",
    author: "Author2,  Author3",
    pages: 90
  });

  book2.save(function(err){
    if ( err ) throw err;
    console.log("Book Saved Successfully");
  });

Abfragen der Datenbank mit Mongoose

Es gibt mehrere APIs, mit denen man die Sammlung in mongoDB abfragen kann. Man kann alle diese APIs finden Hier. In diesem Beispiel verwende ich find API zum Abfragen der Sammlung. Der folgende Code definiert eine Funktion, die nach Dokumenten mit weniger als 100 Seiten abfragt:

var queryBooks = function(){
  //Now querying those books which have less than 100 pages
  //Find API takes in a query condition, attributes in the document to be projected,
  //callback to be executed when the data is available.
  Book.find({pages : {$lt:100}}, "name isbn author pages", function(err, result){
    if ( err ) throw err;
    console.log("Find Operations: " + result);
  });
}

Vorhandene Dokumente aktualisieren

Das Dokument kann mithilfe von aktualisiert werden update API wie unten gezeigt:

var updateBook = function(){
  /*
  Find the book to be updated using the condition and then execute the update
  passed to the API as the second argument
  */
  Book.update({isbn : {$eq: 'MNG125'}}, {$set: {name: "Mongoose Demo 3.1"}}, function(err, result){
    console.log("Updated successfully");
    console.log(result);
  });
}

Vorhandene Dokumente löschen

Dokumente können mit dem aus der Sammlung gelöscht werden remove API und durch Angabe der Bedingung für die Auswahl der zu löschenden Dokumente.

var deleteBook = function(){
  /*
    When callback is not passed, the action is not invoked on the collection
    until the exec() method is called.
    In this case I am not passing the callback and instead executing the action
    by invoking the exec() method.
  */
  Book.remove({isbn:{$eq: 'MNG124'}}).exec();
}

Node.js + MongoDB + Mongoose-Beispielanwendung

Damit habe ich gezeigt, wie die CRUD-Operationen individuell durchgeführt werden können. Fassen Sie dies alles in einem unten aufgeführten Arbeitsbeispiel zusammen:

var mongoose = require('mongoose');
var dbHost="mongodb://localhost:27017/test";
mongoose.connect(dbHost);
//Create a schema for Book
var bookSchema = mongoose.Schema({
  name: String,
  //Also creating index on field isbn
  isbn: {type: String, index: true},
  author: String,
  pages: Number
});

//Create a Model by using the schema defined above
//Optionally one can provide the name of collection where the instances
//of this model get stored. In this case it is "mongoose_demo". Skipping
//this value defaults the name of the collection to plural of model name i.e books.
var Book = mongoose.model('Book', bookSchema, "mongoose_demo");

var db = mongoose.connection;

db.on('error', console.error.bind(console, 'connection error:'));
db.once('open', function(){
  console.log("Connected to DB");

  //Instantiating the Model - An instance of Model represents a mongodb document
  var book1 = new Book({
    name:"Mongoose Demo 1",
    isbn: "MNG123",
    author: "Author1,  Author2",
    pages: 123
  });

  //Saving the model instance to the DB
  book1.save(function(err){
    if ( err ) throw err;
    console.log("Book Saved Successfully");
  });

  var book2 = new Book({
    name:"Mongoose Demo 2",
    isbn: "MNG124",
    author: "Author2,  Author3",
    pages: 90
  });

  book2.save(function(err){
    if ( err ) throw err;
    console.log("Book Saved Successfully");
    deleteBook();
  });

  var book3 = new Book({
    name:"Mongoose Demo 3",
    isbn: "MNG125",
    author: "Author2,  Author4",
    pages: 80
  });

  book3.save(function(err){
    if ( err ) throw err;
    console.log("Book Saved Successfully");
    queryBooks();
    updateBook();

  });

});

var queryBooks = function(){
  //Now querying those books which have less than 100 pages
  //Find API takes in a query condition, attributes in the document to be projected,
  //callback to be executed when the data is available.
  Book.find({pages : {$lt:100}}, "name isbn author pages", function(err, result){
    if ( err ) throw err;
    console.log("Find Operations: " + result);
  });
}

var updateBook = function(){
  /*
  Find the book to be updated using the condition and then execute the update
  passed to the API as the second argument
  */
  Book.update({isbn : {$eq: 'MNG125'}}, {$set: {name: "Mongoose Demo 3.1"}}, function(err, result){
    console.log("Updated successfully");
    console.log(result);
  });
}

var deleteBook = function(){
  /*
    When callback is not passed, the action is not invoked on the collection
    until the exec() method is called.
    In this case I am not passing the callback and instead executing the action
    by invoking the exec() method.
  */
  Book.remove({isbn:{$eq: 'MNG124'}}).exec();
}

Und wenn wir Daten von der Mongo-Konsole abfragen, erhalten wir Folgendes:

> db.mongoose_demo.find()
{ "_id" : ObjectId("55490d87e34c8acc20b5363d"), "name" : "Mongoose Demo 1", "isbn" : "MNG123", "author" : "Author1,  Author2", "pages" : 123, "__v" : 0 }
{ "_id" : ObjectId("55490d87e34c8acc20b5363f"), "name" : "Mongoose Demo 3.1", "isbn" : "MNG125", "author" : "Author2,  Author4", "pages" : 80, "__v" : 0 }

Zusammenfassung

Ich hoffe, dass dieses Tutorial sehr hilfreich ist, um zu verstehen, wie die Mongoose-API für die Verbindung mit der MongoDB verwendet werden kann. Es ist offensichtlich, dass mit Hilfe von Mongoose Object Data Mapping (ODM) einmal komplexere CRUD-Operationen mit minimalem Aufwand geschrieben werden können. Bitte probieren Sie die obigen Beispiele aus und schreiben Sie Ihr Feedback in den Kommentarbereich.