HarmonyOS 鸿蒙Next中rcp同一个请求直接返回上一次请求结果

HarmonyOS 鸿蒙Next中rcp同一个请求直接返回上一次请求结果

import { CacheUtil, JSONUtil, KvUtil } from '@pura/harmony-utils'
import { rcp } from '@kit.RemoteCommunicationKit'
import { BASE_URL } from './NetUrl'
import { BusinessError } from '@kit.BasicServicesKit';
import { LogUtil } from '../utils/log/LogUtil';
import { LogTag } from '../utils/log/LogTag';
import { KvConstants } from '../data/Constans';

const CONNECT_TIME = 5000
const TRANSFER_TIME = 10000
const INACTIVITY_TIME = 10000

//拦截器
class ResponseCache {
  private readonly cache: Record<string, rcp.Response> = {};

  getResponse(url: string): rcp.Response {
    return this.cache[url];
  }

  setResponse(url: string, response: rcp.Response): void {
    this.cache[url] = response;
  }
}

class RcpInterceptor implements rcp.Interceptor {
  private readonly cache: ResponseCache;

  constructor(cache: ResponseCache) {
    this.cache = cache;
  }

  async intercept(context: rcp.RequestContext, next: rcp.RequestHandler): Promise<rcp.Response> {
    const url = context.request.url.href;
    const responseFromCache = this.cache.getResponse(url);
    if (responseFromCache) {
      return Promise.resolve(responseFromCache);
    }
    try {
      //获取当前请求url
      LogUtil.d(LogTag.NET,`========================网络请求开始========================`)
      LogUtil.d(LogTag.NET,`URL:${context.request.url.href}` )
      LogUtil.d(LogTag.NET,`type:${context.request.method}`)
      if (context.request.headers) {
        context.request.headers["Authorization"] = await KvUtil.getString(KvConstants.TOKEN,"")
        LogUtil.d(LogTag.NET,`header:${JSONUtil.beanToJsonStr(context.request.headers as object)}`
      }
      if (context.request.cookies) {
        LogUtil.d(LogTag.NET,`cookie:${JSONUtil.beanToJsonStr(context.request.cookies as object)}`
      }
      if (context.request.content) {
        LogUtil.d(LogTag.NET,`data:${JSONUtil.beanToJsonStr(context.request.content)}`
      }
      LogUtil.d(LogTag.NET,`========================网络请求开始========================`)
    } catch (error) {
      //抛出
      return Promise.reject(error);
    }
    const promise = next.handle(context);
    promise.then((resp) => {
      LogUtil.d(LogTag.NET,`========================网络请求结束========================`)
      LogUtil.d(LogTag.NET,`响应状态:${resp.statusCode}`
      LogUtil.d(LogTag.NET,`响应内容:${resp.toString() as string}`
      LogUtil.d(LogTag.NET,`========================网络请求结束========================`)
      this.cache.setResponse(url, resp);
    });
    return promise;
  }
}

//rcp请求配置
const cache = new ResponseCache()
export let sessionConfig:rcp.SessionConfiguration = {
  requestConfiguration: {
    transfer: {
      autoRedirect: true,
      timeout: {
        //允许建立连接的最长时间
        connectMs: CONNECT_TIME,
        //允许传输数据的最长时间
        transferMs: TRANSFER_TIME,
        //网络传输持续进行，但是服务端收到数据或者客户端收到数据的时间间隔比较长，超出了预期，
        //那么请求会异常。也就是说应用觉得网速太慢用户体验不好的时候，请求取消，执行异常分支
        inactivityMs:INACTIVITY_TIME
      }
    }
  },
  baseAddress:BASE_URL,
  headers:{
    'Content-Type': 'application/json'
  },
  interceptors:[new RcpInterceptor(cache)]
}

//创建rcp
export class BaseRcp{
  /**
   * 封装后的全局rcp对象
   */
  private session: rcp.Session | undefined;

  /**
   * 私有化构造
   */
  private constructor() {
  }

  /**
   * 私有单例对象
   */
  private static rcpInstance: BaseRcp;

  /**
   * 创建单例
   * @returns
   */
  public static getInstance(): BaseRcp {
    if (!BaseRcp.rcpInstance) {
      BaseRcp.rcpInstance = new BaseRcp();
    }
    return BaseRcp.rcpInstance;
  }

  /**
   * 创建session对象
   * @returns
   */
  create(): BaseRcp {
    if (this.session) {
      this.session.close();
      this.session = undefined;
    }
    this.session = rcp.createSession(sessionConfig);
    return this;
  }

  /**
   * 构建efRcpSession对象
   * @returns
   */
  builder(): rcp.Session {
    if (this.session === undefined) {
      throw new Error("构建RcpSession异常,请在构建之前调用create方法创建")
    }
    return this.session as rcp.Session;
  }
}

//返回的数据基本数据类型
export interface BaseResponse<T> {
  code: number;
  msg: string;
  data: T;
}

//返回的数据异形数据类型
export interface BaseExtResponse<T> {
  code: number;
  msg: string;
  rows: T;
}

//业务成功的code
export const CODE_SUCCESS = 200