HarmonyOS 网络请求自定义拦截器如何实现？

Question

如题：HarmonyOS 网络请求自定义拦截器如何实现？

Answer 1

demo如下：

import { rcp } from '@kit.RemoteCommunicationKit';
import url from '@ohos.url';

export interface Logger {
  log: (text: string) => void;
}

export class HeaderInterceptor implements rcp.Interceptor {
  private readonly logger: Logger;

  constructor(logger: Logger) {
    this.logger = logger;
  }

  async intercept(context: rcp.RequestContext, next: rcp.RequestHandler): Promise<rcp.Response> {
    // 修改请请求头内容
    let header = context.request.headers;
    this.logger.log(`[HeaderInterceptor]: curr header is : ${header}`);
    let newHeader: rcp.RequestHeaders | undefined = doSomethingForHeader(header);
    this.logger.log(`[HeaderInterceptor]: new header is : ${header}`);
    context.request.headers = newHeader;

    // 给下个拦截器处理
    return next.handle(context);
  }
}

export class DecryptInterceptor implements rcp.Interceptor {
  private readonly logger: Logger;

  constructor(logger: Logger) {
    this.logger = logger;
  }

  async intercept(context: rcp.RequestContext, next: rcp.RequestHandler): Promise<rcp.Response> {
    let url = context.request.url;
    // 地址不需要解密
    if (!needDecode(url)) {
      // 交给下个拦截器处理
      return next.handle(context);
    }

    // 拿到响应结果
    let response = await next.handle(context);
    if (!response || response.statusCode != 200 || !response.body) {
      Promise.resolve(response);
    }

    // 处理解密逻辑
    return Promise.resolve(decodeResp(response) as rcp.Response);
  }
}

function doSomethingForHeader(header: rcp.RequestHeaders | undefined): rcp.RequestHeaders | undefined {
  return header;
}

// 根据url判断是否解密
function needDecode(url: url.URL) {
  return true;
}


function decodeResp(response: rcp.Response): Response {
  return new Response(decodeBody(response.body), response);
}

class Response {
  request: rcp.Request;
  statusCode: number;
  headers: rcp.ResponseHeaders;
  effectiveUrl?: rcp.URL;
  body?: ArrayBuffer;
  downloadedTo?: rcp.DownloadedTo;
  debugInfo?: rcp.DebugInfo[];
  timeInfo?: rcp.TimeInfo;
  cookies?: rcp.ResponseCookie[];
  httpVersion?: rcp.HttpVersion;
  reasonPhrase?: string;

  constructor(body: ArrayBuffer, response: rcp.Response) {
    this.request = response.request;
    this.statusCode = response.statusCode;
    this.headers = response.headers;
    this.effectiveUrl = response.effectiveUrl;
    this.downloadedTo = response.downloadedTo;
    this.debugInfo = response.debugInfo;
    this.timeInfo = response.timeInfo;
    this.cookies = response.cookies;
    this.httpVersion = response.httpVersion;
    this.reasonPhrase = response.reasonPhrase;
    this.body = body;
  }
}

// 解密 body
function decodeBody(body: ArrayBuffer): string | ArrayBuffer {
  throw new Error('Function not implemented.');
}