Slide 1
Slide 1 text
Intro a RxJava
Antonio Nicolás Pina
Android & Go developer
@anpez
https://www.anpez.es Murcia Android Developers
S02E01
13 diciembre 2016
Slide 2
Slide 2 text
1.
Motivación
Programación
reactiva
funcional
Slide 3
Slide 3 text
Programación reactiva
▣ Orientada a flujos de datos. Casos típicos:
□ Entrada del teclado
□ Red
□ Base de datos
▣ Desacopla la fuente de los datos de los
receptores.
□ Evita el uso de listeners que acoplan el código.
Slide 4
Slide 4 text
Programación funcional
▣ Orientada a funciones matemáticas.
▣ Reutilización de funciones existentes.
▣ Composición de funciones sencillas.
▣ Filosofía UNIX.
Slide 5
Slide 5 text
‘’ Make each program do
one thing well.
To do a new job, build
afresh rather than
complicate old programs
by adding new "features".
Doug McIlroy
The Bell System Technical Journal
1978
Slide 6
Slide 6 text
Programación funcional reactiva
▣ Introducida en 1997
▣ Combina los dos modelos anteriores
▣ Nos permite manejar cadenas de datos o
“eventos”, aplicando funciones (operadores)
sobre los mismos.
▣ RxJava se basa en los Observables de .NET 4
(año 2010).
Slide 7
Slide 7 text
2.
Observable /
Observer Ideas básicas
Slide 8
Slide 8 text
Observable
▣ Interfaz que define la “fuente” de los datos.
▣ Sólo un método: OnSubscribe.
▣ Decenas de implementaciones.
Slide 9
Slide 9 text
Observer
▣ Define una única interfaz común para todos
los objetos que se suscriben a Observables.
▣ Dispone de tres métodos:
□ onNext() Llamada con cada elemento emitido.
□ onError() Para situaciones de error.
□ onCompleted() El procesamiento acabó
correctamente.
Slide 10
Slide 10 text
Observer
▣ Se podría esquematizar así.
try {
for(Elem e: sequence) {
observer.onNext(e);
}
observer.onCompleted();
} catch (Exception e) {
observer.onError();
}
Slide 11
Slide 11 text
Recuerda: siempre manejas streams
Slide 12
Slide 12 text
Creación de Observable
▣ La creación se hace (preferentemente) a
través de métodos estáticos de Observable.
□ Observable.just(elemento)
□ Observable.just(elemento 1, elemento 2, ...)
□ Observable.from(iterable)
□ Observable.interval(3, TimeUnit.SECONDS)
Slide 13
Slide 13 text
3.
Operadores Modificación
del stream
Slide 14
Slide 14 text
Operadores sobre el stream
▣ Hay cientos de operadores aplicables sobre
un stream.
▣ Se pueden definir operadores propios,
aunque es un caso poco habitual.
▣ Con ellos, podemos:
□ Modificar eventos del stream y reemitir la versión
modificada.
□ Filtrar elementos, para que no continúen
downstream.
□ Combinar elementos.
□ ¡Multithreading!
Slide 15
Slide 15 text
Operadores sobre el stream
▣ Casi cualquier cosa que se te ocurra, se puede
hacer combinando operadores.
flatmapthatshit.com
Slide 16
Slide 16 text
Operadores sobre el stream
▣ Hay cientos de operadores aplicables sobre
un stream.
▣ Se pueden definir operadores propios,
aunque es un caso poco habitual.
▣ Con ellos, podemos:
□ Modificar eventos del stream y reemitir la versión
modificada.
□ Filtrar elementos, para que no continúen
downstream.
□ Combinar elementos.
□ ¡Multithreading!
Slide 17
Slide 17 text
RX marbles
Slide 18
Slide 18 text
RX marbles
Slide 19
Slide 19 text
Un ejemplo de stream
Observable.range(0, 5)
.map(x -> x*x)
.filter(x -> x>4)
.subscribe(x-> print(x))
Slide 20
Slide 20 text
Una nota sobre funciones lambda
▣ RxJava funciona sobre Java6, es decir,
Android 2.3.
▣ Java no soporta funciones lambda hasta Java
8.
▣ Para ello, yo utilizo Retrolambda, que permite
utilizar dichas funciones compiladas con
bytecode Java 6.
Slide 21
Slide 21 text
Código para Java 6
Observable.just("http://example.com/image.jpg")
.map(new Func1() {
@Override
public Bitmap call(String url) {
return loader.load(url);
}
})
.subscribe(...)
Slide 22
Slide 22 text
Código para Java 8
Observable.just("http://example.com/image.jpg")
.map(url -> loader.load(url))
.subscribe(...)
Slide 23
Slide 23 text
Warning: bytecode ahead
Slide 24
Slide 24 text
Cuidado!
▣ Bytecode de la versión lambda
iconst_1
invokestatic java/lang/Integer
valueOf((I)Ljava/lang/Integer;);
invokestatic rx/Observable
just((Ljava/lang/Object;)Lrx/Observable;);
invokedynamic call(rx.functions.Func1);
.map(x -> x*x)
Slide 25
Slide 25 text
Cuidado!
▣ Bytecode de la versión con new Func1
iconst_1
invokestatic java/lang/Integer
valueOf((I)Ljava/lang/Integer;);
invokestatic rx/Observable
just((Ljava/lang/Object;)Lrx/Observable;);
new anpez/Test$1
dup
aload0 // reference to self
invokespecial anpez/Test$1 ((Lanpez/Test;)V);
.map(x -> x*x)
Slide 26
Slide 26 text
4.
Threading .observeOn /
.subscribeOn
Slide 27
Slide 27 text
subscribeOn vs observeOn
▣ Estos dos operadores especiales se utilizan
para indicar a RxJava en qué hilos se ha de
ejecutar cada paso.
▣ subscribeOn() indica en qué hilo se han de
emitir los eventos.
▣ observeOn() especifica en qué hilo se ejecuta
el .onNext().
▣ Por defecto, todo ocurre en el mismo hilo en
que se suscribe el Observer.
Slide 28
Slide 28 text
Un ejemplo completo (I)
▣ En este ejemplo cargamos una imagen de red.
Observable.just(url)
.map(url -> loader.load(url))
.subscribe(ImageView::setBitmap);
Slide 29
Slide 29 text
Un ejemplo completo (II)
▣ Ahora la carga se produce en un hilo de I/O.
Observable.just(url)
.map(url -> loader.load(url))
.subscribeOn(Schedulers.io())
.subscribe(ImageView::setBitmap);
Slide 30
Slide 30 text
Un ejemplo completo (y III)
▣ De este modo, la vista se toca en el hilo
correcto.
Observable.just(url)
.map(url -> loader.load(url))
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(ImageView::setBitmap);
Slide 31
Slide 31 text
5.
Casos de uso Ejemplos reales
Slide 32
Slide 32 text
Chisme for Sensu
Ejemplos extraídos de la
última aplicación que he
desarrollado utilizando
RxJava: un cliente para Sensu
Slide 33
Slide 33 text
Retrofit
▣ Con Retrofit podemos obtener un Observable
a partir de una llamada.
public interface ChecksService {
@GET("checks")
Observable> all();
@POST("request")
Observable issue(@Body
Map body);
}
Slide 34
Slide 34 text
Retrofit
▣ Y podemos aplicarle los operadores que
queramos para transformar el resultado.
public Observable issue(Check check) {
Map params = new HashMap<>();
params.put("check", check.name());
return checksService.issue(params)
.map(IssueResponse::issued)
.map(time -> time*1000)
.map(Date::new);
}
Slide 35
Slide 35 text
RxBinding
▣ Librería de Jake Wharton para utilizar RxJava
sobre vistas de Android.
▣ Elimina la necesidad de utilizar listeners.
▣ Simplifica operaciones muy comunes.
RxTextView.textChanges(hostTextView)
.subscribe(this::checkHost);
Slide 36
Slide 36 text
@Mock HostsRepository hostsRepository;
Host host = new Host(1, "[email protected]", "https",
"test.com", 443, "user", "pass");
when(hostsRepository
.all())
.thenReturn(Observable.just(host));
Test!
▣ RxJava también te ayuda a escribir tests.
▣ Utilizando Espresso con Mockito, es muy fácil
mockear un método que devuelve un
Observable.
Slide 37
Slide 37 text
Observable.just(drawerBuilder)
.subscribeOn(Schedulers.computation())
.observeOn(Schedulers.computation())
... // Build drawer on background
.observeOn(AndroidSchedulers.mainThread())
.subscribe(builder -> {
drawer = builder.build();
mainViewModel.initialize();
});
Whatever!
▣ Lo utilizo casi para cualquier cosa.
Slide 38
Slide 38 text
Observable.interval(swapMs, TimeUnit.MILLISECONDS)
.limit(swapRepeats)
.observeOn(AndroidSchedulers.mainThread())
.doOnNext(t -> moveShellVS.execute())
.doOnCompleted(() -> {
status.set(RUNNING);
currentTry.set(1);
})
.subscribe();
Whatever!
Slide 39
Slide 39 text
6.
Conclusiones Warnings varios
Slide 40
Slide 40 text
No content
Slide 41
Slide 41 text
Gotchas
▣ Es muy importante definir un .doOnError()
que recoja los posibles errores.
▣ Los Observers deben poder procesar eventos
más rápido de lo que los emiten los
Observables (Backpressure).
□ No suele ser un problema, hasta que intentamos
hacer algo avanzado.
▣ NO utilizar Observable.create(). Si usamos
RxJava2, utilizar Flowable.create().
Slide 42
Slide 42 text
Gotchas
▣ No usarlo ciegamente, implica una
penalización de rendimiento.
▣ La documentación a veces no es demasiado
clara.
□ Los comentarios de StackOverflow tampoco suelen
ayudar mucho.
▣ Los tutoriales que verás, suelen utilizar
incorrectamente Observable.create().
Slide 43
Slide 43 text
Conclusiones
▣ Se puede usar RxJava para reemplazar
completamente las AsyncTask.
▣ Por norma general, se puede usar RxJava (via
RxBinding o hecho por nosotros mismos), en
lugar de Listeners.
▣ Para tareas de entrada/salida o de
computación es perfecto, ya que la
sobrecarga es mínima en este caso.
Slide 44
Slide 44 text
Credits
Special thanks to all the people who made and
released these awesome resources for free:
▣ Presentation template by SlidesCarnival