Kotlin Coroutine Scope：如果在 Controller Endpoint 中使用，return@runBlocking 是一个问题

Question

目的：假设我正在编写一个轻型异步端点客户端，我想编写一个消耗另一个端点的端点，利用轻型协程。

我的背景：第一次尝试使用 Kotlin Coroutine。我研究了最后几天并四处寻找。我找到了很多解释如何在 Android 中使用协程的文章，我发现很少有其他文章解释如何在主函数中使用协程。不幸的是，我没有找到解释如何使用协同程序编写 Controller 端点的文章，如果我做的事情不推荐，它会在我脑海中响起。

当前情况：我使用协程成功创建了一些方法，但我想知道哪种方法最适合传统 GET。最重要的是，我想知道如何正确处理异常。

主要问题：推荐使用以下方法中的哪一种，我应该注意哪种异常处理？

相关次要问题：

有什么区别

fun someMethodWithRunBlocking(): String? = runBlocking {
 return@runBlocking ...
}

和

suspend fun someMethodWithSuspendModifier(): String?{
  return ...
}

下面的所有试验都在工作并且 returning json 响应但我不知道端点方法上是否“runBlocking”和 returning “return @runBlocking”可能会给我带来一些负面影响。

控制器（端点）

package com.tolearn.controller

import com.tolearn.service.DemoService
import io.micronaut.http.MediaType
import io.micronaut.http.annotation.Controller
import io.micronaut.http.annotation.Get
import io.micronaut.http.annotation.Produces
import kotlinx.coroutines.Deferred
import kotlinx.coroutines.*
import kotlinx.coroutines.runBlocking
import java.net.http.HttpResponse
import javax.inject.Inject

@Controller("/tolearn")
class DemoController {

    @Inject
    lateinit var demoService: DemoService

    //APPROACH 1:
    //EndPoint method with runBlocking CoroutineScope
    //Using Deferred.await
    //Using return@runBlocking
    @Get("/test1")
    @Produces(MediaType.TEXT_PLAIN)
    fun getWithRunBlockingAndDeferred(): String? = runBlocking {

        val jobDeferred: Deferred<String?> = async{
            demoService.fetchUrl()
        }

        jobDeferred.await()

        return@runBlocking jobDeferred.await()
    }

    //APPROACH 2:
    //EndPoint method with runBlocking CoroutineScope
    //Using return@runBlocking
    @Get("/test2")
    @Produces(MediaType.TEXT_PLAIN)
    fun getWithReturnRunBlocking(): String? = runBlocking {

        return@runBlocking demoService.fetchUrl()

    }

    //APPROACH 3:
    //EndPoint method with suspend modifier calling a suspend modifier function
    //No runBlocking neither CoroutineScope at all
    @Get("/test3")
    @Produces(MediaType.TEXT_PLAIN)
    suspend fun getSuspendFunction(): String? {

        return demoService.fetchUrlWithoutCoroutineScope()
    }
}

用于调用另一个 Rest 端点的服务

package com.tolearn.service

import kotlinx.coroutines.coroutineScope
import java.net.URI
import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import java.time.Duration
import javax.inject.Singleton

@Singleton
class DemoService {

    suspend fun fetchUrl(): String? = coroutineScope {

        val client: HttpClient = HttpClient.newBuilder()
                .version(HttpClient.Version.HTTP_2)
                .followRedirects(HttpClient.Redirect.NEVER)
                .connectTimeout(Duration.ofSeconds(20))
                .build()

        val request = HttpRequest.newBuilder()
                .uri(URI.create("http://localhost:3000/employees"))
                .build()

        val response = client.sendAsync(request, HttpResponse.BodyHandlers.ofString());

        print(response.get().body())

        return@coroutineScope response.get().body()
    }

    suspend fun fetchUrlWithoutCoroutineScope(): String? {

        val client: HttpClient = HttpClient.newBuilder()
                .version(HttpClient.Version.HTTP_2)
                .followRedirects(HttpClient.Redirect.NEVER)
                .connectTimeout(Duration.ofSeconds(20))
                .build()

        val request = HttpRequest.newBuilder()
                .uri(URI.create("http://localhost:3000/employees"))
                .build()

        val response = client.sendAsync(request, HttpResponse.BodyHandlers.ofString());

        return response.get().body()
    }

}

万一重要，这里是build.gradle

plugins {
    id("org.jetbrains.kotlin.jvm") version "1.4.10"
    id("org.jetbrains.kotlin.kapt") version "1.4.10"
    id("org.jetbrains.kotlin.plugin.allopen") version "1.4.10"
    id("com.github.johnrengelman.shadow") version "6.1.0"
    id("io.micronaut.application") version "1.2.0"
}

version = "0.1"
group = "com.tolearn"

repositories {
    mavenCentral()
    jcenter()
}

micronaut {
    runtime("netty")
    testRuntime("junit5")
    processing {
        incremental(true)
        annotations("com.tolearn.*")
    }
}

dependencies {
    implementation("io.micronaut:micronaut-validation")
    implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8:${kotlinVersion}")
    implementation("org.jetbrains.kotlin:kotlin-reflect:${kotlinVersion}")
    implementation("io.micronaut.kotlin:micronaut-kotlin-runtime")
    implementation("io.micronaut:micronaut-runtime")
    implementation("javax.annotation:javax.annotation-api")
    implementation("io.micronaut:micronaut-http-client")

    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.2")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-jdk8:1.4.2")

    runtimeOnly("ch.qos.logback:logback-classic")
    runtimeOnly("com.fasterxml.jackson.module:jackson-module-kotlin")
}


application {
    mainClass.set("com.tolearn.ApplicationKt")
}

java {
    sourceCompatibility = JavaVersion.toVersion("11")
}

tasks {
    compileKotlin {
        kotlinOptions {
            jvmTarget = "11"
        }
    }
    compileTestKotlin {
        kotlinOptions {
            jvmTarget = "11"
        }
    }


}

Answer 1

您通常希望避免在“主要”入口点函数和测试之外的生产代码中使用 runBlocking。 runBlocking documentation.

中说明了这一点

对于协程，了解 blocking 和 suspending 之间的区别很重要。

阻止

阻塞代码阻止整个线程继续。请记住，协程适用于异步编程，而不是多线程。因此，假设两个或多个协程可以运行在同一个线程上。现在，当您阻塞线程时会发生什么？ None 其中运行.

这很危险。阻塞代码绝对会毁了你的异步编程。有时您必须使用阻塞代码，例如在处理文件时。 Kotlin 有特殊的方法来处理它，例如 IO Dispatcher，它会运行代码在它自己的隔离线程上，这样它就不会中断你的其他协程。

暂停

这是协程的核心。这个想法是当你的协程被挂起时，它告诉协程作用域另一个协程可以同时执行。挂起部分完全抽象为异步机制的工作方式。这部分取决于范围和调度程序的实现。

暂停不会自动发生。某些框架，例如 KTor 在其 API 中使用协程，因此您经常会发现挂起的函数。

如果您有长时间的运行ning 操作，这些操作本质上不是挂起的，您可以使用我在“阻塞”部分中提到的类似方法来转换它们。

那么什么更好？

嗯，这取决于这一行：

demoService.fetchUrl()

fetchUrl()是暂停还是阻塞？如果它是阻塞的，那么你的所有建议都大致相同（不推荐）。如果是暂停，那么你的第三个选择是最好的。

如果它是阻塞的，那么处理它的最好方法是创建一个协程范围并将其包装在使其暂停的东西中，例如 withContext 和 return 来自你的暂停功能。

但是，只有在协同程序中调用这些函数时才会出现这种情况。我对 Micronaut 不熟悉。如果该框架自动调用您的方法而不使用协程，那么在此 class 中引入它们根本没有意义。

Kotlin Coroutine Scope：如果在 Controller Endpoint 中使用，return@runBlocking 是一个问题

Kotlin Coroutine Scope : Is return@runBlocking an issue if used in Controller Endpoint

kotlin

java-http-client

java-11

kotlin-coroutines

阻止

暂停

那么什么更好？