rxjava, getting started - david wursteisen - 16 octobre 2014

Getting Started

RxJava

David Wursteisen 16 Octobre 2014

David Wursteisen

@dwursteisen

Direction Expertise Innovation

David Wursteisen

Architecture distribuée

Sync/Async/Concurrence

The Internet

Synchrone

Appel bloquant

Asynchrone

Appel non bloquant

Complexité

future.get();

Complexité

future1.get();future2.get();future3.get();future4.get();future5.get();future6.get();future7.get();

Complexité

future1.get();future2.get();future3.get();future4.get();future5.get();future6.get();future7.get();

Ordonnancement optimal ?

Complexité

client.execute(new Callback() { @Override public void completed(HttpResponse response) { }});

Complexité

client.execute(new Callback() { @Override public void completed(HttpResponse response) { client.execute(new Callback() { @Override public void completed(HttpResponse response) { } });

Complexité

client.execute(new Callback() { @Override public void completed(HttpResponse response) { client.execute(new Callback() { @Override public void completed(HttpResponse response) { client.execute(new Callback() { @Override public void completed(HttpResponse response) { } }); }});

Complexité

client.execute(new Callback() { @Override public void completed(HttpResponse response) { client.execute(new Callback() { @Override public void completed(HttpResponse response) { client.execute(new Callback() { @Override public void completed(HttpResponse response) { } }); }});

Callback hell

Concurrence

RxJava permet de manipuler des évènements d’une manière synchrone et/ou asynchrone.

Historique

Il était une fois...

Historique

ReactiveX.io

Observables

Travailler avec des flux

Flux d’évènements fini

Évènements Fin du flux

Flux d’évènements en erreur

Évènements Erreur

Flux d’évènements infini

Évènements

Flux d’évènements

Observable.never()

Observable.empty()

Observable.just(1)

Observable.from(1, 2, 3)

Observable.range(1, 4400)

Observable.timer(5, TimeUnit.SECONDS)

Observable.create(...)

Observable.never()

Observable.empty()

Observable.just(1)

Observable.never()

Observable.empty()

Observable.just(1)

Observable.never()

Observable.empty()

Observable.just(1)

Observable.never()

Observable.empty()

Observable.just(1)

1 4400

Observable.never()

Observable.empty()

Observable.just(1)

t + 5 secondes

Observable.never()

Observable.empty()

Observable.just(1)

λ ϕ φ

json json jsonObservable<json>

Observable<Integer>

Observable<Click>

Observer

Push des données

Observer

OnNext* (OnCompleted|OnError)?

Observer

Observable.range(1, 4400).subscribe()

Observer

Observable.range(1, 4400).subscribe(onNext)

Observer

Observable.range(1, 4400).subscribe(System.out::println)

Observer

Observable.range(1, 4400).subscribe(System.out::println, onError)

Observer

Observable.range(1, 4400).subscribe(System.out::println, System.err::println)

Observer

Observable.range(1, 4400).subscribe(System.out::println, System.err::println,onCompleted)

Observer

Observable.range(1, 4400).subscribe(System.out::println, System.err::println,

() -> System.out.println(“finished”))

Manipulation d’évènements

Quand l’écoute ne suffit plus

filter ( x <= 2 )

delay ( 5, SECONDS )

Observable.from(0, 1, 2, 3, 4)

Observable<Integer>

Observable.from(0, 1, 2, 3, 4) .filter((i) -> i < 3)

Observable<Integer>Observable<Integer>

Observable.from(0, 1, 2, 3, 4) .filter((i) -> i < 3) .delay(5, TimeUnit.SECONDS)

Observable<Integer>Observable<Integer>Observable<Integer>

Observable.from(0, 1, 2, 3, 4) .filter((i) -> i < 3) .delay(5, TimeUnit.SECONDS) .map((i) -> Character.toString((char)(i + 'A')))

Observable<String>

Observable.from(0, 1, 2, 3, 4) .filter((i) -> i < 3) .delay(5, TimeUnit.SECONDS) .map((i) -> Character.toString((char)(i + 'A'))) .subscribe(System.out::println);

Observable<String>

Observable.from(0, 1, 2, 3, 4) .filter((i) -> i < 3) .delay(5, TimeUnit.SECONDS) .map((i) -> Character.toString((char)(i + 'A'))) .subscribe(System.out::println);

0, 1, 2, 3, 4 => A, B, C

Observable<String>

Composition

Création d’un flux à partir d’un ensemble de flux

Composition

Mise en pratique de composition

Learn from the trenches

Composition

Subscription

Et gestion de l’unsubscribe

Subscription

Observable.create(new OnSubscribe<T>() { … });

Subscription

Observable.create(new OnSubscribe<T>() {

@Override public void call(Subscriber<? super T> s) { s.onNext(123); s.onCompleted(); }

Subscription

Observable.create(new OnSubscribe<T>() {

@Override public void call(Subscriber<? super T> s) { s.onNext(123); s.onCompleted(); }

Émission synchronne

Subscription

Observable.create(new OnSubscribe<T>() { @Override public void call(Subscriber<? super T> subscriber) { // ... httpClient.execute(httpRequest, new FutureCallback<HttpResponse>() { @Override public void completed(String content) { subscriber.onNext(content); subscriber.onCompleted(); }

@Override public void failed(Exception e) { subscriber.onError(e); } }); }});

Subscription

Émission asynchronne

Subscription

Propagation des erreurs

Subscription

La souscription permet d’uniformiser des API différentes par leurs natures (Callback, etc...)

Unsubscribe

Subscription subscription = Observable.interval(1, TimeUnit.SECONDS).subscribe();

Unsubscribe

Souscription

Unsubscribe

Handler sur la souscription

Unsubscribe

Subscription subscription = Observable.interval(1, TimeUnit.SECONDS).subscribe();/* ... */subscription.unsubscribe();

Unsubscribe

Subscription subscription = Observable.interval(1, TimeUnit.SECONDS).subscribe();/* ... */subscription.unsubscribe();

Arrêt de la souscription

Schedulers

observableReadingSynchronously(“strings.txt”)

.take(10) .delay(1, SECONDS) .map(parse())

.map(n -> “=> ” + n)) .subscribe(to_the_view())

Schedulers

observableReadingSynchronously(“strings.txt”)

.take(10) .delay(1, SECONDS) .map(parse())

.map(n -> “=> ” + n)) .subscribe(to_the_view())

Schedulers

Computation

Schedulers

Computation

Schedulers

Computation

Schedulers

Computation

Schedulers

Computation

Schedulers

Computation

Schedulers

observableReadingSynchronously(“strings.txt”) .subscribeOn(scheduler) .take(10) .delay(1, SECONDS, scheduler) .map(parse()) .observeOn(scheduler) .map(n -> “=> ” + n)) .subscribe(to_the_view())

Schedulers

observableReadingSynchronously(“strings.txt”) .subscribeOn(Schedulers.io()) .take(10) .delay(1, SECONDS, Schedulers.computation()) .map(parse()) .observeOn(Schedulers.from(uiExecutor())) .map(n -> “=> ” + n)) .subscribe(to_the_view())

Schedulers

Computation

Schedulers

Computation

Schedulers

Computation

Schedulers

Computation

Schedulers

Computation

Hot & Cold Observable

Cold Observable

Observable<Integer> obs = Observable.from(1, 2, 3, 4);

obs.subscribe(System.out::println);

Cold Observable

Subscribe

Cold Observable

obs.subscribe(System.out::println); Subscribe

Cold Observable

obs.subscribe(System.out::println);Souscription différente

Hot Observable

ConnectableObservable<Integer> obs = Observable.from(1, 2, 3, 4).publish();

obs.connect();

Hot Observable

obs.connect();

Hot Observable

obs.connect();

Hot Observable

obs.connect();

Hot Observable

obs.connect();

Hot Observable

obs.connect();Subscribe

Hot Observable

obs.connect();

Partage la même souscription

Hot Observable

obs.connect();

Hot Observable

obs.connect();

Souscription

Cold & Hot Observable

Cold Observable = flux passif

Hot Observable = flux actif

Back Pressure

Contrôler la production

Back Pressure

Production

Back Pressure

Production

buffer

Back Pressure

Production

Pression arrière

Back Pressure

Production

Pression arrière

Demande de production de n élements

Retour d’expérience

Opérateurs

Observable.from(1, 2, 3, 4) .reduce(new LinkedList<Integer>(), (seed, value) -> { seed.add(value); return seed; }) .first() .subscribe(System.out::println);

Opérateurs

Observable.from(1, 2, 3, 4) .reduce(new LinkedList<Integer>(), (seed, value) -> { seed.add(value); return seed; }) .first() .subscribe(System.out::println);

Opérateurs

Observable.from(1, 2, 3, 4) .toList() .first() .subscribe(System.out::println);

Opérateurs

Différence entre first() / single() / take(1) ?

Gestion des erreurs

Observable.from(1, 2, 3, 4) .toList() .single() .subscribe(System.out::println);

Gestion des erreurs

Observable.from(1, 2, 3, 4) .toList() .single() .subscribe(System.out::println);

Notification des erreurs absentes

Gestion des erreurs

static { RxJavaPlugins.getInstance().registerErrorHandler(new RxJavaErrorHandler() { @Override public void handleError(Throwable e) { e.printStackTrace(); } });}

Lambda & Java 8

Observable.from(1, 2, 3, 4) .filter(new Func1<Integer, Boolean>() { @Override public Boolean call(Integer i) { return i > 3; } }) .subscribe(new Action1<Integer>() { @Override public void call(Integer x) { System.out.println(x); } });

Lambda & Java 8

Observable.from(1, 2, 3, 4) .filter(i -> i > 3) .subscribe(System.out::println);

Lambda & Java 8

Observable.from(1, 2, 3, 4) .filter(i -> i > 3) .subscribe(System.out::println);

Retrolambda

Concurrence

obs1.mergeWith(obs2) .take(5) .subscribe(System.out::println);

Concurrence

Doit gérer la concurrence

Concurrence

non concurrence

Sync & Async

Observable<Integer> generator();

Sync & Async

Sync ?

Sync & Async

Sync ? Async ?

Sync & Async

Sync ? Async ?

Computation ?

Sync & Async

Sync ? Async ?

Computation ? Acteur ?

“Leak” des Observables

everything is an event

ViewPager

Preferences

Observable

ViewPager

Preferences

UserService

Observable

Future<RxJava>

Support RxJava

Reactive Streams

Reactive Streams is an initiative to provide a standard for asynchronous stream processing with non-blocking back pressure on the JVM.

http://www.reactive-streams.org/

Reactive Streams

RxJava | Akka Streams | Reactor Composable | Ratpack

Reactive Streams

> 700 Ko | Java | Android

Reactive Streams

> 2.5 Mo | Scala | Akka

Reactive Streams

~1Mo | Java | RingBufferDispatcher

Reactive Streams

Java 8 | Http

Si il ne fallait retenir qu’une chose

RxJava est un modèle de programmation pour écrire des applications asynchrones

Frontend | Backend | Crossplatform

Questions ?

david.wursteisen@soat.fr@dwursteisen

rxjava, getting started - david wursteisen - 16 octobre 2014

executenew callback

manipulation dvnements0

flux dvnements finivnements

flux dvnements infinivnements

manipulation dvnements1

callback hell

mapi character

mapa b

Technology

introduction to retrofit and rxjava

rxjava 2 tips and tricks

reactive android: rxjava and beyond

practical rxjava for android

best practices for unit testing rxjava

rxjava essentials - sample chapter

intro to rxjava/rxandroid - gdg munich android

how to think in rxjava before reacting

rxjava from the trenches

rxjava in practice

rxjava architectures on android #8 android livecode

java 8 stream api and rxjava comparison

activités ils montréal activities session...

model-view-viewmodel and rxjava

an introduction to rxjava

architecture and rxjava

rxjava architectures on android - android livecode berlin

rxjs vs rxjava: intro

dagger & rxjava & retrofit

to be reactive...rxjava