Esta presentación nos muestra qué es la programación reactiva, en qué consiste, qué nos permite hacer y por qué está tan de moda. Además, podemos ver el uso concreto de esta programación utilizando RxJava.
Autor: Juan Pablo González de Gracia.
3. 1. Qué es programación reactiva
2. RxJava
3. Experiencia en paradigma
4. Ejemplos
ÍNDICE
#paradigmarx
4. Qué es programación reactiva
¿Por qué ahora?
¿Qué tiene de nuevo?
¿Es la próxima moda pasajera?
¿Ahora se programa todo así?
#paradigmarx
5. RxJava ¿Qué es?
Es una librería Java que implementa las ReactiveX
(extensiones reactivas )
“Se basa en el en la composición asíncrona y
programas basados en eventos , mediante el
uso de secuencias observables.”
#paradigmarx
6. RxJava ¿Qué ventajas nos aporta?
• Legibilidad
• Simplifica la concurrencia (evitando errores de
programación)
• Composición de operadores y funciones
• Permite añadir comportamiento al procesamiento
asíncrono
• Permite utilizar programación síncrona o asíncrona
#paradigmarx
7. RxJava Simplicidad
Como gran ventaja resuelve los problemas que tenía
Java hasta ahora con el manejo de la programación
concurrente. La librería está disponible desde java 6.
Callbacks & Future<T>
#paradigmarx
9. RxJava Patrón Observer
“Es un patrón de diseño que define una
dependencia del tipo uno-a-muchos entre
objetos, de manera que cuando uno de los
objetos cambia su estado, notifica este
cambio a todos los dependientes.”
#paradigmarx
10. RxJava Observable
Los observables son los elementos que
notifican a todos sus observers los cambios.
Para ello es necesario que estos observer se
registren de alguna manera.
#paradigmarx
11. RxJava Push vs Pull
Estamos acostumbrados a un modelo donde le
pedimos al productor un nuevo elemento cada vez que
lo necesitamos (Pull) en vez de que el productor nos
avise de cuando está disponible (Pull). En ocasiones
provoca bloquear al usuario hasta que esté disponible.
Iterable/ Iterator Observable / Observer
T next() onNext(T)
throws Exception onError(Throwable)
returns onCompleted()
#paradigmarx
12. RxJava Eventos
Un elemento observable puede producir 3
tipos de eventos :
• Evento normal
• Evento de terminación
• Evento de error
#paradigmarx
13. RxJava Suscripción
Cuando se realiza una subscripción , se crea un objeto
Subscription que nos da acceso al control sobre el flujo
de la información, permitiendo saber si hay elementos
subscritos o terminar la conexión
#paradigmarx
14. RxJava Subscriber
Existe un elemento Subscriber que implementa ambos
interfaces, observer (lo que nos permite consumir los
eventos del observable) y subscription (con lo que
podremos controlar el flujo desde dentro del objeto)..
#paradigmarx
16. RxJava Creación de observables
• Vacíos : Observable.emtpy()
• Error : Observable.error()
• Con valores concretos : Observable,just(values)
• Custom : Observable.create(details)
• De una lista : Observable.from()
• Rango númerico : Observable.range(from,n)
#paradigmarx
17. RxJava Hot vs Cold Observables
Existe 2 tipos de Observables. Se distinguen principalmente
sobre la manera en la que emiten eventos. Los “calientes”
emiten eventos independientemente de si hay alguien
escuchando, mientras que los “fríos” sólo lo hacen cuando
tienen suscriptores, generando el evento para sus suscriptores
en exclusiva.
#paradigmarx
18. RxJava Operadores
RxJava tiene una serie de operadores que nos permiten
realizar acciones sobre los elementos del observable,
dominarlos, encadenarlos y realizar composiciones de los
mismos será lo que nos de potencia al usar esta librería. Por
citar algunos
#paradigmarx
19. RxJava Transformación
Son operadores que nos van a servir para aplicar
transformaciones a los elementos de origen de manera que
emitamos objetos distintos a la salida
#paradigmarx
20. RxJava Map
Nos permite aplicar una transformación a un elemento de
nuestro objeto para transformarlo en otra cosa.
#paradigmarx
21. RxJava Scan
Aplica una función a cada dato emitido y emite ese valor
secuencialmente
#paradigmarx
24. RxJava FlatMap
Transforma cada elemento del observable en otra sucesión de
observable, se suscribe y los une en único observable
#paradigmarx
25. RxJava GroupBy
Divide el observable inicial en un conjunto de observables en
base a un criterio.
#paradigmarx
26. RxJava Cache
Almacena todos los resultados y los repite siempre igual.
Hay que tener cuidado con la memoria si estamos
manejando Observables infinitos
#paradigmarx
30. RxJava Otros
• First
• Last
• Take , TakeLast,TakeUntil, TakeWhile
• Skip, SkipLast, SkipUntil, SkipWhile
#paradigmarx
31. RxJava Combinacion de Observables
Es muy habitual trabajar con un conjunto de observables
que queramos combinar de alguna manera. Para ello
RxJava nos ofrece operadores que permiten combinarlos
para emitir un resultado.
#paradigmarx
32. RxJava Merge /Concat
Estos operadores se suscriben los observables que le
pasemos como parámetro y unifica los eventos en un
único stream de salida.
#paradigmarx
33. RxJava Switch
Muestra los eventos del último observable que ha
producido eventos. Cuando aparece un elemento en un
observable posterior, se borra la suscripción actual.
#paradigmarx
34. RxJava Zip
Combina elementos de distintos observables y los fusiona
en un único elemento
Es importante que estén lo más sincronizados posible.
#paradigmarx
43. RxJava Timeout
Copia el Observable en la salida salvo que se produzca un
hueco mayor entre eventos al que se pasa por parámetro
#paradigmarx
44. RxJava Try/catch
RxJava nos permite varias formas de utilizar el try catch.
Quizás una de las más legibles sea OnErrorResumeNext
#paradigmarx
45. RxJava ¿Qué operador usar?
Para los principiantes existe un árbol de decisión que nos
ayuda a saber cual es el que deberíamos usar.
Podéis consultarlo en
http://reactivex.io/documentation/operators.html
#paradigmarx
46. RxJava Side effects
Podemos añadir comportamiento a lo que pasa cuando
suceden ciertos eventos. RxJava nos da muchos eventos a los
que suscribirnos, pero no se pueden alterar :
• doOnCompleted() )
• doOnEach()
• doOnError()
• doOnNext()
• doOnRequest()
• doOnSubscribe()
• doOnTerminate()
• doOnUnsubscribe() )
#paradigmarx
47. RxJava Concurrencia
Normalmente la concurrencia la va a decidir el que nos
consume.
Por ejemplo indicando suscribeOn(scheduler) o
ObserverOn(Scheduler)
#paradigmarx
48. RxJava Lazy vs Eager
Cuando utilizamos RxJava estamos aprovechando las ventajas
de una ejecución perezosa. La ejecución se pospone al último
momento posible, esto es cuando un usuario se suscribe.
Esto ayuda a no bloquear recursos innecesariamente
Cuando creemos Observables utilizaremos Defer, utiliza una
factoria de observable y lo hacer de forma perezosa
#paradigmarx
49. RxJava Bloqueante a No bloqueante
Con RxJava pasar de no bloqueante a bloqueante es muy
sencillo utilizando el operador toBlocking(). Lo contrario, es
más complicado porque implica un rediseño del algoritmo,
aunque RxJava da funciones para ello.
#paradigmarx
50. Paradigma + RxJava
Consumo bajo de recursos
Gran rendimiento
Buen compañero con Vert.x
Mejora de legibilidad separando la operación
de la orquestación
#paradigmarx