鸿蒙应用的网络请求和数据处理：从HTTP到本地缓存的完整方案-平芜编程栈

网络请求是现代应用的核心功能。无论是获取用户数据、上传文件还是实时通信，都需要与服务器进行网络交互。但网络请求涉及许多复杂的问题：网络延迟、错误处理、数据缓存、离线支持等。

本文将为你讲解如何在鸿蒙应用中优雅地处理网络请求和数据，包括HTTP请求、JSON解析、错误处理、数据缓存等。通过学习这些内容，你将能够构建更加健壮和高效的网络层。

HTTP请求的基础实现

鸿蒙提供了http模块来进行HTTP请求。基础的HTTP请求实现相对简单，但要做好错误处理和超时控制。

基础GET请求

importhttpfrom'@ohos.net.http'asyncfunctionfetchData(url:string):Promise<string>{lethttpRequest=http.createHttpRequest()try{awaithttpRequest.request(url,{method:http.RequestMethod.GET,connectTimeout:10000,readTimeout:10000})letresult=httpRequest.getResponseBody()returnresultasstring}catch(error){console.error('Request failed:',error)throwerror}finally{httpRequest.destroy()}}

POST请求和请求头

asyncfunctionpostData(url:string,data:object):Promise<string>{lethttpRequest=http.createHttpRequest()try{awaithttpRequest.request(url,{method:http.RequestMethod.POST,header:{'Content-Type':'application/json','Authorization':'Bearer token'},extraData:JSON.stringify(data),connectTimeout:10000,readTimeout:10000})letresult=httpRequest.getResponseBody()returnresultasstring}catch(error){console.error('Request failed:',error)throwerror}finally{httpRequest.destroy()}}

JSON数据解析

从服务器获取的数据通常是JSON格式。正确的JSON解析对于数据处理至关重要。

基础JSON解析

interfaceUser{id:numbername:stringemail:string}asyncfunctionfetchUser(userId:number):Promise<User>{letresponse=awaitfetchData(`https://api.example.com/users/${userId}`)letuser=JSON.parse(response)asUserreturnuser}

处理复杂的JSON结构

interfacePost{id:numbertitle:stringcontent:stringauthor:User comments:Comment[]}interfaceComment{id:numbertext:stringauthor:User}asyncfunctionfetchPost(postId:number):Promise<Post>{letresponse=awaitfetchData(`https://api.example.com/posts/${postId}`)letpost=JSON.parse(response)asPostreturnpost}

JSON序列化

functionserializeUser(user:User):string{returnJSON.stringify(user)}functionserializeUsers(users:User[]):string{returnJSON.stringify(users,null,2)}

错误处理和重试机制

网络请求经常会失败。实现良好的错误处理和重试机制可以提高应用的稳定性。

基础错误处理

enumRequestError{NETWORK_ERROR='NETWORK_ERROR',TIMEOUT='TIMEOUT',SERVER_ERROR='SERVER_ERROR',PARSE_ERROR='PARSE_ERROR'}classRequestExceptionextendsError{constructor(publiccode:RequestError,message:string){super(message)}}asyncfunctionfetchDataWithErrorHandling(url:string):Promise<string>{try{lethttpRequest=http.createHttpRequest()awaithttpRequest.request(url,{method:http.RequestMethod.GET,connectTimeout:10000,readTimeout:10000})letstatusCode=httpRequest.getResponseCode()if(statusCode>=400){thrownewRequestException(RequestError.SERVER_ERROR,`Server error:${statusCode}`)}returnhttpRequest.getResponseBody()asstring}catch(error){if(errorinstanceofRequestException){throwerror}thrownewRequestException(RequestError.NETWORK_ERROR,'Network request failed')}}

重试机制

asyncfunctionfetchDataWithRetry(url:string,maxRetries:number=3):Promise<string>{letlastError:Error|null=nullfor(leti=0;i<maxRetries;i++){try{returnawaitfetchDataWithErrorHandling(url)}catch(error){lastError=errorasErrorif(i<maxRetries-1){// 指数退避：等待时间随着重试次数增加而增加letdelay=Math.pow(2,i)*1000awaitnewPromise(resolve=>setTimeout(resolve,delay))}}}throwlastError}

数据缓存策略

频繁的网络请求会浪费带宽和电池电量。实现合理的缓存策略可以显著提升应用性能。

内存缓存

classMemoryCache<T>{privatecache:Map<string,{data:T,timestamp:number}>=newMap()privatettl:number// 缓存过期时间（毫秒）constructor(ttl:number=5*60*1000){this.ttl=ttl}set(key:string,data:T):void{this.cache.set(key,{data,timestamp:Date.now()})}get(key:string):T|null{letitem=this.cache.get(key)if(!item){returnnull}if(Date.now()-item.timestamp>this.ttl){this.cache.delete(key)returnnull}returnitem.data}clear():void{this.cache.clear()}}letuserCache=newMemoryCache<User>(10*60*1000)asyncfunctionfetchUserWithCache(userId:number):Promise<User>{letcacheKey=`user_${userId}`// 检查缓存letcachedUser=userCache.get(cacheKey)if(cachedUser){returncachedUser}// 从网络获取letuser=awaitfetchUser(userId)// 存入缓存userCache.set(cacheKey,user)returnuser}

本地存储缓存

importpreferencesfrom'@ohos.data.preferences'classPersistentCache{privatepreferences:preferences.Preferences|null=nullasyncinit(context:any):Promise<void>{this.preferences=awaitpreferences.getPreferences(context,'app_cache')}asyncset(key:string,value:string):Promise<void>{if(!this.preferences){thrownewError('Cache not initialized')}awaitthis.preferences.put(key,value)awaitthis.preferences.flush()}asyncget(key:string):Promise<string|null>{if(!this.preferences){thrownewError('Cache not initialized')}letvalue=awaitthis.preferences.get(key,null)returnvalueasstring|null}asyncremove(key:string):Promise<void>{if(!this.preferences){thrownewError('Cache not initialized')}awaitthis.preferences.delete(key)awaitthis.preferences.flush()}}letpersistentCache=newPersistentCache()asyncfunctionfetchUserWithPersistentCache(userId:number):Promise<User>{letcacheKey=`user_${userId}`// 检查本地缓存letcachedData=awaitpersistentCache.get(cacheKey)if(cachedData){returnJSON.parse(cachedData)asUser}// 从网络获取letuser=awaitfetchUser(userId)// 存入本地缓存awaitpersistentCache.set(cacheKey,JSON.stringify(user))returnuser}

离线支持

应用应该能够在网络不可用时继续工作。实现离线支持需要合理的缓存策略和用户提示。

检查网络连接

importconnectionfrom'@ohos.net.connection'asyncfunctionisNetworkAvailable():Promise<boolean>{try{letnetHandle=awaitconnection.getDefaultNetConnection()letnetCapabilities=awaitconnection.getNetCapabilities(netHandle)returnnetCapabilities.hasCapability(connection.NetCapsType.NET_CAPABILITY_INTERNET)}catch(error){returnfalse}}asyncfunctionfetchDataWithOfflineSupport(url:string):Promise<string>{letisOnline=awaitisNetworkAvailable()if(isOnline){try{returnawaitfetchDataWithRetry(url)}catch(error){// 网络请求失败，尝试使用缓存letcachedData=awaitpersistentCache.get(url)if(cachedData){console.warn('Using cached data due to network error')returncachedData}throwerror}}else{// 离线模式，使用缓存letcachedData=awaitpersistentCache.get(url)if(cachedData){returncachedData}thrownewError('No network connection and no cached data available')}}

最佳实践

使用拦截器统一处理请求

classHttpClient{privaterequestInterceptors:Array<(config:any)=>any>=[]privateresponseInterceptors:Array<(response:any)=>any>=[]addRequestInterceptor(interceptor:(config:any)=>any):void{this.requestInterceptors.push(interceptor)}addResponseInterceptor(interceptor:(response:any)=>any):void{this.responseInterceptors.push(interceptor)}asyncrequest(url:string,config:any={}):Promise<any>{// 执行请求拦截器for(letinterceptorofthis.requestInterceptors){config=interceptor(config)}// 执行请求letresponse=awaitfetchDataWithRetry(url)// 执行响应拦截器for(letinterceptorofthis.responseInterceptors){response=interceptor(response)}returnresponse}}lethttpClient=newHttpClient()// 添加认证拦截器httpClient.addRequestInterceptor((config)=>{config.header=config.header||{}config.header['Authorization']='Bearer token'returnconfig})// 添加日志拦截器httpClient.addResponseInterceptor((response)=>{console.log('Response:',response)returnresponse})

分离数据层和UI层

classUserRepository{asyncgetUser(userId:number):Promise<User>{returnawaitfetchUserWithPersistentCache(userId)}asyncgetUsers(page:number,pageSize:number):Promise<User[]>{leturl=`https://api.example.com/users?page=${page}&pageSize=${pageSize}`letresponse=awaitfetchDataWithOfflineSupport(url)returnJSON.parse(response)asUser[]}}@Component struct UserList{@State users:User[]=[]@State loading:boolean=false@State error:string=''privaterepository=newUserRepository()asyncloadUsers(){this.loading=truetry{this.users=awaitthis.repository.getUsers(1,20)}catch(error){this.error=(errorasError).message}finally{this.loading=false}}build(){Column(){if(this.loading){LoadingProgress()}elseif(this.error){Text(this.error)}else{List(){ForEach(this.users,(user:User)=>{ListItem(){Text(user.name)}})}}}}}