HarmonyOS 鸿蒙Next中并发异步网络请求如何拦截并重发

HarmonyOS 鸿蒙Next中并发异步网络请求如何拦截并重发

各位大佬 需求是这样的

如果使用Promise异步发送网络请求 在未知并发数量的情况下  假设同时进来了5个网络请求 并且这5个请求都返回了一个特殊的状态码 判断如果是这个特殊的状态码后 要去发送另外两个Promise同步请求去解除这个状态  我改如何锁死另外的那两个网络请求让它只被调用一次呢


更多关于HarmonyOS 鸿蒙Next中并发异步网络请求如何拦截并重发的实战教程也可以访问 https://www.itying.com/category-93-b0.html

3 回复

你好，可以使用异步锁来控制并发。

更多关于HarmonyOS 鸿蒙Next中并发异步网络请求如何拦截并重发的实战系列教程也可以访问 https://www.itying.com/category-93-b0.html


在鸿蒙Next中，使用@ohos.net.http模块处理异步网络请求拦截重发：

  1. 创建HttpRequest对象时设置拦截器：
import http from '@ohos.net.http';
let httpRequest = http.createHttp();
httpRequest.on('interceptor', (chain) => {
  const request = chain.request();
  return chain.proceed(request).catch(() => {
    // 重发逻辑
    return chain.proceed(request.clone());
  });
});
  1. 使用TaskPool实现并发请求管理：
import taskpool from '@ohos.taskpool';
@Concurrent
async function fetchData(url: string) {
  // 请求实现
}

taskpool.execute(fetchData, url).then(...);

在HarmonyOS Next中处理并发异步网络请求的拦截和重发，可以通过以下方案实现：

  1. 使用互斥锁机制： 创建全局标志位和锁对象来确保状态解除请求只执行一次：
let isRefreshing = false;
let refreshPromise: Promise<void> | null = null;

async function handleRequest(request: Promise<any>) {
  try {
    const response = await request;
    if (response.code === SPECIAL_CODE) {
      if (!isRefreshing) {
        isRefreshing = true;
        refreshPromise = refreshToken(); // 你的刷新token方法
        await refreshPromise;
        isRefreshing = false;
        refreshPromise = null;
      } else {
        await refreshPromise;
      }
      return await request; // 重试原请求
    }
    return response;
  } catch (error) {
    // 错误处理
  }
}
  1. 请求队列方案： 对于并发请求，可以使用队列管理：
const requestQueue: (() => Promise<any>)[] = [];
let isProcessing = false;

async function processQueue() {
  if (isProcessing) return;
  isProcessing = true;
  
  while (requestQueue.length > 0) {
    const request = requestQueue.shift();
    try {
      await request?.();
    } catch (error) {
      // 错误处理
    }
  }
  
  isProcessing = false;
}

function addToQueue(request: () => Promise<any>) {
  requestQueue.push(request);
  processQueue();
}
  1. 使用Atomics实现更精细的锁控制（如果需要更高性能）：
const lock = new Int32Array(new SharedArrayBuffer(4));

async function withLock(fn: () => Promise<void>) {
  while (Atomics.compareExchange(lock, 0, 0, 1) !== 0) {
    await new Promise(resolve => setTimeout(resolve, 10));
  }
  try {
    await fn();
  } finally {
    Atomics.store(lock, 0, 0);
  }
}

注意处理边界情况：

  • 请求失败后的重试次数限制
  • 超时处理
  • 内存泄漏预防
  • 并发控制取消机制
回到顶部