检查订阅服务器中错误消息的RxJava通用方法

Question

在我的Android项目中，我执行了很多网络请求（使用reverfit和rxjava)，这些请求作为响应返回一个自定义的响应超类型，它可以由有效响应或错误响应组成。

AppResponse {  
   error=AppError {  
      code=12345,
      message='null'
   },
   data=null
}

错误代码不是HTTP错误代码，而是通过使用SimpleXML解析XML结果检索到的内容。大约有4-5个错误代码对所有网络请求都是相同的，例如会话超时。因此，我将编写一个泛型方法，检查所有响应中的错误代码，并设置对策，如请求一个新会话。

首先，我考虑使用OKHTTP拦截器，但因为我需要将结果解析为正确的格式，所以无法使用它。在解析结果之后，我正在使用rxjava，目前我正在subscribe方法中检查结果的响应。

    restClient.requestHostList()
            .subscribeOn(Schedulers.io())
            .unsubscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Subscriber<HostListResponse>() {

                @Override
                public void onError() {

                }
                @Override
                public void onCompleted() {

                }

                @Override
                public void onNext(HostListResponse hostListResponse) {
                    if (hostListResponse.isError()) {

                        if(hostListResponse.getError().getCode() == 12345) {
                            requestNewSession();
                        } else if(hostListResponse.getError().getCode() == 23456) {
                            requestNewLogin();
                        }
                   else {
                            //do some UI stuff here
                        }

我不确定如何继续这里，有类似转换器的东西可以在subscribe中使用来验证结果并可能启动另一个网络请求，还是在到达订阅者之前启动它更好？我还在想，如果onErrorResumeNext（）是一个选项，当Observable未通过结果代码测试时，它会抛出一个错误，如下所示：

restClient.requestHostList()
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .flatMap(new Func1<HostListResponse, Observable<Throwable>>() {
                    @Override
                    public Observable<Throwable> call(HostListResponse hostListResponse) {
                        if (hostListResponse.isError()) {
                            if(hostListResponse.getError().getCode() == 12345) {
                                throw new Exception();
                            }
                        }
                    }
                })
                .onErrorResumeNext(new Func1<Throwable, Observable<? extends Throwable>>() {
                    //do error handling here
                })

Answer 1

最后一个解决方案是可以的。在错误情况下抛出异常是绝对正常的行为。您可以使用compose运算符来包装错误处理逻辑，并将其与所有可观察到的改型内容一起重用：

static final int NO_ERROR = 0;
static final int ERROR_A = 13;
static final int ERROR_B = 666;

Observable<BaseResponse> responseObservable = Observable.create(new Observable.OnSubscribe<BaseResponse>() {
    @Override
    public void call(Subscriber<? super BaseResponse> subscriber) {
        subscriber.onNext(new BaseResponse(ERROR_A));
        //subscriber.onNext(new BaseResponse(ERROR_B));
        //subscriber.onNext(new BaseResponse(NO_ERROR));
        subscriber.onCompleted();
    }
});

responseObservable
        .compose(Utils.applyErrorHandler())//apply to this observable error handling logic
        .subscribe(baseResponse -> {
            System.out.println("ok");
        }, throwable -> {
            System.out.println("error:" + throwable);
        });

处理错误的Utils类：

public static class Utils {
    static Observable.Transformer schedulersTransformer = new Observable.Transformer<BaseResponse, BaseResponse>() {
        @Override
        public Observable<BaseResponse> call(Observable<BaseResponse> observable) {
            return observable.doOnNext(baseResponse -> {
                if (baseResponse.errorCode == ERROR_A) {
                    throw new RuntimeException("Error A");
                } else if (baseResponse.errorCode == ERROR_B) {
                    throw new RuntimeException("Error B");
                }
            });
        }
    };

    @SuppressWarnings("unchecked")
    public static <T> Observable.Transformer<T, T> applyErrorHandler() {
        return (Observable.Transformer<T, T>) schedulersTransformer;
    }
}

其基本思想是对observable应用transformer函数，对每个项目调用doonnext，检查错误代码并抛出相应的异常。在我的示例中，utils被包装到静态帮助器类中，但这取决于您的需求，transformer函数可以通过dagger注入，并替换为例如测试转换函数。

您可以在Dan Lew博客文章中阅读关于compose运算符的更多信息：http://blog.danlew.net/2015/03/02/dont-break-the-chain/