Question

编写了一个用于进行http调用的节点模块，但是发生的事情是当调用错误（由于超时，错误路径（故意完成））后续调用时...我不知道第二个的来源request ...这是模块的代码

var querystring = require('querystring'),
http = require('http'),
util = require('util'),
stream = require('stream'),
Writable = stream.Writable;

exports.serviceCall = function(api, next) {
function bufferInMemory(key, options) {
    Writable.call(this, options);
    this[key] = new Buffer('');
    this._write = function(chunk, encoding, callback) {
        chunk = (Buffer.isBuffer(chunk)) ? chunk : new Buffer(chunk, encoding);
        this[key] = Buffer.concat([this[key], chunk]);
        callback();
    };
}
 util.inherits(bufferInMemory, Writable);
 api.serviceCall = function(options, callback) {
     var target = new bufferInMemory('result', {
        encoding: 'utf8',
        objectMode: true
    });
    var reqTimeout;
    var req = http.request(options, function(res) {
        res.pipe(target);
        target.on('finish', function() {
            if (reqTimeout) {
                clearTimeout(reqTimeout);
                reqTimeout = null;
            }
            if (res.statusCode !== 200 && res.statusCode !== 304) {
                return callback({}, {
                    status: 'fail',
                    data: [],
                });
            } else {
                try {
                    var result;
                    result = JSON.parse(target.result.toString());
                } catch (err) {
                    result = target.result.toString();
                }
                var convertedToJson = result;
                return callback(null, {
                    status: 'success',
                    data: convertedToJson
                });
            }
        }); 
    });
    req.on('error', function(err) {
        var error = err || {};
        if (reqTimeout) {
            clearTimeout(reqTimeout);
            reqTimeout = null;
        }
        req.end();
        return callback(error, {
            status: 'fail',
            data: [],
        });
    });
    var timeoutInit = function() {
        reqTimeout = setTimeout(function() {
            req.emit('error');
        }, 3000);
    };
    timeoutInit();
    /*
     *  this does not work because multiple requests can share the same socket
     */
    // req.on('socket', function(socket) {   
    //     socket.setTimeout(1000, function() {   
    //         console.log('in timeout of api service call');
    //         req.emit('error');
    //     });
    // });
    req.end();
};
next();

};

我在错误处理中遗漏了什么？或者它可能是底层框架（我们使用actionhero.js）决定发送另一个调用，因为第一个调出错误了吗？

Answer 1

http会异步发出请求，你不能缓存它们，因为当从事件队列中返回错误时，作用域会出来。

如果您希望节点处理未捕获异常的崩溃，那么您可以使用进程事件但不建议在生产中使用而不是使用＆＃34; forever＆＃34;在每次未捕获的异常之后，需要重新启动，否则应用程序可能会表现不同。

这是处理未捕获异常的进程事件..

 process.on('uncaughtException', (err) => {
   console.log(`Caught exception: ${err}`);
 });

node.js请求的错误处理

1 个答案: