如何转换io。微型机器人。http。Http要求完成未来

Question

我正在关注4个低级客户，我想调整示例以返回一个完整的未来。我的最终目标是并行使用两个不同的endpoint。我是Micronaut的新手。我相信一个很好的方法是创建两个Micronaut低级别客户，它们返回一个可完成的未来，然后用可完成的未来将两者结合起来。allOf（）。加入

所以我把服务编码为

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.HttpRequest
import io.micronaut.http.client.RxHttpClient
import java.util.concurrent.CompletableFuture
import javax.inject.Singleton

@Singleton
class EmployeeLowLevelClient(private val httpClient: RxHttpClient) {
    internal fun getEmployeeSurname(): CompletableFuture<String>? {

        val req = HttpRequest.GET<String>("http://localhost:3000/employees_a?first_name=Jimis")
        //val flowable = httpClient.retrieve(req)
        return req as CompletableFuture<String> //### HERE IS THE ISSUE

    }
}

借口是

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>
}

Answer 1

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

以下几行相对来说比较直截了当，但我认为可能存在一些困惑。。。

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) }

创建一个CompletableFutures列表，然后向其中添加两个CompletableFutures。然后使用“客户机”调用getEmployeeNames（），使用CompletableFutures。

因此，在我看来，您希望GetEmployeeAn姓氏（）返回一个CompletableFuture，以便将其添加到allFutures

所以你想要一个函数的get雇员Surname（）更像：

internal fun getEmployeeSurname(): CompletableFuture<String>? {

        val req = HttpRequest.GET<String>("http://localhost:3000/employees_a?first_name=Jimis")
        //val flowable = httpClient.retrieve(req)
        return CompletableFuture.runAsync(req)
    }

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

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

employeeLowLevelClient.getEmployeeSurname()?.let { allFutures.add(it) }

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