标签: rx-java

RxJava-何时不使用Observable?

我遇到了一个使用RxJava的场景,我不太确定我是应该使用Observable<T>还是最后一个ImmutableList<T>.

基本上,如果我导入一次最终和不可变数据集,再也不会再次导入,那么我是否真的将其暴露为感冒Observable<T>?

public final class StrategyManager {

    private static final StrategyManager instance = new StrategyManager();

    private final ImmutableList<Strategy> strategies;

    private StrategyManager() {
        strategies = //import from db
    }
    public Observable<Strategy> getStrategies() { 
        return Observable.from(strategies);
    }
    public static StrategyManager get() { 
        return instance;
    }
}
Run Code Online (Sandbox Code Playgroud)

或者我应该将它暴露为ImmutableList<T>?

public final class StrategyManager {

    private static final StrategyManager instance = new StrategyManager();

    private final ImmutableList<Strategy> strategies;

    private StrategyManager() {
        strategies = //import from db
    }
    public …
Run Code Online (Sandbox Code Playgroud)

reactive-programming rx-java

4
推荐指数
1
解决办法
392
查看次数

RxJava:不调用Subscription的unsubscribe()方法

在下面的代码中,我需要在unsubscription(它记录"release")上发布一些资源.

   Observable first = Observable.create(new Observable.OnSubscribe<Object>() {
                    @Override
                    public void call(Subscriber<? super Object> subscriber) {
                        subscriber.add(Subscriptions.create(() -> {
                            log(“release”);         
                        }));
                    }
                }).doOnUnsubscribe(() -> log(“first”));
   Observable second = Observable.create(…).doOnUnsubscribe(() -> log(“second”));
   Observable result = first.mergeWith(second).doOnUnsubscribe(() -> log(“result”));
   Subscription subscription = result.subscribe(…);
   //…
   subscription.unsubscribe();
Run Code Online (Sandbox Code Playgroud)

但它只记录"结果".看起来unsubscription没有传播到merge的子可观察量.那么如何处理第一个observable的Observable.OnSubscribe中的取消订阅?

java reactive-programming rx-java rx-android

4
推荐指数
1
解决办法
683
查看次数

Rx缓冲区自第一个新组元素以来超时

对Rx世界来说很新,我需要实现以下行为:

我需要observable来收集值并在我至少有N个项目时将它们作为列表发出,或者如果从发出组的第一个项目开始经过了T个时间量.

我一次又一次地阅读文档,非常确定它会使用

buffer(timespan, unit, count[, scheduler])
Run Code Online (Sandbox Code Playgroud)

但问题是这里的时间跨度取决于最后一组项目.

如果可能的话,我还需要能够冲洗(强制发射)当前缓冲区,有些项目需要立即处理.我是否正确地假设在这种情况下我需要第二个observable,在每个项目之前执行处理并合并两者?

任何的想法?

Ps:我在Java工作,但我不需要Java代码,解释就足够了.

谢谢!

system.reactive rx-java

4
推荐指数
1
解决办法
623
查看次数

RxJava在Scheduler.io()线程中不起作用

问题在于:我有Observable和Subscriber.我尝试推出Observable的.io()线程,因为它与文件和压缩的归档工作(我将不会显示的代码-过大),但Observable什么也不做!:

Observable<Double> creatingObservable = getCreatingObservable(image);
Subscriber<Double> creatingSubscriber = getCreatingSubscriber();

creatingObservable
        .subscribeOn(Schedulers.io())
        .subscribe(creatingSubscriber);
Run Code Online (Sandbox Code Playgroud)

如果我启动代码没有subscribeOn()- 所有工作.有什么问题以及如何解决它

PS System.out.println()也不起作用.问题有调度程序的所有线程.

java rx-java

4
推荐指数
1
解决办法
1296
查看次数

模拟RxJava Observable的正确方法是什么

我有一个返回Observable's用于RxJava的API.为了测试我想避免网络操作,所以计划模拟响应.但是,由于所有响应都必须包含在内,Observable并且from()方法需要一个Future不具体的类型,因此我的模拟类使用匿名包装类进行复杂处理,我认为必须有更好的方法.

这是我有的:

public class MockApi implements MyApi {

    @Override
    public Observable<MyData> getMyData() {
        return Observable.from(new Future<MyData>() {

            @Override public boolean cancel(boolean mayInterruptIfRunning) { return false; }
            @Override public boolean isCancelled() { return false; }
            @Override public boolean isDone() { return false; }

            @Override
            public MyData get(long timeout, TimeUnit unit) throws InterruptedException,
                    ExecutionException, TimeoutException {
                return get();
            }

            @Override
            public MyData get() throws InterruptedException, ExecutionException {
                return new MyData();
            }

        });
    }

    ... …
Run Code Online (Sandbox Code Playgroud)

testing android rx-java

4
推荐指数
1
解决办法
5517
查看次数

RX子可观察-仅执行一次

通常我用

Observable observable = someObservable.replay().refCount();
Run Code Online (Sandbox Code Playgroud)

创建一个只能执行一次的可观察对象。如果我observable多次订阅,则效果很好:

observable.observeOn(Schedulers.io())
    .subscribeOn(AndroidSchedulers.mainThread())
    .subscribe(...);

observable.observeOn(Schedulers.io())
    .subscribeOn(AndroidSchedulers.mainThread())
    .subscribe(...);
Run Code Online (Sandbox Code Playgroud)

将observable只执行一次-完美的,就像我想它。如果我现在执行以下操作:

Observable obs1 = observable.map(...); // call some operators
Observable obs2 = observable.map(...); // call some operators

obs1.observeOn(Schedulers.io())
    .subscribeOn(AndroidSchedulers.mainThread())
    .subscribe(...);

obs2.observeOn(Schedulers.io())
    .subscribeOn(AndroidSchedulers.mainThread())
    .subscribe(...);
Run Code Online (Sandbox Code Playgroud)

然后observable执行两次。我如何确保不会发生这种情况?

android observable rx-java

4
推荐指数
1
解决办法
4283
查看次数

Rx2 blockingFirst()不起作用

我在rx世界中介绍,我想了解为什么在订阅newThread时阻塞不起作用.例如:

这是有效的:

int i = Observable.fromArray(1,2,3,4).blockingFirst();
Run Code Online (Sandbox Code Playgroud)

这不起作用:

int i = Observable.just(1,2,3,4)
      .subscribeOn(Schedulers.newThread())
      .observeOn(AndroidSchedulers.mainThread()).blockingFirst();
Run Code Online (Sandbox Code Playgroud)

如果有可能使第二种情况起作用.

谢谢 ;)

rx-java rx-android reactivex rx-java2

4
推荐指数
1
解决办法
2292
查看次数

禁用Flowable/Observable Buffer

我遇到的问题始终是使用combineLatest运算符获得的组合中的最后一个值.

我有2个热流道(a,b)以高频率生成事件(每100毫秒一个事件):

Flowable<OrderBook> flowA = sourceA.getObservableOrderBook(value);
Flowable<OrderBook> flowB = sourceB.getObservableOrderBook(value);
Run Code Online (Sandbox Code Playgroud)

结合combineLatest,需要将近300毫秒才能完成它的工作.

Flowable<OrderBookCouple> combined = Flowable.combineLatest(flowA, flowB,        OrderBookCouple::new).observeOn(Schedulers.newThread());
combined.subscribe((bookCouple) -> {
                System.out.println("A timestamp: " + bookCouple.aOrderBook.getTimeStamp());
                System.out.println("B timestamp: " + bookCouple.bOrderBook.getTimeStamp());
                Thread.sleep(300);
            }
Run Code Online (Sandbox Code Playgroud)

在一次执行组合器之后,我想处理最后生成的事件组合,意思是(lastA,lastB).

组合流的默认行为是将所有事件组合缓存在其自己的缓冲区中,以便组合流可以接收非常旧的组合,并且此时间隙正在爆炸.

我应该如何更改我的代码以禁用此缓冲区并始终接收最后一个组合?

java reactive-programming java-8 rx-java rx-java2

4
推荐指数
1
解决办法
344
查看次数

Kotlin和RxJava类型推断失败

我正在尝试在发生计时器的情况下在Observable上实现retryWhen,但是在IDE Android Studio 3.0中有下划线的奇怪错误

这是代码:

rxRssiRepository.onRssiUpdate() //returns Observable<RssiEvent>
        .timeout(10, TimeUnit.MILLISECONDS)
        .retryWhen { t: Observable<Throwable> ->
            t.flatMap { error: Throwable ->
                if (error is TimeoutException) {
                    stopLocationUpdates()
                    Log.v("TIMEOUT", "TIMEOUT RSSI EVENTS")
                    Observable.just(Observable.empty())
                } else {
                    Observable.error(error)
                }
            }
        }
        .concatMap { t: RssiEvent ->
            appendRssiEvent(t)
        }
        .publish()
Run Code Online (Sandbox Code Playgroud)

IDE在.flatMap运算符上用红色下划线表示:

类型推断失败:没有足够的信息来推断参数R in

有趣的flatMap(mapper:(((t:Throwable)?ObservableSource)!):可观察!请明确指定。

与“ if”运算符相同:

控制流表达式的类型推断失败。请明确指定其类型

对于操作员.just:

类型推断失败:没有足够的信息来有趣地推断参数T(项目:T!):可观察!请明确指定。

对于运算符.empty:

类型推断失败:没有足够的信息来推断参数T

有趣(项目:T!):可观察!请明确指定。

对于.error运算符:

类型推断失败:没有足够的信息来推断参数T

有趣的错误(异常:Throwable!):可观察!请明确指定。

如何解决这个问题?

我的意思是,这段代码也位于Java中: 如何添加超时以检测Observable一段时间未发出

但是当我将其转换为Kotlin时,它给了我所描述的情况问题

type-inference kotlin rx-java rx-java2

4
推荐指数
1
解决办法
3929
查看次数

是否有相当于RxJava的Single的Subject?

在RxJava中是否有类似于Subject适用于某个类的类Single?据推测,我会调用它onSuccess( item )或onError( Throwable )方法,输出将转发给SingleSubscriber.

我想我可以使用它Observable Subject并将其转换为a Single但看起来有点笨重.

目前使用RxJava 1但对RxJava 2的情况也很感兴趣.

java reactive-programming rx-java rx-java2

4
推荐指数
1
解决办法
2451
查看次数