Android 使用RxJava+Retrofit 2.0合并网络请求

在开发验证码的功能时，要求验证code的同时判断这个是不是服务码（服务人员专用），这个就需要同时去请求两个接口，只要有一个功能就算成功，不再执行两个接口。

这个问题可以使用RxJava的flatmap完成一次嵌套请求，有一点需要注意的是，我们需要在第一个接口调用失败的情况下，去请求第二个接口，我们先去验证验证码，再验证服务码。

    @Override
    public void checkConfirmCode(String deviceId, String code, OnAPIListener<ConfirmCodeEntity> listener) {

        Map<String, Object> map = new HashMap<>();
        map.put("equ_code", deviceId);
        map.put("confirm_code", code);

        Call<ConfirmCodeEntity> call = api.checkConfirmCode(map);
        call.enqueue(new Callback<ConfirmCodeEntity>() {

            @Override
            public void onResponse(Call<ConfirmCodeEntity> call, Response<ConfirmCodeEntity> response) {
                if(response.body()==null){
                    return;
                }
                LogUtil.e("httpclient checkConfirmCode success:"+response.body());
            }

            @Override
            public void onFailure(Call<ConfirmCodeEntity> call, Throwable t) {
                LogUtil.e("httpclient checkConfirmCode fail:"+t.getMessage());

            }
        });
    }

    @Override
    public void checkEquPassword(String deviceId, String code, final OnAPIListener<ConfirmPasswordEntity> listener) {

        Map<String, Object> map = new HashMap<>();
        map.put("equ_code", deviceId);
        map.put("equ_password", code);

        Call<ConfirmPasswordEntity> call = api.checkEquPassword(map);
        call.enqueue(new Callback<ConfirmPasswordEntity>() {

            @Override
            public void onResponse(Call<ConfirmPasswordEntity> call, Response<ConfirmPasswordEntity> response) {
                if(response.body()==null){
                    return;
                }
                LogUtil.e("httpclient checkConfirmCode success:"+response.body());
                listener.onSuccess(response.body());
            }

            @Override
            public void onFailure(Call<ConfirmPasswordEntity> call, Throwable t) {
                LogUtil.e("httpclient checkConfirmCode fail:"+t.getMessage());
                listener.onError(t);
            }
        });
    }

    /**
     * 验证四位验证码
     * @return
     */
    @Headers({"Accept:application/x.vr.v1.0.1+json","Authorization:*****"})
    @POST("bus/checkconfirmcode")
    @FormUrlEncoded
    Call<ConfirmCodeEntity> checkConfirmCode(@FieldMap Map<String, Object> map);

    /**
     * 验证四位密码
     * @return
     */
    @Headers({"Accept:application/x.vr.v1.0.1+json","Authorization:*****"})
    @POST("bus/checkequpassword")
    @FormUrlEncoded
    Call<ConfirmPasswordEntity> checkEquPassword(@FieldMap Map<String, Object> map);

我们看到有两个接口，一个是验证码接口，一个是密码接口，传参是相同的，网络请求map略有不同，一个是“equ_password”，一个是“equ_code”。我们看到改造之前是单独使用retrofit 2.0进行封装的。

    /**
     * 验证四位验证码
     * @return
     */
    @POST("bus/checkconfirmcode")
    Observable<ConfirmCodeEntity> checkConfirmCode(@Query("equ_code") String deviceId, @Query("confirm_code") String code);

    /**
     * 验证四位验证码
     * @return
     */
    @POST("bus/checkequpassword")
    Observable<ConfirmPasswordEntity> checkEquPassword(@Query("equ_code") String deviceId,  @Query("equ_password") String code);

    compile 'com.squareup.retrofit2:adapter-rxjava:2.2.0'
    compile 'io.reactivex:rxandroid:1.2.1'

使用RxJava之前要在gradle中配置，这里要特别说明一下，retrofit 2.0对RxJava2的支持存在兼容性问题，会报出一个重复包的问题。

    @Override
    public void checkConfirmCode(final String deviceId, final String code, final OnAPIListener<ConfirmCodeEntity> listener) {


        api.checkConfirmCode(deviceId, code)
                .flatMap(new Func1<ConfirmCodeEntity, Observable<ConfirmPasswordEntity>>() {
                    @Override
                    public Observable<ConfirmPasswordEntity> call(ConfirmCodeEntity entity) {
                        LogUtil.i("checkConfirmCode:"+entity.toString());

                        if("ok".equals(entity.getSuccess())){

                            listener.onSuccess(entity);

                            return null;
                        }

                        return api.checkEquPassword(deviceId, code);
                    }
                })
                .subscribeOn(Schedulers.newThread())//请求在新的线程中执行请求
                .observeOn(Schedulers.io())         //请求完成后在io线程中执行
                .doOnNext(new Action1<ConfirmPasswordEntity>() {
                    @Override
                    public void call(ConfirmPasswordEntity entity) {
                        LogUtil.i("doNext");
                    }
                })
                .observeOn(AndroidSchedulers.mainThread())//观察者在UI线程，方便UI线程处理回调
                .subscribe(new Observer<ConfirmPasswordEntity>() {

                    @Override
                    public void onNext(ConfirmPasswordEntity entity) {
                        //完成一次完整的登录请求
                        LogUtil.i("checkConfirmCode onNext:"+entity.toString());
                        if("ok".equals(entity.getSuccess())){

                            final ConfirmCodeEntity confirmCodeEntity = new ConfirmCodeEntity();
                            confirmCodeEntity.setSuccess(entity.getSuccess());
                            confirmCodeEntity.setPlay_time(entity.getPlay_time());
                            confirmCodeEntity.setClient_id("");
                            confirmCodeEntity.setPay_id("");

                            listener.onSuccess(confirmCodeEntity);
                        }
                    }

                    @Override
                    public void onCompleted() {
                        LogUtil.i("checkConfirmCode onCompleted");
                    }

                    @Override
                    public void onError(Throwable error) {
                        //请求失败
                        LogUtil.i("checkConfirmCode onError:"+error.getMessage());
                    }

                });

    }