Comprender el operador RxJava Zip con un ejemplo

De acuerdo con la documentación oficial de RxJava, «Zip combina las emisiones de varios Observables usando una función dada y emite elementos únicos basados ​​en los resultados de esta función para cada combinación». El operador zip nos permite obtener resultados de varios observables al mismo tiempo.

Imagen 1. Entendiendo la Estructura Zip.

Supongamos que tenemos los siguientes dos observables de red: GfGCoursesData: un observable de red que genera una lista de cursos ofrecidos en Geeks for Geeks. GfGDSA: una red observable que devuelve una lista de cursos de estructura de datos Geeks for Geeks

GfFCourses ha notado lo siguiente:

fun getGfGCoursesData(): Observable<List<User>> {
    return networkService.getGfGCoursesData()
}

GFGDSA es el siguiente:

fun getGFGDSA(): Observable<List<User>> {
    return networkService.getGFGDSA()
}

Y aquí está nuestro NetworkService:

class NetworkService {
      
    fun gfgCourses(): Observable<List<User>> {
        return Observable.create<List<User>> { shooterData ->
            if (!shooterData.isDisposed) {
                // fetch gfgData from network
                val gfgData = fetchUserListFromNetwork()
                shooterData.onNext(gfgData)
                shooterData.onComplete()
            }
        }.subscribeOn(Schedulers.io())
    }
  
    fun gfgDSA(): Observable<List<User>> {
        return Observable.create<List<User>> { shooterData ->
            if (!shooterData.isDisposed) {
                // fetch gfgData from network
                val gfgData = fetchUserListFromNetwork()
                shooterData.onNext(gfgData)
                shooterData.onComplete()
            }
        }.subscribeOn(Schedulers.io())
    }
  
    private fun fetchUserListFromNetwork(): List<User> {
        return listOf()
    }
  
}

Como ejemplo, considere el siguiente observador:

private fun getTheObserver(): Observer<List<User>> {
    return object : Observer<List<User>> {
        override fun gfgSubscribed(d: Disposable) {
            println("gfgSubscribed")
        }
  
        override fun onNext(userList: List<User>) {
            println("onNext : $userList")
        }
  
        override fun onError(e: Throwable) {
            println("onError : ${e.message}")
        }
  
        override fun onComplete() {
            println("onComplete")
        }
    }
}

Una herramienta de utilidad para identificar cursos que son comunes.

private fun CommonCourses(GfGCourses: List<User>,
                                   gfgDSACourses: List<User>): List<User> {
    val CommonCourses = ArrayList<User>()
    for (gfgDSACourse in gfgDSACourses) {
        if (GfGCourses.contains(gfgDSACourse)) {
            CommonCourses.add(gfgDSACourse)
        }
    }
    return CommonCourses
}

Pongamos todo junto para obtener una mejor comprensión del operador zip.

Observable.zip(
    gfgCourses(),
    gfgDSACourses(),
    BiFunction<List<User>, List<User>, List<User>> { cricketFans, gfgCourses->
        // fetching results at once.
        return@BiFunction filterUserWhoLovesBoth(cricketFans, gfgDSA)
    })
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(getObserver())

Resumen

Primero, hacemos dos requests de red (simultáneamente porque estamos usando Zip Operator), y luego seleccionamos los cursos de DSA que forman parte de los cursos principales. Ambas llamadas de red se ejecutan en paralelo comprimiendo dos observables con el operador RxJava Zip. Cuando ambos observables han terminado, obtenemos el resultado de ambos. Obtenemos los resultados de ambos observables al mismo tiempo de esta manera.

Conclusión con algunas ventajas de RxZip

• Ejecute todos los trabajos en paralelo si los Programadores están asignados adecuadamente a cada observable.
• Cuando todos los trabajos hayan finalizado, devuelva los resultados de todos ellos en una sola devolución de llamada.
• Podemos utilizar el operador RxJava Zip para resolver el intrigante problema de esta manera.