La Révolution Réactive - Bdx.io 2016

Un retour d'expérience sur la mise en place d'une plateforme de publication pour un groupe de presse français nous permettra de découvrir la "programmation réactive". Nous commencerons par une présentation du paradigme et ses cas d’usage. Puis l'étude de cas nous servira d'exemple sur son implémentation au sein d'un projet de taille conséquente et avec de fortes problématiques de performances. Enfin, nous ferons un tour des implémentations notamment au sein de la JVM (les réactives stream arrivent dans sa prochaine version) pour conclure sur le futur de l'écosystème réactif.

Transcript

1. Don’t call us, we call you La révolution fonctionnelle
2. @lilobase Arnaud LEMAIRE
3. Du « pull » au « push »
4. Reactive X • ReactiveX is a library for composing asynchronous and event-based programs by using observable sequences.
5. Reactive X
6. Qu’est ce que l’asynchrone ?
7. Qu’est ce que l’asynchrone ?
8. Etat vs Evénement • Les évènements sont ponctuels dans le temps, ne peuvent être passés, chaque évènement est important et l’ordre doit être préservé • Malheureusement un évènement isolé est rarement intéressant • Un état est continue, il est définit en permanence mais peut être mis à jour • L’état est ce qui intéresse (le plus souvent) notre utilisateur
9. Discret vs Continu Evénements Etat
10. Système pull Evénements (écritures) Etat (lectures) Actions Affichage
11. Système réactif Evénements (écritures) Etat (lectures) Actions Affichage
12. Pourquoi chez Sud Ouest ?
13. Cas d’usages • Réagir à une action utilisateur • Réagir et traiter un processus externe asynchrone • Réagir à des évènements reçu depuis un système externe
14. Le design pattern iterator [ ].forEach()
15. Le design pattern observer .subscribe( ) .notify( )
16. Les futures .then( ) .( )
17. Iterator + observer + future = Observable .then( ) [ ].subscribe( )
18. Des Iterables aux Observables getDataFromLocalMemorySynchronously()
 .skip(10)
 .limit(5)
 .map(s -> s + "_transformed")
 .forEach(System.out::println) Stream getDataFromNetworkAsynchronously()
 .skip(10)
 .take(5)
 .map(s -> s + "_transformed")
 .subscribe(System.out::println) Observable
19. Observable Observable
 .range(5, 3)
 .subscribe(i -> {
 log(i);
 });
20. Observable Observable<Pair<String, Integer>> groceries = Observable
 .just("bread", "butter", "egg", "milk", "tomato", "cheese","tomato", "egg", "egg")
 .groupBy(prod -> prod)
 .flatMap(grouped -> grouped
 .count()
 .map(quantity -> {
 String productName = grouped.getKey();
 return Pair.of(productName, quantity);
 }))
 .forEach(e -> 
 System.out.println( String.format("%s: %d", e.getKey(), e.getValue()) ));
21. Observable Observable<Status> observe() {
 return Observable.create(subscriber -> {
 TwitterStream twitterStream = 
 new TwitterStreamFactory().getInstance();
 twitterStream.addListener(new StatusListener() {
 @Override
 public void onStatus(Status status) {
 subscriber.onNext(status);
 }
 @Override
 public void onException(Exception ex) {
 subscriber.onError(ex);
 }
 });
 subscriber.add(Subscriptions.create(twitterStream::shutdown));
 });
 }
22. Des collections aux observables private List<Person> query(String sql) {
 //...
 }
 
 List<Person> listPeople() {
 return query("SELECT * FROM PEOPLE");
 }
 
 Observable<Person> listPeople() {
 final List<Person> people = query("SELECT * FROM PEOPLE");
 return Observable.from(people);
 }
23. Eager vers Lazy • La deuxième version n’exécutera la requête que si un subscribe est effectivement déclenché Observable<Person> listPeople() {
 final List<Person> people = query("SELECT * FROM PEOPLE");
 return Observable.from(people);
 }
 
 public Observable<Person> listPeople() {
 return Observable.defer(() ->
 Observable.from(query("SELECT * FROM PEOPLE")));
 }
24. Producer & Subject • Les producers sont les sources de données (vous n’avez pas envie d’en écrire un) • Les subjects sont un mélange entre un observable et un producer, ils peuvent ainsi recevoir et émettre des évènements
25. Hot & Cold • Les observables « cold » vont émettre leurs évènements uniquement si un subscribe est déclenché Observable A Subscribe Observable B Subscribe
26. Hot & Cold • Les observables « hot » émettent en permanence des évènements (mouvement de la souris) Observable A Subscribe Observable B Subscribe
27. BackPressure • Les observables « hot » émettent en permanence des évènements (mouvement de la souris) Observable A Subscribe Observable B Subscribe
30. Merci Arnaud LEMAIRE | @lilobase