Question

我希望能够模拟合并两个单独的流，这些流发出一些对象（扩展相同的Parent对象），使用缓冲区运算符缓冲它们，并在10秒后发出收集的数据。我希望这种机制是无限的，因为只要有来自2个分离流的发射，就会始终调用这个合并/缓冲区。

这是我到目前为止所做的：

 val list1 = mutableListOf<SomeClass1>(
            SomeClass1("1", 1), SomeClass1("2", 2), SomeClass1("3", 3),
            SomeClass1("4", 4), SomeClass1("5", 5), SomeClass1("6", 6),
            SomeClass1("7", 7), SomeClass1("8", 8), SomeClass1("9", 9)
    )
    val list2 = mutableListOf<SomeClass2>(
            SomeClass2(1.00), SomeClass2(2.00), SomeClass2(3.00),
            SomeClass2(4.00), SomeClass2(5.00), SomeClass2(6.00),
            SomeClass2(7.00), SomeClass2(8.00), SomeClass2(9.00)
    )

    val someClass1Observable = Observable
            .fromIterable(list1)
            .zipWith(Observable.interval(2, TimeUnit.SECONDS),
                    BiFunction { item: SomeClass1, _: Long -> item })


    val someClass2Observable = Observable
            .fromIterable(list2)
            .zipWith(Observable.interval(2, TimeUnit.SECONDS),
                    BiFunction { item: SomeClass2, _: Long -> item })


    someClass1Observable.subscribe {
        Log.v("someClass1", it.toString())
    }

    someClass2Observable.subscribe {
        Log.v("someClass2", it.toString())
    }


    Observable.merge(someClass1Observable, someClass2Observable)
            .buffer(10, TimeUnit.SECONDS)
            .repeat()
            .doOnSubscribe { Log.v("parentObservable", "STARTED") }
            .subscribe { t: MutableList<Parent> ->
                Log.v("parentObservable", "onNext")
                t.forEach { Log.v("onNext", it.toString()) }
            }

    Thread.sleep(30000)
    Log.v("AFTER_SLEEP", "AFTER_SLEEP")


    someClass1Observable.subscribe {
        Log.v("someClass1", it.toString())
    }

    someClass2Observable.subscribe {
        Log.v("someClass2", it.toString())
    }

2个流的第一次发射工作正常，合并/缓冲Observable每次在10秒后收集它们的发射。但是，当这两个流结束排放并且我再次订阅它们时，缓冲区/合并Observable就不会工作了。如何使这项工作像无限？是否有更好的方法为这两个单独的流编写代码，这些流发出不需要从列表中读取值的对象，而不是这样，它们每2秒间隔会发出一些新对象？如何使合并/缓冲区Observable工作无限，我的意思是每当这两个Observable流有新的发射时？

Answer 1

要使这些SomeClass流无限，您可以在使用它们之前简单地将.repeat()运算符放在它们上，或者您可以根据需要从interval构建对象：

val someClass1Obs = Observable
    .interval(2, TimeUnit.SECONDS)
    .map { SomeClass1("$it", it.toInt()) } // <-- create objects on demand

我认为这也可以解决你的其他问题。

如何模拟发射2个infiite Observable流并让其他Observable将它们合并并每隔10秒缓冲一次？

1 个答案: