鸿蒙运动项目开发：封装超级好用的 RCP 网络库（中）—— 错误处理，会话管理与网络状态检测篇

##鸿蒙核心技术##运动开发## Remote Communication Kit（远场通信服务）

在上篇中，我们介绍了 RCP 网络库的核心功能，包括请求参数的封装、响应内容的转换以及拦截器与日志记录机制。这些功能为我们的网络库提供了坚实的基础。在本篇中，我们将继续深入探讨网络库的高级特性，包括错误处理、会话管理以及网络状态检测等，进一步提升网络库的健壮性和易用性。

四、网络库的高级特性：错误处理与异常管理

（一）自定义异常类

在网络请求中，错误处理是至关重要的。为了更好地管理错误，我们定义了一个 NetworkException 类，用于封装各种网络相关的异常。

import { ErrorCodes } from "../NetConstants";
import { BusinessError } from "@kit.BasicServicesKit";
import { appLogger } from "../../../app/Application";


export class NetworkException extends Error {

  private static errorMessages: Record<string, string> = {
    [ErrorCodes.NETWORK_UNAVAILABLE]: "网络不可用，请检查网络连接",
    [ErrorCodes.REQUEST_TIMEOUT]: "请求超时，请稍后重试",
    [ErrorCodes.SERVER_ERROR]: "服务器开小差了，请稍后再试",
    [ErrorCodes.INVALID_RESPONSE]: "服务器返回数据格式错误",
    [ErrorCodes.UNAUTHORIZED]: "登录已过期，请重新登录",
    [ErrorCodes.FORBIDDEN]: "无权访问该资源",
    [ErrorCodes.NOT_FOUND]: "请求的资源不存在",
    [ErrorCodes.UNKNOWN_ERROR]: "未知错误，请联系客服",
    [ErrorCodes.URL_NOT_EXIST_ERROR]: "URL不存在",
    [ErrorCodes.URL_ERROR]: "URL格式不合法",
    [ErrorCodes.BAD_REQUEST]: "客户端请求的语法错误，服务器无法理解。",
    [ErrorCodes.REQUEST_CANCEL]: "请求被取消"
  };

  private responseCode?:number
  private originalError?:Error | BusinessError
  private _code: string;

  public get code(): string {
    return this._code;
  }



  constructor(code : string, originalError?: Error | BusinessError,customMessage?: string,responseCode?:number) {
    super(customMessage || NetworkException.getMessage(code))
    this._code = code
    this.name = "NetworkException";
    this.responseCode = responseCode
    this.originalError = originalError
  }


  public isResponseError(): boolean{
    if (this.responseCode) {
      return true
    }else {
      return false
    }
  }

  private static getMessage(code: string): string {
    return NetworkException.errorMessages[code] || NetworkException.errorMessages[ErrorCodes.UNKNOWN_ERROR];
  }


  static updateErrorMessages(newMessages: Record<string, string>): void {
    const keys = Object.keys(newMessages);
    for (let i = 0; i < keys.length; i++) {
      const key = keys[i];
      const value = newMessages[key];
      NetworkException.errorMessages[key] = value
    }
  }

}

核心点解析：

  1. 错误信息映射：通过 errorMessages 对象，将错误代码映射到具体的错误信息。
  2. 自定义错误信息：允许传入自定义的错误信息，以覆盖默认的错误描述。
  3. 错误分类：通过 isResponseError() 方法，区分是响应错误还是其他类型的错误。
  4. 错误信息动态更新：通过 updateErrorMessages() 方法，允许动态更新错误信息映射表。

（二）错误处理逻辑

在网络请求中，错误处理逻辑需要覆盖多种场景，包括网络不可用、请求超时、服务器错误等。我们通过在 RcpNetworkService 类中捕获和抛出 NetworkException，实现了统一的错误处理。


async request<T>(requestOption: RequestOptions,requestKeyFun?:(str:string)=>void): Promise<T> {
  const session = this.rcpSessionManager.getSession(requestOption.connectTimeout??this.httpConfig.connectTimeout,requestOption.transferTimeout??this.httpConfig.transferTimeout)

  try {

    let baseUrl = requestOption.baseUrl?requestOption.baseUrl:this.baseUrl
    if(baseUrl === null || baseUrl.trim().length === 0){
      throw new NetworkException(ErrorCodes.URL_NOT_EXIST_ERROR);
    }

    if (!LibNetworkStatus.getInstance().isNetworkAvailable()) {
      appLogger.error("HttpCore 网络不可用")
      throw new NetworkException(ErrorCodes.NETWORK_UNAVAILABLE);
    }


    let url = baseUrl + requestOption.act;

    if (!isValidUrl(url)) {
      appLogger.error("HttpCore url格式不合法")
      throw new NetworkException(ErrorCodes.URL_ERROR);
    }
    const contentType = requestOption.contentType??RcpContentType.JSON

    const headers: rcp.RequestHeaders = {
      'Content-Type': contentType
    };
    const cacheKey = await USystem.getUniqueId()

    if (this.queryParamAppender) {
      let param = this.queryParamAppender.append(requestOption.queryParams);
      if(param){
        url = url + "?" + param
      }
    }


    const requestObj = new rcp.Request(url, requestOption.method??RequestMethod.GET, headers, this.converterManger.selectRequestConverter(requestOption.content,contentType));
    // 将请求和会话的映射关系存储起来
    this.requestMap.set(cacheKey, { session, request: requestObj });
    if(requestKeyFun){
      requestKeyFun(cacheKey)
    }
    let response = await session.fetch(requestObj);

    if (!response.statusCode) {
      throw new NetworkException(ErrorCodes.INVALID_RESPONSE);
    }

    if (response.statusCode >= HttpStatus.SUCCESS && response.statusCode < 300) {
      // 获取 Content-Type
      const responseContentType = response.headers['Content-Type'];
      const responseData = this.converterManger.selectResponseConverter(response, responseContentType)
      const parsedResult = responseData as T

      return parsedResult;

    }

    switch (response.statusCode) {
      case HttpStatus.UNAUTHORIZED:
        throw new NetworkException(ErrorCodes.UNAUTHORIZED,undefined,undefined,response.statusCode);
      case HttpStatus.FORBIDDEN:
        throw new NetworkException(ErrorCodes.FORBIDDEN,undefined,undefined,response.statusCode);
      case HttpStatus.NOT_FOUND:
        throw new NetworkException(ErrorCodes.NOT_FOUND,undefined,undefined,response.statusCode);
      case HttpStatus.REQUEST_TIMEOUT:
        throw new NetworkException(ErrorCodes.REQUEST_TIMEOUT,undefined,undefined,response.statusCode);
      case HttpStatus.BAD_REQUEST:
        throw new NetworkException(ErrorCodes.BAD_REQUEST,undefined,undefined,response.statusCode);
      case HttpStatus.SERVER_ERROR:
      case HttpStatus.BAD_GATEWAY:
      case HttpStatus.SERVICE_UNAVAILABLE:
      case HttpStatus.GATEWAY_TIMEOUT:
        throw new NetworkException(ErrorCodes.SERVER_ERROR,undefined,undefined,response.statusCode);
      default:
        throw new NetworkException(ErrorCodes.UNKNOWN_ERROR,undefined,undefined,response.statusCode);
    }



  }catch (e) {
    if(e instanceof NetworkException){
      throw e
    } else {
      try{
        let err = e as BusinessError;
        appLogger.error(` ${err.code.toString()} ${err.stack} ${err.message} ${err.name}`)
        throw new NetworkException(err.code.toString(),err,err.message)
      }catch  {
        let err = e as Error;
        appLogger.error(`异常： ${err.stack} ${err.message} ${err.name}`)
        throw err
      }
    }
  }finally {
    this.rcpSessionManager?.releaseSession(session)
    // 当会话被关闭时，移除与该会话关联的所有请求
    this.requestMap.forEach((entry, key) => {
      if (entry.session === session) {
        this.requestMap.delete(key);
      }
    });
  }
}

核心点解析：

  1. 网络状态检测：在发起请求之前，通过 LibNetworkStatus.getInstance().isNetworkAvailable() 检测网络是否可用。
  2. URL 验证：通过 isValidUrl() 方法验证 URL 格式是否正确。
  3. 错误分类与抛出：根据不同的错误场景，抛出对应的 NetworkException。
  4. 统一的错误处理：在 catch 块中，对所有异常进行统一处理，确保错误信息的一致性。

五、网络库的高级特性：会话管理

（一）会话池的实现

为了优化网络请求的性能，我们实现了会话池机制。通过复用会话，可以减少频繁创建和销毁会话的开销。

import { rcp } from "@kit.RemoteCommunicationKit";
import { HttpConfig } from "./HttpConfig";


// 创建安全配置，跳过证书验证
const securityConfig: rcp.SecurityConfiguration = {
  remoteValidation: 'skip'
};


export class RcpSessionManager{

  private currentConcurrentRequests = 0;

  // 定义连接池
  private connectionPool: rcp.Session[] = [];
  private _interceptor: rcp.Interceptor[] = [];

  public set interceptor(value: rcp.Interceptor[]) {
    this._interceptor = value;
  }

  private _httpConfig: HttpConfig = new HttpConfig();

  public set httpConfig(value: HttpConfig) {
    this._httpConfig = value;
  }

  public getSession(connectTimeout:number,transferTimeout:number): rcp.Session {
    // 如果连接池中有可用的会话，直接返回
    if (this.connectionPool.length > 0) {
      return this.connectionPool.pop()!;
    }

    // 如果没有可用的会话，创建一个新的会话
    const session = rcp.createSession({
      interceptors: [...this._interceptor],
      requestConfiguration: {
        transfer: {
          timeout: {
            connectMs: connectTimeout,
            transferMs: transferTimeout
          }
        },
        security: this._httpConfig.security?undefined:securityConfig
      }
    });

    return session;
  }

  public releaseSession(session: rcp.Session): void {
    // 如果当前并发请求小于最大并发限制，将会话放回连接池
    if (this.currentConcurrentRequests < this._httpConfig.maxConcurrentRequests) {
      this.connectionPool.push(session);
    } else {
      session.close();
    }
  }

  public destroy(): void {
    // 关闭所有会话
    this.connectionPool.forEach(session => session.close());
    this.connectionPool.length = 0;
  }
}

核心点解析：

  1. 会话复用：通过 connectionPool 存储空闲的会话，避免频繁创建和销毁会话。
  2. 并发限制：根据 HttpConfig 中的 maxConcurrentRequests 配置，限制并发请求数量。
  3. 会话释放：在请求完成后，将会话放回会话池或关闭会话，以优化资源使用。

（二）会话管理的重要性

会话管理在网络请求中起着至关重要的作用。通过合理管理会话，可以显著提升网络请求的性能和稳定性。例如：

  • 减少连接开销：通过复用会话，减少频繁建立和关闭连接的开销。
  • 控制并发数量：通过限制并发请求数量，避免过多的并发请求对服务器造成压力。
  • 资源回收：在请求完成后及时释放会话资源，避免资源泄漏。

六、网络库的高级特性：网络状态检测

在网络请求中，网络状态的检测是必不可少的。通过检测网络是否可用，可以提前避免因网络问题导致的请求失败。


import connection from **********'
import { appLogger } from '../../app/Application'
import { LibNetworkStatusCallback } from './LibNetworkStatusCallback'

const TAG : string = "LibNetworkStatus"

/**
 * 枚举：网络类型
 */
export enum NetworkType {
  STATE_NULL = 'NULL',//网络状态标识：未联网
  UNKNOWN = 'UNKNOWN',//未知网络
  MOBILE = 'MOBILE',
  WIFI = 'WIFI',
  ETHERNET = 'ETHERNET'
}

/**
 * 枚举：承载类型（内部使用，与具体平台API对接）
 * 注意：这里的枚举值应与平台API中的实际值保持一致
 */
enum BearerType {
  MOBILE = 0,
  WIFI = 1,
  // ... 可能还有其他承载类型，根据平台API添加
  ETHERNET = 3
}

/**
 * 网络信息：
 * 1、网络连接状态管理
 * 2、网络事件注册监听、取消注册
 */
export class LibNetworkStatus {


  /**
   * LibNetworkStatus单例对象
   */
  private static instance: LibNetworkStatus
  /**
   * 当前网络状态
   */
  private currentNetworkStatus:NetworkType = NetworkType.STATE_NULL
  /**
   * 网络是否可用
   */
  private isAvailable = false
  /**
   * 鸿蒙网络连接对象
   */
  private networkConnectio?: connection.NetConnection
  /**
   * 定义回调方法集合，使用WeakSet避免内存泄漏
   */
  private callbacks = new Set<LibNetworkStatusCallback>()

  /**
   * 防抖定时器
   */
  private debounceTimer: number | null = null

  /**
   * 防抖时间（毫秒）
   */
  private static readonly DEBOUNCE_DELAY = 300

  /**
   * 获得LibNetworkStatus单例对象
   * @returns LibNetworkStatus单例对象
   */
  static getInstance (): LibNetworkStatus {
    if (!LibNetworkStatus.instance) {
      LibNetworkStatus.instance = new LibNetworkStatus()
    }
    return LibNetworkStatus.instance
  }

  /**
   * 添加回调方法
   * @param callback 回调方法
   * @param isCallBackCurrentNetworkStatus 是否立即返回当前的网络状态
   */
  addCallback (callback: LibNetworkStatusCallback, isCallBackCurrentNetworkStatus: boolean) {
    if (callback && this.callbacks) {
      appLogger.debug(TAG+"添加回调方法")
      if(this.callbacks.has(callback)){
        return
      }
      this.callbacks.add(callback)

      //立即回调当前网络状态
      if (isCallBackCurrentNetworkStatus) {
        appLogger.debug(TAG+'立即回调当前网络状态: ' + this.currentNetworkStatus)
        callback(this.currentNetworkStatus)
      }
    }
  }

  /**
   * 移除回调方法
   * @param callback 回调方法
   */
  removeCallback (callback: LibNetworkStatusCallback) {
    if (callback && this.callbacks && this.callbacks.has(callback)) {
      appLogger.debug(TAG+'移除回调方法')
      this.callbacks.delete(callback)
    }
  }

  /**
   * 防抖处理网络状态回调
   */
  private debouncedCallback() {
    if (this.debounceTimer !== null) {
      clearTimeout(this.debounceTimer);
    }

    this.debounceTimer = setTimeout(() => {
      if (this.callbacks && this.callbacks.size > 0) {
        appLogger.debug(TAG + '遍历callback集合，回调当前网络状态')
        this.callbacks.forEach(callback => {
          callback(this.currentNetworkStatus)
        })
      }
      this.debounceTimer = null;
    }, LibNetworkStatus.DEBOUNCE_DELAY);
  }

  /**
   * 回调当前网络状态
   */
  callbackNetworkStatus() {
    this.debouncedCallback();
  }

  /**
   * 注册网络状态监听：
   * 设备从无网络到有网络会触发"netAvailable"、"netCapabilitiesChange"、"netConnectionPropertiesChange"事件；
   * 设备从有网络到无网络会触发"netLost"事件
   * 设备从wifi到蜂窝网络会触发"netLost"事件（wifi不可用）、之后触发"netAvailable"事件（蜂窝可用）
   */
  registerNetConnectListener () {
    if (this.networkConnectio) {
      appLogger.debug(TAG+'已订阅网络事件，无需再次订阅')
      return
    }

    //创建NetConnection对象
    this.networkConnectio = connection.createNetConnection()

    //判断默认网络状态
    let hasDefaultNet = connection.hasDefaultNetSync()
    if (hasDefaultNet) {
      appLogger.debug(TAG+'hasDefaultNetSync  ' + hasDefaultNet)
      this.isAvailable = true
      //获得默认网络类型
      this.getDefaultNetSync()
    }

    //注册
    this.networkConnectio.register((error) => {
      if (error) {
        appLogger.debug(TAG+'networkConnectio.register failure: ' + JSON.stringify(error))
      } else {
        appLogger.debug(TAG+' networkConnectio.register success')
      }
    })

    //订阅网络可用事件
    appLogger.debug(TAG+'订阅网络可用事件-->')
    this.networkConnectio.on('netAvailable', (data: connection.NetHandle) => {
      appLogger.debug(TAG+'netAvailable：' + JSON.stringify(data))
      this.isAvailable = true

      //获得默认网络类型
      this.getDefaultNetSync()

      //回调网络状态
      this.callbackNetworkStatus()
    })

    //订阅网络丢失事件
    appLogger.debug(TAG+'订阅网络丢失事件-->')
    this.networkConnectio.on('netLost', (data: connection.NetHandle) => {
      appLogger.debug(TAG+'netLost：' + JSON.stringify(data))
      this.isAvailable = false
      this.currentNetworkStatus = NetworkType.STATE_NULL

      //回调网络状态
      this.callbackNetworkStatus()
    })

    //订阅网络不可用事件
    appLogger.debug(TAG+'订阅网络不可用事件-->')
    this.networkConnectio.on('netUnavailable', () => {
      appLogger.debug(TAG+'netUnavailable')
      this.isAvailable = false
      this.currentNetworkStatus = NetworkType.STATE_NULL

      //回调网络状态
      this.callbackNetworkStatus()
    })
  }

  /**
   * 获得默认网络类型
   */
  getDefaultNetSync () {
    //获得当前网络状态
    let netHandle = connection.getDefaultNetSync()
    if (netHandle) {
      let capabilities = connection.getNetCapabilitiesSync(netHandle)
      appLogger.debug(TAG+'getNetCapabilitiesSync：' + JSON.stringify(capabilities))
      if (capabilities && capabilities.bearerTypes && capabilities.bearerTypes.length > 0) {

        // 获取第一个承载类型
        const bearerType = capabilities.bearerTypes[0];
        // 根据承载类型判断网络类型
        switch (bearerType) {
          case BearerType.MOBILE.valueOf():
          // 蜂窝网络
            appLogger.debug(TAG+'currentNetworkState：蜂窝网络')
            this.currentNetworkStatus =  NetworkType.MOBILE;
                break;
          case BearerType.WIFI.valueOf():
          // Wi-Fi网络
            appLogger.debug(TAG+'currentNetworkState：WIFI网络')
            this.currentNetworkStatus =  NetworkType.WIFI;
            break;
          case BearerType.ETHERNET.valueOf():
          // 以太网网络（通常移动设备不支持，但为完整性保留）
            appLogger.debug(TAG+'currentNetworkState：以太网网络')
            this.currentNetworkStatus =  NetworkType.ETHERNET;
            break;
          default:
          // 未知网络类型
            appLogger.debug(TAG+'currentNetworkState：未知网络类型')
            this.currentNetworkStatus =  NetworkType.UNKNOWN;
            break;
        }

      }
    }
  }

  /**
   * 当前网络是否可用
   */
  isNetworkAvailable () {
    return this.isAvailable
  }

  /**
   * 获得当前网络状态
   * @returns
   */
  getCurrentNetworkStatus () {
    return this.currentNetworkStatus
  }
}

核心点解析：

  1. 单例模式：通过单例模式，确保 LibNetworkStatus 的实例在整个应用中唯一。
  2. 网络状态检测：通过调用鸿蒙提供的网络状态检测 API，判断网络是否可用。

七、总结

在本篇中，我们深入探讨了 RCP 网络库的高级特性，包括错误处理、会话管理以及网络状态检测等。通过这些特性，我们可以构建一个更加健壮、高效且易于使用的网络库。在下篇中，我们将通过实际案例，展示如何在鸿蒙运动项目中使用这个网络库，实现各种网络请求功能。敬请期待！

全部评论

相关推荐

昨天 08:57
沈阳航空航天大学 Java
26届实习，错把leader当成了mentor
鼠鼠目前在鹅实习，leader人很好，非常和蔼随和，他坐我后边，我本来以为他是我的mentor，原来我和mentor是异地，然后第一天leader给我介绍的人是+3😭😭幸好鼠鼠还比较收敛，没有爆典，这怎么办呢&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
Act0：没事 我的两个line manager都是+3 甚至还跨国如果实习不转正的话 和老板聊天就是问问大的scope 或者问问他们对毕业生有什么建议都可以 或者吃吃跨部门的瓜 如果要转正的话 和+2 +3聊天的技巧就是摸清楚他们想解决什么问题 你可以做的就是多帮忙
投递腾讯等公司9个岗位 一人一个landing小技巧 校招我听劝
点赞 评论 收藏
分享
头像
06-07 22:41
南京大学 Java
（计算机基础 核心知识）JAVA
1.简述内部类及其作用成员内部类：作为成员对象的内部类。可以访问private及以上外部类的属性和方法。外部类想要访问内部类属性或方法时，必须要创建一个内部类对象，然后通过该对象访问内部类的属性或方法。外部类也可访问private修饰的内部类属性。局部内部类：存在于方法中的内部类。访问权限类似局部变量，只能访问外部类的final变量。它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的匿名内部类：只能使用一次，没有类名，只能访问外部类的final变量。匿名...
计算机实习秋招 面经/八... 牛客激励计划 牛客解忧铺
点赞 评论 收藏
分享
05-30 14:57
已编辑
北京邮电大学 通信测试工程师
实习offer帮选：上海华为无线软开vs北京荣耀通信测试
投票
本人是双非本211硕，通信工程专业，不考虑转码秋招会继续找通信方向的工作，坐标北京，秋招打算留在北京，且不考虑国企，目前两个公司的情况是1、北京荣耀，offer已发，岗位是通信体验工程师，类似于通信测试岗，二面的时候主管说秋招基本靠转正，这个岗位可能转正率比较高，但因为是测试岗，担心岗位前景不太好，优点是可以争取转正，等秋招进去之后再考虑公司内部转岗。2、上海华为无线软开，泡池子中，前两天收到了保温电话，预计下周开奖，因为华为无转正且位置在上海，所以秋招的时候不会考虑再投这个部门，也就是去了学一段实习经历回来从头开始准备秋招，这个岗位的工作相对荣耀来说较好，是无线网络部门的通信软件开发，如果可以还是希望在实习的时候学些相关知识，但是也担心去了纯打杂什么都学不到，最后什么也没捞着还不如去荣耀混个保底转正。请教牛友们我应该如何选择？
投递荣耀等公司9个岗位
点赞 评论 收藏
分享
05-29 10:04
已编辑
门头沟学院 Java
掌上先机慧策oc面经
#牛客AI配图神器#掌上先机Java开发&nbsp;一面个人介绍redis中存储商品信息怎么存，双删，redis的基本数据类型SQLlist中存储学生对象，学号重复怎么去重，重写equals为什么要重写hashcodejvm的内存结构，那部分占用内存最大堆的内存空间分配方法区为什么要改成元空间jvm垃圾回收方式MySQL的事务隔离级别，可重复读怎么解决脏读某个接口中sql查询很慢，怎么排查如果循环查询sql，单一sql没有达到慢查询时间怎么处理索引失效mysql索引数据结构算法：求数组中第二大的数&nbsp;二面介绍一下项目订单单号怎么生产的，时钟回拨怎么处理，假设三个服务器时间不同，怎么处理订单号的生产除了雪花...
2025校招 面试问题记录 牛客创作赏金赛
点赞 评论 收藏
分享
昨天 08:49
东南大学 Java
点赞 评论 收藏
分享
评论
点赞
收藏
分享

全站热榜

更多

创作者周榜

更多
正在热议
更多
# 我的职场心眼子段位 #
8610次浏览 350人参与
# 通信硬件人社招/春招/实习投递现状 #
25661次浏览 930人参与
# 你找实习最大的坎坷是什么 #
9455次浏览 91人参与
# 职场吐槽大会 #
209137次浏览 1663人参与
# 实习最想跑路的瞬间 #
8599次浏览 79人参与
# 妈妈治愈了你哪些脆皮时刻 #
25897次浏览 276人参与
# 毕业租房也有小确幸 #
116697次浏览 4387人参与
# 运营商笔面经互助 #
147806次浏览 1638人参与
# 24届的你们现状如何了？ #
71982次浏览 410人参与
# 秋招想进国企该如何准备 #
66690次浏览 400人参与
# 我的求职精神状态 #
73315次浏览 912人参与
# 多益网络工作体验 #
46947次浏览 269人参与
# 你的房租占工资的比例是多少？ #
35831次浏览 559人参与
# 硬件人秋招的第一个offer #
74995次浏览 1135人参与
# 科大讯飞求职进展汇总 #
284417次浏览 2723人参与
# 材料进Fab厂真的劝退吗？ #
40661次浏览 177人参与
# 当下环境，你会继续卷互联网，还是看其他行业机会 #
110328次浏览 786人参与
# 机械专业只有考研才有出路吗 #
107154次浏览 870人参与
# 25届网易互娱暑实进度 #
74675次浏览 688人参与
# 工作中的卑微时刻 #
14120次浏览 113人参与
牛客网
牛客网在线编程
牛客网题解
牛客企业服务