RxJava, Getting Started - David Wursteisen - 16 Octobre 2014

RxJava
Getting Started
David Wursteisen 16 Octobre 2014

David Wursteisen
Direction Expertise Innovation
@dwursteisen

Architecture distribuée
Sync/Async/Concurrence

Architecture distribuée
The Internet

Asynchrone
Appel non
bloquant

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é
@Override
@Override
}
});
}
});

Complexité
@Override
@Override
@Override
}
});
}
});

Complexité
@Override
@Override
@Override
}
});
}
});
Callback hell

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

Historique
Il était une fois...

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)
1

Observable.never()
Observable.empty()
Observable.just(1)
1 2 3

Observable.never()
Observable.empty()
Observable.just(1)
1 4400

Observable.never()
Observable.empty()
Observable.just(1)
0
t
t + 5 secondes

Observable.never()
Observable.empty()
Observable.just(1)
A C

Observable<json> json json json
λ ϕ φ
Observable<Integer>
Observable<Click>

Observer
OnNext* (OnCompleted|OnError)?

Observer

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
System.err::println)

Observer
System.err::println,
onCompleted)

Observer
System.err::println,
() -> System.out.println(“finished”))

Manipulation d’évènements
Quand l’écoute ne suffit plus

0 1

0 1
map

0 1
map
A B

1 4

1 4
filter ( x <= 2 )

1 4
1
filter ( x <= 2 )

1 2

1 2
delay ( 5, SECONDS )

1 2
delay ( 5, SECONDS )
1
2

Observable.from(0, 1, 2, 3, 4)
Observable<Integer>

.filter((i) -> i < 3)
Observable<Integer>
Observable<Integer>

.filter((i) -> i < 3)
.delay(5, TimeUnit.SECONDS)
Observable<Integer>
Observable<Integer>
Observable<Integer>

.filter((i) -> i < 3)
.map((i) -> Character.toString((char)(i + 'A')))
Observable<Integer>
Observable<Integer>
Observable<Integer>
Observable<String>

.filter((i) -> i < 3)
.subscribe(System.out::println);
Observable<Integer>
Observable<Integer>
Observable<Integer>
Observable<String>

.filter((i) -> i < 3)
0, 1, 2, 3, 4 => A, B, C
Observable<Integer>
Observable<Integer>
Observable<Integer>
Observable<String>

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

Mise en pratique de composition
Learn from the trenches

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
@Override
public void call(Subscriber<? super T> s) {
s.onNext(123);
s.onCompleted();
}
});
Émission synchronne

Subscription
@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
@Override
// ...
@Override
}
@Override
}
});
}
});
Émission asynchronne

Subscription
@Override
// ...
@Override
}
@Override
}
});
}
});
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.unsubscribe();

Unsubscribe
/* ... */
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
main
IO
Computation
UI

Schedulers
.subscribeOn(scheduler)
.take(10)
.delay(1, SECONDS, scheduler)
.map(parse())
.observeOn(scheduler)
.map(n -> “=> ” + n))

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

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
Souscription différente

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

Hot Observable
Subscribe
obs.connect();

Hot Observable
obs.connect();
Partage la même souscription

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
buffer

Back Pressure
Production
Pression arrière

Back Pressure
Demande de production de n élements
Production
Pression arrière

Opérateurs
Observable.from(1, 2, 3, 4)
.reduce(new LinkedList<Integer>(), (seed, value) -> {
seed.add(value);
return seed;
})
.first()

Opérateurs
.toList()
.first()

Opérateurs
.toList()
.first()
Différence entre first() / single() / take(1) ?

Gestion des erreurs
.toList()
.single()

Gestion des erreurs
.toList()
.single()
Notification des erreurs absentes

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

Lambda & Java 8
.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
@Override
return i > 3;
}
})
@Override
}
});
Bruit

Lambda & Java 8
.filter(i -> i > 3)

Lambda & Java 8
@Override
return i > 3;
}
})
@Override
}
});
.filter(i -> i > 3)
Retrolambda

Concurrence
obs1.mergeWith(obs2)
.take(5)

Concurrence
Doit gérer la concurrence
.take(5)

Concurrence
.take(5)
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

ViewPager
Observable
Preferences

ViewPager
Observable
Preferences
Observable
UserService

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

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

More Related Content

What's hot

Viewers also liked

More from SOAT

RxJava, Getting Started - David Wursteisen - 16 Octobre 2014