Java 按顺序使用不同的请求主体发出多个API请求

用例：我需要使用android客户端（改型）在服务器中发送一些请求。在我得到第一个答案后，我需要更新发送对象的值（取决于我得到的最后一个项目），并重新发送它，直到下载所有数据。我想知道如何通过改造和RxJava实现这一点（我不想使用while循环等）

编辑：

---

问题是，我不知道“平面图”的确切数量，因为数据可能会变大或变小。我有420000条记录，对于每个请求，我都加载1000个数据，你可以

flatMap

它们，并在下一个请求中使用它的响应，使用

it

参数，这是前一个请求的响应

mathApi.multiplyByTwo(1)
    .flatMap {
        mathApi.multiplyByTwo(it)
    }.flatMap {
        mathApi.multiplyByTwo(it)
    }.subscribe {
        // here "it" will be 4 (1*2*2) 
    }

如果您不知道最终会有多少个

flatMap

s，您可以使用递归函数来实现

private fun multiplyByTwo(number: Int) {
    mathApi.multiplyByTwo(number).subscribe {
        if (it < Integer.MAX_VALUE) { // When you run out of data.
            multiplyByTwo(it)
        }
    }
}

private fun multiplyByTwo（数字：Int）{
mathApi.multiplyByTwo（数字）。订阅{
如果（it

您可以

flatMap

它们，并通过使用

it

参数在下一个中使用其响应，该参数是前一个的响应

mathApi.multiplyByTwo(1)
    .flatMap {
        mathApi.multiplyByTwo(it)
    }.flatMap {
        mathApi.multiplyByTwo(it)
    }.subscribe {
        // here "it" will be 4 (1*2*2) 
    }

如果您不知道最终会有多少个

flatMap

s，您可以使用递归函数来实现

private fun multiplyByTwo(number: Int) {
    mathApi.multiplyByTwo(number).subscribe {
        if (it < Integer.MAX_VALUE) { // When you run out of data.
            multiplyByTwo(it)
        }
    }
}

private fun multiplyByTwo（数字：Int）{
mathApi.multiplyByTwo（数字）。订阅{
如果（it

您可以使用包含可变状态的generate函数：

data class ApiResponse(
    val nextPage: Int? = null
)

data class GeneratorState(
    var lastResponse: ApiResponse
)

fun makeApiCall(page: Int): ApiResponse {
    return ApiResponse(page + 1)
}

Flowable
    .generate(
        Callable { GeneratorState(makeApiCall(0)) },
        BiConsumer { state: GeneratorState, emitter: Emitter<ApiResponse> ->
            val latest = state.lastResponse

            if (latest.nextPage != null) {
                val response = makeApiCall(latest.nextPage)
                state.lastResponse = response
                emitter.onNext(response)
            } else {
                emitter.onComplete()
            }
        })
    .subscribe(object : FlowableSubscriber<ApiResponse> {
        var subscription: Subscription? = null

        override fun onSubscribe(s: Subscription) {
            subscription = s
            s.request(1)
        }

        override fun onNext(response: ApiResponse) {
            println("onNext :$response")
            if (response.nextPage != null && response.nextPage < 10) {
                subscription?.request(1)
            } else {
                subscription?.cancel()
            }
        }

        override fun onComplete() {
            println("Completed")
        }

        override fun onError(t: Throwable) {
            t.printStackTrace()
        }
    })

数据类响应(
val nextPage:Int？=null
)
数据类生成器状态(
var lastResponse:ApiResponse
)
趣味makeApiCall（page:Int）：ApiResponse{
返回ApiResponse（第+1页）
}
流动的
.产生(
可调用的{GeneratorState（makeApiCall（0））}，
双消费者{状态：生成器状态，发射器：发射器->
val latest=state.lastResponse
if（latest.nextPage！=null）{
val响应=makeApiCall（最新的.nextPage）
state.lastResponse=响应
emitter.onNext（响应）
}否则{
emitter.onComplete（）
}
})
.subscribe（对象：FlowableSubscriber）{
变量订阅：订阅？=null
覆盖订阅的乐趣（s:订阅）{
订阅=s
s、 请求（1）
}
覆盖fun onNext（响应：ApiResponse）{
println（“onNext:$response”）
if（response.nextPage！=null&&response.nextPage<10）{
订阅？请求（1）
}否则{
订阅？.cancel（）
}
}
覆盖有趣的onComplete（）{
println（“已完成”）
}
覆盖有趣的错误（t:可丢弃）{
t、 printStackTrace（）
}
})

您可以使用包含可变状态的generate函数：

data class ApiResponse(
    val nextPage: Int? = null
)

data class GeneratorState(
    var lastResponse: ApiResponse
)

fun makeApiCall(page: Int): ApiResponse {
    return ApiResponse(page + 1)
}

Flowable
    .generate(
        Callable { GeneratorState(makeApiCall(0)) },
        BiConsumer { state: GeneratorState, emitter: Emitter<ApiResponse> ->
            val latest = state.lastResponse

            if (latest.nextPage != null) {
                val response = makeApiCall(latest.nextPage)
                state.lastResponse = response
                emitter.onNext(response)
            } else {
                emitter.onComplete()
            }
        })
    .subscribe(object : FlowableSubscriber<ApiResponse> {
        var subscription: Subscription? = null

        override fun onSubscribe(s: Subscription) {
            subscription = s
            s.request(1)
        }

        override fun onNext(response: ApiResponse) {
            println("onNext :$response")
            if (response.nextPage != null && response.nextPage < 10) {
                subscription?.request(1)
            } else {
                subscription?.cancel()
            }
        }

        override fun onComplete() {
            println("Completed")
        }

        override fun onError(t: Throwable) {
            t.printStackTrace()
        }
    })

数据类响应(
val nextPage:Int？=null
)
数据类生成器状态(
var lastResponse:ApiResponse
)
趣味makeApiCall（page:Int）：ApiResponse{
返回ApiResponse（第+1页）
}
流动的
.产生(
可调用的{GeneratorState（makeApiCall（0））}，
双消费者{状态：生成器状态，发射器：发射器->
val latest=state.lastResponse
if（latest.nextPage！=null）{
val响应=makeApiCall（最新的.nextPage）
state.lastResponse=响应
emitter.onNext（响应）
}否则{
emitter.onComplete（）
}
})
.subscribe（对象：FlowableSubscriber）{
变量订阅：订阅？=null
覆盖订阅的乐趣（s:订阅）{
订阅=s
s、 请求（1）
}
覆盖fun onNext（响应：ApiResponse）{
println（“onNext:$response”）
if（response.nextPage！=null&&response.nextPage<10）{
订阅？请求（1）
}否则{
订阅？.cancel（）
}
}
覆盖有趣的onComplete（）{
println（“已完成”）
}
覆盖有趣的错误（t:可丢弃）{
t、 printStackTrace（）
}
})

他还可以使用协同程序。不，等等）问题是，我不知道“平面图”的确切数量，因为数据可能会变大或变小。我有420000条记录，对于每个请求我不加载1000个数据。在这种情况下，我只需编写一个递归函数。我将编辑我的回复。你是否试图从你的API一次获取一个页面的数据？他也可以使用协同程序。不，等等）问题是，我不知道“平面图”的确切数量，因为数据可能会变大或变小。我有420000条记录，对于每个请求我不加载1000个数据。在这种情况下，我只需编写一个递归函数。我将编辑我的响应。您是否试图一次从API页面获取数据？