Node.js是否可以一一处理客户端请求？

朱自明

2023-03-14

问题内容：

Node.js是否可以一一处理客户端请求？我有一个项目，正在使用Node.js作为服务器端代理。根据我的理解，如果您使用回调进行响应，那么Node.js应该立即响应新请求，但是实际上Node.js直到完成上一个回调后才会响应新请求。这是正确的操作还是代码使用有误？请帮我。非常感谢你。以下是用于将请求重新发送到后端服务的代码。

var request = require('request');
var http = require('http');

function apiService(){}

apiService.prototype.get = function (context, payload, callback, url){
    return this.requestAPI(context, payload, callback, url, "GET");
}
apiService.prototype.post = function(context, payload, callback, url){
    return this.requestAPI(context, payload, callback, url, "POST");
}
apiService.prototype.del = function(context, payload, callback, url){
    return this.requestAPI(context, payload, callback, url, "DELETE");
}
apiService.prototype.requestAPI = function(context, payload, callback, url, method){

    var config = context.config;
    var targetUrl = config.APIHost
                    + (config.port == null ? "": (":" + config.port)) 
                    + "/" 
                    + config.baseDir
                    + "/"
                    + url;

    var requestObj = {
            url : targetUrl,
            json : true,
            pool: new http.Agent()
        }

    if (config.proxy != null){
        requestObj.proxy = config.proxy;
    }

    switch (method){
        case "POST":
            requestObj.body = payload;
            request.post(requestObj, function (err, resp, body){
                if (err){
                    callback(err);
                    return;
                }
                callback(null, body);
            });
            break;
        case "GET":
            var queryString = "";
            for (att in payload){
                if (queryString != "")
                    queryString += "&";
                queryString += att.toString() + "=" + payload[att];
            }
            if (queryString!="")
                requestObj.url += "?" + queryString;

            request.get(requestObj, function (err, resp, body){
                if (err){
                    callback(err);
                    return;
                }
                callback(null, body);
            });
            break;
        case "DELETE":
            requestObj.body = payload;
            request.del(requestObj, function (err, resp, body){
                if (err){
                    callback(err);
                    return;
                }
                callback(null, body);
            });
            break;
    }
}



Current process



client       request1  ->       Node

client       request2  ->       Node

                                Node    server request1    ->backend

                                Node (waiting for event loop)

                                Node     <- server response1 backend

client       <- response1       Node

                                Node    server request2    ->backend

                                Node     <-  server response2 backend

client       <- response2       Node

What I think it should be



  client       request1  ->       Node

client       request2  ->       Node

                                Node    server request1 ->     backend

                                Node (won't waiting for event loop)

                                Node    server request2 ->     backend

                                Node    <- server response2    backend

client       <-response2        Node

                                Node    <- server response1    backend

client       <-response1        Node

更新：

               var params = {

                        action : 'list'

                };

                $http.post('../../service/buildingBlockService', params)

                .success(function(buildingBlocks){

                        callback(null, buildingBlocks);

                    }).error(function(error){

                        callback(error);

                    })

客户端请求来自Angular
$http。在一页上，同时有多个请求。根据我的Fiddler监视器，来自浏览器的请求是在不等待的情况下发送的，但是服务器重新发送的请求是一对一的。

app.post('/service/buildingBlockService', function (ctx, payload, req, res) {

        var service1 = require('./service/buildingBlockService');

        var service = new service1();

        service.service(ctx, payload, function(error, result){

            res.send(200, result);

        });

    });

更新： 服务器请求的中间层。

var service = require('./apiService');



function BuildingBlockService(){

}



BuildingBlockService.prototype.init = function(){}



BuildingBlockService.prototype.service = function(context, payload, callback) {

    var apiService = new service()

    var params = payload;

    switch (params.action){

        case "list":

        default:

            apiService.get(context, null, callback, "BuildingBlocks");

            break;

    }



};



module.exports = BuildingBlockService;

问题答案：

Node.js是否可以一一处理客户端请求？

是和否。node.js运行您的JS单线程。这意味着在任何给定时间仅运行一个JS执行线程。因此，如果您有两个这样的要求：

// don't use this in real code, it's to simulate a point
function spin(t) {
    var start = Date.now();
    while (Date.now() < start + t) {}
}

app.post("/route1", req, res) {
    console.log("starting processing of /route1 request");
    // simulate taking several seconds of pure CPU to make a response
    spin(2000);
    res.send("done 1");
    console.log("finished processing of /route1 request");
}

app.post("/route2", req, res) {
    console.log("starting processing of /route2 request");
    // simulate taking several seconds of pure CPU to make a response
    spin(2000);
    res.send("done 2");
    console.log("finished processing of /route2 request");
}

并且/ route1请求之后紧接着是/ route2请求，然后node.js服务器将处理/
route1请求，直到该请求完成后才能执行其他任何操作，因为CPU一直处于忙碌状态。

因此，这将产生如下日志：

starting processing of /route1 request
finished processing of /route1 request
starting processing of /route2 request
finished processing of /route2 request

但是，纯粹出于CPU原因，请求花费很长时间是相对罕见的。请求通常涉及某种I / O（要读取的文件，数据库查询，要联系的其他服务器等）。如果该I /
O是使用异步IO而不是同步IO以异步方式完成的，则多个请求可以轻松地同时进行，并且可以同时进行，因为node.js服务器正在等待对于I /
O请求完成，可以免费服务其他请求，也可以服务其他请求。

因此，如果您具有以下服务器代码：

app.post("/route1", req, res) {
    console.log("starting processing of /route1 request");
    // simulate taking several seconds of pure CPU to make a response
    request('http://www.google.com', function (error, response, body) {
        if (!error && response.statusCode == 200) {
            res.send("done 1");
            console.log("finished processing of /route1 request");
        }
    });
}

app.post("/route2", req, res) {
    console.log("starting processing of /route2 request");
    // simulate taking several seconds of pure CPU to make a response
    request('http://www.google.com', function (error, response, body) {
        if (!error && response.statusCode == 200) {
            res.send("done 2");
            console.log("finished processing of /route2 request");
        }
    });
}

并且/ route1请求之后紧接着是/ route2请求，那么您可能会看到此日志（无法保证/ route1和/ route2响应完成的顺序-
它们可以按任何顺序排列），但是两个响应都将是并行处理：

starting processing of /route1 request
starting processing of /route2 request
finished processing of /route1 request
finished processing of /route2 request

如果您的node.js代理服务器似乎表现出串行处理行为而不是并行处理行为，则可能是在实现代理方面存在某种实现问题，因为它肯定能够在其中包含多个请求同时飞行。

Node.js是否可以一一处理客户端请求？

相关阅读

相关文章

相关问答

相关工具

相关文档