HTTP请求Demo，通过createHttp方法创建一个请求任务，再通过request方法发起网络请求

// 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)); 
  } 
}