Kotlin 协程作用域：如果在控制器端点中使用 return@runBlocking 是否会出现问题

Question

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

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

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

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

相关的第二个问题：有什么区别

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

和

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

下面的所有尝试都在工作并返回 json 响应，但我不知道端点方法上的“runBlocking”和返回“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 Endpoint 的服务

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 文档中对此进行了说明。

对于协程，了解阻塞和挂起之间的区别很重要。

阻塞

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

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

暂停

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

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

如果您有长时间运行的操作，并且本质上不是挂起的，您可以使用我在“阻止”部分中提到的内容来转换它们。

那么什么更好呢？

好吧，这取决于这一行：

demoService.fetchUrl()

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

如果它是阻塞的，那么处理它的最佳方法是创建一个协程作用域并将其包装在使其挂起的东西中，例如withContext，然后从挂起函数返回它。

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