RxJava for Android：公开异常并重试（延迟）

我可以观察到以下情况，每30秒执行一次改装的REST调用：

 Subscription subscription = Observable.interval(0, REFRESH_INTERVAL, TimeUnit.SECONDS)
        .concatMap(new Func1<Long, Observable<Response>>() {
           @Override
           public Observable<Response> call(Long time) {
              return webservice.callRetrofitServiceWithRx(parameter);
           }
        })
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new UpdateSuccessAction(), new UpdateErrorAction());

Subscription-Subscription=Observable.interval（0，刷新间隔，时间单位：秒）
.concatMap（新函数1（）{
@凌驾
公共可观察呼叫（长时间）{
返回webservice.callServiceWithRx（参数）；
}
})
.subscribeOn（Schedulers.io（））
.observeOn（AndroidSchedulers.mainThread（））
.subscribe（new UpdateSuccessAction（），new UpdateErrorAction（））；

可能（尤其是REST调用）会引发异常（例如，没有internet连接）

我想要实现的目标：

Observable应该发出/公开异常，这样我就可以在UI上显示错误消息，但它应该继续发出项目（30秒后重试）

当前研究

• 如果我没有定义任何特殊行为，可观察对象将发出异常并停止工作（=30秒内没有重试）

• 如果我尝试重试操作符，异常将被忽略而不会暴露，因此我无法在ui中显示错误

• 如果我尝试onErrorReturn操作符，我可以处理异常，但据我所知，不可能重试

解决方法

我目前的解决方法是重新订阅这个可观察的，但我想知道是否有人有更优雅的解决方案

我假设它能满足您（记录错误）的需要，再加上重试，例如：

Subscription subscription = Observable.interval(0, REFRESH_INTERVAL, TimeUnit.SECONDS)
    .concatMap(new Func1<Long, Observable<Response>>() {
       @Override
       public Observable<Response> call(Long time) {
          return webservice.callRetrofitServiceWithRx(parameter);
       }
    })
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .doOnError(new UpdateErrorAction())
    .retry()
    .subscribe(new UpdateSuccessAction());

Subscription-Subscription=Observable.interval（0，刷新间隔，时间单位：秒）
.concatMap（新函数1（）{
@凌驾
公共可观察呼叫（长时间）{
返回webservice.callServiceWithRx（参数）；
}
})
.subscribeOn（Schedulers.io（））
.observeOn（AndroidSchedulers.mainThread（））
.doError（新的UpdateErrorAction（））
.重试（）
.subscribe（new UpdateSuccessAction（））；

如果找到解决方案，请借助另一个答案

首先，我定义了一个RetryWithDelay函数，它在30秒后而不是立即开始重试

 private static class RetryWithDelay
     implements Func1<Observable<? extends Throwable>, Observable<?>> {

  @Override
  public Observable<?> call(Observable<? extends Throwable> attempts) {
     return attempts.flatMap(new Func1<Throwable, Observable<?>>() {
        @Override
        public Observable<?> call(Throwable throwable) {
           return Observable.timer(CallBO.REFRESH_INTERVAL_IN_SEC,             }
     });
  }
}

private static class RetryWithDelay
执行功能1>{
@凌驾
公共可观察呼叫（可观察>（）{
@凌驾
公共可观察呼叫（可丢弃可丢弃）{
返回Observable.timer（CallBO.REFRESH\u INTERVAL\u以秒为单位，}
});
}
}

然后我在这个可观察链中使用：

Subscription subscription = Observable.interval(0, REFRESH_INTERVAL, TimeUnit.SECONDS)
.concatMap(new Func1<Long, Observable<Response>>() {
   @Override
   public Observable<Response> call(Long time) {
      return webservice.callRetrofitServiceWithRx(parameter);
   }
})
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.doOnError(new UpdateErrorAction())
.retryWhen(new RetryWithDelay())
.subscribe(new UpdateSuccessAction());

Subscription-Subscription=Observable.interval（0，刷新间隔，时间单位：秒）
.concatMap（新函数1（）{
@凌驾
公共可观察呼叫（长时间）{
返回webservice.callServiceWithRx（参数）；
}
})
.subscribeOn（Schedulers.io（））
.observeOn（AndroidSchedulers.mainThread（））
.doError（新的UpdateErrorAction（））
.retryWhen（新RetryWithDelay（））
.subscribe（new UpdateSuccessAction（））；