uniapp请求封装统一处理，token无感刷新刷

import { useStoreUser } from '@/store/user.js';
import requestInterceptor from '@/interceptor/request.js';
import { goLogin } from '@/interceptor/router.js';
import { refreshToken } from './index';

class http {
  /**
   * http 请求基类
   * @param {string} baseUrl 根地址
   * @param {object} header 请求头
   */
  constructor(baseUrl = process.env.VITE_GLOB_API_URL, header = {}) {
    // 启用请求拦截器
    requestInterceptor();

    this.baseUrl = baseUrl;
    this.header = header;

    // 请求缓存
    this.responseCache = [];
    // 是否在刷新token
    this.isRefreshToken = false;
  }

  /**
   * get请求
   * @param {string} url url路径
   * @param {json} params url参数
   * @return {Promise}
   */
  get(url, params) {
    return this.response({
      url,
      params
    });
  }

  /**
   * post请求
   * @param {string} url url路径
   * @param {json} data body参数
   * @param {json} params url参数
   * @return {Promise}
   */
  post(url, data, params) {
    return this.response({
      method: 'POST',
      url,
      data,
      params
    });
  }

  /**
   * put请求
   * @param {string} url url路径
   * @param {json} data body参数
   * @param {json} params url参数
   * @return {Promise}
   */
  put(url, data = {}, params) {
    return this.response({
      method: 'PUT',
      url,
      data,
      params
    });
  }

  /**
   * put请求
   * @param {string} url url路径
   * @param {json} params url参数
   * @return {Promise}
   */
  delete(url, params) {
    return this.response({
      method: 'DELETE',
      url,
      params
    });
  }

  /**
   * 发送请求
   * @param {object} requestData 请求数据 {url: url路径, params: url参数}
   * @param {Function} request 回调方法
   */
  response({ method, url, data, params, responseType }) {
    // 构造请求
    const responsePromise = () => {
      // 设置token
      const user = useStoreUser();
      this.header.Token = user.getToken;
      return new Promise((resolve, reject) => {
        const _this = this;
        uni.request({
          method,
          header: _this.header,
          url: _this.joinUrl(_this.baseUrl + url, params),
          data,
          responseType: responseType,
          success(res) {
            const data = res.data;
            if (res?.statusCode == 200 && data.code == 200) {
              resolve(data.result);
            } else {
              if (res?.statusCode == 401 || data.code == 401) {
                // 没有token
                if (!user.getToken) {
                  reject();
                  return goLogin();
                }
                // 刷新token 401
                if (url == '/login/refreshToken') return reject();
                // 缓存401请求
                _this.responseCache.push(responsePromise);
                // 刷新token
                if (_this.isRefreshToken == false) {
                  refreshToken()
                    .then((res) => {
                      // 设置新token、refreshToken
                      user.setToken(res.token);
                      user.setRefreshToken(res.refreshToken);
                      // 重新发起缓存401请求队列
                      _this.responseCache.forEach((fun) => {
                        fun().then(resolve).catch(reject);
                      });
                      // 清空401请求队列
                      _this.responseCache = [];
                    })
                    .catch(() => {
                      reject();
                      // 刷新token失败，跳转登录
                      goLogin();
                    })
                    .finally(() => {
                      _this.isRefreshToken = false;
                    });
                  _this.isRefreshToken = true;
                }
              } else {
                _this.errorTip(data.message);
                reject(data.message);
              }
            }
          },
          fail(err) {
            _this.errorTip(err);
            reject(err);
          },
          complete() {}
        });
      });
    };

    // 发起请求，返回结果
    return responsePromise();
  }

  // 并接url
  joinUrl(url, params) {
    const paramStr = this.joinParams(params);
    const path = url + (paramStr.length ? '?' + paramStr : '');
    return path;
  }

  // 拼接params
  joinParams(params) {
    const param = [];
    for (let key in params) {
      if (params[key] !== undefined && params[key] !== '' && params[key] !== null) {
        param.push(`${key}=${encodeURIComponent(params[key])}`);
      }
    }
    return param.join('&');
  }

  // 错误提示
  errorTip(message) {
    // 网络请求失败
    if (message.errMsg && message.errMsg.indexOf('statusCode:-1') != -1) {
      message = '网络请求失败';
    }

    uni.showToast({
      title: message,
      duration: 2000,
      icon: 'none'
    });
  }
}

export default new http();