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

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

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

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对象。
  }
}

@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());
  }

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