RxJava 全局异常处理：低成本打造无忧网络请求

2023-10-18 18:54:43

在 RxJava + Retrofit 进行网络请求时，如果你没有使用全局异常处理机制，那么你的代码很可能陷入 "回调地狱" 的陷阱。这种代码结构嵌套层级过多，可读性差，而且难以维护。

为了解决这个问题，我们可以使用 RxJava 的链式调用特性，在网络请求的链式调用中统一处理异常。具体来说，我们可以使用 Observable.onErrorResumeNext() 或 Observable.onErrorReturn() 操作符来实现全局异常处理。

使用 `Observable.onErrorResumeNext()` 操作符

Observable.onErrorResumeNext() 操作符允许你在遇到异常时继续执行链式调用。它接受一个 Observable 工厂作为参数，该工厂将在遇到异常时生成一个新的 Observable。

Observable<String> observable = Observable.create(emitter -> {
    try {
        // 执行网络请求
        String result = doNetworkRequest();
        emitter.onNext(result);
        emitter.onComplete();
    } catch (Exception e) {
        emitter.onError(e);
    }
});

observable.onErrorResumeNext(throwable -> {
    // 在遇到异常时执行的代码
    return Observable.just("默认值");
})
.subscribe(result -> {
    // 处理成功的结果
}, error -> {
    // 处理异常
});

在上面的代码中，onErrorResumeNext() 操作符会在遇到异常时生成一个新的 Observable，该 Observable 会发出一个默认值 "默认值"。这样，即使网络请求失败，你仍然可以继续执行链式调用，并处理默认值。

使用 `Observable.onErrorReturn()` 操作符

Observable.onErrorReturn() 操作符类似于 Observable.onErrorResumeNext()，但它接受一个函数作为参数，该函数将在遇到异常时返回一个值。

Observable<String> observable = Observable.create(emitter -> {
    try {
        // 执行网络请求
        String result = doNetworkRequest();
        emitter.onNext(result);
        emitter.onComplete();
    } catch (Exception e) {
        emitter.onError(e);
    }
});

observable.onErrorReturn(throwable -> {
    // 在遇到异常时返回的默认值
    return "默认值";
})
.subscribe(result -> {
    // 处理成功的结果
}, error -> {
    // 处理异常
});

在上面的代码中，onErrorReturn() 操作符会在遇到异常时返回一个默认值 "默认值"。这样，即使网络请求失败，你仍然可以继续执行链式调用，并处理默认值。

自定义全局异常处理机制

除了使用 RxJava 内置的操作符之外，你还可以自定义一个全局异常处理机制。这种机制可以根据不同的异常类型，做出不同的处理。

public class GlobalErrorTransformer<T> implements ObservableTransformer<T, T> {

    @Override
    public Observable<T> apply(Observable<T> upstream) {
        return upstream.onErrorResumeNext(throwable -> {
            if (throwable instanceof NetworkException) {
                // 处理网络异常
                return Observable.error(new NetworkException());
            } else if (throwable instanceof ServerException) {
                // 处理服务器异常
                return Observable.error(new ServerException());
            } else {
                // 处理其他异常
                return Observable.error(throwable);
            }
        });
    }
}

在上面的代码中，我们创建了一个自定义的 GlobalErrorTransformer，它可以根据异常类型做出不同的处理。然后，我们可以使用 compose() 操作符将这个 Transformer 应用到我们的 Observable 中。

Observable<String> observable = Observable.create(emitter -> {
    try {
        // 执行网络请求
        String result = doNetworkRequest();
        emitter.onNext(result);
        emitter.onComplete();
    } catch (Exception e) {
        emitter.onError(e);
    }
});

observable.compose(new GlobalErrorTransformer<>())
.subscribe(result -> {
    // 处理成功的结果
}, error -> {
    // 处理异常
});