feat: rxjava - Level 2

rxjava/src/main/java/fr/ippon/codingdojo/reactive/Level2.java

+package fr.ippon.codingdojo.reactive;
+
+import fr.ippon.codingdojo.reactive.util.Log;
+import io.reactivex.Observable;
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.List;
+
+/**
+ * Anatomie d'un flux de données (stream).
+ *
+ * Un `Stream`est une séquence données, potentiellement non limitée. Ces données peuvent être connues ou inconnues
+ * à son création.  Les flux sont des constructions asynchrones. Lorsque vous observez un flux, vous ne savez pas
+ * quand les données vont être émises.
+ *
+ * Un `Observer` peut recevoir 3 types d'événements notifié par l'un des 3 méthodes suivantes:
+ *  - onNext: notifie à chaque fois qu'un élément est passé dans le flux
+ *  - onComplete: notifie la fin du flux. `onNext ne sera plus appelé
+ *  - onError: notifie qu'une erreur est arrivée. Le flux n'émettra plus d'éléments, `onComplete`n'est pas appelé.
+ *
+ */
+@Slf4j
+public class Level2 {
+
+    public static void main(String[] args) {
+
+        exercise1();
+        exercise2();
+        exercise3();
+        exercise4();
+
+    }
+
+    /**
+     * TODO: Afficher un message quand
+     *      - un élément est émis dans le flux
+     *      - le flux est terminé
+     *
+     * NOTE: sortie attendue
+     *
+     *   Start Level2/Exercise1
+     *   Next: Flash McQueen
+     *   Next: The King
+     *   Next: Martin
+     *   Next: Sally Carrera
+     *   Done
+     *   Stop
+     *
+     */
+    public static void exercise1() {
+
+        var data = List.of("Flash McQueen", "The King", "Martin", "Sally Carrera");
+
+        log.info("Start Level2/Exercise1");
+        Observable.fromIterable(data)
+                .doOnNext(item -> log.info("Next: " + item))
+                .doOnComplete(Log::done)
+                .subscribe();
+        log.info("Stop");
+    }
+
+    /**
+     * TODO: Déclencher une erreur quand l'élément commence par la chaîne `Unknown`. Utilisez les méthodes
+     *  `doOnNext`, `doOnComplete` et `doOnError` pour afficher les différents événements.
+     *
+     * NOTE: sortie attendue
+     *
+     *   Start Level2/Exercise2
+     *   Next: Flash McQueen
+     *   Next: The King
+     *   Error: Unknown Character !
+     *   Stop
+     *
+     * REMARQUE:
+     *   Une fois l'erreur déclenchée, plus aucun élément n'est émis. La méthode `onComplete n'est pas appelée.
+     *
+     */
+    public static void exercise2() {
+
+        var data = List.of("Flash McQueen", "The King", "Unknown Character", "Martin", "Sally Carrera");
+
+        log.info("Start Level2/Exercise2");
+        Observable.fromIterable(data)
+                .map(item -> {
+                    if (item.startsWith("Unknown")) {
+                        throw new RuntimeException("Unknown Character !");
+                    }
+                    return item;
+                })
+                .doOnNext(s -> log.info("Next: " + s))
+                .doOnComplete(() -> log.info("Never called !"))
+                .doOnError(err -> log.error("Error: " + err.getMessage()))
+                .subscribe();
+        log.info("Stop");
+
+    }
+
+    /**
+     * TODO: Nous allons maintenant recevoir ces événements directement dans le `subscriber`. RxJava met
+     *  3 méthodes à la disposition lors de la souscription.
+     *
+     *  - notifie les éléments : stream.subscribe(item -> {});
+     *  - notifie une erreur : stream.subscribe(item -> {}, error -> {});
+     *  - notifie la fin du flux : stream.subscribe(item -> {}, error -> {}, () -> {});
+     *
+     * NOTE: sortie attendue
+     *
+     *   Start Level2/Exercise2
+     *   Next: Flash McQueen
+     *   Next: The King
+     *   Next: Chick Hicks
+     *   Done
+     *   Stop
+     *
+     */
+    public static void exercise3() {
+
+        var data = List.of("Flash McQueen", "The King", "Chick Hicks");
+
+        log.info("Start Level2/Exercise3");
+        Observable.fromIterable(data)
+                .subscribe(
+                        item -> log.info("Next: " + item),
+                        Log::error,
+                        Log::done
+                );
+        log.info("Stop");
+
+    }
+
+    /**
+     * TODO: Depuis le début, nous utilisons des flux de données avec des valeurs fixes. Utiliser la méthodes `create`
+     *  pour émettre un flux avec les valeurs `Flash McQueen`, `The King`, `Chick Hicks`, `Martin` et `Sally Carrera`.
+     *
+     *
+     * NOTE: sortie attendue
+     *
+     *   Start Level2/Exercise2
+     *   Next: Flash McQueen
+     *   Next: The King
+     *   Next: Chick Hicks
+     *   Next: Martin
+     *   Next: Sally Carrera
+     *   Done
+     *   Stop
+     *
+     */
+    public static void exercise4() {
+
+        log.info("Start Level2/Exercise4");
+        Observable<String> stream = Observable.create(subscriber -> {
+
+            subscriber.onNext("Flash McQueen");
+            subscriber.onNext("The King");
+            subscriber.onNext("Chick Hicks");
+            subscriber.onNext("Martin");
+            subscriber.onNext("Sally Carrera");
+
+            subscriber.onComplete();
+        });
+
+        stream.subscribe(
+                item -> log.info("Next: " + item),
+                Log::error,
+                Log::done
+        );
+        log.info("Stop");
+
+    }
+    
+}