Node.js 和 mongoDB 服务并发请求

Question

我在使用 mongoDB 处理来自我的简单 node.js 服务器的并发请求时遇到问题。

我正在做的是发送 mongo shell 格式的查询，解析它们并从 mongoDB 发回数据。

但由于某种原因，它似乎无法同时处理多个请求.. （顺便说一句，我在本地使用它）

编辑： 我有时会在我的客户端应用程序中收到此错误：

"Stream Error. URL: http://localhostlink:1337"

当服务器没有运行时我也会得到...

编辑2： 我删除了 db.close 语句。

集群在这里真的是正确的解决方案吗，因为我只是升级应用程序以服务 4 个并发请求，这仍然不够。

我应该以其他方式完全重构服务器吗？我只想能够为来自 mongoDB 的数据提供多个请求。

EDIT3：

我可以先创建服务器然后连接到 mongo，还是应该在 MongoClient.connect(...) 函数中创建服务器？

这是我的（未优化的）服务器的代码：

  var http = require('http');
var qs = require('querystring');
var mongo =require('mongodb'); 
var MongoClient = mongo.MongoClient;
var result;
var response;
var ObjectId = require('mongodb').ObjectID;
var myDb;



http.createServer(function (request, res) {
    console.log("creating server...");
    MongoClient.connect("mongodb://127.0.0.1:27017/lalal", function(err, db) {
        if(err) { return console.dir(err); }
if (request.method == 'POST') {
        var body = '';
        response = res;
        request.on('data', function (data) {
            body += data;
            // 1e6 === 1 * Math.pow(10, 6) === 1 * 1000000 ~~~ 1MB
            if (body.length > 1e6) { 
            //     FLOOD ATTACK OR FAULTY CLIENT, NUKE REQUEST
                request.connection.destroy();
            }
        });
        request.on('end', function () {

            var clientData = qs.parse(body);
            var parts = clientData.data.split(".");
            var collectionName = parts.shift();
            var queryBig = parts.join(".");
            var queryParts = queryBig.split("(");
            var method = queryParts[0];
            var query = queryParts.join("(");

            console.log("query:"+query);
            console.log("method:"+method);
            console.log("collection:"+collectionName);

          var callback;
          switch(method){

                case 'find':
                callback = '.toArray(findCallback);';
                break;
                case 'insert':
                query = query.substring(0, query.length - 1);
                callback = ',insertCallback);';
                break;
                case 'remove':
                query = query.substring(0, query.length - 1);
                callback = ',removeCallback);'
                break;
                case 'save':
                query = query.substring(0, query.length - 1);
                callback = ',saveCallback);'
                break;
                case 'update':
                query = query.substring(0, query.length - 1);
                callback = ',updateCallback);'
                break;


            }
         if(query.indexOf('"_id"') != -1)
         {

         var indexHelper = query.indexOf('"_id"')+7;
         var s = query.substring(indexHelper, query.length);

         var indexOfQuote = s.indexOf('"')
         var restOfQuery = s.substring(indexOfQuote+1,s.length);

         var key = s.substring(0,indexOfQuote);

         query = query.substring(0,indexHelper-1) + 'new ObjectId("'+key +'")'+restOfQuery;

         }  
//      Connect to the db


//      myDb = db;
        var collection = db.collection(collectionName);

        var command = 'collection.'+query+callback;
        console.log("command:"+command);
        eval(command);


            function findCallback(err, items){

                console.log(items);

                response.writeHead(200, {'Content-Type': 'text/plain'});
                response.end(JSON.stringify(items));



            }

            function insertCallback(err, objects) {

                console.log(objects);

                if (err) console.warn(err.message);
                if (err && err.message.indexOf('E11000 ') !== -1) {
                    response.writeHead(200, {'Content-Type': 'text/plain'});
                    response.end('"error":"_id already exists"');
                }
                else{
                    response.writeHead(200, {'Content-Type': 'text/plain'});
                    response.end(JSON.stringify(objects));
                }


            }

            function removeCallback(err, numberOfRemovedDocs) {

                response.writeHead(200, {'Content-Type': 'text/plain'});
                response.end(JSON.stringify(numberOfRemovedDocs));

            }

            function saveCallback(err, result) {

                response.writeHead(200, {'Content-Type': 'text/plain'});
                response.end(JSON.stringify(result));

            }

            function updateCallback(err, numberOfUpdatedDocs) {

                response.writeHead(200, {'Content-Type': 'text/plain'});
                response.end(JSON.stringify(numberOfUpdatedDocs));

            }





        });
    }
});
}).listen(1337, '127.0.0.1');



console.log('Server running at http://127.0.0.1:1337/');

Answer 1

您看到的问题是因为 node.js 是单线程的。也就是说，它一次会分派一个请求（这实际上很好，因为它有助于避免由全局变量处理引起的错误）。如果您在执行查询之前发送了响应，您将看到并行查询执行。但是，考虑到您构建程序的方式，使用“集群”模块可能会更好。下面的代码将启动四个并发进程。

var cluster = require('cluster');

if (cluster.isMaster) {
    for (var i = 0; i < 4; i++) {
        cluster.fork();
    }

    cluster.on('exit', function (worker, code, signal) {
        cluster.fork();
    });
}
else {
    // run your node.js + MongoDB code here
}

PS。使用 MongoClient.connect 时无需关闭 db 连接，因为此 API 使用连接池来管理您的连接。