项目初始化

web-vue/packages/core/utils/http/axios/Axios.ts

@@ -0,0 +1,242 @@
+import type { AxiosRequestConfig, AxiosInstance, AxiosResponse, AxiosError } from 'axios';
+import type { RequestOptions, Result, UploadFileParams } from '@jeesite/types/axios';
+import type { CreateAxiosOptions } from './axiosTransform';
+import axios from 'axios';
+import qs from 'qs';
+import { AxiosCanceler } from './axiosCancel';
+import { isFunction } from '@jeesite/core/utils/is';
+import { cloneDeep, omit } from 'lodash-es';
+import { ContentTypeEnum } from '@jeesite/core/enums/httpEnum';
+import { RequestEnum } from '@jeesite/core/enums/httpEnum';
+
+export * from './axiosTransform';
+
+/**
+ * @description:  axios module
+ */
+export class VAxios {
+  private axiosInstance: AxiosInstance;
+  private readonly options: CreateAxiosOptions;
+
+  constructor(options: CreateAxiosOptions) {
+    this.options = options;
+    this.axiosInstance = axios.create(options);
+    this.setupInterceptors();
+  }
+
+  /**
+   * @description:  Create axios instance
+   */
+  private createAxios(config: CreateAxiosOptions): void {
+    this.axiosInstance = axios.create(config);
+  }
+
+  private getTransform() {
+    const { transform } = this.options;
+    return transform;
+  }
+
+  getAxios(): AxiosInstance {
+    return this.axiosInstance;
+  }
+
+  /**
+   * @description: Reconfigure axios
+   */
+  configAxios(config: CreateAxiosOptions) {
+    if (!this.axiosInstance) {
+      return;
+    }
+    this.createAxios(config);
+  }
+
+  /**
+   * @description: Set general header
+   */
+  setHeader(headers: any): void {
+    if (!this.axiosInstance) {
+      return;
+    }
+    Object.assign(this.axiosInstance.defaults.headers, headers);
+  }
+
+  /**
+   * @description: Interceptor configuration
+   */
+  private setupInterceptors() {
+    const transform = this.getTransform();
+    if (!transform) {
+      return;
+    }
+    const { requestInterceptors, requestInterceptorsCatch, responseInterceptors, responseInterceptorsCatch } =
+      transform;
+
+    const axiosCanceler = new AxiosCanceler();
+
+    // Request interceptor configuration processing
+    this.axiosInstance.interceptors.request.use((config: AxiosRequestConfig | any) => {
+      // If cancel repeat request is turned on, then cancel repeat request is prohibited
+      const ignoreCancelToken = config.headers?.ignoreCancelToken;
+
+      const ignoreCancel =
+        ignoreCancelToken !== undefined ? ignoreCancelToken === 'true' : this.options.requestOptions?.ignoreCancelToken;
+
+      !ignoreCancel && axiosCanceler.addPending(config);
+      if (requestInterceptors && isFunction(requestInterceptors)) {
+        config = requestInterceptors(config, this.options);
+      }
+      return config;
+    }, undefined);
+
+    // Request interceptor error capture
+    requestInterceptorsCatch &&
+      isFunction(requestInterceptorsCatch) &&
+      this.axiosInstance.interceptors.request.use(undefined, requestInterceptorsCatch);
+
+    // Response result interceptor processing
+    this.axiosInstance.interceptors.response.use((res: AxiosResponse<any>) => {
+      res && axiosCanceler.removePending(res.config);
+      if (responseInterceptors && isFunction(responseInterceptors)) {
+        res = responseInterceptors(res);
+      }
+      return res;
+    }, undefined);
+
+    // Response result interceptor error capture
+    responseInterceptorsCatch &&
+      isFunction(responseInterceptorsCatch) &&
+      this.axiosInstance.interceptors.response.use(undefined, responseInterceptorsCatch);
+  }
+
+  /**
+   * @description:  File Upload
+   */
+  uploadFile<T = any>(config: AxiosRequestConfig, params: UploadFileParams) {
+    const formData = new window.FormData();
+
+    if (params.data) {
+      Object.keys(params.data).forEach((key) => {
+        if (!params.data) return;
+        const value = params.data[key];
+        if (Array.isArray(value)) {
+          value.forEach((item) => {
+            formData.append(`${key}[]`, item);
+          });
+          return;
+        }
+
+        formData.append(key, params.data[key]);
+      });
+    }
+    formData.append(params.name || 'file', params.file as any, params.filename);
+    const customParams = omit(params, 'file', 'filename');
+
+    Object.keys(customParams).forEach((key) => {
+      formData.append(key, customParams[key]);
+    });
+
+    return this.axiosInstance.request<T>({
+      ...config,
+      method: 'POST',
+      data: formData,
+      headers: {
+        'Content-type': ContentTypeEnum.FORM_DATA,
+        ignoreCancelToken: 'true',
+      },
+    });
+  }
+
+  // support form-data
+  supportFormData(config: AxiosRequestConfig) {
+    const headers = config.headers || this.options.headers;
+    const contentType = headers?.['Content-Type'] || headers?.['content-type'];
+
+    if (
+      contentType !== ContentTypeEnum.FORM_URLENCODED ||
+      !Reflect.has(config, 'data') ||
+      config.method?.toUpperCase() === RequestEnum.GET
+    ) {
+      if (config.url && config.params) {
+        let url = config.url;
+        url += url.indexOf('?') == -1 ? '?' : '&';
+        url += qs.stringify(config.params, { encode: true });
+        config.url = url;
+        config.params = {};
+      }
+      return config;
+    }
+
+    return {
+      ...config,
+      data: qs.stringify(config.data, { arrayFormat: 'indices' }),
+    };
+  }
+
+  get<T = any>(config: AxiosRequestConfig, options?: RequestOptions): Promise<T> {
+    return this.request({ ...config, method: 'GET' }, options);
+  }
+
+  post<T = any>(config: AxiosRequestConfig, options?: RequestOptions): Promise<T> {
+    return this.request({ ...config, method: 'POST' }, options);
+  }
+
+  postJson<T = any>(config: AxiosRequestConfig, options?: RequestOptions): Promise<T> {
+    if (!config.headers) {
+      config.headers = {};
+    }
+    config.headers['content-type'] = ContentTypeEnum.JSON;
+    return this.request({ ...config, method: 'POST' }, options);
+  }
+
+  put<T = any>(config: AxiosRequestConfig, options?: RequestOptions): Promise<T> {
+    return this.request({ ...config, method: 'PUT' }, options);
+  }
+
+  delete<T = any>(config: AxiosRequestConfig, options?: RequestOptions): Promise<T> {
+    return this.request({ ...config, method: 'DELETE' }, options);
+  }
+
+  request<T = any>(config: AxiosRequestConfig, options?: RequestOptions): Promise<T> {
+    let conf: CreateAxiosOptions = cloneDeep(config);
+    const transform = this.getTransform();
+
+    const { requestOptions } = this.options;
+
+    const opt: RequestOptions = Object.assign({}, requestOptions, options);
+
+    const { beforeRequestHook, requestCatchHook, transformRequestHook } = transform || {};
+    if (beforeRequestHook && isFunction(beforeRequestHook)) {
+      conf = beforeRequestHook(conf, opt);
+    }
+    conf.requestOptions = opt;
+
+    conf = this.supportFormData(conf);
+
+    return new Promise((resolve, reject) => {
+      this.axiosInstance
+        .request<any, AxiosResponse<Result>>(conf)
+        .then((res: AxiosResponse<Result>) => {
+          if (transformRequestHook && isFunction(transformRequestHook)) {
+            try {
+              const ret = transformRequestHook(res, opt);
+              resolve(ret);
+            } catch (err) {
+              reject(err || new Error('request error!'));
+            }
+            return;
+          }
+          resolve(res as unknown as Promise<T>);
+        })
+        .catch((e: Error | AxiosError) => {
+          if (requestCatchHook && isFunction(requestCatchHook)) {
+            reject(requestCatchHook(e, opt));
+            return;
+          }
+          if (axios.isAxiosError(e)) {
+            // rewrite error message from axios in here
+          }
+          reject(e);
+        });
+    });
+  }
+}

web-vue/packages/core/utils/http/axios/axiosCancel.ts

@@ -0,0 +1,60 @@
+import type { AxiosRequestConfig, Canceler } from 'axios';
+import axios from 'axios';
+import { isFunction } from '@jeesite/core/utils/is';
+
+// Used to store the identification and cancellation function of each request
+let pendingMap = new Map<string, Canceler>();
+
+export const getPendingUrl = (config: AxiosRequestConfig) => [config.method, config.url].join('&');
+
+export class AxiosCanceler {
+  /**
+   * Add request
+   * @param {Object} config
+   */
+  addPending(config: AxiosRequestConfig) {
+    this.removePending(config);
+    const url = getPendingUrl(config);
+    config.cancelToken =
+      config.cancelToken ||
+      new axios.CancelToken((cancel) => {
+        if (!pendingMap.has(url)) {
+          // If there is no current request in pending, add it
+          pendingMap.set(url, cancel);
+        }
+      });
+  }
+
+  /**
+   * @description: Clear all pending
+   */
+  removeAllPending() {
+    pendingMap.forEach((cancel) => {
+      cancel && isFunction(cancel) && cancel();
+    });
+    pendingMap.clear();
+  }
+
+  /**
+   * Removal request
+   * @param {Object} config
+   */
+  removePending(config: AxiosRequestConfig) {
+    const url = getPendingUrl(config);
+
+    if (pendingMap.has(url)) {
+      // If there is a current request identifier in pending,
+      // the current request needs to be cancelled and removed
+      const cancel = pendingMap.get(url);
+      cancel && cancel(url);
+      pendingMap.delete(url);
+    }
+  }
+
+  /**
+   * @description: reset
+   */
+  reset(): void {
+    pendingMap = new Map<string, Canceler>();
+  }
+}

web-vue/packages/core/utils/http/axios/axiosTransform.ts

@@ -0,0 +1,50 @@
+/**
+ * Data processing class, can be configured according to the project
+ */
+import type { AxiosRequestConfig, AxiosResponse } from 'axios';
+import type { RequestOptions, Result } from '@jeesite/types/axios';
+
+export interface CreateAxiosOptions extends AxiosRequestConfig {
+  authenticationHeader?: string;
+  authenticationScheme?: string;
+  transform?: AxiosTransform;
+  requestOptions?: RequestOptions;
+}
+
+export abstract class AxiosTransform {
+  /**
+   * @description: Process configuration before request
+   * @description: Process configuration before request
+   */
+  beforeRequestHook?: (config: AxiosRequestConfig, options: RequestOptions) => AxiosRequestConfig;
+
+  /**
+   * @description: Request successfully processed
+   */
+  transformRequestHook?: (res: AxiosResponse<Result>, options: RequestOptions) => any;
+
+  /**
+   * @description: 请求失败处理
+   */
+  requestCatchHook?: (e: Error, options: RequestOptions) => Promise<any>;
+
+  /**
+   * @description: 请求之前的拦截器
+   */
+  requestInterceptors?: (config: AxiosRequestConfig, options: CreateAxiosOptions) => AxiosRequestConfig;
+
+  /**
+   * @description: 请求之后的拦截器
+   */
+  responseInterceptors?: (res: AxiosResponse<any>) => AxiosResponse<any>;
+
+  /**
+   * @description: 请求之前的拦截器错误处理
+   */
+  requestInterceptorsCatch?: (error: Error) => void;
+
+  /**
+   * @description: 请求之后的拦截器错误处理
+   */
+  responseInterceptorsCatch?: (error: Error) => void;
+}

web-vue/packages/core/utils/http/axios/checkStatus.ts

@@ -0,0 +1,76 @@
+import type { ErrorMessageMode } from '@jeesite/types/axios';
+import { useMessage } from '@jeesite/core/hooks/web/useMessage';
+import { useI18n } from '@jeesite/core/hooks/web/useI18n';
+// import router from '@jeesite/core/router';
+// import { PageEnum } from '@jeesite/core/enums/pageEnum';
+import { useUserStoreWithOut } from '@jeesite/core/store/modules/user';
+import projectSetting from '@jeesite/core/settings/projectSetting';
+import { SessionTimeoutProcessingEnum } from '@jeesite/core/enums/appEnum';
+
+const { showMessageModal, showMessage } = useMessage();
+// const error = createMessage.error!;
+const stp = projectSetting.sessionTimeoutProcessing;
+
+export function checkStatus(status: number, msg: string, errorMessageMode: ErrorMessageMode = 'message'): void {
+  const { t } = useI18n();
+  const userStore = useUserStoreWithOut();
+  let errMessage = '';
+
+  switch (status) {
+    case 400:
+      errMessage = `${msg}`;
+      break;
+    // 401: Not logged in
+    // Jump to the login page if not logged in, and carry the path of the current page
+    // Return to the current page after successful login. This step needs to be operated on the login page.
+    case 401:
+      userStore.setToken(undefined);
+      errMessage = msg || t('sys.api.errMsg401');
+      if (stp === SessionTimeoutProcessingEnum.PAGE_COVERAGE) {
+        userStore.setSessionTimeout(true);
+      } else {
+        userStore.logout(true);
+      }
+      break;
+    case 403:
+      errMessage = msg || t('sys.api.errMsg403');
+      break;
+    // 404请求不存在
+    case 404:
+      errMessage = msg || t('sys.api.errMsg404');
+      break;
+    case 405:
+      errMessage = msg || t('sys.api.errMsg405');
+      break;
+    case 408:
+      errMessage = msg || t('sys.api.errMsg408');
+      break;
+    case 500:
+      errMessage = msg || t('sys.api.errMsg500');
+      break;
+    case 501:
+      errMessage = msg || t('sys.api.errMsg501');
+      break;
+    case 502:
+      errMessage = msg || t('sys.api.errMsg502');
+      break;
+    case 503:
+      errMessage = msg || t('sys.api.errMsg503');
+      break;
+    case 504:
+      errMessage = msg || t('sys.api.errMsg504');
+      break;
+    case 505:
+      errMessage = msg || t('sys.api.errMsg505');
+      break;
+    default:
+  }
+
+  if (errMessage) {
+    if (errorMessageMode === 'modal') {
+      showMessageModal({ title: t('sys.api.errorTip'), content: errMessage }, 'error');
+    } else if (errorMessageMode === 'message') {
+      showMessage({ content: errMessage, key: `global_error_message_status_${status}` }, 'error');
+    }
+  }
+}

web-vue/packages/core/utils/http/axios/helper.ts

@@ -0,0 +1,44 @@
+import { isObject, isString } from '@jeesite/core/utils/is';
+
+const DATE_TIME_FORMAT = 'YYYY-MM-DD HH:mm';
+
+export function joinTimestamp<T extends boolean>(join: boolean, restful: T): T extends true ? string : object;
+
+export function joinTimestamp(join: boolean, restful = false): string | object {
+  if (!join) {
+    return restful ? '' : {};
+  }
+  const now = new Date().getTime();
+  if (restful) {
+    return `?_t=${now}`;
+  }
+  return { _t: now };
+}
+
+/**
+ * @description: Format request parameter time
+ */
+export function formatRequestDate(params: Recordable) {
+  if (Object.prototype.toString.call(params) !== '[object Object]') {
+    return;
+  }
+
+  for (const key in params) {
+    const format = params[key]?.format ?? null;
+    if (format && typeof format === 'function') {
+      params[key] = params[key].format(DATE_TIME_FORMAT);
+    }
+    const value = params[key];
+    if (value) {
+      if (isString(key)) {
+        try {
+          params[key] = isString(value) ? value.trim() : value;
+        } catch (error: any) {
+          throw new Error(error);
+        }
+      } else if (isObject(value)) {
+        formatRequestDate(params[key]);
+      }
+    }
+  }
+}

web-vue/packages/core/utils/http/axios/index.ts

@@ -0,0 +1,307 @@
+// axios配置  可自行根据项目进行更改，只需更改该文件即可，其他文件可以不动
+// The axios configuration can be changed according to the project, just change the file, other files can be left unchanged
+
+import type { AxiosResponse } from 'axios';
+import type { RequestOptions, Result } from '@jeesite/types/axios';
+import type { AxiosTransform, CreateAxiosOptions } from './axiosTransform';
+import { VAxios } from './Axios';
+import { checkStatus } from './checkStatus';
+import { useGlobSetting } from '@jeesite/core/hooks/setting';
+import { useMessage } from '@jeesite/core/hooks/web/useMessage';
+import { RequestEnum, ContentTypeEnum } from '@jeesite/core/enums/httpEnum';
+import { isString } from '@jeesite/core/utils/is';
+import { getToken } from '@jeesite/core/utils/auth';
+import { setObjToUrlParams, deepMerge } from '@jeesite/core/utils';
+import { useErrorLogStoreWithOut } from '@jeesite/core/store/modules/errorLog';
+import { useI18n } from '@jeesite/core/hooks/web/useI18n';
+import { joinTimestamp, formatRequestDate } from './helper';
+import { useUserStoreWithOut } from '@jeesite/core/store/modules/user';
+import { router } from '@jeesite/core/router';
+import { PageEnum } from '@jeesite/core/enums/pageEnum';
+
+const globSetting = useGlobSetting();
+const urlPrefix = globSetting.urlPrefix;
+const { showMessageModal, showMessage } = useMessage();
+let isShowMessage = false;
+let isShowMessageModal = false;
+
+/**
+ * @description: 数据处理，方便区分多种处理方式
+ */
+const transform: AxiosTransform = {
+  /**
+   * @description: 处理请求数据。如果数据不是预期格式，可直接抛出错误
+   */
+  transformRequestHook: (res: AxiosResponse<Result>, options: RequestOptions) => {
+    const { t } = useI18n();
+    const { isTransformResponse, isReturnNativeResponse } = options;
+    // 是否返回原生响应头 比如：需要获取响应头时使用该属性
+    if (isReturnNativeResponse) {
+      return res;
+    }
+    // 不进行任何处理，直接返回
+    // 用于页面代码可能需要直接获取code，data，message这些信息时开启
+    if (!isTransformResponse) {
+      return res.data;
+    }
+    // 错误的时候返回
+
+    const { data, config } = res;
+    // if (!data) { // boolean false return error
+    //   // return '[HTTP] Request has no return value';
+    //   throw new Error(t('sys.api.apiRequestFailed'));
+    // }
+
+    // 处理响应头中的令牌
+    const token = res?.headers[(config as any)?.authenticationHeader];
+    if (token) {
+      const userStore = useUserStoreWithOut();
+      userStore.setToken(token);
+    }
+
+    // 非对象类型的直接返回数据
+    if (typeof data !== 'object') return data;
+
+    //  这里 code，result，message为 后台统一的字段，需要在 types.ts内修改为项目自己的接口返回格式
+    // const { code, result, message } = data;
+    const { sessionid, result, message } = data;
+
+    // 设置会话编码
+    if (data && Reflect.has(data, 'sessionid')) {
+      const userStore = useUserStoreWithOut();
+      userStore.setToken(sessionid);
+    }
+
+    if (data && Reflect.has(data, 'result')) {
+      if (result === 'login' && options.errorMessageMode !== 'none') {
+        if (!isShowMessage) {
+          isShowMessage = true;
+          // userStore.resetState();
+          const currentRoute = router.currentRoute.value;
+          if (currentRoute.path !== '/') {
+            showMessage(data.message, undefined, 180);
+          }
+          if (config.url?.indexOf('__notUpdateSession=true') == -1) {
+            let path = PageEnum.BASE_LOGIN as string;
+            if (currentRoute.path !== '/' && currentRoute.path !== PageEnum.BASE_LOGIN) {
+              path = path + '?redirect=' + currentRoute.fullPath;
+            }
+            router.replace(path);
+          }
+          setTimeout(() => (isShowMessage = false), 1000);
+        }
+        throw new Error(t('sys.api.timeoutMessage'));
+      } else if (result === 'false') {
+        const errorMessage = message || t('sys.api.apiRequestFailed');
+        if (options.errorMessageMode === 'modal') {
+          if (!isShowMessageModal) {
+            isShowMessageModal = true;
+            showMessageModal({
+              content: errorMessage,
+              onOk() {
+                isShowMessageModal = false;
+                return Promise.resolve();
+              },
+            });
+          }
+          throw new Error(errorMessage);
+        } else if (options.errorMessageMode === 'message') {
+          if (!isShowMessage) {
+            isShowMessage = true;
+            showMessage(errorMessage);
+            setTimeout(() => (isShowMessage = false), 1000);
+          }
+          throw new Error(errorMessage);
+        }
+      }
+    }
+    return data;
+  },
+
+  // 请求之前处理config
+  beforeRequestHook: (config, options) => {
+    const { apiUrl, joinPrefix, joinParamsToUrl, formatDate, joinTime = true, urlPrefix } = options;
+
+    if (joinPrefix) {
+      config.url = `${urlPrefix}${config.url}`;
+    }
+
+    if (apiUrl && isString(apiUrl)) {
+      config.url = `${apiUrl}${config.url}`;
+    }
+    const params = config.params || {};
+    const data = config.data || false;
+    formatDate && data && !isString(data) && formatRequestDate(data);
+    if (config.method?.toUpperCase() === RequestEnum.GET) {
+      if (!isString(params)) {
+        // 给 get 请求加上时间戳参数，避免从缓存中拿数据。
+        config.params = Object.assign(params || {}, joinTimestamp(joinTime, false));
+      } else {
+        // 兼容restful风格
+        config.url = config.url + params + `${joinTimestamp(joinTime, true)}`;
+        config.params = undefined;
+      }
+    } else {
+      if (!isString(params)) {
+        formatDate && formatRequestDate(params);
+        if (Reflect.has(config, 'data') && config.data && Object.keys(config.data).length > 0) {
+          config.data = data;
+          config.params = params;
+        } else {
+          // 非GET请求如果没有提供data，则将params视为data
+          config.data = params;
+          config.params = undefined;
+        }
+        if (joinParamsToUrl) {
+          config.url = setObjToUrlParams(config.url as string, Object.assign({}, config.params, config.data));
+        }
+      } else {
+        // 兼容restful风格
+        config.url = config.url + params;
+        config.params = undefined;
+      }
+    }
+    return config;
+  },
+
+  /**
+   * @description: 请求拦截器处理
+   */
+  requestInterceptors: (config: Recordable, options) => {
+    // 请求之前处理config
+    if (config?.requestOptions?.withToken !== false && options.authenticationHeader) {
+      const token = getToken();
+      if (token) {
+        config.headers[options.authenticationHeader] = options.authenticationScheme
+          ? `${options.authenticationScheme} ${token}`
+          : token;
+      }
+    }
+    return config;
+  },
+
+  /**
+   * @description: 响应拦截器处理
+   */
+  responseInterceptors: (res: AxiosResponse<any>) => {
+    return res;
+  },
+
+  /**
+   * @description: 响应错误处理
+   */
+  responseInterceptorsCatch: (error: any) => {
+    const { t } = useI18n();
+    const errorLogStore = useErrorLogStoreWithOut();
+    errorLogStore.addAjaxErrorInfo(error);
+    const { response, code, message, config } = error || {};
+    const errorMessageMode = config?.requestOptions?.errorMessageMode || 'none';
+    const msg: string = response?.data?.message ?? '';
+    const err: string = error?.toString?.() ?? '';
+
+    if (errorMessageMode === 'none') {
+      return Promise.resolve(response);
+    }
+
+    let errMessage = '';
+    try {
+      if (code === 'ECONNABORTED' && message.indexOf('timeout') !== -1) {
+        errMessage = t('sys.api.apiTimeoutMessage');
+      } else if (err?.includes('Network Error')) {
+        errMessage = t('sys.api.networkExceptionMsg');
+      } else if (code === 'ERR_BAD_RESPONSE') {
+        errMessage = t('sys.api.apiRequestFailed');
+      }
+
+      if (errMessage) {
+        if (errorMessageMode === 'modal') {
+          if (!isShowMessageModal) {
+            isShowMessageModal = true;
+            showMessageModal({
+              title: t('sys.api.errorTip'),
+              content: msg || errMessage,
+              onOk() {
+                isShowMessageModal = false;
+                return Promise.resolve(response);
+              },
+            });
+          }
+        } else if (errorMessageMode === 'message') {
+          if (!isShowMessage) {
+            isShowMessage = true;
+            showMessage({ content: msg || errMessage }, 'error');
+            setTimeout(() => (isShowMessage = false), 1000);
+          }
+        }
+        return Promise.reject(error);
+      }
+    } catch (error: any) {
+      throw new Error(error);
+    }
+
+    checkStatus(response?.status, msg, errorMessageMode);
+    return Promise.reject(error);
+  },
+};
+
+function createAxios(opt?: Partial<CreateAxiosOptions>) {
+  return new VAxios(
+    deepMerge(
+      {
+        // authenticationHeader: 'Authorization',
+        // authenticationScheme: 'Bearer',
+        authenticationHeader: 'x-token',
+        authenticationScheme: '',
+        // 请求超时时间，默认3分钟
+        timeout: 3 * 60 * 1000,
+        // 基础接口地址
+        // baseURL: globSetting.apiUrl,
+        // 默认请求头设置
+        // headers: { 'Content-Type': ContentTypeEnum.JSON },
+        // 如果是form-data格式
+        headers: {
+          'content-type': ContentTypeEnum.FORM_URLENCODED,
+          'x-requested-with': 'XMLHttpRequest',
+          'x-ajax': 'json',
+        },
+        // 数据处理方式
+        transform,
+        // 配置项，下面的选项都可以在独立的接口请求中覆盖
+        requestOptions: {
+          // 默认将prefix 添加到url
+          joinPrefix: true,
+          // 是否返回原生响应头 比如：需要获取响应头时使用该属性
+          isReturnNativeResponse: false,
+          // 需要对返回数据进行处理
+          isTransformResponse: true,
+          // post请求的时候添加参数到url
+          joinParamsToUrl: false,
+          // 格式化提交参数时间
+          formatDate: false,
+          // 消息提示类型
+          errorMessageMode: 'modal',
+          // 接口地址
+          apiUrl: globSetting.apiUrl,
+          // 接口拼接地址
+          urlPrefix: urlPrefix,
+          //  是否加入时间戳
+          joinTime: true,
+          // 忽略重复请求
+          ignoreCancelToken: true,
+          // 是否携带token
+          withToken: true,
+        },
+      },
+      opt || {},
+    ),
+  );
+}
+export const defHttp = createAxios();
+
+// other api url
+// export const otherHttp = createAxios({
+//   requestOptions: {
+//     apiUrl: 'xxx',
+//     urlPrefix: 'xxx',
+//   },
+// });