Retrofit 网络请求的异常处理与重试策略实战

sealedclassApiException(message:String,cause:Throwable? =null):Exception(message,cause){
// 网络层异常
classNetworkException(cause:Throwable):ApiException("网络连接失败",cause)

// HTTP 异常
classHttpException(valcode:Int,message:String):ApiException(message)

// 业务异常
classBusinessException(valcode:Int,message:String):ApiException(message)

// 未知异常
classUnknownException(cause:Throwable):ApiException("未知错误",cause)
}

dataclassApiResponse<T>(
valcode:Int,
valmessage:String,
valdata:T?
)

classApiCallAdapterFactory:CallAdapter.Factory(){
overridefunget(
returnType:Type,
annotations:Array<outAnnotation>,
retrofit:Retrofit
):CallAdapter<*,*>?{
if(getRawType(returnType)!=Call::class.java)returnnull

valresponseType=getParameterUpperBound(0,returnTypeasParameterizedType)
returnApiCallAdapter<Any>(responseType)
}

privateclassApiCallAdapter<R>(privatevalresponseType:Type):CallAdapter<ApiResponse<R>,Call<R>>{
overridefunresponseType():Type=responseType

overridefunadapt(call:Call<ApiResponse<R>>):Call<R>{
returnApiCall(call)
}
}
}

classApiCall<T>(privatevaldelegate:Call<ApiResponse<T>>):Call<T>{

overridefunenqueue(callback:Callback<T>){
delegate.enqueue(object:Callback<ApiResponse<T>>{
overridefunonResponse(call:Call<ApiResponse<T>>,response:Response<ApiResponse<T>>){
if(response.isSuccessful){
valbody=response.body()
if(body!=null){
when(body.code){
200->callback.onResponse(this@ApiCall,Response.success(body.data))
401->callback.onFailure(this@ApiCall,ApiException.HttpException(401,"未授权"))
else->callback.onFailure(this@ApiCall,ApiException.BusinessException(body.code,body.message))
}
}else{
callback.onFailure(this@ApiCall,ApiException.UnknownException(NullPointerException("Response body is null")))
}
}else{
callback.onFailure(this@ApiCall,ApiException.HttpException(response.code(),response.message()))
}
}

overridefunonFailure(call:Call<ApiResponse<T>>,t:Throwable){
valexception=when(t){
isConnectException,isUnknownHostException->ApiException.NetworkException(t)
isSocketTimeoutException->ApiException.HttpException(408,"请求超时")
else->ApiException.UnknownException(t)
}
callback.onFailure(this@ApiCall,exception)
}
})
}

overridefunclone():Call<T>=ApiCall(delegate.clone())
overridefunexecute():Response<T>=throwUnsupportedOperationException("同步请求不支持")
overridefunisExecuted():Boolean=delegate.isExecuted
overridefuncancel()=delegate.cancel()
overridefunisCanceled():Boolean=delegate.isCanceled
overridefunrequest():Request=delegate.request()
overridefuntimeout():Timeout=delegate.timeout()
}

classRetryInterceptor(
privatevalmaxRetry:Int=3,
privatevalretryDelay:Long=1000L
):Interceptor{

overridefunintercept(chain:Interceptor.Chain):Response{
valrequest=chain.request()
varresponse:Response? =null
varexception:IOException? =null

repeat(maxRetry){attempt->
try{
response=chain.proceed(request)
// 如果是 5xx 错误，尝试重试
if(response!!.isSuccessful||response!!.code<500){
returnresponse!!
}
response!!.close()
}catch(e:IOException){
exception=e
}

// 最后一次不需要延迟
if(attempt<maxRetry-1){
Thread.sleep(retryDelay*(attempt+1))// 指数退避
}
}

// 所有重试都失败
throwexception?:IOException("Max retry reached")
}
}

valclient=OkHttpClient.Builder()
.addInterceptor(RetryInterceptor(maxRetry=3,retryDelay=1000))
.build()

classTokenInterceptor(
privatevaltokenManager:TokenManager
):Interceptor{

overridefunintercept(chain:Interceptor.Chain):Response{
valoriginalRequest=chain.request()

// 添加 Token
valrequestWithToken=originalRequest.newBuilder()
.header("Authorization","Bearer ${tokenManager.getAccessToken()}")
.build()

valresponse=chain.proceed(requestWithToken)

// 如果返回 401，尝试刷新 Token
if(response.code==401){
response.close()

synchronized(this){
valnewToken=tokenManager.refreshToken()

// 用新 Token 重试
valnewRequest=originalRequest.newBuilder()
.header("Authorization","Bearer $newToken")
.build()

returnchain.proceed(newRequest)
}
}

returnresponse
}
}

suspendfunfetchUserInfo():Result<UserInfo>=flow{
valresponse=apiService.getUserInfo()
emit(response)
}.retry(retries=2){cause->
// 只对网络异常重试
causeisApiException.NetworkException
}.catch{e->
emit(Result.failure(e))
}.map{
Result.success(it)
}.first()

classCacheInterceptor(privatevalcache:Cache):Interceptor{
overridefunintercept(chain:Interceptor.Chain):Response{
valrequest=chain.request()

returntry{
chain.proceed(request)
}catch(e:IOException){
// 网络失败，尝试读取缓存
valcacheResponse=cache.get(request)
if(cacheResponse!=null){
cacheResponse.newBuilder()
.header("Cache-Control","only-if-cached, max-stale=2592000")// 30天
.build()
}else{
throwe
}
}
}
}

valclient=OkHttpClient.Builder()
.addInterceptor(TokenInterceptor(tokenManager))
.addInterceptor(RetryInterceptor(maxRetry=3))
.addInterceptor(CacheInterceptor(cache))
.connectTimeout(10,TimeUnit.SECONDS)
.readTimeout(30,TimeUnit.SECONDS)
.build()

valretrofit=Retrofit.Builder()
.baseUrl("https://api.example.com/")
.client(client)
.addCallAdapterFactory(ApiCallAdapterFactory())
.addConverterFactory(GsonConverterFactory.create())
.build()

valrequest=chain.request()
if(request.method!="GET"&&request.method!="HEAD"){
// POST/PUT/DELETE 等非幂等请求，不自动重试
returnchain.proceed(request)
}

privatevallock=Mutex()

suspendfunrefreshToken():String{
lock.withLock{
// 检查是否已经被其他线程刷新过
if(isTokenValid())returngetAccessToken()

// 调用刷新接口
valnewToken=apiService.refreshToken(getRefreshToken())
saveAccessToken(newToken)
returnnewToken
}
}

valdelay=retryDelay*(1shlattempt)+Random.nextLong(0,500)
Thread.sleep(delay)