rxjava: আমি কি আবার চেষ্টা করতে পারি () তবে দেরি করে?

Question 1

নেটওয়ার্ক অনুরোধগুলি অবিচ্ছিন্নভাবে পরিচালনা করতে আমি আমার অ্যান্ড্রয়েড অ্যাপে rxjava ব্যবহার করছি। এখন আমি একটি নির্দিষ্ট সময় কেটে যাওয়ার পরে ব্যর্থ নেটওয়ার্কের অনুরোধটি আবার চেষ্টা করতে চাই।

পর্যবেক্ষণে পুনরায় চেষ্টা () ব্যবহার করার কি কোনও উপায় আছে তবে কেবলমাত্র একটি নির্দিষ্ট বিলম্বের পরে আবার চেষ্টা করার?

বর্তমানে পর্যালোচনা করা হচ্ছে (পর্যবেক্ষণের বিপরীতে প্রথমবার চেষ্টা করা হচ্ছে) পর্যবেক্ষণযোগ্যদের জানার কোনও উপায় আছে কি?

আমার ডাবনো () / থ্রোটলউইথটাইমআউট () এ নজর ছিল তবে তারা মনে হয় কিছু আলাদা করছে।

সম্পাদনা করুন:

আমি মনে করি এটি করার একটি উপায় আমি খুঁজে পেয়েছি তবে আমি এটি নিশ্চিত করার আগ্রহী যে এটি করা সঠিক উপায় বা অন্যান্য, আরও ভাল উপায়।

আমি যা করছি তা হ'ল: আমার অবজারভেবলের কল () পদ্ধতিতে nঅনশস্ক্রাইব করুন, সাবস্ক্রাইবারদের অনার () পদ্ধতিতে কল করার আগে আমি কেবলমাত্র পছন্দসই সময়ের জন্য থ্রেডকে ঘুমিয়ে যাই। সুতরাং, প্রতি 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);
    }
}

যেহেতু এই পদ্ধতিটি আইও থ্রেডে চলছে তাই এটি ইউআইকে অবরুদ্ধ করে না। আমি দেখতে পাচ্ছি কেবলমাত্র সমস্যাটি হ'ল এমনকি প্রথম ত্রুটিটি বিলম্বের সাথে রিপোর্ট করা হয়েছে যাতে পুনরায় চেষ্টা না করা হলেও দেরি রয়েছে) আমি আরও ভাল চাই যদি বিলম্বটি ত্রুটির পরে প্রয়োগ না করা হয় তবে পরিবর্তে পুনরায় চেষ্টা করার আগে (তবে প্রথম চেষ্টা করার আগে নয়, স্পষ্টতই)।

Question 2

আপনি retryWhen()যে কোনও পর্যবেক্ষনে পুনরায় চেষ্টা করার যুক্তিকে যুক্ত করতে অপারেটরটি ব্যবহার করতে পারেন ।

নিম্নলিখিত শ্রেণিতে পুনরায় চেষ্টা করার যুক্তি রয়েছে:

আরএক্সজাভা 2.x

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);
                    }
                });
    }
}

আরএক্সজাভা 1.x

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));

Question 3

পলের উত্তরের দ্বারা অনুপ্রাণিত হয়ে , এবং আপনি যদি অভিজিৎ সরকারretryWhen কর্তৃক প্রদত্ত সমস্যাগুলি নিয়ে উদ্বিগ্ন না হন , তবে আরএক্সজেভা 2 শর্তহীন শর্তাবলীর সাথে পুনর্বাসনে দেরি করার সহজ উপায় হ'ল:

source.retryWhen(throwables -> throwables.delay(1, TimeUnit.SECONDS))

আপনি পুনরায় চেষ্টা ও পুনরাবৃত্তি যখন আরও নমুনা এবং ব্যাখ্যা দেখতে চাইতে পারেন ।

Question 4

এই উদাহরণটি 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."));

যদি কিছু সংযোগ.সেন্ড () ব্যর্থ হয় তবে আমাদের উত্স একক ব্যর্থ। যখন এটি ঘটে তখন পুনরায় চেষ্টা করার ভিতরে ব্যর্থতার পর্যবেক্ষণযোগ্য যখন ত্রুটিটি প্রকাশ করে। আমরা এই নির্গমনটি 300 মিমি দ্বারা বিলম্ব করি এবং আবার চেষ্টা করার সিগন্যালে এটি প্রেরণ করি। (5) গ্যারান্টি দেয় যে আমাদের সংকেত পর্যবেক্ষণযোগ্য আমরা পাঁচটি ত্রুটি পাওয়ার পরে শেষ হয়ে যাবে। পুনরায় চেষ্টা করুন যখন সমাপ্তিটি দেখুন এবং পঞ্চম ব্যর্থতার পরে আবার চেষ্টা করবেন না।

Question 5

এই একটি সমাধান বেন Christensen এর স্নিপেট আমি দেখেছি, উপর ভিত্তি করে হয় RetryWhen উদাহরণ , এবং RetryWhenTestsConditional (আমি পরিবর্তন করতে হয়েছিল n.getThrowable()করার nকাজে এটি জন্য)। অ্যান্ড্রয়েডে ল্যাম্বডে স্বাক্ষরকরণের জন্য আমি ইভেন্ট / গ্রেডেল-রেট্রোলাম্বদা ব্যবহার করেছি তবে আপনাকে ল্যাম্বডাস ব্যবহার করতে হবে না (যদিও এটি অত্যন্ত প্রস্তাবিত)। বিলম্বের জন্য আমি এক্সফোনেনশিয়াল ব্যাক-অফ বাস্তবায়িত করেছি, তবে আপনি সেখানে যে কোনও ব্যাক অফ যুক্তি চান তা আপনি প্লাগ করতে পারেন। সম্পূর্ণতার জন্য আমি subscribeOnএবং observeOnঅপারেটরগুলি যুক্ত করেছি। আমি এর জন্য ReactiveX / RxAndroid ব্যবহার করছি AndroidSchedulers.mainThread()।

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);

Question 6

MyRequestObservable.retry ব্যবহার না করে আমি একটি মোড়ক ফাংশন retryObservable (MyRequestObservable, retrycount, সেকেন্ড) ব্যবহার করি যা একটি নতুন পর্যবেক্ষণযোগ্য ফিরিয়ে দেয় যা দেরি করার জন্য ইন্ডিয়ারেশন হ্যান্ডেল করে তাই আমি করতে পারি

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);
                    }

                }
            });

        }

    });

}

Question 7

retryWhenএটি একটি জটিল, সম্ভবত বগি, অপারেটর। অফিসিয়াল ডক এবং কমপক্ষে এখানে একটি উত্তর rangeঅপারেটর ব্যবহার করে , যা ব্যর্থ হবে যদি সেখানে চেষ্টা করার দরকার নেই। রিঅ্যাকটিভএক্স সদস্য ডেভিড কর্নোকের সাথে আমার আলোচনা দেখুন ।

আমি পরিবর্তন করে kjones 'উত্তর উপর উন্নত flatMapকরতে concatMapহবে এবং একটি যোগ করে RetryDelayStrategyবর্গ। ব্যাক-অফের সাথে বিলম্বের জন্য গুরুত্বপূর্ণ, যা flatMapকরার সময় নির্গমন ক্রম সংরক্ষণ করে না concatMap। RetryDelayStrategy, যেমন নাম নির্দেশ করে যাক ব্যবহারকারী ব্যাক বন্ধ সহ উৎপাদিত পুনরায় চেষ্টা বিলম্ব বিভিন্ন মোড, থেকে পছন্দ করে নিন আছে। কোডটি আমার গিটহাবের উপর নিম্নলিখিত পরীক্ষার ক্ষেত্রে সম্পূর্ণ পাওয়া যায় :

1 ম প্রচেষ্টা সফল হয়েছে (পুনরায় চেষ্টা করা হবে না)
1 টি পুনরায় চেষ্টা করার পরে ব্যর্থ
৩ বার পুনরায় চেষ্টা করার চেষ্টা করা হয়েছে তবে ২ য় তারিখে সাফল্য পাওয়া যায় তাই তৃতীয়বারের মতো আবার চেষ্টা করা যায় না
3 য় পুনরায় চেষ্টা করুন সাফল্য

setRandomJokesপদ্ধতি দেখুন ।

Question 8

কেজোনসের উত্তরের ভিত্তিতে এখানে এক্সটেনশন হিসাবে বিলম্বের সাথে আবার চেষ্টা করুন আরএক্সজেভা ২.x এর কোটলিন সংস্করণ। এর 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)

Question 9

এখন আরএক্সজাভা সংস্করণ 1.0+ এর সাথে আপনি বিলম্বের সাথে পুনরায় চেষ্টা করতে জিপউইথ ব্যবহার করতে পারেন।

কেজনস উত্তরে পরিবর্তন যুক্ত করা হচ্ছে ।

সংশোধিত

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;
                             }
                         });
    }
}

Question 10

কেজনস থেকে একই উত্তর তবে আরএক্সজেভা ২.x সংস্করণের জন্য সর্বশেষ সংস্করণে আপডেট হয়েছে : ('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));

Question 11

পুনরায় চেষ্টা করা অপারেটরটিতে পর্যবেক্ষনে ফিরে আসাতে আপনি বিলম্ব যোগ করতে পারেন

          /**
 * 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

Question 12

কেবল এটির মতো করুন:

                  Observable.just("")
                            .delay(2, TimeUnit.SECONDS) //delay
                            .flatMap(new Func1<String, Observable<File>>() {
                                @Override
                                public Observable<File> call(String s) {
                                    L.from(TAG).d("postAvatar=");

                                    File file = PhotoPickUtil.getTempFile();
                                    if (file.length() <= 0) {
                                        throw new NullPointerException();
                                    }
                                    return Observable.just(file);
                                }
                            })
                            .retry(6)
                            .subscribe(new Action1<File>() {
                                @Override
                                public void call(File file) {
                                    postAvatar(file);
                                }
                            }, new Action1<Throwable>() {
                                @Override
                                public void call(Throwable throwable) {

                                }
                            });

Question 13

কোটলিন এবং আরএক্সজেভা 1 সংস্করণের জন্য

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
                    }
                })
    }
}

Question 14

(কোটলিন) আমি ঘৃণ্য ব্যাকঅফ এবং অবজারভেবল.রেঞ্জের প্রয়োগ প্রতিরক্ষা নির্গমন সহ কিছুটা উন্নত কোড:

    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") }
}

Question 15

ইভেন্টটিতে যখন আপনার পুনঃপ্রকাশের গণনাটি মুদ্রণ করতে হবে, আপনি রক্সজাভার উইকি পৃষ্ঠায় প্রদত্ত উদাহরণটি https://github.com/ReactiveX/RxJava/wiki/Error- হ্যান্ডলিং- অপারেটরগুলি ব্যবহার করতে পারেন

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));