RxJava+retrifit->BaseObservable用于集中式响应处理的API调用

Question

例如：对于来自服务器的特定错误代码，我在响应正文中接收一个新的Auth令牌，刷新该令牌，然后克隆。当然，服务器的响应还有其他几个全局行为。

当前解决方案（不含Rx）：

    public abstract void onResponse(Call<T> call, Response<T> response, boolean isSuccess);

    public abstract void onFailure(Call<T> call, Response<T> response, Throwable t, boolean isTimeout);

    @Override
    public void onResponse(Call<T> call, Response<T> response) {
        if (_isCanceled) return;

        if (response != null && !response.isSuccessful()) {
            if (response.code() == "SomeCode" && retryCount < RETRY_LIMIT) {
                TokenResponseModel newToken = null;
                try {
                    newToken = new Gson().fromJson(new String(response.errorBody().bytes(), "UTF-8"), TokenResponseModel.class);
                } catch (Exception e) {
                    e.printStackTrace();
                }

                    SomeClass.token = newToken.token;
                    retryCount++;
                    call.clone().enqueue(this);
                    return;
                }
            }
        } else {
            onResponse(call, response, true);
            removeFinishedRequest();
            return;
        }

        onFailure(call, response, null, false);
        removeFinishedRequest();
    }

    @Override
    public void onFailure(Call<T> call, Throwable t) {
        if (_isCanceled) return;

        if (t instanceof UnknownHostException)
            if (eventBus != null)
                eventBus.post(new NoConnectionErrorEvent());

        onFailure(call, null, t, false);
        removeFinishedRequest();
    }

我的问题是：在最终链接（或重试）回订阅服务器方法之前，有没有什么方法可以实现这种集中式响应处理行为？

Answer 1

您提供的两个链接是一个非常好的起点，我用来构造解决方案来应对意外

• 有时由于暂时缺乏网络连接而发生网络错误，或者切换到低穿透网络标准（如EDGE)，这会导致SocketTimeoutException
• 服务器错误->有时由于服务器过载而发生

我已经重写了calladapter.Factory来处理错误并对它们做出适当的反应。

重写calladapter.Factory以处理错误：

public class RxCallAdapterFactoryWithErrorHandling extends CallAdapter.Factory {
    private final RxJavaCallAdapterFactory original;

    public RxCallAdapterFactoryWithErrorHandling() {
        original = RxJavaCallAdapterFactory.create();
    }

    @Override
    public CallAdapter<?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
        return new RxCallAdapterWrapper(retrofit, original.get(returnType, annotations, retrofit));
    }

    public class RxCallAdapterWrapper implements CallAdapter<Observable<?>> {
        private final Retrofit retrofit;
        private final CallAdapter<?> wrapped;

        public RxCallAdapterWrapper(Retrofit retrofit, CallAdapter<?> wrapped) {
            this.retrofit = retrofit;
            this.wrapped = wrapped;
        }

        @Override
        public Type responseType() {
            return wrapped.responseType();
        }

        @SuppressWarnings("unchecked")
        @Override
        public <R> Observable<?> adapt(final Call<R> call) {
            return ((Observable) wrapped.adapt(call)).onErrorResumeNext(new Func1<Throwable, Observable>() {
                @Override
                public Observable call(Throwable throwable) {
                    Throwable returnThrowable = throwable;
                    if (throwable instanceof HttpException) {
                        HttpException httpException = (HttpException) throwable;
                        returnThrowable = httpException;
                        int responseCode = httpException.response().code();
                        if (NetworkUtils.isClientError(responseCode)) {
                            returnThrowable = new HttpClientException(throwable);
                        }
                        if (NetworkUtils.isServerError(responseCode)) {
                            returnThrowable = new HttpServerException(throwable);
                        }
                    }

                    if (throwable instanceof UnknownHostException) {
                        returnThrowable = throwable;
                    }

                    return Observable.error(returnThrowable);
                }
            }).retryWhen(new RetryWithDelayIf(3, DateUtils.SECOND_IN_MILLIS, new Func1<Throwable, Boolean>() {
                @Override
                public Boolean call(Throwable throwable) {
                    return throwable instanceof HttpServerException
                            || throwable instanceof SocketTimeoutException
                            || throwable instanceof UnknownHostException;
                }
            }));
        }
    }
}

HttpServerException只是一个自定义异常。

在retrofit.builder中使用它

Retrofit retrofit = new Retrofit.Builder()
        .addCallAdapterFactory(new RxCallAdapterFactoryWithErrorHandling())
        .build();