拆分一个 stream，编辑其字段然后将其重新组合为单个 stream

Question

我有以下结构

           --- Stream A [ A.map1.diff() ] ---
          |                                     |
          |                                     |
Source --- --- Stream B [ B.map5.diff() ] --- --- combineLatest(A,B,C)
          |                                     |
          |                                     |
           --- Stream C [ C.map9.diff() ] ---

源始终发出所有地图的当前总值。 各个流应该只发出它们各自地图的差异。 diff 函数是可流动的扩展，绝对有效（在其他一些地方使用）。 如果没有变化，则差异不会发出。

现在让我们假设 map9 有差异。 combineLatest 现在将具有 map9 的更新值，但是 map1 和 map5 仍然具有首次创建可流动对象时的原点 state，这意味着创建时的所有值，因为我们首先需要所有值才能区分。 当 map5 有差异时，它与 map1 和 map9 相同。

就好像每个 Stream 都有三个单独的 combineLatest 块实例，每个实例都只有各自 map 的更新值。

现在的问题是 combineLatest 发出的每个更新都是巨大的，因为它基本上总是只有触发它的值之外的所有值。

我已经查看了Splitting 然后将流与 RX和Recombining 来自同一个反应式 stream（我知道的不同语言）的元素相结合来尝试解决这个问题，但没有成功。

编辑：这是我无法更改的套接字连接结构的一部分。 有一个所有连接共享的根 flowable 和每个连接的单独订阅 flowable。 我将添加它的外观摘要。

Edit2：我不同意拆分可流动的 stream 的想法。如果有一种方法可以在不拆分的情况下编辑FlowAgg的字段，例如通过一个一个地进行，我也很乐意接受。

摘抄：

data class FlowAgg(
    val devices: Map<Int, Device),
    val assignments: Map<Int, Assignment),
    val systemtime: Map<Int, Timestamp)
)
data class Summary(
    val id: Int,
    val device: Device? = null,
    val assigment: Assignment? = null,
    val systemtime: Timestamp? = null
)

[...]

socketTopic(
    path = "/summary",
    root = { _ ->
        Flowables.combineLatest(
            DeviceFlowable,
            AssignmentFlowable,
            SystemtimeFlowable
        ) { devices, assignments, systemtime ->
            FlowAgg(
                devices = devices,
                assignments= assignments,
                systemtime = systemtime ,
            )
        },
    subscription = { broadcast ->
        broadcast
            .publish { flow -> // flow: Flowable<FlowAgg>
                Flowables.combineLatest(
                    flow.map { it.devices }.diff(),
                    flow.map { it.assignments }.diff(),
                    flow.map { it.systemTime }.diff()
                ) { devices, assignments, systemTime ->
                    val keys = devices.keys + assignments.keys + systemTime.keys
                    keys.map {
                        Summary(
                            id = it,
                            devices = devices[it],
                            assignments = devices[it],
                            systemtime = devices[it]
                        )
                }
                .map {
                    Json.encodeToString(ListSerializer(Summary.serializer()), it)
                }
            }
    }
)

Answer 1

我找到了 combineLatest 块并行执行问题的罪魁祸首。 我认为，单独的发布导致了线程上下文的分裂。

它现在的行为符合预期。

我按如下方式更改了订阅：

subscription = { broadcast ->
        Flowables.combineLatest(
            broadcast.map { it.devices }.diff(),
            broadcast.map { it.assignments }.diff(),
            broadcast.map { it.systemTime }.diff()
        ) { devices, assignments, systemTime ->
            FlowAgg(devices, assignments, systemTime)
        }
        .debounce(5, TimeUnit.MILLISECONDS)
        .map { (devices, assignments, systemTime) ->
            val keys = devices.keys + assignments.keys + systemTime.keys
            keys.map {
                Summary(
                    id = it,
                    devices = devices[it],
                    assignments = devices[it],
                    systemtime = devices[it]
               )
        }
        .map {
            Json.encodeToString(ListSerializer(Summary.serializer()), it)
        }
    }
}

编辑：我还更改了 diff function 以接受标志，该标志表明它在没有更改时也发出一个空映射，并将 combineLatest 替换为 zip 并删除了去抖动。 这非常有效：

subscription = { broadcast ->
        Flowables.zip(
            broadcast.map { it.devices }.diff(),
            broadcast.map { it.assignments }.diff(),
            broadcast.map { it.systemTime }.diff()
        ) { devices, assignments, systemTime ->
            FlowAgg(devices, assignments, systemTime)
        }
        .map { (devices, assignments, systemTime) ->
            val keys = devices.keys + assignments.keys + systemTime.keys
            keys.map {
                Summary(
                    id = it,
                    devices = devices[it],
                    assignments = devices[it],
                    systemtime = devices[it]
               )
        }
        .map {
            Json.encodeToString(ListSerializer(Summary.serializer()), it)
        }
    }
}