HarmonyOS鸿蒙Next中RCP网络请求的拦截器怎么写呢

可以通过实现 Interceptor 接口并添加到会话配置来实现。

核心代码

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

// 请求拦截器示例（修改请求）
export class RequestInterceptor implements rcp.Interceptor {
  async intercept(context: rcp.RequestContext, next: rcp.RequestHandler): Promise<rcp.Response> {
    // 请求前逻辑（如修改URL/Headers）
    console.log(`Requesting ${context.request.url.href}`);
    return next.handle(context); // 继续执行请求
  }
}

// 响应拦截器示例（修改响应）
export class ResponseInterceptor implements rcp.Interceptor {
  async intercept(context: rcp.RequestContext, next: rcp.RequestHandler): Promise<rcp.Response> {
    const response = await next.handle(context); // 先执行请求
    // 响应后逻辑（如修改Headers）
    console.log(`Response received: ${response.statusCode}`);
    return response;
  }
}

完整代码

import {
  RequestConfig, 
  RcpResponse, 
  RcpError,
  RequestInterceptor,
  ResponseInterceptor,
  ErrorInterceptor
} from '../types/RcpTypes';

/**
 * 常用拦截器实现
 */

/**
 * 认证拦截器
 * 自动添加Authorization头
 */
export class AuthInterceptor {
  private token: string;
  private type: string;

  constructor(token: string, type?: string) {
    this.token = token;
    this.type = type || 'Bearer';
  }

  /**
   * 更新令牌
   */
  updateToken(token: string): void {
    this.token = token;
  }

  /**
   * 清除令牌
   */
  clearToken(): void {
    this.token = '';
  }

  /**
   * 拦截器函数
   */
  interceptor: RequestInterceptor = (config: RequestConfig): RequestConfig => {
    if (this.token) {
      if (!config.headers) {
        config.headers = {};
      }
      config.headers['Authorization'] = `${this.type} ${this.token}`;
    }
    return config;
  };
}

/**
 * 日志拦截器
 * 记录请求和响应信息
 */
export class LogInterceptor {
  private enableRequest: boolean;
  private enableResponse: boolean;
  private enableError: boolean;

  constructor(
    enableRequest?: boolean,
    enableResponse?: boolean,
    enableError?: boolean
  ) {
    this.enableRequest = enableRequest !== false;
    this.enableResponse = enableResponse !== false;
    this.enableError = enableError !== false;
  }

  /**
   * 请求拦截器
   */
  requestInterceptor: RequestInterceptor = (config: RequestConfig): RequestConfig => {
    if (this.enableRequest) {
      console.info('RCP Request:', {
        method: config.method,
        url: config.url,
        headers: config.headers,
        timestamp: new Date().toISOString()
      });
    }
    return config;
  };

  /**
   * 响应拦截器
   */
  responseInterceptor: ResponseInterceptor = (response: RcpResponse<Object>): RcpResponse<Object> => {
    if (this.enableResponse) {
      console.info(' RCP Response:', {
        status: response.status,
        statusText: response.statusText,
        ok: response.ok,
        dataSize: this.getDataSize(response.data),
        timestamp: new Date().toISOString()
      });
    }
    return response;
  };

  /**
   * 错误拦截器
   */
  errorInterceptor: ErrorInterceptor = (error: RcpError): RcpError => {
    if (this.enableError) {
      console.error(' RCP Error:', {
        code: error.code,
        message: error.message,
        data: error.data,
        timestamp: new Date().toISOString()
      });
    }
    return error;
  };

  /**
   * 获取数据大小描述
   */
  private getDataSize(data: Object): string {
    try {
      if (typeof data === 'string') {
        return `${data.length} chars`;
      }
      if (data instanceof ArrayBuffer) {
        return `${data.byteLength} bytes`;
      }
      return `${JSON.stringify(data).length} chars`;
    } catch {
      return 'unknown size';
    }
  }
}

/**
 * 重试拦截器
 * 自动重试失败的请求
 */
interface GeneratedTypeLiteralInterface_1 {
  retryCount?: number;
}

export class RetryInterceptor {
  private maxRetries: number;
  private retryDelay: number;
  private shouldRetry: (error: RcpError) => boolean;

  constructor(
    maxRetries?: number,
    retryDelay?: number,
    shouldRetry?: (error: RcpError) => boolean
  ) {
    this.maxRetries = maxRetries || 3;
    this.retryDelay = retryDelay || 1000;
    this.shouldRetry = shouldRetry || this.defaultShouldRetry;
  }

  /**
   * 默认重试条件
   */
  private defaultShouldRetry = (error: RcpError): boolean => {
    // 网络错误或5xx服务器错误时重试
    return error.code >= 500 || error.code === 0;
  };

  /**
   * 错误拦截器（用于重试逻辑）
   */
  errorInterceptor: ErrorInterceptor = async (error: RcpError): Promise<RcpError> => {
    const defaultData: Record<string, Object> = {};
    const errorData = (error.data as GeneratedTypeLiteralInterface_1) || defaultData;
    const retryCount = (errorData.retryCount as number) || 0;

    if (this.shouldRetry(error) && retryCount < this.maxRetries) {
      console.info(` Retrying request (${retryCount + 1}/${this.maxRetries})`);
      
      // 延迟重试
      await this.delay(this.retryDelay * Math.pow(2, retryCount));
      
      // 标记重试次数
      const updatedData: Record<string, Object> = {};
      if (error.data) {
        Object.keys(error.data).forEach(key => {
          updatedData[key] = error.data![key];
        });
      }
      updatedData.retryCount = retryCount + 1;
      updatedData.shouldRetry = true;
      error.data = updatedData;
    }

    return error;
  };

  /**
   * 延迟函数
   */
  private delay(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

/**
 * 超时拦截器
 * 为请求设置统一超时时间
 */
export class TimeoutInterceptor {
  private defaultTimeout: number;

  constructor(timeout?: number) {
    this.defaultTimeout = timeout || 30000;
  }

  /**
   * 请求拦截器
   */
  interceptor: RequestInterceptor = (config: RequestConfig): RequestConfig => {
    if (!config.timeout) {
      config.timeout = this.defaultTimeout;
    }
    return config;
  };
}