Guide to RxJava (#2597)

* alin.cojanu25@gmail.com

* add junit tests

* core-java - sneaky throws

* delete project spring_sample_annotations and spring_sample_xml ->not intended for this article

* RxJava

* delete old project

* refactored lambdas

* repaired subject test

* guide to rxjava

rxjava/src/main/java/com/baelding/rxjava/ConnectableObservableImpl.java

@@ -9,7 +9,8 @@ public class ConnectableObservableImpl {
 
     public static void main(String[] args) throws InterruptedException {
 
-        ConnectableObservable<Long> connectable = Observable.interval(200, TimeUnit.MILLISECONDS).publish();
+        ConnectableObservable<Long> connectable
+          = Observable.interval(200, TimeUnit.MILLISECONDS).publish();
         connectable.subscribe(System.out::println);
 
         System.out.println("Connect");

rxjava/src/main/java/com/baelding/rxjava/ObservableImpl.java

@@ -3,12 +3,22 @@ package com.baelding.rxjava;
 import rx.Observable;
 import rx.observables.BlockingObservable;
 
+import java.util.Arrays;
+import java.util.List;
+
 public class ObservableImpl {
 
-    public static void main(String[] args) {
+    static Integer[] numbers = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 
-        Integer[] numbers = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
-        String[] letters = {"a", "b", "c", "d", "e", "f", "g"};
+    static String[] letters = {"a", "b", "c", "d", "e", "f", "g", "h", "i"};
+    static String[] titles = {"title"};
+    public static List<String> titleList = Arrays.asList(titles);
+
+    public static Observable<String> getTitle() {
+        return Observable.from(titleList);
+    }
+
+    public static void main(String[] args) {
 
         System.out.println("-------Just-----------");
         Observable<String> observable = Observable.just("Hello");
@@ -28,14 +38,9 @@ public class ObservableImpl {
 
         System.out.println();
         System.out.println("-------FlatMap-----------");
-        Observable.from(letters)
-          .flatMap((letter) -> {
-              String[] returnStrings = {letter.toUpperCase(), letter.toLowerCase()};
-              return Observable.from(returnStrings);
-          })
-          .subscribe(
-            System.out::print
-          );
+        Observable.just("book1", "book2")
+          .flatMap(s -> getTitle())
+          .subscribe(System.out::print);
 
         System.out.println();
         System.out.println("--------Scan----------");
@@ -55,16 +60,12 @@ public class ObservableImpl {
         System.out.println("-------Filter-----------");
         Observable.from(numbers)
           .filter(i -> (i % 2 == 1))
-          .subscribe(
-            System.out::println
-          );
+          .subscribe(System.out::println);
 
         System.out.println("------DefaultIfEmpty------------");
         Observable.empty()
           .defaultIfEmpty("Observable is empty")
-          .subscribe(
-            System.out::println
-          );
+          .subscribe(System.out::println);
 
         System.out.println("------DefaultIfEmpty-2-----------");
         Observable.from(letters)

rxjava/src/main/java/com/baelding/rxjava/SubjectImpl.java

@@ -1,69 +1,73 @@
 package com.baelding.rxjava;
 
-import rx.Observable;
-import rx.schedulers.Schedulers;
+import rx.Observer;
 import rx.subjects.PublishSubject;
 
 public class SubjectImpl {
 
-    public static final String[] subscriber1 = {""};
-    public static final String[] subscriber2 = {""};
+    public static Integer subscriber1 = 0;
+    public static Integer subscriber2 = 0;
 
-    public static String subjectMethod() throws InterruptedException {
+    public static Integer subjectMethod() {
+        PublishSubject<Integer> subject = PublishSubject.create();
 
-        String[] letters = {"a", "b", "c", "d", "e", "f", "g"};
-        Long signal = 500L;
-        PublishSubject<String> subject;
+        subject.subscribe(getFirstObserver());
 
-        synchronized (signal) {
-            subject = PublishSubject.create();
-            subject.subscribe(
-              (letter) -> {
-                  subscriber1[0] += letter;
-                  System.out.println("Subscriber 1: " + subscriber1[0]);
-                  try {
-                      Thread.sleep(500);
-                  } catch (InterruptedException e) {
-                      e.printStackTrace();
-                  }
-                  if (letter.equals("c")) {
-                      synchronized (signal) {
-                          signal.notify();
-                      }
-                  }
-              }
-            );
-        }
+        subject.onNext(1);
+        subject.onNext(2);
+        subject.onNext(3);
 
-        Observable.from(letters)
-          .subscribeOn(Schedulers.computation())
-          .subscribe(
-            subject::onNext,
-            subject::onError,
-            () -> {
-                System.out.println("Subscriber 1 completed ");
-                subject.onCompleted();
-                synchronized (signal) {
-                    signal.notify();
-                }
+        subject.subscribe(getSecondObserver());
+
+        subject.onNext(4);
+        subject.onCompleted();
+        return subscriber1 + subscriber2;
+    }
+
+
+    public static Observer<Integer> getFirstObserver() {
+        return new Observer<Integer>() {
+
+            @Override
+            public void onNext(Integer value) {
+                subscriber1 += value;
+                System.out.println("Subscriber1: " + value);
             }
-          );
 
-        synchronized (signal) {
-            signal.wait();
-            subject.subscribe(
-              (letter) -> {
-                  subscriber2[0] += letter;
-                  System.out.println("Subscriber 2: " + subscriber2[0]);
-              },
-              subject::onError,
-              () -> System.out.println("Subscriber 2 completed ")
-            );
-        }
+            @Override
+            public void onError(Throwable e) {
+                System.out.println("error");
+            }
 
-        synchronized (signal) {
-            signal.wait();
-            return subscriber1[0] + subscriber2[0];
-        }
+            @Override
+            public void onCompleted() {
+                System.out.println("Subscriber1 completed");
+            }
+        };
+    }
+
+    public static Observer<Integer> getSecondObserver() {
+        return new Observer<Integer>() {
+
+            @Override
+            public void onNext(Integer value) {
+                subscriber2 += value;
+                System.out.println("Subscriber2: " + value);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                System.out.println("error");
+            }
+
+            @Override
+            public void onCompleted() {
+                System.out.println("Subscriber2 completed");
+            }
+        };
+    }
+
+    public static void main(String[] args) throws InterruptedException {
+        System.out.println(subjectMethod());
     }
 }