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

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

ExceptionHandle

public class ExceptionHandle {

  private static final int UNAUTHORIZED = 401;
  private static final int FORBIDDEN = 403;
  private static final int NOT_FOUND = 404;
  private static final int REQUEST_TIMEOUT = 408;
  private static final int INTERNAL_SERVER_ERROR = 500;
  private static final int BAD_GATEWAY = 502;
  private static final int SERVICE_UNAVAILABLE = 503;
  private static final int GATEWAY_TIMEOUT = 504;

  public static ResponseException handleException(Throwable e){
    //转换成ResponseException,根据状态码判定错误信息
    ResponseException ex;
    if(e instanceof HttpException){
      HttpException httpException=(HttpException)e;
      /**
       * 传入状态码,根据状态码判定错误信息
       */
      ex=new ResponseException(e,ERROR.HTTP_ERROR);
      switch (httpException.code()){
        case UNAUTHORIZED:
          ex.message="未验证";
          break;
        case FORBIDDEN:
          ex.message="服务禁止访问";
          break;
        case NOT_FOUND:
          ex.message="服务不存在";
          break;
        case REQUEST_TIMEOUT:
          ex.message="请求超时";
          break;
        case GATEWAY_TIMEOUT:
          ex.message="网关超时";
          break;
        case INTERNAL_SERVER_ERROR:
          ex.message="服务器内部错误";
          break;
        case BAD_GATEWAY:

          break;
        case SERVICE_UNAVAILABLE:
          break;
        default:
          ex.message = "网络错误";
          break;
      }
      return ex;
    }else if(e instanceof JsonParseException
        || e instanceof JSONException
        || e instanceof ParseException){
      ex=new ResponseException(e,ERROR.PARSE_ERROR);
      ex.message="解析错误";
      return ex;
    }else if(e instanceof ConnectException){
      ex=new ResponseException(e,ERROR.NETWORD_ERROR);
      ex.message="连接失败";
      return ex;
    }else if(e instanceof javax.net.ssl.SSLHandshakeException){
      ex=new ResponseException(e,ERROR.SSL_ERROR);
      ex.message="证书验证失败";
      return ex;
    }else {
      ex=new ResponseException(e,ERROR.UNKNOWN);
      ex.message="未知错误";
      return ex;
    }
  }
  /**
   * 约定异常
   */
 public static  class ERROR{
    /**
     * 自定义异常
     */
    private static final int UNAUTHORIZED = 401;//请求用户进行身份验证
    private static final int UNREQUEST=403;//服务器理解请求客户端的请求,但是拒绝执行此请求
    private static final int UNFINDSOURCE=404;//服务器无法根据客户端的请求找到资源
    private static final int SEVERERROR=500;//服务器内部错误,无法完成请求。
    /**
     * 协议出错
     */
    public static final int HTTP_ERROR = 1003;
    /**
     * 未知错误
     */
    public static final int UNKNOWN = 1000;
    /**
     * 解析错误
     */
    public static final int PARSE_ERROR = 1001;
    /**
     * 网络错误
     */
    public static final int NETWORD_ERROR = 1002;
    /**
     * 证书出错
     */
    public static final int SSL_ERROR = 1005;
  }
  /**
   * 自定义Throwable
   */
  public static class ResponseThrowable extends Exception{
    public int code;
    public String message;
    public ResponseThrowable(Throwable throwable,int code){
      super(throwable);
      this.code=code;
    }
  }
  /**
   * 服务器异常
   */
  public class ServerException extends RuntimeException{
    public int code;
    public String message;
  }

  /**
   * 统一异常类,便于处理
   */
  public static class ResponseException extends Exception{
    public int code;
    public String message;
    public ResponseException (Throwable throwable,int code){
      super(throwable);
      this.code=code;
    }
  }
}

然后自己定义了一个Observer

public abstract class BaseObserver<T> implements Observer<T> {
  private Context context;

  public BaseObserver(Context context){
    this.context=context;
  }

  @Override
  public void onSubscribe(Disposable d) {

  }
  @Override
  public void onNext(T t) {

  }
  @Override
  public void onError(Throwable e) {
    if(e instanceof ExceptionHandle.ResponseException){
      onError((ExceptionHandle.ResponseException)e);
    }else{
      onError(new ExceptionHandle.ResponseException(e,ExceptionHandle.ERROR.UNKNOWN));
    }
  }
  @Override
  public void onComplete() {

  }
  public abstract void onError(ExceptionHandle.ResponseException exception);
}

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

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

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

先看代码:

  public static class HandleFuc<T> implements Function<UserGuideSoftConfigRForm<UserGuideSoftConfigPageInfo<List<UserguideSoftConfig>>>, T> {
    @Override
    public T apply(UserGuideSoftConfigRForm<UserGuideSoftConfigPageInfo<List<UserguideSoftConfig>>> Response) {
      if (!Response.getCode().equals("200")){
        Throwable e=new Throwable("约定错误");
        /**
         * 可以根据不同的状态嘛返回不同的提示信息
         * 与服务器约定返回异常信息
         */
        ExceptionHandle.ResponseException responseException = new ExceptionHandle.ResponseException(e, ExceptionHandle.ERROR.HTTP_ERROR);
        return (T) Observable.error(responseException);//发出错误异常
      }
      return (T) Observable.just(Response);//发出服务器数据,返回Observable<Response>
    }
  }

  //处理错误的变换
  public static class ErrorTransformer<T> implements ObservableTransformer {
    @Override
    public Observable<T> apply(Observable upstream) {
      return (Observable<T>) upstream.flatMap(new HandleFuc<T>());//flatMap会重新创建一个Observable,当它处理完事件后会汇入原先的Observable对象。
    }
  }

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

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

@Provides
  ErrorTransformer provideErrorTransformer(){
    return new ErrorTransformer();
  }

 public Observable<UserGuideSoftConfigRForm<UserGuideSoftConfigPageInfo<List<UserguideSoftConfig>>>> getApplication(PageParmForm pageParmForm){
    return retrofit.create(Service.class)
        .getApplicationList(pageParmForm)
        .compose(errorTransformer)
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread());
  }

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

最后看看Activity:

new NetRepository().getApplication(new PageParmForm(Constant.orderStr,Constant.pageNum,Constant.pageSize))
    .subscribe(new BaseObserver<UserGuideSoftConfigRForm<UserGuideSoftConfigPageInfo<List<UserguideSoftConfig>>>>(NetWorkActivity.this) {
      @Override
      public void onError(ExceptionHandle.ResponseException exception) {
        myToast.showToast(NetWorkActivity.this,exception.getMessage());
        Log.d("carhandbook",exception.getMessage());
      }

      @Override
      public void onNext(UserGuideSoftConfigRForm<UserGuideSoftConfigPageInfo<List<UserguideSoftConfig>>> Response) {
        data=Response.getData().getList();
        code=Response.getCode();
        myToast.showToast(NetWorkActivity.this,code);
        generateAdapter.setData(data);
        generateAdapter.notifyDataSetChanged();
      }
    });

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

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

(0)

相关推荐

  • Android Retrofit和Rxjava的网络请求

    Android  Retrofit和Rxjava的网络请求 去年的时候好多公司就已经使用Rxjava和Retrofit了,最近自自己学习了一下,感觉真的是很好用,让自己的网络请求变得更简单了,而且封装性极强. 首先做一下准备工作,导入需要引用的文件 compile 'com.android.support:appcompat-v7:25.1.0' testCompile 'junit:junit:4.12' compile 'io.reactivex:rxjava:1.1.0' compile

  • 深入浅出RxJava+Retrofit+OkHttp网络请求

    浅谈RxJava+Retrofit+OkHttp 封装使用之前发出后收到很多朋友的关注,原本只是自己学习后的一些经验总结,但是有同学运用到实战当中,这让我很惶恐,所有后续一直更新了很多次版本,有些地方难免有所变动导致之前的博客有所出入,正好最近受到掘金邀请内测博客,所以决定重新写一版,按照最后迭代完成的封装详细的讲述一遍,欢迎大家关注! 注意:由于本章的特殊性,后续文章比较长而且复杂,涉及内容也很多,所以大家准备好茶水,前方高能预警. 简介: Retrofit: Retrofit是Square

  • RxJava+Retrofit实现网络请求封装的方法

    简要介绍 Retrofit是当前应用非常广泛的网络请求框架,通常结合RxJava来进行网络请求,本文将展示一个采用RxJava+Retrofit的网络请求demo. 集成步骤 1.app工程的build.gradle中添加依赖 //retrofit2 implementation 'com.google.code.gson:gson:2.8.5' implementation 'com.squareup.retrofit2:retrofit:2.5.0' implementation 'com.

  • Kotlin结合Rxjava+Retrofit实现极简网络请求的方法

    前言 因为最近正在写的项目集成了两个网络请求框架(Volley and Retrofit)对比之下也是选择了Retrofit.既然选择那自然要让自己以后开发更加省力(就是懒).于是我在Retrofit中加入了Rxjava,这也是当下蛮流行的一个请求框架.然后又利用了Kotlin的一些新特性,使网络请求变得特别简单,代码量特别少. Kotlin镇楼 RxJava RxJava学习是一个曲折漫长的过程,但一旦掌握,妙用无穷. 通过这里了解更多:http://www.jb51.net/article/

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

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

  • Android  Retrofit和Rxjava的网络请求

    Android  Retrofit和Rxjava的网络请求 去年的时候好多公司就已经使用Rxjava和Retrofit了,最近自自己学习了一下,感觉真的是很好用,让自己的网络请求变得更简单了,而且封装性极强. 首先做一下准备工作,导入需要引用的文件 compile 'com.android.support:appcompat-v7:25.1.0' testCompile 'junit:junit:4.12' compile 'io.reactivex:rxjava:1.1.0' compile

  • RxJava之网络请求最常见的三种场景

    本文想阐述一下当你开发Android应用并采用RxJava作为你的架构,尤其是有关网络请求时最常见的三种场景. 我使用Retrofit来作为网络层,简单的内存缓存-HashMap来做缓存,也可以使用Room或者其他数据库实现来替代. Retrofit接口有如下的一些简单方法,它获取一个事件列表. @GET("events") Single<List<Event>> getEventsFeed(...); 通过我的Repository接口来暴露,可订阅如下: Si

  • Swift利用AFN实现封装网络请求详解

    前言 相信大家都知道,我们一般在一个项目中,网络请求都封装成一个单例,以确保整个项目的网络请求 Session 是同一个. 单例模式定义:一个类有且仅有一个实例,并且自行实例化向整个系统提供,下面话不多说了,来一起看看详细的介绍吧. 通过cocoaPods 导入第三方框架 01-切换到项目目录 cd 项目名称 02-初始化Pods pod init 03-打开 Pods 文件 open Podfile 04-编辑 Podfile # 设置支持最低平台 platform :ios, '8.0' t

  • Rxjava+Retrofit+Okhttp进行网络访问及数据解析

    目录 1,创建Android项目(Android studio)导入相关依赖 2,定义接口类 3,发出请求,回调信息 4,Rxjava 和 Retrofit的结合 前言: 在平时项目开发中Okhttp3.x.Rxjava2.x.Retrofit2.x,使用的越来越多了,需要我们不断的去学习别人的优秀开发设计程序,今天简单的了解下 1,创建Android项目(Android studio)导入相关依赖 implementation 'com.squareup.okhttp3:okhttp:3.11

  • Android网络请求框架Retrofit详解

    介绍: Retrofit 是Square公司开发的一款针对Android网络请求的框架,Retrofit2底层基于OkHttp实现的,OkHttp现在已经得到Google官方认可,大量的app都采用OkHttp做网络请求.本文使用Retrofit2.0.0版本进行实例演示. 使用Retrofit可以进行GET,POST,PUT,DELETE等请求方式. 同步请求:需要在子线程中完成,会阻塞主线程. Response response = call.execute().body(); 异步请求:请

随机推荐