Node.js Mongodb原生驱动程序连接共享

Node.js Mongodb-native driver connection sharing

本文关键字：连接 共享 驱动程序 原生 js Mongodb Node      更新时间：2023-09-26

main.js 

var http = require('http');
var UserModel = require('./models/user.js');
var server = http.createServer(function(req, res){
  UserModel.create({
  }), function(e, o){
    if(e) { console.log(e); } else {
    } console.log(o); }
  });
}).listen(3000);

connections.js

var mongo = require('mongodb');
module.exports = {
    dbMain: new mongo.Db('main', new mongo.Server('127.0.0.1', 27017, { auto_reconnect: true }, {})),
    dbLog: new mongo.Db('log', new mongo.Server('127.0.0.1', 27017, { auto_reconnect: true }, {}))
};

/models/user.js

var mongodb = require('mongodb');
var db = require('./connections.js').dbMain;
module.exports = {
  create: function(newData, callback){
    db.open(function(e, db){
      db.collection('users', function(e, collection){
        collection.insert(newData, callback);
      });
    });
  }
}

当我使用上面的代码时，服务器崩溃了，第二次收到请求时，我们仍然打开了数据库连接，所以让我们将db.close添加到Users.create函数中。

  create: function(newData, callback){
    db.open(function(e, db){
      db.collection('users', function(e, collection){
        collection.insert(newData, function(e, o){
          db.close(); // Voila.
          callback(e, o);
        });
      });
    });
  }

在这个阶段，服务器CAN仍然崩溃，因为多个连接打开，我不明白为什么或如何发生这种情况，但它确实发生了。

我该如何将我的项目组织成模型（我不想使用Mongoose，我的验证是在不同的层而不是模型中完成的，所以Mongoose对我来说是一种过度使用）？此外，我如何处理项目中的连接？

您可以有一个库来很好地封装所有这些-这意味着只有一个到数据库的连接将被打开，并且第二个请求将返回相同的（打开的）连接-如果您每秒获得1000+，这是一个成败攸关的问题（即，每次请求都不重新打开连接）。。。

users.js：

var connections = require('./connections.js');
var serverCache = connections('127.0.0.1', 27017); 
module.exports = {
  create: function(newData, callback){
    serverCache('main', 'users', function(e, collection){
      collection.insert(newData, callback);
    })
  }
}

connections.js

var mongo = require('mongodb');
// a mongo connection cache
// pass in host & port
// it returns a function accepting dbName, collectionName & callback
var mongoCache = function(host, port){
  // keep our open connections
  var mongoDatabases = {};
  var ensureDatabase = function(dbName, readyCallback){
    // check if we already have this db connection open
    if(mongoDatabases[dbName]){
      readyCallback(null, mongoDatabases[dbName]);
      return;
    }
    // get the connection
    var server = new mongo.Server(host, port, {auto_reconnect: true});
    // get a handle on the database
    var db = new mongo.Db(dbName, server);
    db.open(function(error, databaseConnection){
      if(error) throw error;
      // add the database to the cache
      mongoDatabases[dbName] = databaseConnection;
      // remove the database from the cache if it closes
      databaseConnection.on('close', function(){
        delete(mongoDatabases[dbName]);
      })
      // return the database connection
      readyCallback(error, databaseConnection);
    })
  }
  var ensureCollection = function(dbName, collectionName, readyCallback){
    ensureDatabase(dbName, function(error, databaseConnection){
      if(error) throw error;
      databaseConnection.createCollection(collectionName, function(error, collection) {
        if(error) throw error;
        // return the collection finally
        readyCallback(error, collection);
      })
    })
  }
  return ensureCollection;
}
module.exports = mongoCache;

我目前正在使用一个带有多个http请求的全局连接。在过去，我创建了一个复杂的库，它创建了几个到MongoDB的连接，并为每个连接随机选择一个。

后来我发现本地司机可以为我做这件事，非常整洁。目前我使用的是一个对象，驱动程序选择将查询发送到哪个连接。

var srvOpts = {
    auto_reconnect: true,
    poolSize: 10,
};
var conn = new Mongo.Server("localhost", 27017, srvOpts),
    db = new Mongo.Db("dbname", conn, {});
db.open(function (){});

正如你所知，这是一个很好的想法，我正在考虑将这个想法复制到我正在使用的Redis驱动程序中，但我时间紧迫，所以我怀疑我是否会很快这么做。

相关文章：