我是ReactiveX和反应式编程的新手.我需要为Couchbase CAS操作实现重试机制,但Couchbase网站上的示例显示重试时,它似乎无限期地重试.我需要在那里的某个地方有一个重试限制和重试计数.
简单的retry()可以工作,因为它接受retryLimit,但我不希望它只在CASMismatchException上重试每个异常.
有任何想法吗?我正在使用RxJava库.
给定输入:
[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) 我正在使用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时,它应该"注入"一个新的网络呼叫.
我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()?我有一个文件列表,我想从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集成是否有更好的方法来实现这一目标?
在其他语言的流/功能域中有一个常见的操作,即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) 我真的很喜欢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) 我知道这是多次被问到的问题.然而,有些东西我从来没有找到答案.所以希望有人能给我一些启示.
我们都知道AsyncTask和Thread是执行后台任务以避免ANR问题的选项.建议asynctask只应用于短期运行任务,而线程可用于长时间运行的任务.asynctask不应该用于长任务的原因众所周知,这是因为asynctask可能导致泄漏,因为它可能会在活动被破坏后继续运行.这是令人信服的.但是,它还会导致一些其他问题:
谢谢
multithreading android android-asynctask android-handler rx-java
我有一个问题,理解为什么以下代码不起作用.我做错了什么或者是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) 当且仅当在最后x毫秒内发出相同的确切项目时,我想防止发生排放.我看过油门和去抖操作员,但我不确定他们是否可以帮助我.我可以使用另一个操作员,还是可以用某种方式编写它们?
rx-java ×10
android ×6
java ×4
retrofit ×3
auth0 ×1
couchbase ×1
long-polling ×1
networking ×1
okhttp ×1
rx-android ×1
rx-java2 ×1
rxjs ×1