Androidアプリでrxjavaを使用して、ネットワークリクエストを非同期的に処理します。特定の時間が経過した後にのみ、失敗したネットワークリクエストを再試行します。
Observableでretry()を使用する方法はありますが、一定の遅延後にのみ再試行しますか?
Observableに、現在再試行されていることを知らせる方法はありますか(最初に試行したのではなく)?
私はdebounce()/ throttleWithTimeout()を見ましたが、彼らは何か違うことをしているようです。
編集:
私はそれを行うための1つの方法を見つけたと思いますが、これがそれを行う正しい方法であることの確認または他のより良い方法のいずれかに興味があります。
私がやっていることはこれです:私のObservable.OnSubscribeのcall()メソッドで、Subscribers onError()メソッドを呼び出す前に、スレッドを必要な時間だけスリープさせます。したがって、1000ミリ秒ごとに再試行するには、次のようにします。
@Override
public void call(Subscriber<? super List<ProductNode>> subscriber) {
try {
Log.d(TAG, "trying to load all products with pid: " + pid);
subscriber.onNext(productClient.getProductNodesForParentId(pid));
subscriber.onCompleted();
} catch (Exception e) {
try {
Thread.sleep(1000);
} catch (InterruptedException e1) {
e.printStackTrace();
}
subscriber.onError(e);
}
}
このメソッドはIOスレッドで実行されているため、UIをブロックしません。唯一の問題は、最初のエラーでも遅延が報告されるため、遅延がある場合でも遅延があることです。いいえretry()。遅延が適用されなかった場合afterエラーが、代わりに before再試行(ただし、最初の試行の前ではないことは明らかです)。
retryWhen()
演算子を使用して、Observableに再試行ロジックを追加できます。
次のクラスには、再試行ロジックが含まれています。
public class RetryWithDelay implements Function<Observable<? extends Throwable>, Observable<?>> {
private final int maxRetries;
private final int retryDelayMillis;
private int retryCount;
public RetryWithDelay(final int maxRetries, final int retryDelayMillis) {
this.maxRetries = maxRetries;
this.retryDelayMillis = retryDelayMillis;
this.retryCount = 0;
}
@Override
public Observable<?> apply(final Observable<? extends Throwable> attempts) {
return attempts
.flatMap(new Function<Throwable, Observable<?>>() {
@Override
public Observable<?> apply(final Throwable throwable) {
if (++retryCount < maxRetries) {
// When this Observable calls onNext, the original
// Observable will be retried (i.e. re-subscribed).
return Observable.timer(retryDelayMillis,
TimeUnit.MILLISECONDS);
}
// Max retries hit. Just pass the error along.
return Observable.error(throwable);
}
});
}
}
public class RetryWithDelay implements
Func1<Observable<? extends Throwable>, Observable<?>> {
private final int maxRetries;
private final int retryDelayMillis;
private int retryCount;
public RetryWithDelay(final int maxRetries, final int retryDelayMillis) {
this.maxRetries = maxRetries;
this.retryDelayMillis = retryDelayMillis;
this.retryCount = 0;
}
@Override
public Observable<?> call(Observable<? extends Throwable> attempts) {
return attempts
.flatMap(new Func1<Throwable, Observable<?>>() {
@Override
public Observable<?> call(Throwable throwable) {
if (++retryCount < maxRetries) {
// When this Observable calls onNext, the original
// Observable will be retried (i.e. re-subscribed).
return Observable.timer(retryDelayMillis,
TimeUnit.MILLISECONDS);
}
// Max retries hit. Just pass the error along.
return Observable.error(throwable);
}
});
}
}
使用法:
// Add retry logic to existing observable.
// Retry max of 3 times with a delay of 2 seconds.
observable
.retryWhen(new RetryWithDelay(3, 2000));
ポールの答え に触発され、 Abhijit Sarkar で示されたretryWhen
の問題に関心がない場合、rxJava2無条件で再サブスクリプションを遅らせる最も簡単な方法は次のとおりです。
source.retryWhen(throwables -> throwables.delay(1, TimeUnit.SECONDS))
retryWhenおよびrepeatWhen でさらにサンプルと説明を参照できます。
これは、私が見たBen Christensenのスニペット、 RetryWhen Example 、および RetryWhenTestsConditional に基づいたソリューションです(動作させるにはn.getThrowable()
をn
に変更する必要がありました)。 evant/gradle-retrolambda を使用してAndroidでラムダ表記を機能させましたが、ラムダを使用する必要はありません(強く推奨されています)。遅延のために、指数関数的なバックオフを実装しましたが、必要なバックオフロジックをそこにプラグインできます。完全を期すために、subscribeOn
およびobserveOn
演算子を追加しました。 AndroidSchedulers.mainThread()
に ReactiveX/RxAndroid を使用しています。
int ATTEMPT_COUNT = 10;
public class Tuple<X, Y> {
public final X x;
public final Y y;
public Tuple(X x, Y y) {
this.x = x;
this.y = y;
}
}
observable
.subscribeOn(Schedulers.io())
.retryWhen(
attempts -> {
return attempts.zipWith(Observable.range(1, ATTEMPT_COUNT + 1), (n, i) -> new Tuple<Throwable, Integer>(n, i))
.flatMap(
ni -> {
if (ni.y > ATTEMPT_COUNT)
return Observable.error(ni.x);
return Observable.timer((long) Math.pow(2, ni.y), TimeUnit.SECONDS);
});
})
.observeOn(AndroidSchedulers.mainThread())
.subscribe(subscriber);
myRequestObservable.retryを使用する代わりに、遅延のインダイレクションを処理する新しいObservableを返すラッパー関数retryObservable(MyRequestObservable、retrycount、seconds)を使用します。
retryObservable(restApi.getObservableStuff(), 3, 30)
.subscribe(new Action1<BonusIndividualList>(){
@Override
public void call(BonusIndividualList arg0)
{
//success!
}
},
new Action1<Throwable>(){
@Override
public void call(Throwable arg0) {
// failed after the 3 retries !
}});
// wrapper code
private static <T> Observable<T> retryObservable(
final Observable<T> requestObservable, final int nbRetry,
final long seconds) {
return Observable.create(new Observable.OnSubscribe<T>() {
@Override
public void call(final Subscriber<? super T> subscriber) {
requestObservable.subscribe(new Action1<T>() {
@Override
public void call(T arg0) {
subscriber.onNext(arg0);
subscriber.onCompleted();
}
},
new Action1<Throwable>() {
@Override
public void call(Throwable error) {
if (nbRetry > 0) {
Observable.just(requestObservable)
.delay(seconds, TimeUnit.SECONDS)
.observeOn(mainThread())
.subscribe(new Action1<Observable<T>>(){
@Override
public void call(Observable<T> observable){
retryObservable(observable,
nbRetry - 1, seconds)
.subscribe(subscriber);
}
});
} else {
// still fail after retries
subscriber.onError(error);
}
}
});
}
});
}
この例はjxjava 2.2.2で機能します。
遅滞なく再試行:
Single.just(somePaylodData)
.map(data -> someConnection.send(data))
.retry(5)
.doOnSuccess(status -> log.info("Yay! {}", status);
遅延して再試行:
Single.just(somePaylodData)
.map(data -> someConnection.send(data))
.retryWhen((Flowable<Throwable> f) -> f.take(5).delay(300, TimeUnit.MILLISECONDS))
.doOnSuccess(status -> log.info("Yay! {}", status)
.doOnError((Throwable error)
-> log.error("I tried five times with a 300ms break"
+ " delay in between. But it was in vain."));
SomeConnection.send()が失敗すると、ソースシングルは失敗します。それが起こると、retryWhen内の失敗の観察可能なものがエラーを出力します。その放出を300ミリ秒遅延させ、それを送り返して再試行を通知します。 take(5)は、5つのエラーを受け取った後にシグナルオブザーバブルが終了することを保証します。 retryWhenは終了を確認し、5回目の失敗後に再試行しません。
retryWhen
は複雑な、おそらくバグのある演算子です。公式ドキュメントと少なくとも1つの回答では、range
演算子を使用しています。再試行が行われない場合は失敗します。 ReactiveXメンバーのDavid Karnokとの discussion を参照してください。
flatMap
をconcatMap
に変更し、RetryDelayStrategy
クラスを追加して、kjonesの答えを改善しました。 flatMap
は放出順序を保持しませんが、concatMap
は保持しますが、これはバックオフを伴う遅延にとって重要です。名前が示すように、RetryDelayStrategy
は、バックオフを含む再試行遅延を生成するさまざまなモードからユーザーが選択できるようにします。このコードは、私の GitHub で利用でき、以下のテストケースが含まれています。
setRandomJokes
メソッドを参照してください。
RxJavaバージョン1.0以降では、zipWithを使用して遅延を伴う再試行を実現できます。
kjones answerに変更を追加します。
変更済み
public class RetryWithDelay implements
Func1<Observable<? extends Throwable>, Observable<?>> {
private final int MAX_RETRIES;
private final int DELAY_DURATION;
private final int START_RETRY;
/**
* Provide number of retries and seconds to be delayed between retry.
*
* @param maxRetries Number of retries.
* @param delayDurationInSeconds Seconds to be delays in each retry.
*/
public RetryWithDelay(int maxRetries, int delayDurationInSeconds) {
MAX_RETRIES = maxRetries;
DELAY_DURATION = delayDurationInSeconds;
START_RETRY = 1;
}
@Override
public Observable<?> call(Observable<? extends Throwable> observable) {
return observable
.delay(DELAY_DURATION, TimeUnit.SECONDS)
.zipWith(Observable.range(START_RETRY, MAX_RETRIES),
new Func2<Throwable, Integer, Integer>() {
@Override
public Integer call(Throwable throwable, Integer attempt) {
return attempt;
}
});
}
}
kjonesと同じ回答ですが、最新バージョンに更新されますFor RxJava 2.x version:( 'io.reactivex.rxjava2:rxjava:2.1.3')
public class RetryWithDelay implements Function<Flowable<Throwable>, Publisher<?>> {
private final int maxRetries;
private final long retryDelayMillis;
private int retryCount;
public RetryWithDelay(final int maxRetries, final int retryDelayMillis) {
this.maxRetries = maxRetries;
this.retryDelayMillis = retryDelayMillis;
this.retryCount = 0;
}
@Override
public Publisher<?> apply(Flowable<Throwable> throwableFlowable) throws Exception {
return throwableFlowable.flatMap(new Function<Throwable, Publisher<?>>() {
@Override
public Publisher<?> apply(Throwable throwable) throws Exception {
if (++retryCount < maxRetries) {
// When this Observable calls onNext, the original
// Observable will be retried (i.e. re-subscribed).
return Flowable.timer(retryDelayMillis,
TimeUnit.MILLISECONDS);
}
// Max retries hit. Just pass the error along.
return Flowable.error(throwable);
}
});
}
}
使用法:
//既存のオブザーバブルに再試行ロジックを追加します。 // 2秒の遅延で最大3回再試行します。
observable
.retryWhen(new RetryWithDelay(3, 2000));
RetryWhen演算子で返されるObservableに遅延を追加できます。
/**
* Here we can see how onErrorResumeNext works and emit an item in case that an error occur in the pipeline and an exception is propagated
*/
@Test
public void observableOnErrorResumeNext() {
Subscription subscription = Observable.just(null)
.map(Object::toString)
.doOnError(failure -> System.out.println("Error:" + failure.getCause()))
.retryWhen(errors -> errors.doOnNext(o -> count++)
.flatMap(t -> count > 3 ? Observable.error(t) : Observable.just(null).delay(100, TimeUnit.MILLISECONDS)),
Schedulers.newThread())
.onErrorResumeNext(t -> {
System.out.println("Error after all retries:" + t.getCause());
return Observable.just("I save the world for extinction!");
})
.subscribe(s -> System.out.println(s));
new TestSubscriber((Observer) subscription).awaitTerminalEvent(500, TimeUnit.MILLISECONDS);
}
ここでさらに例を見ることができます。 https://github.com/politrons/reactive
(Kotlin)指数関数的バックオフとObservable.range()の防御放出を適用して、コードを少し改善しました:
fun testOnRetryWithDelayExponentialBackoff() {
val interval = 1
val maxCount = 3
val ai = AtomicInteger(1);
val source = Observable.create<Unit> { emitter ->
val attempt = ai.getAndIncrement()
println("Subscribe ${attempt}")
if (attempt >= maxCount) {
emitter.onNext(Unit)
emitter.onComplete()
}
emitter.onError(RuntimeException("Test $attempt"))
}
// Below implementation of "retryWhen" function, remove all "println()" for real code.
val sourceWithRetry: Observable<Unit> = source.retryWhen { throwableRx ->
throwableRx.doOnNext({ println("Error: $it") })
.zipWith(Observable.range(1, maxCount)
.concatMap { Observable.just(it).delay(0, TimeUnit.MILLISECONDS) },
BiFunction { t1: Throwable, t2: Int -> t1 to t2 }
)
.flatMap { pair ->
if (pair.second >= maxCount) {
Observable.error(pair.first)
} else {
val delay = interval * 2F.pow(pair.second)
println("retry delay: $delay")
Observable.timer(delay.toLong(), TimeUnit.SECONDS)
}
}
}
//Code to print the result in terminal.
sourceWithRetry
.doOnComplete { println("Complete") }
.doOnError({ println("Final Error: $it") })
.blockingForEach { println("$it") }
}
kjones ここでの回答に基づいて、RxJava 2.xのKotlinバージョンが遅延として拡張機能として再試行されます。 Observable
を置き換えて、Flowable
と同じ拡張子を作成します。
_fun <T> Observable<T>.retryWithDelay(maxRetries: Int, retryDelayMillis: Int): Observable<T> {
var retryCount = 0
return retryWhen { thObservable ->
thObservable.flatMap { throwable ->
if (++retryCount < maxRetries) {
Observable.timer(retryDelayMillis.toLong(), TimeUnit.MILLISECONDS)
} else {
Observable.error(throwable)
}
}
}
}
_
次に、観測可能なobservable.retryWithDelay(3, 1000)
で使用します
再試行カウントを印刷する必要がある場合は、RxjavaのWikiページで提供されている例を使用できます https://github.com/ReactiveX/RxJava/wiki/Error-Handling-Operators
observable.retryWhen(errors ->
// Count and increment the number of errors.
errors.map(error -> 1).scan((i, j) -> i + j)
.doOnNext(errorCount -> System.out.println(" -> query errors #: " + errorCount))
// Limit the maximum number of retries.
.takeWhile(errorCount -> errorCount < retryCounts)
// Signal resubscribe event after some delay.
.flatMapSingle(errorCount -> Single.timer(errorCount, TimeUnit.SECONDS));
KotlinおよびRxJava1バージョンの場合
class RetryWithDelay(private val MAX_RETRIES: Int, private val DELAY_DURATION_IN_SECONDS: Long)
: Function1<Observable<out Throwable>, Observable<*>> {
private val START_RETRY: Int = 1
override fun invoke(observable: Observable<out Throwable>): Observable<*> {
return observable.delay(DELAY_DURATION_IN_SECONDS, TimeUnit.SECONDS)
.zipWith(Observable.range(START_RETRY, MAX_RETRIES),
object : Function2<Throwable, Int, Int> {
override fun invoke(throwable: Throwable, attempt: Int): Int {
return attempt
}
})
}
}