如何利用Retrofit+RxJava实现网络请求的异常处理

2023-08-24 20:22:05 74

通常情况下我们在与服务器进行通信的时候，不一定就不会出错，有时会出现其他的错误，这个时候我们只要和服务器约定好各种异常，在返回结果处进行判断，到底是执行错误，还是返回正常数据。具体的思路大致就是这样。这里我们定义ExceptionHandle，这里我参考网上的东西，然后稍微做了一些改动。

ExceptionHandle

publicclassExceptionHandle{

privatestaticfinalintUNAUTHORIZED=401;
privatestaticfinalintFORBIDDEN=403;
privatestaticfinalintNOT_FOUND=404;
privatestaticfinalintREQUEST_TIMEOUT=408;
privatestaticfinalintINTERNAL_SERVER_ERROR=500;
privatestaticfinalintBAD_GATEWAY=502;
privatestaticfinalintSERVICE_UNAVAILABLE=503;
privatestaticfinalintGATEWAY_TIMEOUT=504;

publicstaticResponseExceptionhandleException(Throwablee){
//转换成ResponseException,根据状态码判定错误信息
ResponseExceptionex;
if(einstanceofHttpException){
HttpExceptionhttpException=(HttpException)e;
/**
*传入状态码，根据状态码判定错误信息
*/
ex=newResponseException(e,ERROR.HTTP_ERROR);
switch(httpException.code()){
caseUNAUTHORIZED:
ex.message="未验证";
break;
caseFORBIDDEN:
ex.message="服务禁止访问";
break;
caseNOT_FOUND:
ex.message="服务不存在";
break;
caseREQUEST_TIMEOUT:
ex.message="请求超时";
break;
caseGATEWAY_TIMEOUT:
ex.message="网关超时";
break;
caseINTERNAL_SERVER_ERROR:
ex.message="服务器内部错误";
break;
caseBAD_GATEWAY:

break;
caseSERVICE_UNAVAILABLE:
break;
default:
ex.message="网络错误";
break;
}
returnex;
}elseif(einstanceofJsonParseException
||einstanceofJSONException
||einstanceofParseException){
ex=newResponseException(e,ERROR.PARSE_ERROR);
ex.message="解析错误";
returnex;
}elseif(einstanceofConnectException){
ex=newResponseException(e,ERROR.NETWORD_ERROR);
ex.message="连接失败";
returnex;
}elseif(einstanceofjavax.net.ssl.SSLHandshakeException){
ex=newResponseException(e,ERROR.SSL_ERROR);
ex.message="证书验证失败";
returnex;
}else{
ex=newResponseException(e,ERROR.UNKNOWN);
ex.message="未知错误";
returnex;
}
}
/**
*约定异常
*/
publicstaticclassERROR{
/**
*自定义异常
*/
privatestaticfinalintUNAUTHORIZED=401;//请求用户进行身份验证
privatestaticfinalintUNREQUEST=403;//服务器理解请求客户端的请求，但是拒绝执行此请求
privatestaticfinalintUNFINDSOURCE=404;//服务器无法根据客户端的请求找到资源
privatestaticfinalintSEVERERROR=500;//服务器内部错误，无法完成请求。
/**
*协议出错
*/
publicstaticfinalintHTTP_ERROR=1003;
/**
*未知错误
*/
publicstaticfinalintUNKNOWN=1000;
/**
*解析错误
*/
publicstaticfinalintPARSE_ERROR=1001;
/**
*网络错误
*/
publicstaticfinalintNETWORD_ERROR=1002;
/**
*证书出错
*/
publicstaticfinalintSSL_ERROR=1005;
}
/**
*自定义Throwable
*/
publicstaticclassResponseThrowableextendsException{
publicintcode;
publicStringmessage;
publicResponseThrowable(Throwablethrowable,intcode){
super(throwable);
this.code=code;
}
}
/**
*服务器异常
*/
publicclassServerExceptionextendsRuntimeException{
publicintcode;
publicStringmessage;
}

/**
*统一异常类，便于处理
*/
publicstaticclassResponseExceptionextendsException{
publicintcode;
publicStringmessage;
publicResponseException(Throwablethrowable,intcode){
super(throwable);
this.code=code;
}
}
}

然后自己定义了一个Observer

publicabstractclassBaseObserverimplementsObserver{
privateContextcontext;

publicBaseObserver(Contextcontext){
this.context=context;
}

@Override
publicvoidonSubscribe(Disposabled){

}
@Override
publicvoidonNext(Tt){

}
@Override
publicvoidonError(Throwablee){
if(einstanceofExceptionHandle.ResponseException){
onError((ExceptionHandle.ResponseException)e);
}else{
onError(newExceptionHandle.ResponseException(e,ExceptionHandle.ERROR.UNKNOWN));
}
}
@Override
publicvoidonComplete(){

}
publicabstractvoidonError(ExceptionHandle.ResponseExceptionexception);
}

这里发生错误时，Observerble会先调用onError(Throwablee),按照我的写法呢，会继续调用自定义onError。

那么什么时候我们对服务器的返回结果进行判断，什么时候该发出异常了，请继续往下看：

这里我们打算用到ObservableTransformer，Transformer其实就是就是对Observable进行一定的变换。

先看代码：

publicstaticclassHandleFucimplementsFunction>>,T>{
@Override
publicTapply(UserGuideSoftConfigRForm>>Response){
if(!Response.getCode().equals("200")){
Throwablee=newThrowable("约定错误");
/**
*可以根据不同的状态嘛返回不同的提示信息
*与服务器约定返回异常信息
*/
ExceptionHandle.ResponseExceptionresponseException=newExceptionHandle.ResponseException(e,ExceptionHandle.ERROR.HTTP_ERROR);
return(T)Observable.error(responseException);//发出错误异常
}
return(T)Observable.just(Response);//发出服务器数据，返回Observable
}
}

//处理错误的变换
publicstaticclassErrorTransformerimplementsObservableTransformer{
@Override
publicObservableapply(Observableupstream){
return(Observable)upstream.flatMap(newHandleFuc());//flatMap会重新创建一个Observable,当它处理完事件后会汇入原先的Observable对象。
}
}

说明：我们的HandleFuc其实就是对服务器返回来的结果进行判断，逻辑很简单了，错误就抛出异常直接执行error方法。如果没有错误，就发送正常数据。这里值的说明一点的是，flatMap会重新创建一个Observable,当它处理完事件后会重新汇入初始的Observerble并开始发送事件。

使用起来其实就很简单了：

@Provides
ErrorTransformerprovideErrorTransformer(){
returnnewErrorTransformer();
}

publicObservable>>>getApplication(PageParmFormpageParmForm){
returnretrofit.create(Service.class)
.getApplicationList(pageParmForm)
.compose(errorTransformer)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread());
}

直接用compose方法包裹起来即可。

最后看看Activity：

newNetRepository().getApplication(newPageParmForm(Constant.orderStr,Constant.pageNum,Constant.pageSize))
.subscribe(newBaseObserver>>>(NetWorkActivity.this){
@Override
publicvoidonError(ExceptionHandle.ResponseExceptionexception){
myToast.showToast(NetWorkActivity.this,exception.getMessage());
Log.d("carhandbook",exception.getMessage());
}

@Override
publicvoidonNext(UserGuideSoftConfigRForm>>Response){
data=Response.getData().getList();
code=Response.getCode();
myToast.showToast(NetWorkActivity.this,code);
generateAdapter.setData(data);
generateAdapter.notifyDataSetChanged();
}
});

好了对网络请求的异常处理整个思路大致就是这样了。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。

如何利用Retrofit+RxJava实现网络请求的异常处理

热门推荐

随机推荐