无感刷新token

import axios from 'axios'
import header from '@/api/header.js';
import router from '@/router';
import { MessageBox, Message } from 'element-ui';
import apiBase from '@/api/apiBase.js';
const host = api();
const successCode = 100000;
const mismatchCode = 100020;
const TIMEOUT = 100000;
const service = axios.create({
  baseURL: host,
  timeout: TIMEOUT,
})
// 是否正在刷新的标记
let isRefreshing = false
// 保存需要重新发起请求的队列
let retryRequests = [];
service.interceptors.response.use(
  response => {
    if (response.data.code === 409) {
      if (!isRefreshing) {
        isRefreshing = true
        return refreshToken({ refreshToken: localStorage.getItem('dh_refreshToken'), token: getToken() }).then(res => {
          const { accesstoken } = res.content
          setToken(accesstoken)
          //   遍历执行需要重新发起请求的队列
          retryRequests.forEach(cb => cb(res));
          //   清空队列
          retryRequests = [];
        }).catch(err => {
          retryRequests = [];
          removeToken()
          router.push({
            path: '/',
          });
          return Promise.reject(err)
        }).finally(() => {
          isRefreshing = false
        })
      } else {
        // 正在刷新token，返回一个未执行resolve的promise
        // 把promise 的resolve 保存到队列的回调里面，等待刷新Token后调用
        // 原调用者会处于等待状态直到 队列重新发起请求，再把响应返回，以达到用户无感知的目的（无痛刷新）
        return new Promise(resolve => {
          // 将resolve放进队列，用一个函数形式来保存，等token刷新后直接执行
          retryRequests.push(info => {
            // 将新的Token重新赋值
            config.params.token = info.Token;
            config.params.appkey = info.AppKey;
            resolve(service.request(config));//service.request是一个请求从新发起的
          });
        });
      }

    }
    return response && response.data
  },
  (error) => {
    Message.error(error.response.data.msg)
    return Promise.reject(error)
  }
)

function post(Data, Url, Success, Failure) {
  let obj = {};
  if (Url.indexOf('?') > 0) {
    obj = Url.slice(Url.indexOf('?')) + JSON.stringify(Data);
  } else {
    obj = JSON.stringify(Data);
  }
  if (Failure === undefined)
    Failure = (res) => {
      Message.error(res.data.msg);
    };
  service({
    url: Url,
    method: 'POST',
    headers: header.headersBody(obj),
    data: Data,
  })
    .then((res) => {
      if (res.data.code === successCode) {
        Success(res);
        store.state.isloading = false;
      } else if (res.data.code === mismatchCode) {
        if (store.state.relogin) {
          store.state.relogin = false;
          MessageBox.alert('请重新登录', {
            confirmButtonText: '确定',
            callback: () => {
              var url = sessionStorage.getItem('loginForm');
              if (url) {
                setTimeout(() => {
                  router.push({
                    path: url,
                  });
                }, 500);
              } else {
                router.push({
                  path: '/',
                });
              }
            },
          });
        }
      } else {
        Failure(res);
        store.state.isloading = false;
      }
    })
    .catch((error) => {
      store.state.isloading = false;
      if (error.code === 'ECONNABORTED') {
        Message.error('请求超时,请重试。');
      } else if (error.message === 'Network Error') {
        console.log(error);
        Message.error('请求错误,请检查网络设置。');
      }
      // Message.error("请求出错！");
      console.log(Url, error.message);
    });
}
export default {
  post
};

function getToken() {
  return localStorage.getItem('dh_accesstoken')
}
function setToken(token) {
  localStorage.setItem('dh_accesstoken', token)
}
function refreshToken(refreshToken, accesstoken) {
  return post({
    url: apiBase.getApiAdress().Sso.RefreshToken,
    data: {
      refreshToken,
      accesstoken
    }
  })
}