Android RxJava 错误处理与重试机制详解

Android RxJava 错误处理与重试机制详解

前言

在Android开发中，RxJava因其强大的异步编程能力和响应式编程范式而广受欢迎。然而，网络请求、文件IO等操作难免会遇到错误和异常，如何优雅地处理这些错误并实现合理的重试机制，是每个开发者都需要掌握的技能。本文将深入探讨RxJava中的错误处理与重试机制。

一、RxJava错误处理基础

1.1 Observer中的onError

最基本的错误处理方式是在Observer中实现onError方法：

java

observable.subscribe(new Observer<String>() {
    @Override
    public void onSubscribe(Disposable d) {}

    @Override
    public void onNext(String s) {
        // 处理正常数据
    }

    @Override
    public void onError(Throwable e) {
        // 处理错误
        if (e instanceof IOException) {
            showToast("网络错误");
        } else if (e instanceof NullPointerException) {
            showToast("数据解析错误");
        }
    }

    @Override
    public void onComplete() {}
});

1.2 Consumer形式的错误处理

对于简化版的订阅，可以使用Consumer来处理错误：

java

observable.subscribe(
    data -> handleData(data),  // onNext
    throwable -> handleError(throwable)  // onError
);

二、RxJava操作符错误处理

2.1 onErrorReturn

当发生错误时，返回一个默认值：

java

observable
    .onErrorReturn(throwable -> {
        if (throwable instanceof IOException) {
            return "default value";
        }
        return "unknown error";
    })
    .subscribe(...);

2.2 onErrorResumeNext

当发生错误时，切换到另一个Observable：

java

observable
    .onErrorResumeNext(throwable -> {
        if (throwable instanceof SocketTimeoutException) {
            return Observable.just("从缓存获取的数据");
        }
        return Observable.error(throwable);
    })
    .subscribe(...);

2.3 onExceptionResumeNext

类似于onErrorResumeNext，但只在遇到Exception时切换，不处理Error：

java

observable
    .onExceptionResumeNext(Observable.just("fallback data"))
    .subscribe(...);

三、RxJava重试机制

3.1 retry()

最简单的重试，遇到错误就无限重试：

java

observable.retry().subscribe(...);

3.2 retry(long count)

指定重试次数：

java

observable.retry(3).subscribe(...); // 最多重试3次

3.3 retry(Predicate predicate)

根据条件决定是否重试：

java

observable.retry(throwable -> {
    if (throwable instanceof SocketTimeoutException) {
        return true; // 超时则重试
    }
    return false; // 其他错误不重试
}).subscribe(...);

3.4 retryWhen

更灵活的重试机制，可以控制重试的延迟和次数：

java

observable.retryWhen(throwableObservable -> 
    throwableObservable.flatMap(throwable -> {
        if (throwable instanceof IOException) {
            return Observable.timer(1, TimeUnit.SECONDS); // 延迟1秒后重试
        }
        return Observable.error(throwable); // 其他错误不重试
    }))
    .subscribe(...);

四、高级重试策略

4.1 指数退避重试

网络请求常用策略，重试间隔随时间指数增长：

java

observable.retryWhen(throwableObservable -> 
    throwableObservable
        .zipWith(Observable.range(1, 3), (throwable, retryCount) -> {
            if (retryCount > 3) {
                throw Exceptions.propagate(throwable);
            }
            return retryCount;
        })
        .flatMap(retryCount -> Observable.timer((long) Math.pow(2, retryCount), TimeUnit.SECONDS))
    ))
    .subscribe(...);

4.2 带最大重试次数的延迟重试

java

private Observable<Long> getRetryObservable() {
    final int maxRetries = 3;
    final long initialDelay = 1;
    final TimeUnit unit = TimeUnit.SECONDS;
    
    return Observable.range(1, maxRetries)
        .flatMap(retryCount -> Observable.timer(initialDelay * retryCount, unit));
}

observable.retryWhen(throwableObservable -> 
    throwableObservable
        .flatMap(throwable -> {
            if (throwable instanceof IOException) {
                return getRetryObservable();
            }
            return Observable.error(throwable);
        }))
    .subscribe(...);

五、全局错误处理

5.1 RxJavaPlugins.setErrorHandler

设置全局错误处理器，捕获未被处理的错误：

java

RxJavaPlugins.setErrorHandler(throwable -> {
    if (throwable instanceof UndeliverableException) {
        // RxJava无法传递的异常
        Log.e("RxJava", "Undeliverable exception", throwable);
    } else {
        // 其他未捕获异常
        Thread.currentThread().getUncaughtExceptionHandler()
            .uncaughtException(Thread.currentThread(), throwable);
    }
});

六、实际应用示例

6.1 网络请求重试

java

@GET("api/data")
Observable<Data> fetchData();

// 使用
apiService.fetchData()
    .retryWhen(throwableObservable -> 
        throwableObservable
            .zipWith(Observable.range(1, 3), (throwable, retryCount) -> {
                if (retryCount > 3) {
                    throw Exceptions.propagate(throwable);
                }
                return retryCount;
            })
            .flatMap(retryCount -> Observable.timer(retryCount, TimeUnit.SECONDS))
    )
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(
        data -> updateUI(data),
        throwable -> showError(throwable)
    );

6.2 结合Room数据库的缓存策略

java

// 先从网络获取，失败后从数据库获取缓存
apiService.fetchData()
    .onErrorResumeNext(throwable -> {
        if (throwable instanceof IOException) {
            return database.dataDao().getCachedData().toObservable();
        }
        return Observable.error(throwable);
    })
    .subscribe(...);

七、注意事项

1. 内存泄漏：长时间的重试可能导致内存泄漏，确保在Activity/Fragment销毁时取消订阅

2. 线程安全：重试操作默认在相同的线程执行，确保线程安全

3. 副作用：重试可能导致操作重复执行，确保操作具有幂等性

4. 性能影响：过多的重试会影响性能和电池寿命，合理设置重试次数和间隔

结语

RxJava提供了丰富的错误处理和重试机制，合理使用这些功能可以显著提升应用的健壮性和用户体验。在实际开发中，应根据具体场景选择合适的策略，并注意处理好边界条件和资源释放问题。

希望本文能帮助你更好地理解和使用RxJava的错误处理与重试机制！