如何使用Observable.zip（…）来获取API响应？

Question

我必须点击3个API才能更新同一屏幕，因此，我认为RxJava是并行执行此操作的最快方法。在搜索实现时，我遇到了Observable.zip（...）函数，因为它可以并行执行多个API命中。

我正在使用Retrofit来调用API，并且已经使用gson注释创建了Pojo类。

Pojo示例课程：

data class ResponseGetFCData(

    @SerializedName("End")
    val end: String,
    @SerializedName("Uni")
    val uni: String,
    @SerializedName("Y")
    val y: Double
)

data class ResponseAK(

    @SerializedName("End")
    val end: String,
    @SerializedName("Manu")
    val manu: String,
    @SerializedName("Start")
    val start: String,
    @SerializedName("TY")
    val tY: Double

)

Sample Api Interface：

interface Api{
@GET("GetUniPI")
    fun getFCdata(@Query("pi") pi: String
                 , @Query("uni") uni: String): Observable<ResponseGetFCData>
}

Objective：从3个API中的2个的响应中，我必须进行一些数学计算，第三个API响应将携带用于回收者视图的数据。在这里，我必须通过从API 1中获取y和从API 2中获取ty以及类似的计算来计算（y * ty）/ 100。

MyCode：活动中的onCreate（....）：

        val requests = ArrayList<Observable<*>>()
        val backendApi = WinRetrofitHelper.winApiInstance()

        requests.add(backendApi.getFCdata("","","",""))
        requests.add(backendApi.getAKCountry())
        requests.add(backendApi.getRecyclerData("","",""))

        Observable
                .zip(requests) {

                }
                )
                .subscribe({

                    Log.e("Exe Summary","******************Success*******************")

                }) {

                    Log.e("Exe Summary",it.stackTrace.toString())
                }

因此，在这里我没有得到如何从这3个API获取响应以及如何和在何处计算数学，以及如何从第3个API响应更新recyclerview适配器中的数据。请以更好的方法帮助我理解这一点。

Answer 1

或者您可以尝试协程。它具有简单易懂的语法]

fun toDoWorkConcurrent() {

    job2 = launch {

        try {
            val work1 = async { getThingsDone(43) }
            val work2 = async { getThingsDoneAgain(123) }

            val result = computeResult(work1.await(), work2.await())

            withContext(UI) {
                tvResult1.text = result.toString()
            }

        } catch (exception: Exception) {
            exception.printStackTrace()
        }

    }
}

private fun computeResult(await: Int, await1: Int): Int {
    return await + await1
}

编辑： Source

Answer 2

请尝试这样

 Observable.zip(yourobservalelist, new Function<Object[], Object>() {
        @Override
        public Object apply(Object[] objects) throws Exception {


            return objects;
        }
    })

            .subscribeOn(Schedulers.newThread())
            .observeOn(AndroidSchedulers.mainThread())
            .doOnSubscribe(new Consumer<Disposable>() {
                @Override
                public void accept(Disposable disposable) throws Exception {

                }
            })
            .doOnTerminate(new Action() {
                @Override
                public void run() throws Exception {

                }
            })
            .subscribe(new Consumer<Object>() {
                           @Override
                           public void accept(Object o) throws Exception {
                               //Do something on successful completion of allrequests

                               //}
                           }
                       },

                    // Will be triggered if any error during requests will happen
                    new Consumer<Throwable>() {
                        @Override
                        public void accept(Throwable e) throws Exception {
                            //Do something on error completion of requests
                            e.printStackTrace();
                        }
                    });


}