Node.js

Question

我有一个 'script' 可以对特定 API 发出数千个请求。这个 API 每秒只允许 5 个请求（并且它的测量可能与我不同）。为了发出请求，我正在使用 request-promise 框架，并且我已经用这个取代了正常的 request-promise 函数：

const request_promise  = require('request-promise')

function waitRetryPromise() {
  var count = 0 // keeps count of requests
  function rp(options) {
    const timedCall = (resolve) => setTimeout( ()=>resolve(rp(options)),1000) // recursive call
    count += 1
    if (count % 3 == 0) { // recalls after a second on every third request
      return new Promise(timedCall)
    } else {
      return request_promise(options)
    }
  }
  return rp
}

const rp = waitRetryPromise()

一旦连续发出大约 300 个请求（给予或接受），这些请求就会开始相互干扰。有没有人有更好的解决方案？我认为对同一个函数的递归调用会有所帮助，它确实有帮助，但并没有解决问题。也许有一种模式可以对请求进行排队，一次处理几个请求？也许是图书馆？

谢谢！

Answer 1

我不确定，但也许你从下面得到了一些想法

function placeAnOrder(orderNumber) {
    console.log("customer order:", orderNumber)
    cookAndDeliverFood(function () {
        console.log("food delivered order:", orderNumber);
    });
}

//  1 sec need to cook

function cookAndDeliverFood(callback){
    setTimeout(callback, 1000);
}

//users web request
placeAnOrder(1);
placeAnOrder(2);
placeAnOrder(3);

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

Answer 2

我的代码将运行 TimedQueue 所以只要他们是工作要做。 process() 方法在所有工作完成后解析：

class Queue {
    constructor() {
        this.queue = [];
    }

    enqueue(obj) {
        return this.queue.push(obj);
    }

    dequeue() {
        return this.queue.shift();
    }

    hasWork() {
        return (this.queue.length > 0);
    }
}

function t_o(delay) {
    return new Promise(function (resolve, reject) {
        setTimeout(function () {
            resolve();
        }, delay);
    });
}

class TimedQueue extends Queue {
    constructor(delay) {
        super();
        this.delay = delay;
    }

    dequeue() {
        return t_o(this.delay).then(() => {
            return super.dequeue();
        });
    }
    
    process(cb) {
        return this.dequeue().then(data => {
            cb(data);
            if (this.hasWork())
                return this.process(cb);
        });
    }
}


var q = new TimedQueue(500);

for (var request = 0; request < 10; ++request)
    q.enqueue(request);

q.process(console.log).then(function () {
    console.log('done');
});

Answer 3

好的，不要重复调用 rp 等，只需确保在请求之间延迟适当的时间...每秒 5 次，即 200 毫秒

function waitRetryPromise() {
    let promise = Promise.resolve();
    return function rp(options) {
        return promise = promise
        .then(() => new Promise(resolve => setTimeout(resolve, 200)))
        .then(() => request_promise(options));
    }
}
const rp = waitRetryPromise();

Node.js - 使用每秒 5 个请求的 API 限制

Node.js - Working with an API limit of 5 requests per second

javascript

promise

request-promise