【Android】Retrofit+RxJava+OkHttp的基础、封装和项目中的使用

2.统一处理错误：
在payload 类里面，请求失败时，抛出了一个fault 异常给上层，我在activity/fragment 中拿到这个异常，然后判断错误码，进行异常处理。在onerror () 中添加。
对应 错误码 处理 相应的错误，代码如下：

public void call(throwable throwable) { 
  log.e("tag","error message:"+throwable.getmessage()); 
  if(throwable instanceof fault){   
  fault fault = (fault) throwable;   
    if(fault.geterrorcode() == 404){   
      //错误处理
      }else if(fault.geterrorcode() == 500){ 
      //错误处理 
      }else if(fault.geterrorcode() == 501){     
      //错误处理 
    } 
  }
}

六，添加公共参数

实际项目中，每个接口都有一些基本的相同的参数，我们称之为公共参数，比如：userid、usertoken、username、deviceid等等，我们不必每个接口都去写，可以写一个拦截器，在拦截器里面拦截请求，为每个请求都添加相同的公共参数。
拦截器代码如下：

/*
 * 拦截器
 *
 * 向请求头里添加公共参数
 */
public class httpcommoninterceptor implements interceptor {   
private map mheaderparamsmap = new hashmap<>(); 
  public httpcommoninterceptor() { 
  }   
    @override
    public response intercept(chain chain) throws ioexception {   
    log.d("httpcommoninterceptor","add common params");   
        request oldrequest = chain.request();   
        // 添加新的参数，添加到url 中 
        /*httpurl.builder authorizedurlbuilder = oldrequest.url().newbuilder()     
        .scheme(oldrequest.url().scheme()) 
        .host(oldrequest.url().host());*/

      // 新的请求 
      request.builder requestbuilder =  oldrequest.newbuilder();
      requestbuilder.method(oldrequest.method(), oldrequest.body());

      //添加公共参数,添加到header中       
     if(mheaderparamsmap.size() > 0){     
          for(map.entry params:mheaderparamsmap.entryset()){ 
              requestbuilder.header(params.getkey(),params.getvalue());     
        }   
   }   
      request newrequest = requestbuilder.build(); 
      return chain.proceed(newrequest); 
  }  

  public static class builder{     
  httpcommoninterceptor mhttpcommoninterceptor;   
      public builder(){     
      mhttpcommoninterceptor = new httpcommoninterceptor();   
  }  

  public builder addheaderparams(string key, string value){     
      mhttpcommoninterceptor.mheaderparamsmap.put(key,value); 
      return this; 
  }    

  public builder  addheaderparams(string key, int value){ 
      return addheaderparams(key, string.valueof(value));
  }    

  public builder  addheaderparams(string key, float value){
      return addheaderparams(key, string.valueof(value)); 
  }

  public builder  addheaderparams(string key, long value){ 
      return addheaderparams(key, string.valueof(value));     
  }  

  public builder  addheaderparams(string key, double value){   
      return addheaderparams(key, string.valueof(value));   
  }

  public httpcommoninterceptor build(){
      return mhttpcommoninterceptor;   
  } 

  }
}

以上就是添加公共参数的拦截器，在 retrofitservicemanager 类里面加入okhttpclient 配置就好了。
代码如下：

// 添加公共参数拦截器
httpcommoninterceptor commoninterceptor = new httpcommoninterceptor.builder()   
      .addheaderparams("paltform","android") 
      .addheaderparams("usertoken","1234343434dfdfd3434")
      .addheaderparams("userid","123445")     
      .build();
builder.addinterceptor(commoninterceptor);

项目使用篇 —–>插入广告！本项目来源于金融研习社app，金融理财类的在线教育

项目是基于rxjava1
1.引入依赖：

compile 'com.squareup.retrofit2:retrofit:2.0.2'
compile 'com.squareup.retrofit2:converter-gson:2.0.2'
compile 'io.reactivex:rxandroid:1.2.0'
compile 'io.reactivex:rxjava:1.1.5'
compile 'com.squareup.retrofit2:adapter-rxjava:2.0.2'
compile 'com.squareup.okhttp3:logging-interceptor:3.5.0'

2.创建一个httpservice接口：

public interface httpservice {
/**
 * 获取用户详细资料
 */
@post("api/xxx/getuseralldetails")
observable getuseralldetails(@body getuseralldetailsrequestbean bean);

/**
 * @param apkurl 下载地址
 */
@get()
@streaming
call downloadnewapk(@url string apkurl);

/**
 * 获取推广大使分享图片
 */
@get("api/xxx/invitedimage")
observable getinvitedimage(@querymap map map);

}

3.创建http请求类，并在里面初始化并配置retrofit和okhttp:

public class httpmethods {
    public string tag = "httpmethods";
    public static final string cache_name = "xxx";
    public static string base_url = urlconstant.base_url;
    private static final int default_connect_timeout = 30;
    private static final int default_write_timeout = 30;
    private static final int default_read_timeout = 30;
    private retrofit retrofit;
    private httpservice httpservice;
    /**
     * 请求失败重连次数
     */
    private int retry_count = 0;
    private okhttpclient.builder okhttpbuilder;

    //构造方法私有
    private httpmethods() {
        //手动创建一个okhttpclient并设置超时时间
        okhttpbuilder = new okhttpclient.builder();

        /**
         * 设置缓存
         */
        file cachefile = new file(applicationcontext.context.getexternalcachedir(), cache_name);
        cache cache = new cache(cachefile, 1024 * 1024 * 50);
        interceptor cacheinterceptor = new interceptor() {
            @override
            public response intercept(chain chain) throws ioexception {
                request request = chain.request();
                if (!netutil.isnetworkconnected()) {
                    request = request.newbuilder()
                            .cachecontrol(cachecontrol.force_cache)
                            .build();
                }
                response response = chain.proceed(request);
                if (!netutil.isnetworkconnected()) {
                    int maxage = 0;
                    // 有网络时 设置缓存超时时间0个小时
                    response.newbuilder()
                            .header("cache-control", "public, max-age=" + maxage)
                            .removeheader(cache_name)// 清除头信息，因为服务器如果不支持，会返回一些干扰信息，不清除下面无法生效
                            .build();
                } else {
                    // 无网络时，设置超时为4周
                    int maxstale = 60 * 60 * 24 * 28;
                    response.newbuilder()
                            .header("cache-control", "public, only-if-cached, max-stale=" + maxstale)
                            .removeheader(cache_name)
                            .build();
                }
                return response;
            }
        };
        okhttpbuilder.cache(cache).addinterceptor(cacheinterceptor);


        /**
         * 设置头信息
         */
        interceptor headerinterceptor = new interceptor() {
            @override
            public response intercept(chain chain) throws ioexception {
                request originalrequest = chain.request();
                request.builder requestbuilder = originalrequest.newbuilder()
                        .addheader("accept-encoding", "gzip")
                        .addheader("accept", "application/json")
                        .addheader("content-type", "application/json; charset=utf-8")
                        .method(originalrequest.method(), originalrequest.body());
                requestbuilder.addheader("authorization", "bearer " + baseconstant.token);//添加请求头信息，服务器进行token有效性验证
                request request = requestbuilder.build();
                return chain.proceed(request);
            }
        };
        okhttpbuilder.addinterceptor(headerinterceptor);


//        if (buildconfig.debug) {
        httplogginginterceptor logginginterceptor = new httplogginginterceptor(new httplogginginterceptor.logger() {
            @override
            public void log(string message) {
                logger.d(message);
            }


        });
        logginginterceptor.setlevel(httplogginginterceptor.level.body);
        //设置 debug log 模式
        okhttpbuilder.addinterceptor(logginginterceptor);
//        }
        /**
         * 设置超时和重新连接
         */
        okhttpbuilder.connecttimeout(default_connect_timeout, timeunit.seconds);
        okhttpbuilder.readtimeout(default_write_timeout, timeunit.seconds);
        okhttpbuilder.writetimeout(default_read_timeout, timeunit.seconds);
        //错误重连
        okhttpbuilder.retryonconnectionfailure(true);


        retrofit = new retrofit.builder()
                .client(okhttpbuilder.build())
                .addconverterfactory(gsonconverterfactory.create())//json转换成javabean
                .addcalladapterfactory(rxjavacalladapterfactory.create())
                .baseurl(base_url)
                .build();
        httpservice = retrofit.create(httpservice.class);
    }

    //在访问httpmethods时创建单例
    private static class singletonholder {
        private static final httpmethods instance = new httpmethods();

    }

    //获取单例
    public static httpmethods getinstance() {
        return singletonholder.instance;
    }

    /**
     * 获取retrofit
     */
    public retrofit getretrofit() {
        return retrofit;
    }

    public void changebaseurl(string baseurl) {
        retrofit = new retrofit.builder()
                .client(okhttpbuilder.build())
                .addconverterfactory(gsonconverterfactory.create())
                .addcalladapterfactory(rxjavacalladapterfactory.create())
                .baseurl(baseurl)
                .build();
        httpservice = retrofit.create(httpservice.class);
    }

    /**
     * 获取httpservice
     */
    public httpservice gethttpservice() {
        return httpservice;
    }

     /**
     * 设置订阅 和 所在的线程环境
     */
    public  void tosubscribe(observable o, subscriber s) {

        o.subscribeon(schedulers.io())
                .unsubscribeon(schedulers.io())
                .observeon(androidschedulers.mainthread())
                .retry(retry_count)//请求失败重连次数
                .subscribe(s);

    }
}

4.设置回调：
调用者自己对请求数据进行处理 成功时 通过result是否等于1分别回调onsuccees和onfault，默认处理了401错误转登录。

public class onsuccessandfaultsub extends subscriber implements progresscancellistener {
    /**
     * 是否需要显示默认loading
     */
    private boolean showprogress = true;
    private onsuccessandfaultlistener monsuccessandfaultlistener;

    private context context;
    private waitprogressdialog progressdialog;

    /**
     * @param monsuccessandfaultlistener 成功回调监听
     */
    public onsuccessandfaultsub(onsuccessandfaultlistener monsuccessandfaultlistener) {
        this.monsuccessandfaultlistener = monsuccessandfaultlistener;
    }

    /**
     * @param monsuccessandfaultlistener 成功回调监听
      * @param context                    上下文
      */
    public onsuccessandfaultsub(onsuccessandfaultlistener monsuccessandfaultlistener, context context) {
        this.monsuccessandfaultlistener = monsuccessandfaultlistener;
        this.context = context;
        progressdialog = new waitprogressdialog(context, this);
    }

    /**
     * @param monsuccessandfaultlistener 成功回调监听
      * @param context                    上下文
      * @param showprogress               是否需要显示默认loading
     */
    public onsuccessandfaultsub(onsuccessandfaultlistener monsuccessandfaultlistener, context context, boolean showprogress) {
        this.monsuccessandfaultlistener = monsuccessandfaultlistener;
        this.context = context;
        progressdialog = new waitprogressdialog(context, this);
        this.showprogress = showprogress;
    }

    private void showprogressdialog() {
        if (showprogress && null != progressdialog) {
            progressdialog.show();
        }
    }

    private void dismissprogressdialog() {
        if (showprogress && null != progressdialog) {
            progressdialog.dismiss();
        }
    }

    /**
     * 订阅开始时调用
      * 显示progressdialog
     */
    @override
    public void onstart() {
        showprogressdialog();
    }

    /**
     * 完成，隐藏progressdialog
     */
    @override
    public void oncompleted() {
        dismissprogressdialog();
        progressdialog = null;
    }

    /**
     * 对错误进行统一处理
      * 隐藏progressdialog
     */
    @override
    public void onerror(throwable e) {
        try {

            if (e instanceof sockettimeoutexception) {//请求超时
            } else if (e instanceof connectexception) {//网络连接超时
                monsuccessandfaultlistener.onfault("网络连接超时");
            } else if (e instanceof sslhandshakeexception) {//安全证书异常
                monsuccessandfaultlistener.onfault("安全证书异常");
            } else if (e instanceof httpexception) {//请求的地址不存在
                int code = ((httpexception) e).code();
                if (code == 504) {
                    monsuccessandfaultlistener.onfault("网络异常，请检查您的网络状态");
                } else if (code == 404) {
                    monsuccessandfaultlistener.onfault("请求的地址不存在");
                } else {
                    monsuccessandfaultlistener.onfault("请求失败");
                }
            } else if (e instanceof unknownhostexception) {//域名解析失败
                monsuccessandfaultlistener.onfault("域名解析失败");
            } else {
                monsuccessandfaultlistener.onfault("error:" + e.getmessage());
            }
        } catch (exception e2) {
            e2.printstacktrace();
        } finally {
            log.e("onsuccessandfaultsub", "error:" + e.getmessage());
            dismissprogressdialog();
            progressdialog = null;

        }

    }

    /**
     * 当result等于1回调给调用者，否则自动显示错误信息，若错误信息为401跳转登录页面。
      */
    @override
    public void onnext(responsebody body) {
        try {
            final string result = compressutils.decompress(body.bytestream());
            log.e("body", result);
            jsonobject jsonobject = new jsonobject(result);
            int resultcode = jsonobject.getint("errorcode");
            if (resultcode == 1) {
                monsuccessandfaultlistener.onsuccess(result);
            } else {
                string errormsg = jsonobject.getstring("errormessage");
                monsuccessandfaultlistener.onfault(errormsg);
                log.e("onsuccessandfaultsub", "errormsg: " + errormsg);
            }
        } catch (exception e) {
            e.printstacktrace();
        }
    }

    /**
     * 取消progressdialog的时候，取消对observable的订阅，同时也取消了http请求
      */
    @override
    public void oncancelprogress() {
        if (!this.isunsubscribed()) {
            this.unsubscribe();
        }
    }
}

 *请求服务loading关闭监听 
 */
public interface progresscancellistener {
    void oncancelprogress();
}

5.请求的用法：
建议分类成不同的api，以便快速查找
api里面进行观察者和被观察者的订阅

private void getuserdata() {
    onsuccessandfaultlistener l = new onsuccessandfaultlistener() {
        @override
        public void onsuccess(string result) {//成功回调
            yxspreference.setuserdata(result);
            userdatabean = gsonutils.fromjson(result, userdetailresponsebean.class);
            fulldata();
        }

        @override
        public void onfault(string errormsg) {//失败的回调
            snackbarmanager.showshortmsg(getactivity(), errormsg);
        }
    };

    userapi.getuseralldetails(new onsuccessandfaultsub(l) , yxspreference.getmemberid()
    );
}

onsuccessandfaultsub 继承 subscriber

public class userapi {
    /**
     * 获取用户详细信息
     */
    public static void getuseralldetails(subscriber subscriber, int memberid) {
        getuseralldetailsrequestbean bean = new getuseralldetailsrequestbean();
        bean.getdata().setmemberid(memberid);
        observable observable = httpmethods.getinstance().gethttpservice().getuseralldetails(bean); //在httpserver中
        httpmethods.getinstance().tosubscribe(observable, subscriber);
    }
}