javascript - 如何使用嵌套请求处理异步 token 更新？

Question

我在 POST 请求中发出一个 POST 请求。第二个 POST 使用第一个 POST 请求的 token。

我真的不知道 2nd POST 什么时候结束，但我很确定它会比 token 的到期时间更长，让我们假设它是大约 10 秒。

现在我的问题是我该如何处理它。我的意思是如何更新 token ，知道它在 2nd POST 中使用。

这是我的代码:

var request = require('request');
var async   = require('async');
var fs      = require('fs');
var renew_token_timer ;



var o = {
    "someValue": "s",
    "someValue2": "g"
};
var s = JSON.stringify(o);

request({
    headers: {
      'Content-Type': 'application/json'
    },
    uri: '/getToken',
    body: s,
    method: 'POST'
}, function (err, res, body) {

    var renew_token = setInterval(function(){
      console.log("renew token now after 10sec");
    },10000);

    var token = JSON.parse(body);
    var tasks = [];
    for(let i = 1; i < 10 ; i++){
        tasks.push(function(callback){
            getPeople(25, i, token, callback);
        });
    }
    async.series(tasks,
    function(err, results) {
        console.log("FINISHED");
    });

  });

  function getContacts(pageSize, page, access_token, callback){
    var to_send = {"test" : "test"};

   var to_send = JSON.stringify(to_send);
   var url = "/getPeople";
   request({
    headers: {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer ' + token,
    },
     time : true,
     uri: url,
     body: to_send,
     method: 'POST'
    }, function (err, res, body) {
        callback();
   });
  }

有什么建议吗？

Answer 1

为了简化这一点，让我们将调用提取到有前途的函数中:

  function retrieveToken() {
   return new Promise((res, rej) => {
    request({
     headers: { 'Content-Type': 'application/json'  },
     uri: '/getToken',
     body: JSON.stringify({ "someValue": "s",  "someValue2": "g" }),
     method: 'POST'
    }, (err, _, body) => err ? rej(err) : res(JSON.parse(body)));
  });
 }

 const retrieveContacts = (size, page, token) => new Promise(res => getContacts(size, page, token, res));

现在很简单:

 (async function() {
   // Get the first token to start:
   let token = await retrieveToken();
   // Update the token sometimes:
   setInterval(async () => token = await retrieveToken(), 8000);
   // Retrieve the data
   for(let i = 1, i < 10; i++)
     await retrieveContacts(25, i, token);
 })();

这只是每 10 秒更新一次 token 变量，这样它就会指向一个新的 token。这应该适用于大多数情况。

---

现在，如果检索 token 花费的时间比估计的时间长，则请求可能会使用已弃用的 token 。为防止这种情况，只需使用 token Promise 并在执行请求之前等待它:

 (async function() {
   // Get the first token to start:
   let tokenPromise = retrieveToken();
   // Update the token sometimes:
   setInterval(() => tokenPromise = retrieveToken(), 10000);
   // Retrieve the data
   for(let i = 1, i < 10; i++)
     await retrieveContacts(25, i, await tokenPromise);
 })();

这将等待新的 token 进入，然后在先前的 token 被弃用后发送另一个请求。