如何在spring应用程序中启动corutines

我有一个应用程序，它使用消息队列中的一些消息并对其进行处理。该处理作为挂起功能实现，有一个服务将事件发布到

频道

，我有另一个服务基本上可以：

for (event in channel) {
   eventProcessor.process(event)
}

问题是，这也是一个挂起函数，我真的不确定在Spring的上下文中启动它的正确方式是什么

我最初的解决方案是执行以下操作：

@Bean
fun myProcessor(eventProcessor: EventProcessor, channel: Channel<Event>): Job {
GlobalScope.launch {
  eventProcessor.startProcessing(channel)
}
}

@Bean
趣味myProcessor（eventProcessor:eventProcessor，channel:channel）：作业{
环球镜发射{
eventProcessor.startProcessing（通道）
}
}

---

但它似乎有点骇人，我不知道该怎么做。

在

GlobalScope

上启动任何东西都是一个非常糟糕的主意。这样就失去了结构化并发的所有优势

相反，让您的

EventProcessor

实现

CoroutineScope

这将强制您指定

coroutineContext

，以便您可以使用

调度程序。默认值为：

override val coroutineContext = Dispatchers.Default

因此，完整示例如下所示：

@SpringBootApplication
class SpringKotlinCoroutinesApplication {
    @Bean
    fun myProcessor(eventProcessor: EventProcessor, channel: Channel<Event>): Job {
        return eventProcessor.startProcessing(channel)
    }

    @Bean
    fun p() = EventProcessor()

    @Bean
    fun c() = Channel<Event>()
}

fun main(args: Array<String>) {
    runApplication<SpringKotlinCoroutinesApplication>(*args)
}

class Event

class EventProcessor : CoroutineScope {
    override val coroutineContext = Dispatchers.Default

    fun startProcessing(channel: Channel<Event>) = launch {
        for (e in channel) {
            println(e)
        }
    }
}

@springboot应用程序
SpringkotlincroutineApplication类{
@豆子
趣味myProcessor（eventProcessor:eventProcessor，channel:channel）：作业{
返回eventProcessor.startProcessing（通道）
}
@豆子
fun p（）=事件处理器（）
@豆子
fun c（）=通道（）
}
趣味主线（args:Array）{
运行应用程序（*args）
}
班级活动
类事件处理器：CoroutineScope{
override val coroutineContext=Dispatchers.Default
乐趣启动处理（频道：频道）=启动{
对于（通道中的e）{
println（e）
}
}
}
在
全球范围内启动任何东西都是一个非常糟糕的主意。这样就失去了结构化并发的所有优势

相反，让您的
EventProcessor
实现
CoroutineScope

这将强制您指定
coroutineContext
，以便您可以使用
调度程序。默认值为：

override val coroutineContext = Dispatchers.Default

因此，完整示例如下所示：

@SpringBootApplication
class SpringKotlinCoroutinesApplication {
    @Bean
    fun myProcessor(eventProcessor: EventProcessor, channel: Channel<Event>): Job {
        return eventProcessor.startProcessing(channel)
    }

    @Bean
    fun p() = EventProcessor()

    @Bean
    fun c() = Channel<Event>()
}

fun main(args: Array<String>) {
    runApplication<SpringKotlinCoroutinesApplication>(*args)
}

class Event

class EventProcessor : CoroutineScope {
    override val coroutineContext = Dispatchers.Default

    fun startProcessing(channel: Channel<Event>) = launch {
        for (e in channel) {
            println(e)
        }
    }
}

@springboot应用程序
SpringkotlincroutineApplication类{
@豆子
趣味myProcessor（eventProcessor:eventProcessor，channel:channel）：作业{
返回eventProcessor.startProcessing（通道）
}
@豆子
fun p（）=事件处理器（）
@豆子
fun c（）=通道（）
}
趣味主线（args:Array）{
运行应用程序（*args）
}
班级活动
类事件处理器：CoroutineScope{
override val coroutineContext=Dispatchers.Default
乐趣启动处理（频道：频道）=启动{
对于（通道中的e）{
println（e）
}
}
}
好的，谢谢，这是有道理的，但是除非我错过了一些东西，否则仍然不能回答我应该如何在spring中启动它的问题。更新了完整的示例。好的，我明白你的意思，但这意味着Job应该作为一个bean暴露在spring上下文中？然后谁负责在关机时取消任务？理想情况下，
EventProcessor
应该是一个Bean。由于它扩展了
CoroutineScope
，它将取消其任务。但在您的示例中，您使用的是
myProcessor（）
，这是非常多余的。好的，谢谢，这是有道理的，但除非我遗漏了一些东西，否则仍然无法回答关于如何在spring中启动它的问题。更新了完整的示例。好的，我明白您的观点，但这意味着作业应该作为bean公开到spring上下文中？然后谁负责在关机时取消任务？理想情况下，
EventProcessor
应该是一个Bean。由于它扩展了
CoroutineScope
，它将取消其任务。但在您的示例中，您使用的是
myProcessor（）
，这是非常多余的。