Wie verwalte ich MongoDB-Verbindungen in einer Node.js-Webanwendung?

Question

Ich benutze die node-mongodb-native Treiber mit MongoDB, um eine Website zu schreiben.

Ich habe einige Fragen zur Verwaltung von Verbindungen:

1. Reicht es aus, nur eine MongoDB-Verbindung für alle Anfragen zu verwenden? Gibt es irgendwelche Leistungsprobleme? Wenn nicht, kann ich eine globale Verbindung einrichten, die für die gesamte Anwendung verwendet wird?

2. Wenn nicht, ist es gut, wenn ich eine neue Verbindung öffne, wenn die Anfrage ankommt, und sie schließe, wenn die Anfrage bearbeitet wurde? Ist es teuer, eine Verbindung zu öffnen und zu schließen?

3. Sollte ich einen globalen Verbindungspool verwenden? Ich habe gehört, dass der Treiber einen nativen Verbindungspool hat. Ist das eine gute Wahl?

4. Wenn ich einen Verbindungspool verwende, wie viele Verbindungen sollten verwendet werden?

5. Gibt es noch andere Dinge, die ich beachten sollte?

Answer 1

Sie sollten eine Verbindung als Dienst erstellen und sie bei Bedarf wiederverwenden.

// db.service.js
import { MongoClient } from "mongodb";
import database from "../config/database";

const dbService = {
  db: undefined,
  connect: callback => {
    MongoClient.connect(database.uri, function(err, data) {
      if (err) {
        MongoClient.close();
        callback(err);
      }
      dbService.db = data;
      console.log("Connected to database");
      callback(null);
    });
  }
};

export default dbService;

mein App.js-Beispiel

// App Start
dbService.connect(err => {
  if (err) {
    console.log("Error: ", err);
    process.exit(1);
  }

  server.listen(config.port, () => {
    console.log(`Api runnning at ${config.port}`);
  });
});

und verwenden Sie es, wo immer Sie wollen, mit

import dbService from "db.service.js"
const db = dbService.db

Answer 2

Ich habe generic-pool mit redis-Verbindungen in meiner Anwendung verwendet - ich kann es nur empfehlen. Es ist generisch und ich weiß definitiv, dass es mit Mysql funktioniert, also denke ich nicht, dass Sie irgendwelche Probleme mit ihm und Mongo haben werden

https://github.com/coopernurse/node-pool

Answer 3

Ich habe unten Code in meinem Projekt implementiert, um Verbindungspooling in meinem Code zu implementieren, so dass es eine minimale Verbindung in meinem Projekt erstellen und verfügbare Verbindung wiederverwenden wird

/* Mongo.js*/

var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/yourdatabasename"; 
var assert = require('assert');

var connection=[];
// Create the database connection
establishConnection = function(callback){

                MongoClient.connect(url, { poolSize: 10 },function(err, db) {
                    assert.equal(null, err);

                        connection = db
                        if(typeof callback === 'function' && callback())
                            callback(connection)

                    }

                )

}

function getconnection(){
    return connection
}

module.exports = {

    establishConnection:establishConnection,
    getconnection:getconnection
}

/*app.js*/
// establish one connection with all other routes will use.
var db = require('./routes/mongo')

db.establishConnection();

//you can also call with callback if you wanna create any collection at starting
/*
db.establishConnection(function(conn){
  conn.createCollection("collectionName", function(err, res) {
    if (err) throw err;
    console.log("Collection created!");
  });
};
*/

// anyother route.js

var db = require('./mongo')

router.get('/', function(req, res, next) {
    var connection = db.getconnection()
    res.send("Hello");

});

Answer 4

Wenn Sie Express verwenden, gibt es eine andere, einfachere Methode, nämlich die Nutzung der in Express integrierten Funktion zur gemeinsamen Nutzung von Daten zwischen Routen und Modulen innerhalb Ihrer App. Es gibt ein Objekt namens app.locals. Wir können ihm Eigenschaften zuweisen und von unseren Routen aus darauf zugreifen. Um es zu verwenden, instanziieren Sie Ihre Mongo-Verbindung in Ihrer app.js-Datei.

var app = express();

MongoClient.connect('mongodb://localhost:27017/')
.then(client =>{
  const db = client.db('your-db');
  const collection = db.collection('your-collection');
  app.locals.collection = collection;
});
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              // view engine setup
app.set('views', path.join(__dirname, 'views'));

Auf diese Datenbankverbindung oder auch auf andere Daten, die Sie mit den Modulen Ihrer Anwendung teilen möchten, können Sie nun innerhalb Ihrer Routen mit req.app.locals wie unten beschrieben, ohne dass zusätzliche Module erstellt und benötigt werden.

app.get('/', (req, res) => {
  const collection = req.app.locals.collection;
  collection.find({}).toArray()
  .then(response => res.status(200).json(response))
  .catch(error => console.error(error));
});

Diese Methode stellt sicher, dass die Datenbankverbindung für die Dauer der Anwendung geöffnet bleibt, es sei denn, Sie entscheiden sich, sie jederzeit zu schließen. Sie ist leicht zugänglich mit req.app.locals.your-collection und erfordert keine Erstellung von zusätzlichen Modulen.

Answer 5

Der beste Ansatz zur Implementierung von Verbindungspooling ist, dass Sie eine globale Array-Variable erstellen sollten, die den DB-Namen mit dem Verbindungsobjekt enthält, das von MongoClient und verwenden Sie diese Verbindung dann immer wieder, wenn Sie die Datenbank kontaktieren müssen.

1. In Ihrem Server.js definieren. var global.dbconnections = [];

2. Erstellen einer Dienstbenennung connectionService.js . Es wird 2 Methoden geben getConnection y createConnection . Wenn der Benutzer also aufruft getConnection() findet es Details in der globalen Verbindungsvariable und gibt Verbindungsdetails zurück, wenn sie bereits existieren, sonst ruft es createConnection() und Rückverbindung Details.

3. Rufen Sie diesen Dienst mit <db_name> und gibt das Verbindungsobjekt zurück, wenn es bereits vorhanden ist, ansonsten wird eine neue Verbindung erstellt und an Sie zurückgegeben.

Ich hoffe, es hilft :)

Hier ist die connectionService.js Code:

var mongo = require('mongoskin');
var mongodb = require('mongodb');
var Q = require('q');
var service = {};
service.getConnection = getConnection ;
module.exports = service;

function getConnection(appDB){
    var deferred = Q.defer();
    var connectionDetails=global.dbconnections.find(item=>item.appDB==appDB)

    if(connectionDetails){deferred.resolve(connectionDetails.connection);
    }else{createConnection(appDB).then(function(connectionDetails){
            deferred.resolve(connectionDetails);})
    }
    return deferred.promise;
}

function createConnection(appDB){
    var deferred = Q.defer();
    mongodb.MongoClient.connect(connectionServer + appDB, (err,database)=> 
    {
        if(err) deferred.reject(err.name + ': ' + err.message);
        global.dbconnections.push({appDB: appDB,  connection: database});
        deferred.resolve(database);
    })
     return deferred.promise;
}