在节点js中失败后重试自己的承诺

Question

我想在 Promise 中重试我的请求。如果我总是有一个 401 错误作为循环，我想启动我的刷新：（如果我在刷新时有 401 循环直到 200）

我试过这个：

const request = require('request');
let conf    = require('../conf');

let core_service = require('coreService');

let self = module.exports = {
    get_count_questions: function() {
        return new Promise((resolve, reject) => {
            request({
                method: 'GET',
                uri: 'http://api/count-questions',
                auth: {
                    'bearer': conf.token
                },
                json: true
            }, function (error, response, body) {
                if (!error && response.statusCode === 200) {
                    resolve(body);
                } else if (!error && response.statusCode === 401) {
                    core_service.refreshToken().then((data) => {
                        console.log('token refresh');
                        return self.get_count_questions();
                    })
                } else {
                    reject(error);
                }
            })
        });
    }
};

我只尝试了“self.get_count_questions();”没有回报，但它不起作用。我没有错误消息，只是我的应用程序冻结了。

我在我的 console.log 中看到“令牌刷新”，但在我的应用程序冻结之后...

编辑

我用这个修改过，感觉更好，但是刷新令牌很慢。就在 401 之前，我的应用停止，大约 1 分 40 秒后，运行：

else if (!error && response.statusCode === 401) {
    console.log('need refresh token');
    core_service.refreshToken()
                .then((response) => {
                    console.log(response);
                    resolve(self.get_count_questions())
                } );
}

我的 refreshToken 函数：

refreshToken: function () {
    return new Promise((resolve, reject) => {
        request({
            method: 'GET',
            uri   : 'http://api/refresh',
            auth  : {
                'bearer': conf.token
            },
            json  : true
        }, function (error, response, body) {
            console.log('=====> refresh token <======');
            conf.token = body.data;
            console.log('new Token');
            console.log('=====> end refresh token <======');
            if (!error && response.statusCode === 200) {
                resolve('Refresh token successful');
            } else {
                reject('Error refresh');
            }
        })
    });
}

如果我在每个请求上刷新我的令牌，我就会遇到问题：

if (!error && response.statusCode === 200) {
     core_service.refreshToken().then((data)=> {
         resolve(body);
     });

}

Answer 1

你必须解决返回的承诺。当你使用一个 Promise 解决时，你基本上是说，用这个 Promise 的结果来完成这个 Promise。

var prom = function() {
  return new Promise((resolve, reject) => {
    console.log('request start')
    setTimeout(() => {
      console.log('request finish')
      let ran = Math.random();

      if (ran < 0.1)
        resolve('success');

      else if (ran >= 0.1 && ran < 0.98)
        setTimeout(() => {
          console.log('retry');
          resolve(prom());
        }, 500);

      else
        reject('error');

    }, 500);
  });
};

prom().then(console.log.bind(console), console.log.bind(console));

所以你应该像这样更新你的 else if 块：

else if (!error && response.statusCode === 401) {
  console.log('need refresh token');
  core_service.refreshToken()
    .then(() => resolve(self.get_count_questions()));
} 

Answer 2

您正在进行递归调用，但您实际上从未对它的承诺做任何事情。因此，您最初的承诺永远不会解决。

您需要将递归调用（到refreshToken().then()）的承诺传递给resolve()。

Answer 3

现在你几乎拥有它。

但是：

return core_service.refreshToken()
                   .then(self.get_count_questions);

您将其返回给request() 回调；该返回值没有被使用。

相反，您需要将原来的承诺从then() 解析为新的承诺，方法是将它传递给原来的resolve() 函数：

resolve(core_service.refreshToken().then(...));

Answer 4

我知道这不是最佳解决方案，但它可能会有所帮助

const request = require('request');
    let conf    = require('../conf');

    let core_service = require('coreService');

    let self = module.exports = {
        get_count_questions: function() {
            return new Promise((resolve, reject) => {
                request({
                    method: 'GET',
                    uri: 'http://api/count-questions',
                    auth: {
                        'bearer': conf.token
                    },
                    json: true
                }, function (error, response, body) {
             try{
                    if (!error && response.statusCode === 200) {
                        resolve(body);
                    } else if (!error && response.statusCode === 401) {
                       throw new Error(response.statusCode);
                    } else {
                        reject(error);
                    }
                 }catch(exc){if(exc === 401){
                            core_service.refreshToken().then((data) => {
                            console.log('token refresh');
                            return self.get_count_questions();
                        })      
                       }

                    }       
                })
            });
        }
    };

Answer 5

您需要在重试请求后调用初始解析/拒绝函数：

let self = module.exports = {
    get_count_questions: function() {
        return new Promise((resolve, reject) => {
            request({
                method: 'GET',
                uri: 'http://api/count-questions',
                auth: {
                    'bearer': conf.token
                },
                json: true
            }, function (error, response, body) {
                if (!error && response.statusCode === 200) {
                    resolve(body);
                } else if (!error && response.statusCode === 401) {
                    core_service.refreshToken().then((data) => {
                        console.log('token refresh');
                        self.get_count_questions().then((data) => {
                          // call initial resolve function
                          resolve(data);
                        }).catch((error) => {
                          // call initial reject function
                          reject(error);
                        });
                    }).catch((error) => {
                        // reject if refreshToken fails
                        reject(error);
                    });
                } else {
                    reject(error);
                }
            })
        });
    }
};

您还必须确保第二次调用实际解决/拒绝并且不会进入另一个 401。因为否则您将有无限递归。