Java 如何将io.micronaut.http.HttpRequest转换为CompletableFuture

我正在跟进，我想调整这个例子，以返回一个完整的未来。我的最终目标是并行使用两个不同的端点。我是Micronaut的新手。我相信一个好的方法是创建两个Micronaut低级客户端，它们返回一个可完成的未来，然后使用CompletableFuture.allOf（）.join（）将两者连接起来

因此，我将服务编码为

import com.mycomp.application.clients.EmployeClient
import com.mycomp.application.clients.EmployeeLowLevelClient
import java.awt.desktop.PrintFilesEvent
import java.util.*
import java.util.concurrent.CompletableFuture
import javax.inject.Inject
import javax.inject.Singleton

@Singleton
class EmployeeService {

    @Inject
    lateinit var employeClient: EmployeClient //Declarative Cliente

    @Inject
    lateinit var employeeLowLevelClient: EmployeeLowLevelClient //Low Level Client

    fun thenCombineAsyncExample() {

        val allFutures: MutableList<CompletableFuture<String>> = ArrayList<CompletableFuture<String>>()

        allFutures.add(employeClient.getEmployeesA()) //### THIS WORKS
        allFutures.add(employeClient.getEmployeesB()) //### THIS WORKS
        employeeLowLevelClient.getEmployeeSurname()?.let { allFutures.add(it) } //### THIS FAILS

        CompletableFuture.allOf(*allFutures.toTypedArray<CompletableFuture<*>>()).join()

        for (i in 0..1) {
            print("response: " + allFutures[i].get().toString())
        }
    }
}

有趣的是，我并没有得到声明性客户端的异常

import io.micronaut.http.annotation.Get
import io.micronaut.http.client.annotation.Client
import io.reactivex.Single
import java.util.concurrent.CompletableFuture

@Client()
interface EmployeClient {

    @Get("http://localhost:3000/employees_a?first_name=Jimis")
    fun getEmployeesA(): CompletableFuture<String>

    @Get("http://localhost:3001/employees_b?first_name=Jimis")
    fun getEmployeesB(): CompletableFuture<String>
}

import io.micronaut.http.annotation.Get
导入io.micronaut.http.client.annotation.client
导入io.reactivex.Single
导入java.util.concurrent.CompletableFuture
@客户（）
接口EmployeClient{
@得到（”http://localhost:3000/employees_a?first_name=Jimis")
fun getEmployeesA（）：CompletableFuture
@得到（”http://localhost:3001/employees_b?first_name=Jimis")
乐趣getEmployeesB（）：可完成的未来
}

如果我理解正确，您希望异步发出一些Http请求

下面的几行比较直截了当，但我认为可能会有一些混乱

val allFutures:MutableList=ArrayList（）
allFutures.add（employeClient.getEmployeesA（））/###这很有效
allFutures.add（employeClient.getEmployeesB（））/####这很有效
employeeLowLevelClient.GetEmployeeNames（）？。让{allFutures.add（it）}

您可以创建一个

CompletableFuture

s的列表。然后向其中添加两个

CompletableFuture

s。然后使用“客户机”调用带有

CompletableFuture

s的

getEmployeeNameName（）

因此，在我看来，您希望

getEmployeeAn姓氏（）

返回一个

CompletableFuture

，以便将其添加到

allFutures

因此，您希望为

getEmployeeNames（）

创建一个函数，更像：

internal fun GetEmployeeNames（）：CompletableFuture？{
val req=HttpRequest.GET（“http://localhost:3000/employees_a?first_name=Jimis")
//val flowable=httpClient.retrieve（请求）
返回CompletableFuture.runAsync（req）
}

然后，该函数返回包装在可完成未来的Http请求。您不能仅仅将HttpClient转换为一个完整的未来，因为两者之间没有共同点

所以现在当你这样做的时候：

employeeLowLevelClient.getemployeenam姓氏（）？.let{allFutures.add（it）}

它应该添加

CompletableFuture

调用应该在单独的线程上运行，而不会阻塞主线程上的执行。

Rob，谢谢。我在“…CompletableFuture.runAsync（req）…”中得到“类型不匹配。必需：CompletableFuture？找到：CompletableFuture！”。

java.lang.ClassCastException: class io.micronaut.http.client.netty.NettyClientHttpRequest cannot be cast to class java.util.concurrent.CompletableFuture (io.micronaut.http.client.netty.NettyClientHttpRequest is in unnamed module of loader 'app'; java.util.concurrent.CompletableFuture is in module java.base of loader 'bootstrap')

import io.micronaut.http.annotation.Get
import io.micronaut.http.client.annotation.Client
import io.reactivex.Single
import java.util.concurrent.CompletableFuture

@Client()
interface EmployeClient {

    @Get("http://localhost:3000/employees_a?first_name=Jimis")
    fun getEmployeesA(): CompletableFuture<String>

    @Get("http://localhost:3001/employees_b?first_name=Jimis")
    fun getEmployeesB(): CompletableFuture<String>
}