Descripción general de RxJava
RxJava es una biblioteca de programación reactiva para crear operaciones asincrónicas basadas en eventos. Llamada en cadena basada en flujo de eventos, lógica clara y concisa.
Mi comprensión de RxJava es hacer fluir eventos desde el punto de inicio (aguas arriba) hasta el punto final (aguas abajo). Hay muchas tarjetas en el medio para operar y pasar los datos. Cada tarjeta obtiene el resultado pasado por la tarjeta anterior y luego procesa el evento y pasa el resultado a la siguiente tarjeta, de modo que el evento fluya desde el punto de inicio hasta el punto final a través de la tarjeta una y otra vez.
Modo de observador RxJava
El observador tradicional es un observador más que los observadores. Cuando lo observado cambia, todos los observadores son notificados a tiempo.
RXjava es un observador y múltiples observadores. Los objetos observados están conectados como una cadena, y los datos pasan en una dirección entre Observado hasta que pasa a Observer.
Comprensión del principio RxJava: el observador pasa eventos al observador en secuencia a través de la suscripción,
https://github.com/ReactiveX/RxJava
Resumir:
- RxJava es una biblioteca para implementar operaciones asincrónicas basadas en el flujo de eventos
- Función: realice una operación asíncrona, similar a la función de AsyncTask y Handler en Android
- Características: dado que el uso de RxJava se basa en la llamada en cadena del flujo de eventos, hace que la lógica de RxJava sea concisa, elegante y
fácil de usar.
Ejemplo de uso
Observando el hilo principal
Una de las operaciones más comunes cuando se trata de tareas asincrónicas en Android es observar el resultado o los resultados de la tarea en el hilo principal. Con Android Vanilla, esto suele ser posible a través de AsyncTask.Observable. Por el contrario, con RxJava declararías en el subproceso principal que sea observable:
Observable.just("one", "two", "three", "four", "five")
.subscribeOn(Schedulers.newThread())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(/* an Observer */);
Esto ejecuta el Observable en un nuevo subproceso y onNext emite el resultado en el subproceso principal.
Observar cualquier Observable
El ejemplo anterior es solo una especialización de un concepto más general: vincular la comunicación asíncrona a un bucle de mensajes de Android, o Looper.Para observar un Observable arbitrario, cree una asociación llamando al Looper: SchedulerAndroidSchedulers.from
Looper backgroundLooper = // ...
Observable.just("one", "two", "three", "four", "five")
.observeOn(AndroidSchedulers.from(backgroundLooper))
.subscribe(/* an Observer */)
Esto ejecutará el Observable en un nuevo subproceso y emitirá el resultado backgroundLooper onNext en cualquier subproceso en ejecución.
referencia relacionada
https://blog.csdn.net/yzwfeng/article/details/123493988