#TechMeetup
Be Reactive
Be Reactive
Agenda
Intro
Anatomia
Operadores
Showtime!
Be Reactive - Intro
Qué diferencia hay entre una consulta DB y las transmisiones de un mouse por puerto serie?
Be Reactive - Intro
Programación reactiva es programar usando stream de datos de manera asíncrona.
Combinación de Patrones Observer e Interator junto Programación Funcional
Be Reactive - Intro
Rx es:
Set of types -> Representing async data stream
Set of Operators -> Query async data stream
Set of Types -> Parameterize concurrency
Be Reactive - Anatomia
Los bloques básicos son: Observables y Observers
Una implementación común de los Observers son los Subscribers
Un Observable emite items y un Subscriber los consume
Be Reactive - Anatomia
Pero el patrón Observer…
Una diferencia, es que un Observable no emite items hasta no alguien no se suscriba explícitamente.
Pero el patrón Iterator…
Hay una dualidad con este patrón, Evento Iterable (pull) Observable (push)
Recuperar datos T next() onNext(T)
Descubrir errores throws Exception onError(Exception)
Completado returns onCompleted()
Be Reactive - Anatomia
Si combinamos Observables y Observers:
Observable.from() .subscribeOn() .observeOn() .subscribe()
Be Reactive - Anatomia
Y la concurrencia....? Schedulers
Observable.from() .subscribeOn() .observeOn() .subscribe()
subscribeOn() -> realizá todas las operaciones en este Thread.observerOn() -> pusheá los resultados a este Thread.
Observers / Subscriber
new Observer<T>() { @Override public void onCompleted() {} @Override public void onError(Throwable throwable) {} @Override public void onNext(T t) {}};
Be Reactive - Anatomia
Be Reactive - Anatomia
Subscriptions = Observable Observer
Be Reactive - Operadores
Permiten componer secuencias asíncronas de manera declarativa.
Operan sobre Observables y retornan Observables
Permiten encadenarse, como el patrón Builder, pero en este caso el orden si importa.
Be Reactive - Operadores
create() crea un Observable desde cero.from() convierte otros objetos en Observablesjust() convierte otro objeto u objetos en Observables que emita esos objetos.
Be Reactive - Operadores
map() (Transforming)
Puede ser usado para transformar un ítem emitido en otro tipo.
myObservable.map(new Func1<String, Integer>() { @Override public Integer call(String s) { return s.hashCode(); }});
Be Reactive - Operadores
flatMap() (Transforming)
Transforma los ítems emitidos por un Observable en Observables, y luego “aplana” la emisión de esos Observables en un solo.
myObservable.flatMap(new Func1<List<String>, Observable<String>>() {
@Override public Observable<String> call(List<String> list) { return Observable.from(list); }})
Be Reactive - Operadores
zip() (Combining)
Combina los ítems emitidos por múltiples Observables y emite un solo ítem basado en el resultado de una función.
Observable.zip(myObservable, myObservable2, new Func2<String, String, Pair<String, String>>() { @Override
public Pair<String, String> call(String s, String s2) {return new Pair<String, String>(s, s2); }});
Be Reactive - Operadores
combineLastest() (Combining)
Cuando un ítem es emitido por alguno de los Observables, lo combina con el último emitido por cada Observable y emite el resultado basado en una función
Be Reactive - Operadores
debounce() (filtering)
Solo emite un ítem si un tiempo particular ha transcurrido.
myObservable.debounce(400, TimeUnit.MILLISECONDS)
Be Reactive - Example
AsyncTask
new AsyncTask<String, Void ,User>(){ @Override protected User doInBackground(String... values) {
return githubApi.getUser(values[0]); }
@Override protected void onPostExecute(User user) { super.onPostExecute(user); }};
Be Reactive - Example
Rx
Observable.create(new Observable.OnSubscribe<User>() { @Override public void call(Subscriber<? super User> subscriber) { User user = githubApi.getUser("username");
subscriber.onNext(user); subscriber.onCompleted(); }}).subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(new Observer<User>() { ... });
Be Reactive - Cooking, Cooking, Cooking
santexgroup.com
Top Related