问题描述

我想通过Kotlin RowCallbackHandler流式传输Spring JDBC Sequence捕获的结果对象。

代码基本上是这样的：

fun findManyObjects(): Sequence<Thing> = sequence {
    val rowHandler = object : RowCallbackHandler {
        override fun processRow(resultSet: ResultSet) {
            val thing = // create from resultSet
            yield(thing) // ERROR! No coroutine scope
        }
    }
    jdbcTemplate.query("select * from ...",rowHandler)
}

但是我收到编译错误：

只能在协程体内调用悬浮函数。

但是，正是这个“协程体”应该存在，因为整个块都包装在sequence构建器中。但这似乎不适用于嵌套对象。

显示不与嵌套对象一起编译的最小示例：

// compiles
sequence {
    yield(1)
}

// doesn't compile
sequence {
   object {
        fun doit() {
            yield(1) // Suspension functions can be called only within coroutine body.
        }
    }
}

如何将对象从ResultSet传递到Sequence？

解决方法

将`Flow`用于异步数据流

无法在yield对象内调用RowCallbackHandler的原因是双重的。

processRow函数不是一个挂起的函数（并且不能这样，因为它是在Java中声明和调用的）。像yield这样的挂起函数只能由另一个挂起函数调用。
sequence { ... }构建器返回时，序列总是结束。即使您和我知道query方法将在从序列返回之前调用RowCallbackHandler，但Kotlin编译器也无法得知。不允许从函数和对象（而不是序列本身）中产生序列值，因为无法知道它们将在何处或何时运行。

要解决此问题，我们需要引入另一种协程：一种协程可以在等待RowCallbackHandler被调用时挂起。

不幸的是，由于我们在这里谈论的是JDBC，因此引入成熟的协程可能没有太多好处。在后台，对数据库的调用将始终以阻塞的方式进行，从而消除了很多好处。不尝试并“串流”结果，而只是以一种无聊的老式方式遍历它们，可能会更简单。但是，让我们一起探索各种可能性。

序列问题

序列是为按需计算而设计的，并且非异步。他们不能等待其他异步操作，例如回调。序列生成器的yield函数只是在等待调用者检索下一个项目时挂起，这是序列允许调用的唯一挂起函数。如果尝试在序列中使用像delay这样的简单挂起调用，则可以演示这一点。您会收到一个编译错误，让您知道您在受限的协程范围内进行操作。

sequence<String> { delay(1000) } // doesn't compile

由于无法调用挂起函数，因此无法等待回调被调用。意识到这一局限性后，Kotlin为按需值流提供了一种替代机制，该流确实以异步方式提供数据。称为流。

回调流

Roman Elizarov在他的中型文章 Callbacks and Kotlin Flows 中很好地描述了使用Flows从回调接口提供值的机制。

如果您确实想使用回调流程，只需将sequence替换为callbackFlow，并将yield替换为sendBlocking。

您的代码可能看起来像这样：

fun findManyObjects(): Flow<Thing> = callbackFlow {
    val rowHandler = object : RowCallbackHandler {
        override fun processRow(resultSet: ResultSet) {
            val thing = // create from resultSet
            sendBlocking(thing)
        }
    }
    jdbcTemplate.query("select * from ...",rowHandler)
    close() // the query is finished,so there are no more rows
}

更简单的流程

虽然这是流式处理由回调提供的值的惯用方法，但它可能不是解决此问题的最简单方法。通过完全避免回调，您可以使用更为常见的flow构建器，将每个值传递给其emit函数。但是，既然您已经拥有了协程形式的异步性，那么您不仅可以返回一个流，然后允许Spring立即关闭结果集。您需要能够延迟结果集的关闭，直到实际消耗完流为止。这意味着剥去RowCallbackHandler或ResultSetExtractor提供的抽象，它们希望以阻塞的方式处理所有结果，而是提供自己的实现。

fun Connection.findManyObjects(): Flow<Thing> = flow {
    prepareStatement("select * from ...").use { statement ->
        statement.executeQuery().use { resultSet ->        
            while (resultSet.next()) {
                val thing = // create from resultSet
                emit(thing)
            }
        }
    }
}

请注意use块，它将处理关闭语句和结果集。因为直到use循环完成并且发出所有值之后，我们才到达while块的末尾，所以在结果集保持打开状态时，流可以自由地暂停。

那为什么要使用流程呢？

您可能会注意到，如果以此方式进行操作，您实际上可以将flow和emit替换为sequence和yield。那么我们来了整整一圈吗？好吧，有点。区别在于flow只能从协程中消费，而sequence则可以遍历结果值而无需暂停。在这种情况下，很难进行调用，因为 JDBC操作始终会阻塞。

如果使用序列，则调用线程将在等待接收数据时阻塞。序列中的值始终由使用该序列的事物计算，因此，如果该序列调用了阻塞函数，则使用者的线程将阻塞等待该值。在非协程应用程序中，这可能还可以，但是如果您正在使用协程，您确实要避免在看起来无害的序列中隐藏阻塞调用。
如果使用流，则可以通过使流在特定调度程序上运行来至少隔离阻塞调用。例如，您可以使用内置的IO调度程序来执行JDBC调用，然后切换回默认调度程序以进行进一步的处理。如果您确实想流式传输值，我认为这是比使用序列更好的方法。

请牢记所有这些，如果您选择其中一种解决方案，则需要谨慎使用协程和调度程序。如果您不想为此担心，那么使用常规的ResultSetExtractor并暂时忽略序列和流并没有什么错。

在Kotlin序列中的嵌套对象中使用yield