Kotlin内的java.net.http.HttpClient挂起函数：未解析引用：等待

我正在尝试使用Kotlin协同路由编写Http请求，如中所述

及

就我所见，我的代码与这两个示例非常接近：

package com.tolearn.service

import java.net.URI
import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import java.net.http.HttpResponse.BodyHandlers
import javax.inject.Inject
import javax.inject.Named
import javax.inject.Singleton


@Singleton
class DemoService {

    fun postDemo(key: String, msg: String){

        suspend fun getCoroutine(){
    
            val someData = getData()
    
            print(someData)
        }
    
        suspend fun getData(): String {
    
    
            val client = HttpClient.newBuilder()
                    .version(HttpClient.Version.HTTP_2)
                    .build();
    
            val request = HttpRequest.newBuilder()
                    .uri(URI.create("http://localhost:3000/employees"))
                    .build();
    
            val response = client.sendAsync(request, BodyHandlers.ofString());
    
            return response.await().body() ***here I get Unresolved reference: await
            //return response.get().body() ***this line works but I understand I should prefer use previous line with "awai()" instead of "get()"
        }
    }
}

我的最终目标是公开一个端点（控制器），它将在挂起函数中调用另一个端点抛出java.net.http.HttpClient。我的微服务是完全无状态的，并且需要尽可能地更快、更轻。这是我第一次编写Kotlin协同程序。基于理论研究，我知道协同程序比线程便宜，我为协同程序做了一个很好的选择。尽管如此，我对它还是新手，正在与错误/异常处理等疑问作斗争，更直接地说，我为什么会得到未解决的引用：等待

所以我的直接问题是：为什么返回response.await（）.body（）导致未解析的引用：await？我应该用response.get（）.body（）替换吗

任何其他建议或提示将受到高度赞赏

***编辑

这是我的身材，格雷德尔。我刚刚添加了kotlinx-coroutines-jdk8:1.4.2

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"
    id("com.google.protobuf") version "0.8.13"
}

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

repositories {
    mavenLocal()
    jcenter()
    mavenCentral()
}

micronaut {
    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("io.micronaut.grpc:micronaut-grpc-runtime")
    implementation("javax.annotation:javax.annotation-api")
    implementation("io.micronaut.kafka:micronaut-kafka")

    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")
    testImplementation("io.micronaut:micronaut-http-client")
}


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

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

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


}

sourceSets {
    main {
        java {
            srcDirs("build/generated/source/proto/main/grpc")
            //srcDirs 'build/generated/source/proto/main/grpckt'
            srcDirs("build/generated/source/proto/main/java")
        }
    }
}

protobuf {
    protoc { artifact = "com.google.protobuf:protoc:3.14.0" }
    plugins {
        grpc { artifact = "io.grpc:protoc-gen-grpc-java:1.33.1" }
        //grpckt { artifact = "io.grpc:protoc-gen-grpc-kotlin:1.0.0" }
    }
    generateProtoTasks {
        all()*.plugins {
            grpc {}
            //grpckt {}
        }
    }
}

---

确保类路径上有

kotlinx-coroutines-jdk8

库，然后使用以下导入语句：

import kotlinx.coroutines.future.await 

---

await（）

是一个扩展函数，因此需要像导入类一样导入它。如果无法导入，请确保项目依赖项中有

kotlinx-coroutines-jdk8

库。这就是扩展函数的来源。我添加了kotlinx-coroutines-jdk8。谢谢但我仍然得到了未解决的参考：等待。我一定要等待吗？有点奇怪，因为响应是由client.sendaync填写的。如果我遗漏了什么，你能看到我的导入吗？是的，你需要导入扩展函数本身。在IntelliJ或Android Studio中，您可以将光标放在上面，然后按Alt+Enter，这样它将建议自动执行。这就是问题所在：IntelliJ不建议任何导入。您可以使用

import kotlinx.coroutines.future.wait导入它