RxJava-检查条件并仅在条件为真时重复一次

我使用

RxJava+reformation

在我的Android应用程序中进行API调用。当用户发出请求并且其令牌过期时，可能会出现这种情况。在这种情况下，我会在我的

onNext

中收到一个正常的响应，但响应中不包含结果，而是包含一个带有某些代码的错误元素。如果发生这种情况，我需要重新登录用户，只有在获得新的令牌后，才能重复原始请求。 所以我想用

RxJava

来组织这个。 为了使事情更简单，我将举一个简单的例子。假设我有以下方法：

public void test(int someInt){
    Observable.just(someInt)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Subscriber<Integer>() {
                @Override
                public void onCompleted() {
                    log("onCompleted");
                }

                @Override
                public void onError(Throwable e) {
                    e.printStackTrace();
                    log("onError");
                }

                @Override
                public void onNext(Integer integer) {
                    log("onNext - " + integer);
                }
            });

公共无效测试（int-someInt）{
可观察的。只是（someInt）
.subscribeOn（Schedulers.io（））
.observeOn（AndroidSchedulers.mainThread（））
.subscribe（新订户（）{
@凌驾
未完成的公共无效（）{
日志（“未完成”）；
}
@凌驾
公共无效申报人（可丢弃的e）{
e、 printStackTrace（）；
日志（“onError”）；
}
@凌驾
public void onNext（整数）{
log（“onNext-”+整数）；
}
});

在调用

onNext（）

之前，我想检查

是否（someInt==0）

。如果我得到

false

我想继续并得到

onNext（）

已调用，但如果我得到

true

我想执行一些操作并只重复一次原始可观察值，如果第二次条件返回false，我不想重复

有人能帮我弄清楚我有什么选择吗？

---

另外，我是RX世界的新手。

给你。因为你想重试整个链。retryWhen非常适合，所以你必须“玩”一点错误

在下面，如果您检测到无效令牌，您将传递一个错误（仅在第一次），retryWhen将捕获该错误并重新订阅整个接收链（从

可观察开始。仅（someInt）

）

haveRetriedOnce=false；
可观察的。只是（someInt）
.subscribeOn（Schedulers.io（））
.observeOn（AndroidSchedulers.mainThread（））
.flatMap（整数->{
如果（整数==0）{
如果（已重试）{
返回Observable.error（new UserOperationException（））；
}
//问题，抛出一个错误。retryWhen将捕获它
返回Observable.error（新的InvalidTokenException（））；
}否则{
返回可观测值。just（整数）；
}
})
.retryWhen（可观察->可观察.flatMap（可丢弃->{
if（InvalidTokenException的可丢弃实例）{
haveRetriedOnce=true；
仅返回（0）；//重试，此处的int不相关
}否则{
//其他错误，请进一步传递
返回可观测误差（可丢弃）；
}
}))
.subscribe（新订户（）{
@凌驾
未完成的公共无效（）{
日志（“未完成”）；
}
@凌驾
公共无效申报人（可丢弃的e）{
e、 printStackTrace（）；
日志（“onError”）；
}
@凌驾
public void onNext（整数）{
log（“onNext-”+整数）；
}
}

此处不允许“返回”

：

可观察返回。只需（-1）

 haveRetriedOnce = false;

 Observable.just(someInt)
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .flatMap(integer ->{
          if(integer == 0){
            if(haveRetriedOnce){
               return Observable.error(new UserOperationException());
            }
            // problem, throw an error and the .retryWhen will catch it
            return Observable.error(new InvalidTokenException());
          }else{
            return Observable.just(integer);
          }
        })
        .retryWhen(observable -> observable.flatMap(throwable->{
          if(throwable instanceOf InvalidTokenException){
            haveRetriedOnce = true;
            return just(0); // retry, the int here is irrelevant
          }else{
            // other error, pass it further
            return Observable.error(throwable);
          }
        }))
        .subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                log("onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                e.printStackTrace();
                log("onError");
            }

            @Override
            public void onNext(Integer integer) {
                log("onNext - " + integer);
            }
        }