标签: rx-java

RxJava:重试时有重试限制

我是ReactiveX和反应式编程的新手.我需要为Couchbase CAS操作实现重试机制,但Couchbase网站上的示例显示重试时,它似乎无限期地重试.我需要在那里的某个地方有一个重试限制和重试计数.

简单的retry()可以工作,因为它接受retryLimit,但我不希望它只在CASMismatchException上重试每个异常.

有任何想法吗?我正在使用RxJava库.

couchbase rx-java

10
推荐指数
2
解决办法
7138
查看次数

如何链接多个RxJava的groupBy()方法,例如groupBy().groupBy()

给定输入:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Run Code Online (Sandbox Code Playgroud)

将数字分组为奇数或偶数,然后小于或大于5.

预期产量:

[[1, 3, 5], [2, 4], [6, 8, 10], [7, 9]]
Run Code Online (Sandbox Code Playgroud)

输出的顺序不受限制.

我现在使用以下方法:

Observable.range(1, 10)
    .groupBy(n -> n % 2 == 0)
    .flatMap((GroupedObservable<Boolean, Integer> g) -> {
        return Observable.just(g).flatMap(ObservableUtils.<Boolean, Integer>flatGroup()).groupBy(n -> n > 5);
    })
    .subscribe((final GroupedObservable<Boolean, Integer> g) -> {
        Observable.just(g).flatMap(ObservableUtils.<Boolean, Integer>flatGroup()).forEach(n -> println(g + ": " + n));
    });
Run Code Online (Sandbox Code Playgroud)

请注意,ObservableUtils是我编写的,用于简化代码.

但我对它并不满意,因为它还不够简单,只能表明目标.

我的期望如下:

Observable.range(1, 10)
    .groupBy(n -> n % 2 == 0)
    .groupBy(n -> n > 5) …
Run Code Online (Sandbox Code Playgroud)

java android reactive-programming rx-java

10
推荐指数
1
解决办法
8137
查看次数

如何在不添加特定代码的情况下处理auth0 403错误(Retrofit/okhttp/RxAndroid)

我正在使用Auth0,它给了我一个JWT(json web令牌)和一个refreshtoken.我在http标头中使用此JWT与我的后端进行通信.

403当它确定JWT已经过期时,它可能会发生,服务器给我一个.在这种情况下,我可以让Auth0使用refreshtoken向我发出一个新的JWT.这意味着我调用Auth0后端,将它传递给refreshtoken,它给了我一个新的JWT,然后我可以在我的请求中使用它.

我的问题是,如何在我的所有网络代码中有效地编写此行为?我将有几个端点可以交谈,他们都可以返回403.

我想我应该首先制作一个拦截器,将JWT添加到所有请求中.

然后应该有检测403的行为,静静地对Auth0进行网络调用,检索新的JWT.然后应该再次尝试原始请求,并在其标题中添加新的JWT.

所以我更希望将403处理到我的其他代码看不到的地方,并且绝对不必在任何地方重写它.

任何关于如何实现这一点的指示将不胜感激.

-

要清楚,我基本上是在寻找如何使用RxAndroid Observables实现这一目标的指针.当某个Observable找到403时,它应该"注入"一个新的网络呼叫.

android rx-java retrofit okhttp auth0

10
推荐指数
1
解决办法
6239
查看次数

在RxJava中线程安全是否必需SerializedSubject

我Subject在RxJava中创建了一个实例,并onNext()从多个线程调用它:

PublishSubject<String> subject = PublishSubject.create();
//...
subject.onNext("A");  //thread A
subject.onNext("B");  //thread B
Run Code Online (Sandbox Code Playgroud)

该RxJava文档说:

注意不要onNext(?)从多个线程调用其方法(或其他方法),因为这可能导致非序列化调用,这违反了Observable合约并在结果中产生歧义Subject.

  • 我是否必须打电话toSerialized(),Subject假设我不关心是否"A"在之前或之后"B"?序列化将如何帮助?
  • Subject无论如何都是线程安全的还是我会在没有的情况下破坏RxJava toSerialized()?
  • 文件中提到的" 可观察合同 "是什么?

java thread-safety rx-java

10
推荐指数
1
解决办法
2735
查看次数

使用RxJava和Retrofit进行N次连续api调用

我有一个文件列表,我想从Android设备上传到后端.由于内存限制,我想在第一次完成之后进行第二次API调用,在第二次完成之后进行第三次API调用,依此类推.

我写了类似的东西

private Observable<Integer> uploadFiles(List<File> files) {
        return Observable.create(subscriber -> {
            for (int i = 0, size = files.size(); i < size; i++) {
                UploadModel uploadModel = new UploadModel(files.get(0));
                int uploadResult = retrofitApi.uploadSynchronously(uploadModel);
                subscriber.onNext(uploadResult);
            }
            subscriber.onCompleted();
        }).subscribeOn(Schedulers.newThread());
    }
Run Code Online (Sandbox Code Playgroud)

但是我觉得这可能违背了Rx的精神,而且说的是如果你使用Observable.create,你可能做错了......这是一种合理的方法吗?使用Retrofit的RxJava集成是否有更好的方法来实现这一目标?

java android rx-java retrofit

10
推荐指数
1
解决办法
5554
查看次数

什么是RxJava相当于orElse

在其他语言的流/功能域中有一个常见的操作,即orElse().它就像一个if,当当前链没有得到任何结果时,它变为备用链.在使用Maybe类型的语言中,它基本上会继续使用某种类型的链,或者在None类型上更改为orElse.

理想情况:

Observable.just(false)
          .filter(value -> { return value; })
          .map(value -> { return 1; })
          .orElse(Observable.just(0));

Observable.<Boolean>error(new IllegalStateException("Just playing"))
          .filter(value -> { return value; })
          .map(value -> { return 1; })
          .orElse(Observable.just(0));
Run Code Online (Sandbox Code Playgroud)

它目前可以使用concat和takeFirst进行复制,但它在语义上并不相同,并且不能正确地处理错误处理.

Observable.concat(Observable.just(false)
                            .filter(value -> { return value; })
                            .map(value -> { return 1; }), 
                  Observable.just(0))
          .takeFirst();
Run Code Online (Sandbox Code Playgroud)

android rx-java

10
推荐指数
1
解决办法
1716
查看次数

在RxJava中使用"skipWhile"和"repeatWhen"来实现服务器轮询

我真的很喜欢RxJava,它是一个很棒的工具,但有些时候很难理解它是如何工作的.我们在Android项目中使用Retrofit和RxJava,并且有以下用例:

我需要轮询服务器,重试之间有一些延迟,而服务器正在做一些工作.服务器完成后,我必须提供结果.所以我用RxJava成功完成了它,这里是代码片段:我用"skipWhile"和"repeatWhen"

Subscription checkJobSubscription = mDataManager.checkJob(prepareTweakJob)
        .skipWhile(new Func1<CheckJobResponse, Boolean>() {

            @Override
            public Boolean call(CheckJobResponse checkJobResponse) {
                boolean shouldSkip = false;

                if (SHOW_LOGS) Logger.v(TAG, "checkJob, skipWhile, jobStatus " + checkJobResponse.getJobStatus());

                switch (checkJobResponse.getJobStatus()){
                    case CheckJobResponse.PROCESSING:
                        shouldSkip = true;
                        break;
                    case CheckJobResponse.DONE:
                    case CheckJobResponse.ERROR:
                        shouldSkip = false;
                        break;
                }
                if (SHOW_LOGS) Logger.v(TAG, "checkJob, skipWhile, shouldSkip " + shouldSkip);

                return shouldSkip;
            }
        })
        .repeatWhen(new Func1<Observable<? extends Void>, Observable<?>>() {
            @Override
            public Observable<?> call(Observable<? extends Void> observable) {
                if (SHOW_LOGS) Logger.v(TAG, "checkJob, repeatWhen " + …
Run Code Online (Sandbox Code Playgroud)

networking android long-polling rx-java retrofit

10
推荐指数
1
解决办法
3417
查看次数

Android AsyncTask vs Thread + Handler vs rxjava

我知道这是多次被问到的问题.然而,有些东西我从来没有找到答案.所以希望有人能给我一些启示.

我们都知道AsyncTask和Thread是执行后台任务以避免ANR问题的选项.建议asynctask只应用于短期运行任务,而线程可用于长时间运行的任务.asynctask不应该用于长任务的原因众所周知,这是因为asynctask可能导致泄漏,因为它可能会在活动被破坏后继续运行.这是令人信服的.但是,它还会导致一些其他问题:

  1. 线程是否也独立于活动生命周期?因此,asynctask的风险也可以应用于线程.那么为什么线程适合长时间运行的任务呢?
  2. 看起来asynctask的风险仅适用于与活动一起使用时.如果我们在服务中使用它(不是IntentService,因为IntentService在其工作完成后停止),并且只要我们可以保证在服务停止时取消asyntask,我们可以将它用于长期运行的任务吗?并不意味着它可以在服务中使用asynctask吗?
  3. 我和rxjava玩了一段时间,真的很喜欢它.它消除了担心线程(除非你必须决定哪个线程订阅和观察所发出的数据)的需要.从我所看到的,rxjava(与其他一些lib一起,比如改造)似乎是asynctask和thread的完美替代品.我想知道我们是否可以完全忘记它们,或者有任何特定的情况,rxjava无法实现asynctask和线程可以做的那些我应该知道的?

谢谢

multithreading android android-asynctask android-handler rx-java

10
推荐指数
1
解决办法
2057
查看次数

如果调用doOnSubscribe()返回的对象,则RxJava2 dispose()不起作用

我有一个问题,理解为什么以下代码不起作用.我做错了什么或者是RxJava2实现中的某种错误?

private Disposable savedDisposable;

@Test
public void test() {
    final TestObserver<Integer> observer = new TestObserver<>();

    Observable<Integer> t = Observable.just(10)
            .delay(100, TimeUnit.MILLISECONDS)
            .doOnSubscribe(disposable -> savedDisposable = disposable);

    t.subscribe(observer);

    savedDisposable.dispose();  //this doesn't work
    //observer.dispose();       //this works  

    assertTrue(observer.isDisposed());
}
Run Code Online (Sandbox Code Playgroud)

java rx-java rx-java2

10
推荐指数
1
解决办法
967
查看次数

如果在x毫秒前发生相同的发射,则防止发射

当且仅当在最后x毫秒内发出相同的确切项目时,我想防止发生排放.我看过油门和去抖操作员,但我不确定他们是否可以帮助我.我可以使用另一个操作员,还是可以用某种方式编写它们?

system.reactive rxjs rx-java rx-android

10
推荐指数
1
解决办法
163
查看次数