Este documento presenta una introducción a la programación reactiva. Explica conceptos clave como Observables y Observers, y cómo RxJava permite modelar flujos de datos asíncronos de forma declarativa mediante operadores como map, filter y merge. También cubre temas como backpressure y diferentes formas de crear y consumir Observables.

1. JVM Reactive Programming
Mexico City JVM Group
October 2016
domix
domix
coderDog

2. !Gracias por estar aqui¡

3. !Ya estamos en vivo¡

4. bit.ly/jm_live

5. La idea de ‘Live’
• Reuniones intermedias entre cada meetup
presencial en CDMX
• Para desarrolladores que no pueden asistir
• Para expositores nacionales o internacionales
• Esfuerzo paralelo a las actividades de JVM_MX
• YOLO

6. Anuncio parroquial

7. Nuevo libro por
Javeros Mexicanos

8. Raul Estrada (@BusinessRul)
Isaac Ruiz Guerra (@rugi)

10. bit.ly/book_smack

11. Reactive
Programming

12. Reactive Programming
• “Reactive Programming” es programar con flujos de
datos asíncronos.
• Flujo de datos (Data Stream): Una secuencia de valores
• Modelo de programación basado en el principio de
empujar (push) en lugar de obtener (pull).
• Los valores se “emiten” cuando están listos, no cuando
se solicitan de una forma no-bloqueante (non-blocking)
• Se permite ejecutar operaciones en paralelo en lugar de
forma serial.

13. Functional
Reactive Programming
• Functional programming
• https://maryrosecook.com/blog/post/a-practical-
introduction-to-functional-programming
• Lleva a Reactive Programming al siguiente nivel.
• Permute aplicar funciones al flujo de datos.
• map, filter, zip, take, etc..
• Integra flujo de tiempo y los eventos de composición en
la programación funcional.

14. ReactiveX
Reactive eXtensions
• Creado en Microsoft por Erik Meijer
• Colección de funciones útiles para hacer
programación reactiva.
• ReactiveX esta implementado en mas de 10
lenguajes.
• RxJava es la implementación de ReactiveX, fue
escrita por el equipo de Netflix

15. ReactiveX
• Observable: fuente de flujos de datos (sender).
• Observer: Escucha los valores emitidos (receiver)
• El Observer se suscribe (escucha) al Observable
• Los Observers reaccionan a cualquier elemento o
secuencias de elementos que emita el Observable
• Muchos Observers pueden suscribirse al mismo
Observable.

16. Observable Observer
Pattern
• Permite operaciones concurrentes: el Observer
no necesita bloquear mientras espera que el
Observable emita valores
• El Observer espera a recibir valores cuando el
Observable esta listo para emitirlos
• Sobre la base de empuje (push) en lugar de
obtener (pull)

17. RxJava

18. RxJava
• Proyecto Open Source con Licencia Apache.
• Implementación en Java de ReactiveX de
Microsoft
• El API de Netflix la usa para hacer la capa de
servicio completamente asíncrona.
• El objetivo es la JVM no el lenguaje.
• Existe soporte para Java, Groovy, Clojure, y Scala

19. RxJava Features
• Composable: Fácilmente se puede encadenar o
combinar
• Flexible: Se puede usar para emitir:
• Un valor escalar (network result)
• Secuencia (elementos en una lista)
• Flujos infinitos (sensores de clima)
• Mitiga el callback hell: Fácilmente se puede transformar
un flujo asíncrono en otro

20. Usando Iterables
• Antes de reactivo
1. Invocar un método
2. Esperar el resultado
3. Almacenar el resultado en una variable
4. Usar la variable para hacer algo util.

21. Usando Observables
1. Definir un Observer que especifica que hacer
con cada valor emitido
2. Invocar un método que regrese un Observable
3. Suscribirse el Observer al Observable. Esto le
dice al Observable que tiene un subscriptor
esperando a recibir valores cuando estén
disponibles.

22. En RxJava
• El método Subscribe conecta un Observer a un
Observable
• Una ves suscrito, no hay necesidad de bloquear
el hilo actual.
• Los valores llegaran al Observer cuando estén
listos y disponibles

23. Interface rx.Observer
public interface rx.Observer<T> {
void onCompleted();
void onError(Throwable e);
void onNext(T t);
}

24. void onCompleted();
/**
* Notifies the Observer that the
* {@link Observable} has finished sending
* push-based notifications.
* <p>
* The {@link Observable} will not call
* this method if it calls {@link #onError}.
*/
void onCompleted();

25. void onCompleted();
• El Observable invoca este método después de
que se invocó el método onNext por ultima
ocasión y no encontró ningún error.
• La llamada a onComplete finaliza la
subscripción.

26. void onError(Throwable e);
/**
* Notifies the Observer that the {@link Observable}
* has experienced an error condition.
* <p>
* If the {@link Observable} calls this method, it
* will not thereafter call {@link #onNext} or
* {@link #onCompleted}.
*
* @param e
* the exception encountered by the
* Observable
*/
void onError(Throwable e);

27. void onError(Throwable e);
• El Observable invoca este método para indicar
que ha fallado al obtener la información
esperada o alguno otro problema.
• Esto detiene al Observable y no hará mas
invocaciones.
• Envía la excepción que genero el problema.

28. void onNext(T t)
/**
* Provides the Observer with a new item to observe.
* <p>
* The {@link Observable} may call this method 0 or
* more times.
* <p>
* The {@code Observable} will not call this method
* again after it calls either {@link #onCompleted}
* or {@link #onError}.
*
* @param t
* the item emitted by the Observable
*/
void onNext(T t);

29. void onNext(T t)
• El Observable invoca este método cada vez que
el Observable emite un elemento.
• Este método puede ser invocado cualquier
número de veces (de cero a muchos).
• Siempre seguido por onError o onComplete
(pero no ambos)

30. Uso sencillo
public Observable<Double>
dollarToCurrencyExchangeRate(String targetCurrencyCode) {
// se crea de alguna manera el Observable
return ...
}
public void foo() {
dollarToCurrencyExchangeRate("MXN")
.subscribe(System.out::println);
}

31. Composing el Observable
public void foo() {
dollarToCurrencyExchangeRate("MXN")
.throttleWithTimeout(2, TimeUnit.MINUTES)
.distinctUntilChanged()
.filter(value -> value > 0)
.map(Object::toString)
.subscribe(System.out::println);
}

32. ¿Como esta
implementado el Observable?
• ¿Tal vez ejecuta su lógica en el hilo del subscriptor?
• ¿Tal vez delega parte del trabajo a otros hilos?
• ¿Usará NIO?
• ¿Tal vez es un actor?
• ¿Devolverá datos de un cache?
• ¡Al Observer no le importa!

33. Consumiendo Observables
Modo largo…
rx.Observable.just(1, 2, 3)
.subscribe(new rx.Observer<Integer>() {
@Override
public void onCompleted() {
System.out.println("No más elementos.");
}
@Override
public void onError(Throwable e) {
System.out.println(
String.format("Ocurrio un problema: %s", e.getMessage()));
}
@Override
public void onNext(Integer integer) {
System.out.println(
String.format("Valor recibido: %d", integer));
}
});

34. Consumiendo Observables
Modo corto Java 8.
rx.Observable.just(1, 2, 3)
.subscribe(
value ->
System.out.println(
String.format("Valor recibido: %d", value)),
throwable ->
System.out.println(
String.format("Ocurrio un problema: %s",
throwable.getMessage())),
() -> System.out.println("No más elementos."));

35. Operadores doOn*
rx.Observable.just(1, 2, 3, 4, 5)
.doOnNext(value -> {
if (Integer.valueOf(4).equals(value)) {
throw new RuntimeException("El cuatro es feo.");
}
})
.doOnError(throwable -> System.out.println(
String.format("Ocurrio un problema: %s",
throwable.getMessage())))
.doOnCompleted(() ->
System.out.println("No más elementos."))
.subscribe(value ->
System.out.println(
String.format("Valor recibido: %d", value)));

37. Creando Observable
de forma explicita.
rx.Observable.<Integer>create(subscriber -> {
try {
for (int i = 0; i < 5; i++) {
subscriber.onNext(i);
}
// Si olvidamos invocar onCompleted se
// pueden crear Observables sin fin.
subscriber.onCompleted();
} catch (Throwable cause) {
subscriber.onError(cause);
}
});

39. Como crear Observables

40. Manipulando
Observable

41. Transformando data map
rx.Observable.just(1, 2, 3, 4, 5)
.map(value -> String
.format("Value: %s", value.toString()))
.subscribe(System.out::println);

42. Combinando Observables

43. Filtrando

44. Limitando elementos

45. Ejercicio 1
Implementar la kata
FizzBuzz
http://codingdojo.org/cgi-bin/index.pl?KataFizzBuzz
https://en.wikipedia.org/wiki/Fizz_buzz
Hasta el número 20

46. Backpressure
• ¿Que ocurre si un Observable esta emitiendo elementos más rápido de lo que
el Observer puede procesarlos?
• Cold Observable:
• Emite una secuencia particular de elementos, puede empezar a emitirla
cuando su Observer lo considere conveniente y a la tasa de entrega que el
Observer desee, sin interferir la integridad de la secuencia.
• Hot Observable:
• Es un Observable que empieza a generar elementos inmediatamente
cuando es creado. Los subscriptores pueden empezar a observar la
secuencia de elementos emitidos a la mitad de la secuencia, empezando
con el primer elemento emitido posterior al establecimiento de la
subscripción. Dicho Observable emite elementos a su propio ritmo y es
responsabilidad de los Observers mantener ese mismo ritmo.

47. Debounce

48. throttleFirst

49. throttleWithTimeout

50. List<Observable<byte[]>> observables =
//obtengo todas las instancias de los servicios
discoveryClient.getInstances("service_id").stream()
//Obtengo su URI remota (host:port)
.map(serviceInstance -> serviceInstance.getUri().toString())
//Genera un Worker que hará el trabajo de pedirle
//a cada instancia del servicio el archivo.
//DownloadCacheWorker implementa java.util.concurrent.Callable
.map(baseUrl -> new DownloadLocalCacheWorker(baseUrl, bucket, key))
//Genero un Future para hacerlo asíncrono
.map(callable ->
((ThreadPoolTaskExecutor) taskExecutor).submit(callable))
//Lo convierto a Observable para facilitar
//el manejo de errores
.map(Observable::from)
//Genero una lista de Observables
.collect(Collectors.toList());

51.
//Genero un solo Observable a partir de todos
Observable.merge(observables)
//Si algo falla al obtener el archivo del
//servicio remoto, simplemente regreso null
.onErrorReturn(throwable -> {
log.warn("No se encontró algo", throwable);
return null;
}).doOnCompleted(() -> {})
//Descarto todos los null
.filter(fileContent -> fileContent != null)
//obtengo el primer resultado exitoso
//(en teoría solo debe existir en un solo servidor)
.firstOrDefault(null)
//hago la llamada bloqueante
.toBlocking()
//aplico la lógica de manejo del archivo
.subscribe(new DownloadLocalCacheObserver(response, key, notFound));

52. A seguir
• Project Reactor
• https://projectreactor.io/
• Akka
• http://akka.io/
• Reactive Streams
• http://www.reactive-streams.org/