基于HarmonyOS的HTTPS请求过程开发示例（ArkTS） 原创

├──entry/src/main/ets                // 代码区
│  ├──common
│  │  ├──constants
│  │  │  ├──StyleConstants.ets       // 样式常量类 
│  │  │  └──CommonConstants.ets      // 常量类
│  │  └──utils
│  │     ├──HttpUtil.ets             // 网络请求方法
│  │     └──Logger.ets               // 日志打印工具类
│  ├──entryability
│  │  └──EntryAbility.ts             // 程序入口类
│  └──pages
│     └──WebPage.ets                 // 页面入口
└──entry/src/main/resources          // 资源文件目录

// HttpUtil.ets
import http from '@ohos.net.http';
export default async function httpGet(url: string) {
  if (!url) {
    return undefined;
  }
  let request = http.createHttp();
  let options = {
    method: http.RequestMethod.GET,
    header: { 'Content-Type': 'application/json' },
    readTimeout: CommonConstant.READ_TIMEOUT,
    connectTimeout: CommonConstant.CONNECT_TIMEOUT
  } as http.HttpRequestOptions;
  let result = await request.request(url, options);
  return result;
}

// WebPage.ets
import http from '@ohos.net.http';
...
@Entry
@Component
struct WebPage {
  @State webVisibility: Visibility = Visibility.Hidden;
  ...
  build() {
    Column() {
      ...
    }
  }

  async onRequest() {
    if (this.webVisibility === Visibility.Hidden) {
      this.webVisibility = Visibility.Visible;
      try {
        let result = await httpGet(this.webSrc);
        if (result && result.responseCode === http.ResponseCode.OK) {
          this.controller.clearHistory();
          this.controller.loadUrl(this.webSrc);
        } 
      } catch (error) {
        promptAction.showToast({
          message: $r('app.string.http_response_error')
        })
      }
    } else {
      this.webVisibility = Visibility.Hidden;
    }
  }
}

// http_exec.cpp
bool HttpExec::RequestWithoutCache(RequestContext *context)
{
    if (!staticVariable_.initialized) {
        NETSTACK_LOGE("curl not init");
        return false;
    }
    auto handle = curl_easy_init();
    ...
    if (!SetOption(handle, context, context->GetCurlHeaderList())) {
        NETSTACK_LOGE("set option failed");
        return false;
    }
    ...
    return true;
}
...
bool HttpExec::SetOption(CURL *curl, RequestContext *context, struct curl_slist *requestHeader)
{
    const std::string &method = context->options.GetMethod();
    if (!MethodForGet(method) && !MethodForPost(method)) {
        NETSTACK_LOGE("method %{public}s not supported", method.c_str());
        return false;
    }
    if (context->options.GetMethod() == HttpConstant::HTTP_METHOD_HEAD) {
        NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_NOBODY, 1L, context);
    }
    // 设置请求URL
    NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_URL, context->options.GetUrl().c_str(), context);
    ...
    // 设置CURLOPT_WRITEFUNCTION传输选项，OnWritingMemoryBody为回调函数
    NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_WRITEFUNCTION, OnWritingMemoryBody, context);
    NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_WRITEDATA, context, context);
    // 在OnWritingMemoryHeader写入响应头数据
    NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_HEADERFUNCTION, OnWritingMemoryHeader, context);
    NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_HEADERDATA, context, context);
    ...
    return true;
}
...
#define NETSTACK_CURL_EASY_SET_OPTION(handle, opt, data, asyncContext)                                   \
    do {            
        CURLcode result = curl_easy_setopt(handle, opt, data);                                           \
        if (result != CURLE_OK) {                                                                        \
            const char *err = curl_easy_strerror(result);                                                \
            NETSTACK_LOGE("Failed to set option: %{public}s, %{public}s %{public}d", #opt, err, result); \
            (asyncContext)->SetErrorCode(result);                                                        \
            return false;                                                                                \
        }                                                                                                \

// http_exec.cpp
void HttpExec::SendRequest()
{
    ...
    do {
        ...
        auto ret = curl_multi_perform(staticVariable_.curlMulti, &runningHandle);
        ...
    } while (runningHandle > 0);
}
...
void HttpExec::ReadResponse()
{
    CURLMsg *msg = nullptr; /* NOLINT */
    do {
        ...
        msg = curl_multi_info_read(staticVariable_.curlMulti, &leftMsg);
        if (msg) {
            if (msg->msg == CURLMSG_DONE) {
                HandleCurlData(msg);
            }
        }
    } while (msg);
}

// http_exec.cpp
bool HttpExec::GetCurlDataFromHandle(CURL *handle, RequestContext *context, CURLMSG curlMsg, CURLcode result)
{
    ...
    context->response.ParseHeaders();
    return true;
}
// http_response.cpp
void HttpResponse::ParseHeaders()
{
    std::vector<std::string> vec = CommonUtils::Split(rawHeader_, HttpConstant::HTTP_LINE_SEPARATOR);
    for (const auto &header : vec) {
        if (CommonUtils::Strip(header).empty()) {
            continue;
        }
        auto index = header.find(HttpConstant::HTTP_HEADER_SEPARATOR);
        if (index == std::string::npos) {
            header_[CommonUtils::Strip(header)] = "";
            NETSTACK_LOGI("HEAD: %{public}s", CommonUtils::Strip(header).c_str());
            continue;
        }
        header_[CommonUtils::ToLower(CommonUtils::Strip(header.substr(0, index)))] =
            CommonUtils::Strip(header.substr(index + 1));
    }
}