Rxjava2结合Retrofit

https://blog.csdn.net/carson_ho/article/details/79125101

嵌套请求API:

    /**
     * 嵌套请求API,先查询市区ID,再修改资料,在查询更新本地资料
     *
     * @param provincesId 省份ID
     * @param city        城市名(去掉后缀的名与地区)
     * @param map         修改资料
     */
    public void personalinst(final String provincesId, final String city, final Map<String, String> map) {
        eventMsg.setType("personalinst");
        Observable<ResultsMsg<CityId>> getCityId = RequestManagers.getRetrofit().getCityId("1", provincesId);
        personalinst = RequestManagers.getRetrofit().personalinst(map);
        personalsel = RequestManagers.getRetrofit().personalsel(map.get("UserID"));
        getCityId.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .doOnNext(resultsMsg -> {
                    //第一个请求成功
                    //得到市区ID列表
                    CityId cityId = (CityId) resultsMsg.getData();
                    for (CityId.Data data : cityId.getList()) {
                        if (data.getTxtarea().contains(city)) {
                            map.put("CityID", data.getId());
                            map.put("ProvinceID", provincesId);
                            break;
                        }
                    }
                })
                .observeOn(Schedulers.io())
                .concatMap(resultsMsg -> {
                    // 将网络请求1转换成网络请求2，即发送网络请求2
                    return personalinst;
                })
                .concatMap(resultsMsg -> {
                    // 将网络请求2转换成网络请求3，即发送网络请求3
                    return personalsel;
                })
                .observeOn(AndroidSchedulers.mainThread())  // （初始观察者）切换到主线程 处理网络请求2的结果
                .subscribe(new Consumer<ResultsMsg<DetailedUserInfo>>() {
                    @Override
                    public void accept(ResultsMsg<DetailedUserInfo> result) throws Exception {
                        Log.d(TAG, "第3次网络请求成功");
                        eventMsg.setMessage(String.valueOf(result.getState()).equals("1") ? CannotLittle.SUCCESS : result.getMessage());
                        DataHolder.getInstance().detailedUserInfo = (DetailedUserInfo) result.getData();
                        EventBus.getDefault().post(eventMsg);
                    }
                }, throwable -> {
                    eventMsg.setMessage(((Throwable) throwable).getMessage());
                    EventBus.getDefault().post(eventMsg);
                });
        
    }

请求失败重连: 

/**
     * 非后台抛的错误,请求失败会重连
     */
    protected void onDataReconnection(Observable observable) {
        currentRetryCount = 0;
        waitRetryTime = 0;
        observable.retryWhen(new Function<Observable<Throwable>, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(@NonNull Observable<Throwable> throwableObservable) throws Exception {
                // 参数Observable<Throwable>中的泛型 = 上游操作符抛出的异常，可通过该条件来判断异常的类型
                return throwableObservable.flatMap(new Function<Throwable, ObservableSource<?>>() {
                    @Override
                    public ObservableSource<?> apply(@NonNull Throwable throwable) throws Exception {
                        /**
                         * 需求1：根据异常类型选择是否重试
                         * 即，当发生的异常 = 网络异常 = IO异常 才选择重试
                         */
                        if (throwable instanceof IOException) {
                            //限制重试次数
                            if (currentRetryCount < Request.maxConnectCount) {
                                // 记录重试次数
                                currentRetryCount++;
                                Log.d("BaseData", "重试次数 = " + currentRetryCount);
                                //延迟请求,遇到的异常越多，延迟时间越长
                                waitRetryTime = currentRetryCount * 1000;
                                Log.d("BaseData", "等待时间 =" + waitRetryTime);
                                return Observable.just(1).delay(waitRetryTime, TimeUnit.MILLISECONDS);
                            } else {
                                // 若重试次数已 > 设置重试次数，则不重试
                                // 通过发送error来停止重试（可在观察者的onError（）中获取信息）
                                return Observable.error(new Throwable("网络异常"));
                            }
                        } else {
                            return Observable.error(throwable);
                        }
                    }
                });
            }
        })
                .subscribeOn(Schedulers.io())               // 在IO线程进行网络请求
                .observeOn(AndroidSchedulers.mainThread())  // 回到主线程 处理请求结果
                .subscribe(new Consumer<ResultsMsg>() {
                    @Override
                    public void accept(ResultsMsg results) throws Exception {
                        //结果进行处理
                        resultReduction(results);
                    }
                }, throwable -> {
                    //返回错误信息
                    eventMsg.setMessage(((Throwable) throwable).getMessage());
                    EventBus.getDefault().post(eventMsg);
                });
    }

 请求数据:

   protected void onData(Observable observable) {
        observable.subscribeOn(Schedulers.io())               // 在IO线程进行网络请求
                .observeOn(AndroidSchedulers.mainThread())  // 回到主线程 处理请求结果
                .subscribe(results -> {
                    //结果进行处理
                    resultReduction((ResultsMsg) results);
                }, throwable -> {
                    //返回错误信息
                    eventMsg.setMessage(((Throwable) throwable).getMessage());
                    EventBus.getDefault().post(eventMsg);
                });
    }

    /**
     * 对返回成功做处理
     *
     * @param results 返回数据
     */
    private void resultReduction(ResultsMsg results) {
        //结果进行处理
        if (String.valueOf(results.getState()).equals("1")) {
            eventMsg.setMessage(CannotLittle.SUCCESS);
            eventMsg.setData(results.getData());
            //是否需要保存数据
            if (isSaveData != null)
                isSaveData.onSave(eventMsg);
        } else {
            eventMsg.setMessage(results.getMessage());
        }
        EventBus.getDefault().post(eventMsg);
    }

POST请求:

需要设置表单的提交类型为FormUrlEncoded，否则提交的参数会拼接到URL里
单个参数是@Field("phone") String phone，Map参数是@FieldMap Map<String, String> map
    @POST(API.ADD_JOBS)
    @FormUrlEncoded
    Observable<ResultsMsg> addJobs(@FieldMap Map<String, String> map);

动态设置Url:

在请求参数里设置@Url
    /**
     * 发送验证码
     */
    @GET
    Observable<ResultsMsg> sendCode(@Url String url,@Query("mobile") String mobile);
注意事项：
设置@Url以后，请求参数里不能再配合@Path注解去填补缺省值了，必须要在url里给全，但是可以配合@Query等使用