0

假设我正在生成一个有限的消息流作为Flow<Message>. 我遍历一些消息源，当没有更多消息时，跳出循环以正常完成流程。

val messages = flow {
    while (source.hasNext()) {
        emit(source.next())
    }
    println("Finished sending all the messages")
}

消费者只需调用collect以依次接收每条消息，直到流程完成。

messages.collect { doSomethingWith(it) }
println("All the messages have been processed")

但是当我需要告诉调用者为什么流程停止时会发生什么？例如，假设消息生产者需要身份验证，而我必须处理令牌到期。现在有两个原因可能会终止流程，所以我的生产者看起来像这样：

val messages = flow {
    while(source.hasNext()) {
        if (authentication.isExpired) {
            break
        }
        emit(source.next())
    }
    println("Finished sending all the messages")
}

问题在于消费者不知道流程为何结束。消息只是用完了，还是需要重新验证并继续获取消息？现在，我可以想到两种可能的方法来处理它，我都不喜欢这两种方法。

例外

一个简单的解决方案是用异常发出“异常”流终止信号，如下所示：

val messages = flow {
    while (source.hasNext()) {
        if (authentication.isExpired) {
            throw AuthenticationExpiredException()
        }
        emit(source.next())
    }
    println("Finished sending all the messages")
}

太好了，因为现在消费者可以使用try/catch来确定流程终止的原因：

try {
    messages.collect { doSomethingWith(it) }
    println("There are no more messages")
} catch (e: AuthenticationExpiredException) {
    println("The auth token expired")
}

但是使用这样的异常绝对不是我想做的事情。在他关于Kotlin 和 Exceptions的文章中，Kotlin 库负责人 Roman Elizarov 明确告诉我们：

不要使用异常来返回结果值，[并且]避免try/catch在一般应用程序代码中。

这是一篇很棒的文章，我同意它的原因有很多，但是不想使用异常的一个关键原因是它引入了未经类型检查的行为。如果我使用 my AuthenticationExpiredException，那么在不阅读代码的情况下，流程的调用者不知道他们必须捕获并处理它。try没有/ ，代码将编译得很好catch，并且在运行时会失败。这是 Kotlin 中有意的语言设计选择：在编译时不检查异常，因为它们根本不打算以这种方式使用。

密封类

在 Kotlin 的其他地方返回不同类型的结果的一个好方法是使用密封类。所以我可能会写这样的东西：

sealed class FlowResult<out T> {
    data class Value<T>(val value: T): FlowResult<T>
    object: NoMoreMessages: FlowResult<Nothing>()
    object: AuthenticationExpired: FlowResult<Nothing>()
}

val messages = flow {
    while(source.hasNext()) {
        if (authentication.isExpired) {
            emit(AuthenticationExpired)
            break
        }
        emit(Value(source.next()))
    }
    emit(NoMoreMessages)
}

这要好得多，因为现在两个可能的密切原因被平等对待。消费者可以使用一个when块来处理不同的结果，如果它们不包含处理AuthenticationExpired.

这种方法的问题是我无法强制执行“失败”结果必须始终是流程中的最后一项的规则。例如，假设我犯了一个错误，不小心错过了break循环中的 。

val messages = flow {
    while(source.hasNext()) {
        if (authentication.isExpired) {
            emit(AuthenticationExpired)
        }
        emit(Value(source.next()))
    }
    emit(NoMoreMessages)
}

现在我将最终发出AuthenticationExpired值而不实际终止流。它只会继续发送消息。这可能会导致各种错误和安全问题，但它会编译得很好。

感觉我真正在寻找的是一种collect可以返回值的机制，如下所示：

val closeReason = messages.collect { doSomethingWith(it) }
when (closeReason) {
    ...
}

有没有办法可以实现这样的目标？还是有另一种方法可以解决我所描述的问题？

4

1 回答 1

1

没有实现您想要的内置方法，但可以在现有 API 之上构建并将其与密封类组合：

// Essentially a functional Either type
sealed class Signal<out V, out T> {
    data class Value<V>(val value: V): Signal<V, Nothing>
    data class Terminal<T>(val value: T): Signal<Nothing, T>
}

然后构建一组扩展方法来做你想要的处理

inline suspend fun <reified V, T> Flow<Signal<V,T>>.collect(
    valueCollector: suspend (V) -> Unit
): T = onEach {
    if (it is Signal.Value) {
        valueCollector(it.value)
    }
}.filterIsInstance<Signal.Terminal<T>>().first().value

这value使用提供的收集器处理项目，并返回Terminal它看到的第一个实例的值作为返回值。

于 2020-09-05T19:06:39.053 回答