Save 37% off PRO during our Black Friday Sale! »

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

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.

Beb422437c1dfb5366f197919e41ac50?s=128

Arnaud LEMAIRE
PRO

October 21, 2016
Tweet

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
  28. None
  29. None
  30. Merci Arnaud LEMAIRE | @lilobase