Este documento presenta una introducción a la programación reactiva con RxJava. Explica que RxJava es una librería Java que implementa el patrón Observer para manejar eventos de forma asíncrona mediante observables. También describe algunos de los operadores más comunes como map, filter y zip que permiten transformar y combinar observables de forma declarativa. Finalmente, menciona algunas ventajas de este paradigma como la simplificación de la concurrencia y la mejora de la legibilidad del código.

1. Programación Reactiva
13/09/2016Google Campus
#paradigmarx

2. ¿Quien soy?
jpgonzalez@paradigmadigital.com
#paradigmarx

3. 1. Qué es programación reactiva
2. RxJava
3. Experiencia en paradigma
4. Demo
Í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

8. RxJava Fundamentos
Para gestionar todo lo que ocurre, esta
librería utiliza principalmente el patrón
Observer
#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

15. RxJava Subscriber
#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

22. RxJava Reduce
Aplica una función a cada dato emitido y emite el resultado
#paradigmarx

23. RxJava Buffer
Permite almacenar un grupo de resultado y emitirlo como
grupo
#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

27. RxJava Filtrado
Permiten descartar ciertos elementos y emitir sólo un
subconjunto de los elementos iniciales.
#paradigmarx

28. RxJava Filter
Realiza un filtrado sobre los eventos de origen
#paradigmarx

29. RxJava Distinct
Elimina los duplicados
#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

35. RxJava CombineLatest/Amb
Permite realizar combinaciones con elementos sin que
estén sincronizados
#paradigmarx

36. RxJava Temporales
Permiten alterar el tiempo en la generación de eventos.
#paradigmarx

37. RxJava Timer
Crea un observable para que emita un evento determinado
en un tiempo predefinido.
#paradigmarx

38. RxJava Delay
Retrasa la emisión de eventos por un determinado tiempo
#paradigmarx

39. RxJava Interval
Emite una secuencia de números infinitos separados por
un intervalo definido
#paradigmarx

40. RxJava Repeat
Crea un Observable que repite un evento múltiples veces.
#paradigmarx

41. RxJava Retry
Permite reconectar cuando se produce un error
#paradigmarx

42. RxJava Single
Emite un único evento o da error
#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

51. Ejemplos
#paradigmarx

52. #paradigmarx

53. #paradigmarx

54. #paradigmarx
http://developer.couchbase.com/documentation/server/4.1/sdks/java-2.2/documents-atomic.html

55. #paradigmarx

56. #paradigmarx
Muchas gracias
Buscamos talento : people@paradigmadigital.com