En este artículo voy a explicar los fundamentos de RxJava a través de ejemplos. Este artículo es para los principiantes de RxJava. Por otra parte, si usted ya sabe algo acerca de RxJava, este artículo es bueno para revisar su conocimiento.

RxJava es una implementación de Java VM de ReactiveX una biblioteca para componer programas asíncronos y basados en eventos mediante el uso de secuencias observables.

Los bloques de construcción de RxJava son Observables y Suscriptores. El Observable se utiliza para emitir elementos y el Subscriber se utiliza para consumir esos elementos. Tal vez algunos de ustedes pensarán: «Hmmm esto es tan similar al patrón Observable estándar». Y sí lo es, pero RxJava lo hace mucho mejor y tiene más opciones. Por ejemplo, los Observables no suelen empezar a emitir elementos hasta que alguien se suscribe a ellos. Esta es una gran característica porque de esta manera debe ahorrar sus actuaciones.

RxJava funciona así. Subscriber se suscribe a Observable, entonces Observable llama a Subscriber.onNext() para cualquier número de elementos, si algo va mal aquí está Subsciber.onError() y si todo termina bien, aquí está Subscriber.onCompleted(). Ves que esto es fácil!

¡Cállate! Dame algunos códigos elegantes!

Ejemplo 1

En este ejemplo crearemos un Observable y un Subscriber básicos, y luego los enlazaremos, y veremos qué pasa. ¡Alerta de spoiler! Algo impresionante…

Creemos un Observable básico:

El Observable creado emite la Cadena «Blue Factory» y luego se completa. La cadena «Blue Factory» se recibirá en el método onNext() del suscriptor. Ahora vamos a crear Subscriber.

Subscriber recibe el valor de String en el método onNext() y lo imprime, también String «I’m done» se imprime cuando se llama a los métodos onCompleted().

Ahora únelos.

Resultado:

I/System.out: Blue Factory

I/System.out: He terminado

Cuando ocurre la suscripción, myObservable llama a los métodos onNext() y onComplited() de mySubscription. Los resultados son las salidas «Blue factory» y «I’m done», después todo se detiene y termina.

¿Puedo hacerlo más sencillo?

¡Por supuesto! Puedes hacerlo!

Puedes notar que una creación de miObservable tiene demasiado código y se ve desordenado. RxJava nos da algunos atajos de lujo.

Algunos de esos atajos son métodos como Observable.just() y Observable.from();

Observable.just() emite sólo un elemento y Observable.from() emite un elemento por uno de la lista de elementos.

¡Cállate! ¡Dame algo de código elegante!

Ejemplo 2

En este ejemplo haremos lo mismo que en el Ejemplo 1, pero ahora con menos código.

Creemos nuestro nuevo Observable elegante y con buena pinta:

¡Vaya! Parece que nuestro Observable ha perdido algo de peso!
Creemos el Subscriber:

¡El Subscriber es el mismo!
¡Ahora únelos y espera a que ocurra la magia!

Resultado:

I/System.out: Blue Factory
I/System.out: He terminado

Como ves, conseguimos completar nuestra tarea, y hacer exactamente lo mismo con menos código.
¡Cállate!

Ejemplo 3

En este ejemplo haremos algo un poco diferente con Observable.from(). La idea es imprimir las cadenas «Blue», «Factory», «Blog», «Post».
Recordemos qué es Observable.from(). Observable.from() recibe la lista de elementos y emite uno por uno, así que Observable.from() es exactamente lo que necesitamos.
Primero vamos a crear un ArrayList con cadenas:

Creemos ese Observable.from(), ¿de acuerdo?

Como puedes ver, Observable.from() recibe como argumento un ArrayList cargado con Strings. Ahora, vamos a crear Subscriber y a enlazarlos, y a esperar la magia.

Resultado:

I/System.out: Blue
I/System.out: Factory
I/System.out: Blog
I/System.out: Post

¡Como ves, hemos vuelto a hacer nuestra tarea con éxito!
Todo lo que has aprendido hasta ahora son puros trucos básicos, pero ahora haremos algunos trucos más «difíciles»

¿Qué son los Operadores en Rx?

Los Operadores son métodos creados para resolver transformaciones y manejar problemas de llamadas a la API. Voy a mostrar un ejemplo simple para la transformación con Map, y tal vez en algunos artículos más ejemplos de manejo de llamadas a la API con Retrofit, RxJava en el patrón arquitectónico MVP.

Por ejemplo vamos a anexar nuestra cadena «Blue Factory» con » Blog Post». Podemos hacerlo de varias maneras.

Primera manera:

Podemos hacerlo en Observable, pero Observable se supone que emite elementos, no para cambiarlos.
Segunda forma:

La misma historia, Subscriber no se supone que cambie los elementos.
La solución es añadir un paso más, añadiendo Operator. Operator es un paso adicional entre Observable y Subscriber, donde el objeto puede ser transformado.
¡Así que vamos a hacerlo de la manera correcta!
¡Cállate!

Ejemplo 4

Primero vamos a crear el Observable:

Nota que miObservable emite sólo un elemento sin cambios.
Ahora vamos a crear el Operador, para este ejemplo la mejor solución es utilizar el operador Map. El operador Map puede transformar nuestro objeto de la forma que queramos y devolverlo a Subscriber.

En la llamada del operador (String s) se realiza la transformación del método String «Blue Factory».
Y aquí está Subscriber:

Resultado:

I/System.out: Blue Factory Blog Post

Este ejemplo representa una pequeña fracción de lo que los operadores pueden hacer. Por ejemplo, el operador Map puede apilarse varias veces como en el ejemplo siguiente:
¡Cállate! Dame un poco de código!

Ejemplo 5

Los operadores también pueden cambiar el tipo de elemento emitido como en el ejemplo siguiente:
¡Cállate!

Ejemplo 6

En este ejemplo el Observable emitirá la Cadena «5» y el Operador la transformará en el Entero 5. Vamos a crear Observable.

Nota que el tipo de miObservable es Observable y el Observable emite String.
¡Creemos el operador Map!

Nota que el método Map operator call(String s) recibe String y devuelve Integer.
Creemos Subscriber y los enlazamos.

El tipo Subscriber es el mismo que el tipo Observable, y el tipo que devuelve Operators (Integer).
Aquí te muestro sólo una pequeña fracción de la imagen. ¡Con los operadores puedes hacer todo lo que quieras! Y la mejor parte de esto es que RxJava tiene abundancia de diferentes operadores. Aquí usted puede comprobar todos los operadores: https://github.com/ReactiveX/RxJava/wiki/Alphabetical-List-of-Observable-Operators.

En conclusión Los operadores son poderosos para la transformación de objetos y el pulido de datos, y después de todo esto, su código se verá agradable y limpio!

¿Qué puedo hacer con RXJava?

Puedes hacer todo lo que quieras porque tu Observable puede ser todo, puede ser: String, Integer, llamada a la API, click, etc. A medida que avances como desarrollador de Android usarás RxJava sobre todo para las llamadas a la API y para los widgets de android. RxJava proporciona un fácil manejo de la API, ya que no tiene que preocuparse por los hilos y puede encadenar algunas solicitudes y obtener el resultado en un solo suscriptor. Con RxJava puedes manejar el comportamiento de un widget, por ejemplo, lo que el widget hará después de ser presionado cinco veces, o puedes crear un Observable que emita una cadena cada 4 segundos desde la entrada EditText, y muchas otras cosas. Espero que este artículo le da los fundamentos de RxJava y espero que siga explorando RxJava en el futuro.