Node.js: Modularisierung von Express.js- und Node.js-Anwendungen

In diesem Tutorial wird erläutert, wie Node.js- und Express.js-Anwendungen modularisiert werden. Ich verwende den vorhandenen Code aus meinem vorherigen Beitrag und erkläre, wie man modulare Node.js-Anwendungen schreibt.

Wenn es darum geht, die modularen Node.js-Anwendungen zu schreiben, gibt es keine bessere Möglichkeit, die modularen Anwendungen zu schreiben. Das ergibt sich aus Ihrer Erfahrung und Sie werden möglicherweise auf eine andere Möglichkeit stoßen, den Code neu zu organisieren, und jedes Mal sieht es für Sie möglicherweise besser aus. In diesem Tutorial werde ich erklären, welcher Ansatz aus meiner Erfahrung mit besser ist Express.js und Node.js.

Ich habe Ihnen hier gezeigt, wie Sie RESTful-APIs mit Express.js und Node.js erstellen. In diesem Beitrag zeige ich Ihnen, wie wir den Code modularisieren können, dh zusammengehörige Teile des Codes in einer einzigen Javascript-Datei behalten. Beispielsweise kann Code, der sich mit der Datenbank befasst, in einer Javascript-Datei platziert werden, der Code, der sich mit der Verarbeitung von Anforderungen befasst, kann in einer anderen Javascript-Datei platziert werden.

Schreiben modularer Node.js-Anwendungen

Ich werde aus dem Beispiel in diesem Beitrag die folgenden Module erstellen:

  • Startpunkt der Anwendung
  • Datenbankzugriffsmodul
  • Controller-Modul
  • Grundlegende Einführung in die Modularisierung in Node.js

    nodejs-logo

    Bevor ich mich etwas weiter mit der Modularisierung von Node.js-Anwendungen befasse, möchte ich anhand eines sehr einfachen Beispiels das Grundkonzept hinter der Modularisierung von Code in Node.js erläutern. Ich werde eine einfache Taschenrechner-App schreiben, die Addition, Subtraktion und Multiplikation unterstützt. Ich werde ein Modul für die Berechnung erstellen und ein weiteres, das die Anwendung tatsächlich ausführt. Es gäbe also zwei Javascript-Dateien, nämlich: Rechner.js Und app.js.

    Schauen wir uns den Rechner.js an:

    //File name: calculator.js
    //Use module.exports to export any function to be available via require()
    module.exports.add = function(a,b){return a+b;}
    module.exports.subtract = function(a,b){return a-b;}
    module.exports.multiply = function(a,b){return a*b;}
    

    module ist ein Objekt in Node.js, das zum Erstellen verwendet wird Module. Wir machen die Methoden in Rechner.js verfügbar, indem wir sie dem zuweisen exports Eigentum von Modul Objekt. Wir haben jetzt ein Modul zur Durchführung von Berechnungen.

    Notiz: Interessante Lektüre darüber Unterschied zwischen module.exports und exports.

    Jetzt verwenden wir dieses Modul in unserer app.js, das den Einstiegspunkt für dieses einfache Beispiel darstellt, um das Grundkonzept der Modularität zu demonstrieren.

    var calculator = require("./calculator");
    console.log("Sum of 4,5: "+ calculator.add(4,5));
    console.log("Difference between 4,5: "+ calculator.subtract(4,5));
    console.log("Product of 4,5: "+ calculator.multiply(4,5));
    

    Wenn wir das oben Gesagte ausführen, würden wir etwa Folgendes sehen:
    Grundlegende Modularität in Node.js

    Mit dieser grundlegenden Einführung in Modularität in Node.js Lassen Sie mich Ihnen zeigen, wie wir das Beispiel im Beitrag: RESTful-Beispiel mit ExpressJS + Node.js + MongooseJS umgestalten und modularisieren können.

    Modularisierendes RESTful-Beispiel: Node.js-Anwendung

    Wie eingangs erwähnt, würde es das geben ein Modul für DB-bezogenen Code, ein Modul für Controller-Operationen und dann ein Anwendungsstartpunkt. Die Verzeichnisstruktur des Beispiels sieht wie folgt aus:
    Knotenmodularitätsverzeichnisstruktur

    Installieren Sie die erforderlichen Pakete, z. B. Express, Body-Parser und Mongoose, mit dem Befehl npm install express body-parser mongoose --save.

    Der Code für die book_dao.js ist wie folgt:

    //Filename: book_dao.js
    //mongoose is used for interacting with MongoDB
    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);
    
    //Connecting to Mongod instance.
    mongoose.connection;
    
    module.exports.findOne = function(isbn, callback){
      Book.findOne({isbn: isbn}, function(err, result){
        if ( err ) throw err;
        callback(result);
      });
    }
    
    module.exports.findAll = function(callback){
      Book.find({}, function(err, result){
        if ( err ) throw err;
        callback(result);
      });
    }
    
    module.exports.addNewBook = function(body, callback){
      var book = new Book({
        name:body.name,
        isbn: body.isbn,
        author: body.author,
        pages: body.pages
      });
    
      //Saving the model instance to the DB
      book.save(function(err, result){
        if ( err ) throw err;
        callback({
          messaage:"Successfully added book",
          book:result
        });
      });
    }
    
    module.exports.editBook = function(body, isbn, callback){
      Book.findOne({isbn: isbn}, function(err, result){
        if ( err ) throw err;
    
        if(!result){
          callback({
            message:"Book with ISBN: " + isbn+" not found.",
          });
        }
    
        result.name   = body.name;
        result.isbn   = body.isbn;
        result.author = body.author;
        result.pages  = body.pages;
    
        result.save(function(err, result){
          if ( err ) throw err;
          callback({
            message:"Successfully updated the book",
            book: result
          });
        });
    
      });
    }
    
    module.exports.deleteBook = function(isbn, callback){
      Book.findOneAndRemove({isbn: isbn}, function(err, result){
          callback({
            message: "Successfully deleted the book",
            book: result
          });
      });
    }
    

    Aus dem obigen Code können Sie ersehen, dass die book_dao.js hängt nur von der ab Mongoose-API.

    Der Code für book_controller.js ist wie folgt:

    var bookDao = require("./book_dao");
    
    module.exports.getBookDetails = function(params, callback){
      console.log("Fetching details for book with ISBN: " + params.isbn);
      bookDao.findOne(params.isbn, callback);
    }
    
    module.exports.getAllBooks = function(callback){
      console.log("Fetching all books");
      bookDao.findAll(callback);
    }
    
    module.exports.addNewBook = function(body, callback){
      console.log("Adding new book");
      bookDao.addNewBook(body, callback);
    }
    
    module.exports.editBook = function(body, isbn, callback){
      console.log("Editing Book");
      bookDao.editBook(body, isbn, callback);
    }
    module.exports.deleteBook = function(isbn, callback){
      console.log("Deleting book");
      bookDao.deleteBook(isbn, callback);
    }
    

    Der Code für routes.js ist unten angegeben:

    var bookController = require("./book_controller");
    
    module.exports = function(app){
      //Get the details of the book with the given isbn
      app.get('/book/:isbn', function(req, res){
        bookController.getBookDetails(req.params, function(results){res.json(results);});
      });
    
      //Get all the books
      app.get('/book', function(req, res){
        bookController.getAllBooks(function(results){res.json(results);});
      });
    
      app.post('/book', function(req, res){
        bookController.addNewBook(req.body, function(results){
          res.json(results);
        });
      });
    
      app.put('/book/:isbn', function(req, res){
        bookController.editBook(req.body, req.params.isbn, function(results){
          res.json(results);
        });
      });
    
      app.delete('/book/:isbn', function(req, res){
        bookController.deleteBook(req.params.isbn, function(results){
          res.json(results);
        });
      });
    }
    

    routes.js ist für die Zuordnung der URLs zu den Methoden im Controller verantwortlich.

    Aus dem obigen Code ist das klar book_dao.js hängt nur davon ab Mungo, book_controller.js hängt nur von der ab book_dao.js Und Routen.js hängt nur davon ab book_controller.js

    Ausführen der Modular Node.js-Beispielanwendung

    Das Folgende ist der Code für app.js Dies ist der Ausgangspunkt für unsere Anwendung oder mit anderen Worten der Ort, an dem der Server initiiert und gestartet wird.

    //Filename: app.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');
    
    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());
    
    //Including the routes module
    var routes = require("./lib/routes");
    routes(app);
    
    //Starting up the server on the port: 3300
    app.listen(app.get('port'), function(){
      console.log('Server up: http://localhost:' + app.get('port'));
    });
    

    Obenstehendes app.js kommt drauf an Routen.js um die Routen und Controller-Bindung einzurichten.

    Lassen Sie uns das obige Beispiel wie unten gezeigt ausführen:

    G:\node\testapp\modular_sample_2>node app.js
    Server up: http://localhost:3300
    

    Den Code für dieses Beispiel finden Sie im Github sowie.

    Ich hoffe, dieses Tutorial hat Ihnen geholfen zu verstehen, wie Sie eine Node.js-Anwendung modularisieren. In diesem Tutorial wurde ein RESTful-Beispiel aus unseren vorherigen Tutorials verwendet. Beachten Sie, dass es keine einheitliche Regel für die Modularisierung des Codes gibt. Er kann basierend auf Ihrer Erfahrung improvisiert werden. Wenn Sie Fragen zum Schreiben der modularen Node.js-Anwendungen haben, schreiben Sie diese bitte in den Kommentarbereich.

    Kommentar verfassen

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

    Nach oben scrollen