标签: rx-java

对具有有限并行性的Scala期货进行排序(无需处理ExecutorContexts)

背景:我有一个功能:

  def doWork(symbol: String): Future[Unit]
Run Code Online (Sandbox Code Playgroud)

它会启动一些副作用以获取数据并存储它,并在完成时完成Future.但是,后端基础结构具有使用限制,因此可以并行地生成不超过5个这些请求.我有一个N符号列表,我需要通过:

  var symbols = Array("MSFT",...)
Run Code Online (Sandbox Code Playgroud)

但是我想对它们进行排序,使得不超过5个同时执行.鉴于:

  val allowableParallelism = 5
Run Code Online (Sandbox Code Playgroud)

我当前的解决方案是(假设我正在使用async/await):

  val symbolChunks = symbols.toList.grouped(allowableParallelism).toList
  def toThunk(x: List[String]) = () => Future.sequence(x.map(doWork))
  val symbolThunks = symbolChunks.map(toThunk)
  val done = Promise[Unit]()
  def procThunks(x: List[() => Future[List[Unit]]]): Unit = x match {
    case Nil => done.success()
    case x::xs => x().onComplete(_ => procThunks(xs))
  }
  procThunks(symbolThunks)
  await { done.future }
Run Code Online (Sandbox Code Playgroud)

但是,由于显而易见的原因,我对此并不十分满意.我觉得这应该是可能的折叠,但每次我尝试,我最终热切地创造期货.我还使用了concatMap尝试了一个带有RxScala Observables的版本,但这看起来也有些过分.

有没有更好的方法来实现这一目标?

scala future rx-java

6
推荐指数
1
解决办法
1236
查看次数

如何将基于回调的API转换为基于Observable的API?

我正在使用的库Message使用回调对象发出一系列对象.

interface MessageCallback {
    onMessage(Message message);
}
Run Code Online (Sandbox Code Playgroud)

使用某个libraryObject.setCallback(MessageCallback)调用添加回调,并使用非阻塞libraryObject.start()方法调用启动该进程.

创建Observable<Message>将发出这些对象的最佳方法是什么?

怎么libraryObject.start()阻止?

java multithreading rx-java

6
推荐指数
2
解决办法
1871
查看次数

RxJava:如何在取消订阅时中断线程?

我Observable.create()用来创建一个observable来对调度程序执行一些工作(例如Schedulers.io(),然后返回结果)AndroidSchedulers.mainThread().

val subscription = observable<T> {
        try {
            // perform action synchronously
            it.onNext(action.invoke(context, args))
            it.onCompleted()
        } catch (t: Exception) {
            it.onError(t)
        }
    }.subscribeOn(scheduler)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(
                    {
                        // handle result here
                        result.set(it)
                    },
                    {
                        // handle error here
                        errorHandler.handleTaskError(model, this, it)
                    },
                    {
                        // notify completed
                        model.completeTask(this)
                    }
            )
Run Code Online (Sandbox Code Playgroud)

内部操作action.invoke()是同步的,可能是阻塞IO操作.当用户决定取消它时,我取消订阅observable:subscription.unsubscribe()

但是,I/O操作不会被中断.是否有任何rx-java API来中断操作?

cancellation rx-java

6
推荐指数
1
解决办法
6459
查看次数

ReactiveX在超时后发出null或sentinel值

寻找一种干净的方法来转换源Observable以null在一段时间内不发出项目后发出单个(或标记值).

例如,如果源可观察的发射1, 2, 3然后在发射之前停止发射10秒,4, 5, 6我希望发射的项目是1, 2, 3, null, 4, 5, 6.

用例用于在UI中显示值,其中显示的值应变为破折号-或者N/A最后发出的值是陈旧/旧的.

我查看了timeout运算符,但它终止Observable了超时发生的时间,这是不可取的.

使用RxJava.

rx-java reactivex

6
推荐指数
1
解决办法
1171
查看次数

Schedulers.immediate()不使用命令行gradle测试

我正在尝试测试使用RxJava从交互器检索数据的演示者.在设置方法中,我正在执行以下操作:

@Before 
public void setup() {
    RxAndroidPlugins.getInstance().registerSchedulersHook(new RxAndroidSchedulersHook() {
        @Override
        public Scheduler getMainThreadScheduler() {
            return Schedulers.immediate();
        }
    });
}
Run Code Online (Sandbox Code Playgroud)

所以在我的测试方法中,我可以测试演示者调用:

@Test
public void testLoad() {
    presenter.load();
    verify(view).dataLoaded(data);
    verify(interactor).load();
}
Run Code Online (Sandbox Code Playgroud)

如果我使用Android Studio运行测试,一切都按预期工作,问题是如果我尝试命令行

gradle test
Run Code Online (Sandbox Code Playgroud)

然后测试失败,因为: Actually, there were zero interactions with this mock.

所以我试图在调用演示者之后立即放置一个Thread.sleep(2000),然后它就可以工作了,所以我猜测Schedulers.immediate(); 不是从命令行工作,但我不知道为什么以及如何调试/修复.你有什么主意吗?

编辑:演示者实现 - >

public void load() {
    Observable<List<Data>> obs = interactor.load()
            .observeOn(AndroidSchedulers.mainThread())
            .subscribeOn(Schedulers.io());
    obs.subscribe(new Observer<List<Data>>() {
        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onNext(List<Data> data) {
            view.dataLoaded(data); …
Run Code Online (Sandbox Code Playgroud)

android unit-testing rx-java

6
推荐指数
1
解决办法
286
查看次数

何时使用doOnTerminate vs doOnUnsubscribe?

当需要订阅我的observable时,我需要得到通知.我还需要通知观察者有错误或已完成.所以我认为我应该使用doOnSubscribe:

注册观察者订阅Observable时要采取的行动

并且doOnTerminate:

在Observable成功完成或出错时注册要执行的操作

然后我看到doOnUnsubscribe:

注册观察者取消订阅Observable时要采取的行动

并认为doOnSubscribe/ 的对称性doOnUnsubscribe会更好.

那么,doOnTerminate以前总会被叫到doOnUnsubscribe吗?如果我只是想知道事情是"完成的",那我选择哪个真的很重要?

android rx-java rx-android

6
推荐指数
1
解决办法
4508
查看次数

如何断言Completable是否已订阅/完成(RxJava2)

我无法确定Completable测试中是否已订阅,例如:

interface IWebApi {
    Observable<Data> download();
}

interface IDataRepository {
    Completable insert(Data data);
}

class SyncService {

    IWebApi webApi;
    IDataRepository repository;

    public SyncService(IWebApi webApi, IDataRepository repository) {
        this.webApi = webApi;
        this.repository = repository;
    }

    public Completable sync() {
        return webApi.download()
            .flatMapCompletable((Data data) -> { repository.insert(data) })
    }
}
Run Code Online (Sandbox Code Playgroud)

然后在我的测试中:

@Test
public void syncTest() {
    Data data = new Data();
    IDataRepository repository = mock (IDataRepository.class);
    IWebApi webApi = mock (IWebApi.class);

    given(webApi.download()).willReturn(Observable.just(data));
    given(repository.insert(data)).willReturn(Completable.complete());

    TestObserver<Void> observer = new TestObserver<Void>();
    SyncService service …
Run Code Online (Sandbox Code Playgroud)

java unit-testing mockito rx-java rx-java2

6
推荐指数
1
解决办法
4954
查看次数

Observable.just()返回Kotlin中的Unit

我有一块Observable,它最终会返回一个错误并重试或只返回onNext.我在onNext中不需要任何东西,所以这只是一个Observable<Unit>.

现在的问题是,在链的末尾,我必须点击这个onNext,除了旧的,我没有任何东西Observable.just().但我不能返回Observable.just(null),因为它返回Nothing?,而不是Unit.我不能回来Unit,因为它不可实现.所以我有Observable.just(null).map{}.它有效,但看起来很难看.想要更好的解决方案吗?

android kotlin rx-java

6
推荐指数
1
解决办法
1504
查看次数

如何在没有.flatMap的情况下控制流,这会打破一个反应流,阻止像distinctUntilChanged这样的运营商在整个流上工作

我想为不同的实现处理不同的可观察逻辑链State.这可以通过密封的类/代数数据类型/ union +轻松实现.flatMap(),但这会打破流,操作员.distinctUntilChanged()只能在.flatMap()函数内工作,而不是整个流本身.

sealed class State {
    object Loading : State()
    data class Loaded(val value: Int) : State()
}

@Test fun distinctTest() {
    val relay = PublishRelay.create<State>()
    relay.flatMap {
        fun handle(state: State): Observable<*> = when (state) {
            State.Loading -> Observable.just(state)
                    .distinctUntilChanged()
                    .doOnNext { println("loading") }

            is State.Loaded -> Observable.just(state)
                    .distinctUntilChanged()
                    .doOnNext { println(it.value) }
        }
        handle(it)
    }
            .subscribe()

    relay.accept(State.Loading)
    relay.accept(State.Loaded(1))
    relay.accept(State.Loaded(2))
    relay.accept(State.Loaded(3))
    relay.accept(State.Loaded(3))
    //desired: loading, 1, 2, 3
    //actual: loading, …
Run Code Online (Sandbox Code Playgroud)

algebraic-data-types reactive-programming kotlin rx-java rx-java2

6
推荐指数
1
解决办法
425
查看次数

返回RxJava的Completable方法的命名约定

我有一个带有视图类(Fragment,Activity)的Android应用程序ViewModel。

所述ViewModel自曝方法,如getUserName它返回Observable<String>。尽管也许有可能找到一个更好的名字(也许observeUserName),但我对当前的名字感到满意-这是可以解释的。

但是,这里开始了最困难的部分:ViewModel还可以告诉视图执行某些操作-例如关闭自身,弹出后退堆栈等。在这种情况下,ViewModel定义以下方法(和相应的Subject):

class ViewModel {
   // other methods, fields

   // ViewModel can call returnToPreviousScreen.onComplete()
   CompletableSubject returnToPreviousScreen = CompletableSubject.create();

   Completable returnToPreviousScreen() { return returnToPreviousScreen; }
}
Run Code Online (Sandbox Code Playgroud)

我认为该方法的名称很糟糕。我找不到更好的东西。诸如此类的observeWhenToReturnToPreviousScreen内容可能更具解释性,但难以阅读。

因此,是否有建议或命名方法来命名此类方法?

android naming naming-conventions rx-java reactive

6
推荐指数
1
解决办法
417
查看次数