axios处理重复请求的方法小结_Javascript

使用到的技术/库：axios、ts、发布订阅者模式。

本文将使用发布订阅者模式来处理重复的axios请求。将实现“一定时间内发送多个相同的请求时，只向服务器发出第一个请求，然后将第一个请求的响应结果分发给各个请求方法”的效果。

前言

首先，我们要先定义何为重复的请求？

接口地址、类型、参数相同，则视为相同的请求；
上一个请求还未返回响应结果时，又发送一个相同的请求，则视为重复请求。

其次，我们将每次请求生成一个唯一的key并缓存起来，用作判断是否已存在相同的请求。

最后，我们需要实现一个发布订阅者模式，在存在重复请求时，中断请求，并添加订阅，当之前的请求结果返回时，发布给订阅者。

还有一个问题，如何中断请求？只需在axios的请求拦截器中返回一个promise.reject()即可，这样将会直接执行axios的响应拦截器中的错误处理方法，而不会向服务器发送请求。

技术实现

1. 生成key

根据接口的地址、类型、参数，我们可以判断是否为相同的请求，那我们可以在key中包含这些关键信息。

import { type axiosrequestconfig } from 'axios'

const getdatatype = (obj: unknown) => {
  let res = object.prototype.tostring.call(obj).split(' ')[1]
  res = res.substring(0, res.length - 1).tolowercase()
  return res
}

const getkey = (config: axiosrequestconfig) => {
  const { method, url, data, params } = config;
  let key = `${method}-${url}`;

  try {
    if (data && getdatatype(data) === 'object') {
      key += `-${json.stringify(data)}`;
    } else if (getdatatype(data) === 'formdata') {
      for (const [k, v] of data.entries()) {
        if (v instanceof blob) {
          continue;
        }

        key += `-${k}-${v}`;
      }
    }
    
    if (params && getdatatype(params) === 'object') {
      key += `-${json.stringify(params)}`;
    }
  } catch (e) {console.error(e);}
  
  return key;
};

判断参数类型是为了处理formdata、二进制等格式情况。

2. 缓存请求

我们可以创建一个全局变量来保存请求信息，在请求拦截器（发送请求之前）中将请求信息添加至全局变量，然后在响应拦截器（请求完成之后）中移除相关信息。

import axios from 'axios';

const historyrequests = new map<string, number>()

axios.interceptors.request.use(
  (config) => {
    // 生成key
    const key = createkey(config);
    // 响应拦截器中需要用到
    config.headers.key = key;
    // 缓存请求信息
    historyrequests.set(key, 1);

    return config;
  },
  (error) => {
    return promise.reject(error);
  }
);

instance.interceptors.response.use(
  (res) => {
    // 请求完成，删除缓存信息
    const key = res.config.headers.key as string;
    if (historyrequests.has(key)) {
      historyrequests.delete(key);
    }

    return res;
  },
  (error) => {
    return promise.reject(error);
  }
);

3. 发布订阅者模式实现

订阅者通过注册事件到调度中心，当发布者触发事件时，由调度中心执行相应的订阅事件。

export default class eventbus<t extends record<string | symbol, any>> {
  private listeners: record<keyof t, ((...args: any[]) => void)[]> = {} as any

  $on<k extends keyof t>(event: k, callback: t[k]) {
    if (!this.listeners[event]) {
      this.listeners[event] = []
    }
    this.listeners[event].push(callback)
  }

  $emit<k extends keyof t>(event: k, ...args: parameters<t[k]>) {
    const callbacks = this.listeners[event]
    if (!callbacks || callbacks?.length === 0) {
      return
    }

    callbacks.foreach((callback) => {
      callback(...args)
    })
  }

  $off<k extends keyof t>(event: k, listener?: t[k]) {
    if (!listener) {
      delete this.listeners[event]
      return
    }

    const fns = this.listeners[event]
    if (!fns || !fns.length) {
      return
    }

    const idx = fns.indexof(listener)
    if (idx !== -1) {
      fns.splice(idx, 1)
    }
  }

  clear() {
    this.listeners = {} as any
  }
}

4. 完整代码实现

import axios, {
  type axiosrequestconfig,
  axioserror,
  type axiosresponse
} from 'axios';
import { getdatatype } from './utils';
import { eventbus } from './event/eventbus';

interface ibaseresponse {
  code: number;
  msg: string;
  data?: unknown;
}

const createkey = (config: axiosrequestconfig) => {
  const { method, url, data, params } = config;
  let key = `${method}-${url}`;

  try {
    if (data && getdatatype(data) === 'object') {
      key += `-${json.stringify(data)}`;
    } else if (getdatatype(data) === 'formdata') {
      for (const [k, v] of data.entries()) {
        if (v instanceof blob) {
          continue
        }
        key += `-${k}-${v}`;
      }
    }
    if (params && getdatatype(params) === 'object') {
      key += `-${json.stringify(params)}`;
    }
  } catch (e) {console.error(e);}
  return key;
};

const instance = axios.create({
  baseurl: '',
  timeout: 5000,
  withcredentials: true,
  headers: {
    'content-type': 'application/json;'
  }
});

const historyrequests = new map<string, number>();
instance.interceptors.request.use(
  (config) => {
    const key = createkey(config);
    // 在响应拦截器中需要用到该key发布/订阅事件
    config.headers.key = key;
    // 判断是否存在相同请求，存在则中断请求
    if (historyrequests.has(key)) {
      // 为了后续方便处理中断请求超时
      config.headers.requesttime = date.now();
      
      // 抛出错误并传递相应参数
      return promise.reject(
        new axioserror('redundant request', 'err_repeated', config)
      );
    }
    historyrequests.set(key, 1);
    return config;
  },
  (error: axioserror) => {
    return promise.reject(error);
  }
);

const responseinterceptor = (res: axiosresponse<ibaseresponse | blob>) => {
  const result: [
    axiosresponse<ibaseresponse | blob> | undefined,
    axioserror | undefined
  ] = [undefined, undefined];
  const data = res.data;
  // 可根据你的接口响应数据作处理，这里假设code不为200都为错误
  if (data instanceof blob || data.code === 200) {
    result[0] = res;
  } else {
    result[1] = new axioserror(data.msg);
  }
  return result;
};

const eventbus = new eventbus<{
  [key: string]: (
    data?: axiosresponse<ibaseresponse | blob>,
    error?: axioserror
  ) => void;
}>();

instance.interceptors.response.use(
  (res) => {
    const [data, error] = responseinterceptor(res);

    // 如果存在重复请求，则发布结果，执行订阅事件
    const key = res.config.headers.key as string;
    if (historyrequests.has(key)) {
      historyrequests.delete(key);
      eventbus.$emit(key, data, error);
    }

    return data !== undefined ? data : promise.reject(error);
  },
  (error: axioserror) => {
    // 处理中断的重复请求
    if (error.code === 'err_repeated') {
      return new promise((resolve, reject) => {
        const config = error.config!;
        const key = config.headers.key as string;
        const callback = (
          res?: axiosresponse<ibaseresponse | blob>,
          err?: axioserror
        ) => {
          res ? resolve(res) : reject(err);
          eventbus.$off(key, callback);
        };
        // 订阅事件
        eventbus.$on(key, callback);

        // 处理超时
        const timeout = config.timeout || 5000;
        const requesttime = config.headers.requesttime as number;
        const now = date.now();
        if (now - requesttime > timeout) {
          historyrequests.delete(key);
          const error = new axioserror(
            `timeout of ${timeout}ms exceeded`,
            'econnaborted',
            config
          );
          error.name = 'axioserror';
          eventbus.$emit(key, undefined, error);
        }
      });
    }

    return promise.reject(error);
  }
);

可以根据你的实际需求调整相关代码，例如：你需要对某些请求放行，则可以通过在headers中添加一个属性来控制是否允许重复请求。

以上就是axios处理重复请求的方法小结的详细内容，更多关于axios处理重复请求的资料请关注代码网其它相关文章！