RESTful-Beispiel mit ExpressJS + Node.js + MongooseJS

Beispiel für RESTful-Webdienste: ExpressJS + Node.js + MongooseJS

In meinen vorherigen Artikeln habe ich CRUD-Operationen Node.js + MongoDB – Durchführen von CRUD-Operationen und Mongoose – Node.js + MongoDB mit Mongoose Tutorial erklärt. In diesem Beitrag zeige ich es dir wie man CRUD-Operationen mit RESTful Web Services und ExpressJS mit MongooseJS erstellt. Ich würde für dieses Beispiel die folgenden 3 Knotenpakete verwenden, nämlich:

  • ExpressJS
  • Body-Parser
  • MongooseJS
  • ExpressJs

    Von der Node Package Manager-Website:

    Schnelles, unvoreingenommenes, minimalistisches Web-Framework

    Express wird zum Erstellen von Webanwendungen mit Node.js verwendet. Es bietet Unterstützung für Routen, das Einrichten von Ansichtsvorlagen und mehr. Dies ist derzeit das beliebteste Node.js-Webframework. Der Vorteil der Verwendung ExpressJS besteht darin, die Zeit und die Anzahl der geschriebenen Codezeilen zu reduzieren, sofern nicht die einfachen Node.js-Module verwendet werden.

    Body-Parser

    Von der Website des Node Package Managers:

    Node.js Body-Parsing-Middleware.

    Diese Middleware wird zum Abfangen der Anfragen, zum Parsen des Anfragetexts und zum anschließenden Auffüllen in die node.js verwendet req Objekt.

    MongooseJS

    Von der Node Package Manager-Website:

    MongooseJS ist ein MongoDB-Objektmodellierungstool, das für den Einsatz in einer asynchronen Umgebung entwickelt wurde.

    Dies wird verwendet, um Modellobjekte zu definieren und sie dann für die Interaktion mit MongoDB zu verwenden, einer Art ORM in der OO-Programmierwelt. MongooseJS ist ein Object Data Mapping (ODM) für JavaScript-Frameworks. Dies hilft Ihnen, die JavaScript-Objekte der MongoDB-Datenbank zuzuordnen. Dieses Tool wird von der MongoDB-Community selbst entwickelt und gepflegt.

    enm

    Definieren der RESTful-API

    In diesem Tutorial werde ich ein einfaches Beispiel für RESTful Web Services (sprich: Spring REST Web Services) mit ExpressJS, Node.js und MongooseJS implementieren. Der Abschnitt rechts unten definiert lediglich die Liste der Operationen, die im Rahmen der Übung durchgeführt werden. Die Liste der RESTful-APIs ist:

    • Liste aller Bücher im System abrufen: GET /book/
    • Details zu einem Buch im System abrufen: GET /book/:isbn
    • Fügen Sie dem System ein neues Buch hinzu: POST /book/
    • Bearbeiten Sie die Details des vorhandenen Buches im System: PUT /book/:isbn
    • Löschen Sie das angegebene Buch aus dem System: DELETE /book/:isbn

    1. Liste aller Bücher im System abrufen: GET /book/
    Parameter: Keine Parameter
    Antwort: Die Antwort wird ein Array von JSON-Objekten sein (Lesen Sie auch: Was ist JSON?) mit der unten angegebenen Struktur.

    [
      {
        "_id":STRING,
        "name":STRING,
        "isbn":STRING,
        "author":STRING,
        "pages":INTEGER,
        "_v":STRING
      }
    ]
    

    2. Details zu einem Buch im System abrufen: GET /book/:isbn
    Parameter: ISBN des Buches
    Antwort: Die Antwort wird das JSON-Objekt mit der unten angegebenen Struktur sein.

    {
      "_id":STRING,
      "name":STRING,
      "isbn":STRING,
      "author":STRING,
      "pages":INTEGER,
      "_v":STRING
    }
    

    3. Fügen Sie dem System ein neues Buch hinzu: POST /book/
    Parameter: Daten im folgenden Format müssen im Anfragetext gesendet werden

    {
      "name":STRING,
      "isbn":STRING,
      "author":STRING,
      "pages":INTEGER
    }
    

    Antwort: Die Antwort wird das JSON-Objekt mit der unten angegebenen Struktur sein.

    {
        "messaage": "Successfully added book",
        "book": {
            "__v": STRING,
            "name": STRING,
            "isbn": STRING,
            "author": STRING,
            "pages": INTEGER,
            "_id": STRING
        }
    }
    

    4. Bearbeiten Sie die Details des vorhandenen Buches im System: PUT /book/:isbn
    Parameter: ISBN des Buchs und die aktualisierten Buchinformationen im untenstehenden Format im Anfragetext.

    {
      "name":STRING,
      "isbn":STRING,
      "author":STRING,
      "pages":INTEGER
    }
    

    Antwort: Die Antwort wird das JSON-Objekt mit der unten angegebenen Struktur sein.

    {
        "messaage": "Successfully updated the book",
        "book": {
            "__v": STRING,
            "name": STRING,
            "isbn": STRING,
            "author": STRING,
            "pages": INTEGER,
            "_id": STRING
        }
    }
    

    5. Löschen Sie das angegebene Buch aus dem System: DELETE /book/:isbn
    Parameter: ISBN des zu löschenden Buches
    Antwort: Die Antwort wird das JSON-Objekt mit der unten angegebenen Struktur sein.

    {
        "messaage": "Successfully deleted the book",
        "book": {
            "__v": STRING,
            "name": STRING,
            "isbn": STRING,
            "author": STRING,
            "pages": INTEGER,
            "_id": STRING
        }
    }
    

    Implementierung der RESTful-API: ExpressJS + Body-Parser + Node.js

    Wie bereits erwähnt, würde ich die Knotenpakete express.js, node.js und body-parser.js mit MongooseJS verwenden. Der folgende Code richtet die Pakete ein und startet den Webserver auf Port 3300.

    //Express is required for creating Node.js based web apps
    var express = require('express');
    
    //body-parser is used to parse the Request body and populate the req.
    var bodyParser = require('body-parser');
    
    //mongoose is used for interacting with MongoDB
    var mongoose = require('mongoose');
    
    var app = express();
    app.set('port', 3300);
    
    //Configuring Express App to make use of BodyParser's JSON parser to parse
    //JSON request body
    app.use(bodyParser.json());
    
    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);
    
    //Connecting to Mongod instance.
    mongoose.connection;
    
    //Starting up the server on the port: 3300
    app.listen(app.get('port'), function(){
      console.log('Server up: http://localhost:' + app.get('port'));
    });
    

    Sie können den obigen Code in der Datei express_demo.js speichern und ihn dann mit ausführen node express_demo.js sollten Sie die folgende Ausgabe sehen können:

    Server up: http://localhost:3300
    

    Implementierung von GET /book

    Der folgende Code implementiert diese API:

    //Get all the books
    app.get('/book', function(req, res){
      //Find all the books in the system.
      Book.find({}, function(err, result){
        if ( err ) throw err;
        //Save the result into the response object.
        res.json(result);
      });
    });
    

    In ExpressJS erstellen wir eine Anwendungsinstanz mit express() (wie oben gezeigt) und richten Sie dann die Routen mithilfe der Anwendungsinstanz ein. Zum Beispiel verwenden wir für einen GET-Aufruf applicationInstance.get("ROUTE", handler(req, res){})für einen POST-Aufruf würden wir es so einrichten applicationInstance.post("ROUTE", handler(req, res){}) und so weiter für andere HTTP-Methoden wie PUT, DELETE und andere.

    Implementierung von GET /book/:isbn

    Der folgende Code ist die Implementierung der API

    //Get the details of the book with the given isbn
    app.get('/book/:isbn', function(req, res){
      console.log("Fetching details for book with ISBN: " + req.params.isbn);
      //The parameter in the route is accessed via request.params object.
      Book.findOne({isbn: req.params.isbn}, function(err, result){
        if ( err ) throw err;
        res.json(result);
      });
    });
    

    In dieser Implementierung sind folgende Punkte zu beachten:

  • Erstellen parametrisierter Routen mithilfe von :variable_Name in der Routendefinition. In diesem Fall habe ich die Route als definiert /book/:isbn und dies entspricht jeder URL der Form /book/abc123
  • Zugriff auf die Pfadvariable in der Route über das request.params-Objekt. In diesem Fall rufe ich die in der URL übergebene ISBN-Zeichenfolge ab req.params.isbn
  • Verwenden von findOne mit Abfrageobjekt. In diesem Fall verwende ich die findOne()-API von MongoDB zusammen mit dem Abfrageobjekt, das mithilfe der übergebenen ISBN-Informationen erstellt wird, um eine Buchinformation abzurufen, die mit der ISBN übereinstimmt
  • Implementierung von POST /book

    Diese API wird verwendet, um ein neues Buch zum System hinzuzufügen. Die Informationen des Buches müssen im Anfragetext übergeben werden und wir verwenden das Body-Parser-Modul, um den JSON im Anfragetext zu analysieren und ihn in den Knoten aufzufüllen request Objekt. Der folgende Code implementiert diese API

    //Add a new book
    app.post("/book", function(req, res){
      console.log("Adding new Book: " + req.body.name);
      var book = new Book({
        name:req.body.name,
        isbn: req.body.isbn,
        author: req.body.author,
        pages: req.body.pages
      });
    
      //Saving the model instance to the DB
      book.save(function(err, result){
        if ( err ) throw err;
        //After successfully saving the book we generate a JSON response with the
        //message and the inserted book information.
        res.json({
          messaage:"Successfully added book",
          book:result
        });
      });
    });
    

    In dieser Implementierung lesen wir die JSON Die vom Client übergebenen Daten füllen unsere Instanz von Book Modellklasse erstellen und mithilfe der Mongoose-API in der Datenbank speichern.

    Implementierung PUT /book/:isbn

    Diese Implementierung ähnelt GET /book/:isbn hinsichtlich der Parameterverarbeitung und POST /book hinsichtlich der Verarbeitung der vom Client übergebenen Buchdaten. Wir fragen die vorhandenen Informationen in der Datenbank ab und füllen diese vorhandenen Daten dann mit den vom Client übergebenen Daten.

    //Update an existing book
    app.put("/book/:isbn", function(req, res){
      Book.findOne({isbn: req.params.isbn}, function(err, result){
        if ( err ) throw err;
    
        if(!result){
          res.json({
            message:"Book with ISBN: " + req.params.isbn+" not found.",
          });
        }
    
        result.name   = req.body.name;
        result.isbn   = req.body.isbn;
        result.author = req.body.author;
        result.pages  = req.body.pages;
    
        result.save(function(err, result){
          if ( err ) throw err;
          res.json({
            message:"Successfully updated the book",
            book: result
          });
        });
    
      });
    });
    

    Implementierung von DELETE /book/:isbn

    Auch diese Implementierung ähnelt GET /book/:isbn hinsichtlich der Parameterbehandlung und der Suche nach dem Buch aus der Datenbank. Um die von uns verwendeten Buchinformationen zu löschen findAndRemove API in Mongoose.

    //Delete an existing book
    app.delete("/book/:isbn", function(req, res){
      Book.findOneAndRemove({isbn: req.params.isbn}, function(err, result){
          res.json({
            message: "Successfully deleted the book",
            book: result
          });
      });
    });
    

    Testen der REST-APIs

    Nachdem ich Ihnen nun die Implementierung einzelner APIs gezeigt habe, können wir mit dem Testen der implementierten APIs fortfahren. Zum Testen von POST, PUT, DELETE verwende ich Plugin des Postman-Clients für Chrome.

    GET /book

    GET /book

    GET /book/:isbn

    GET /book/:isbn

    POST /Buch

    POST

    PUT /book/:isbn

    SETZEN

    LÖSCHEN /book/:isbn

    LÖSCHEN

    Zusammenfassung

    Ich habe Ihnen gezeigt, wie die REST-API entworfen und dann mithilfe von implementiert wird ExpressJS, Node.js und MongooseJS. Wenn Sie nach einer vollständigen Lösung suchen, kopieren Sie den folgenden Code in eine Datei mit dem Namen: express_demo.js

    //Saved in file: express_demo.js
    //Express is required for creating Node.js based web apps
    var express = require('express');
    
    //body-parser is used to parse the Request body and populate the req.
    var bodyParser = require('body-parser');
    
    //mongoose is used for interacting with MongoDB
    var mongoose = require('mongoose');
    
    var app = express();
    app.set('port', 3300);
    
    //Configuring Express App to make use of BodyParser's JSON parser to parse
    //JSON request body
    app.use(bodyParser.json());
    
    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);
    
    //Connecting to Mongod instance.
    mongoose.connection;
    
    //Starting up the server on the port: 3300
    app.listen(app.get('port'), function(){
      console.log('Server up: http://localhost:' + app.get('port'));
    });
    
    //Get the details of the book with the given isbn
    app.get('/book/:isbn', function(req, res){
      console.log("Fetching details for book with ISBN: " + req.params.isbn);
    
      Book.findOne({isbn: req.params.isbn}, function(err, result){
        if ( err ) throw err;
        res.json(result);
      });
    });
    
    //Get all the books
    app.get('/book', function(req, res){
      //Find all the books in the system.
      Book.find({}, function(err, result){
        if ( err ) throw err;
        //Save the result into the response object.
        res.json(result);
      });
    });
    
    //Add a new book
    app.post("/book", function(req, res){
      console.log("Adding new Book: " + req.body.name);
      var book = new Book({
        name:req.body.name,
        isbn: req.body.isbn,
        author: req.body.author,
        pages: req.body.pages
      });
    
      //Saving the model instance to the DB
      book.save(function(err, result){
        if ( err ) throw err;
        res.json({
          messaage:"Successfully added book",
          book:result
        });
      });
    });
    
    //Update an existing book
    app.put("/book/:isbn", function(req, res){
      Book.findOne({isbn: req.params.isbn}, function(err, result){
        if ( err ) throw err;
    
        if(!result){
          res.json({
            message:"Book with ISBN: " + req.params.isbn+" not found.",
          });
        }
    
        result.name   = req.body.name;
        result.isbn   = req.body.isbn;
        result.author = req.body.author;
        result.pages  = req.body.pages;
    
        result.save(function(err, result){
          if ( err ) throw err;
          res.json({
            message:"Successfully updated the book",
            book: result
          });
        });
    
      });
    });
    
    //Delete an existing book
    app.delete("/book/:isbn", function(req, res){
      Book.findOneAndRemove({isbn: req.params.isbn}, function(err, result){
          res.json({
            message: "Successfully deleted the book",
            book: result
          });
      });
    });
    

    Bevor Sie dies ausführen, müssen Sie die folgenden Pakete installieren: express, body-parser, mongoose mit dem Befehl npm install.

    Nachschlagewerke für Node.js

    Kommentar verfassen

    Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

    Nach oben scrollen