Operador de aplazamiento de RxJava

En este artículo, aprenderemos sobre el operador de aplazamiento de RxJava. Dependiendo de nuestro caso de uso, sabremos cuándo utilizar el operador Defer. Con frecuencia cometemos errores al utilizar el operador de aplazamiento RxJava. Aclaremos esto para no cometer un error.

Según la documentación:

Aplazar: espere hasta que el observador se suscriba antes de crear el Observable y construya un nuevo Observable para cada observador.

Entonces, en este caso, usaremos un ejemplo para aprender sobre el operador Defer de RxJava. Supongamos que tenemos una clase GfG, como se muestra a continuación:

class GfG {
    var course: String = "DSA"
 
    fun getCourseObservable(): Observable<String> {
        return Observable.just(course)
    }
 
    fun getCourseDeferObservable(): Observable<String> {
        return Observable.defer {
            return@defer Observable.just(course)
        }
    }
 
}

 
 Tenemos dos métodos en la clase GfG descritos anteriormente: 

1. getCourseObservable() : esta función simplemente devuelve el Observable<String> usando Observable.just(course).
2. getCourseDeferObservable() : el Observable<String> se devuelve usando Observable.just(course), pero encerrado dentro del Observable defer().

Ahora, probemos ambos métodos y veamos qué sucede. 

val course = Gfg()
val courseObservable = course.getCourseObservable()
val courseDeferObservable = course.getCourseDeferObservable()
course.price = "DSA"
courseObservable
.subscribe { brand ->
    Log.d("GfGExample", "courseObservable : $course")
}
courseDeferObservable
.subscribe { brand ->
    Log.d("GfGExample", "courseDeferObservable : $course")
}

Primero, vamos a hacer el objeto precio. Luego, usando el objeto de precio, usamos los métodos getCourseObservable y getCourseDeferObservable para recuperar los observables. Luego especificamos la marca del curso como «DSA». A continuación, suscribimos ambos observables para determinar el precio del curso. 

La salida del código anterior: 

GfGExample: courseObservable : DEFAULT
GfGExample: courseDeferObservable : DSA

Aquí, podemos ver que el cursoObservable recibe «DEFAULT» como el nombre del curso, pero el cursoDeferObservable recibe «DSA» como el curso. Debido a que no se usó el operador de aplazamiento, CourseObservable devuelve el valor anterior «DEFAULT». Debido a que se utilizó el operador de aplazamiento, CourseDeferObservable devuelve el valor más reciente, «DSA». Indica que Defer no genera el Observable hasta que el observador se suscribe y que cada observador recibe un nuevo Observable.

Conclusión

Hay dos puntos críticos para recordar: 

1. El Observable no se crea hasta que el observador se suscribe.
2. Para cada observador, Defer genera un nuevo observable.

Como resultado, podemos utilizar el operador de aplazamiento RxJava para resolver el problema intrigante. ¡Espero que este artículo te haya ayudado a entender el tema!