Reactive Streams and RxJava2

Reactive Streams and RxJava2

• 1. Reactive Streams and RxJava2 Yakov Fain, Farata Systems
 
 yfain
• 2. About myself • Solutions Architect at Farata Systems • Java Champion • Latest book:
 “Angular 2 Development with TypeScript”

• 3. “If I had asked people what they wanted, they would have said faster horses”
 
 Henry Ford

• 4. Synchronous vs asynchronous • Synchronous programming is straightforward • Asynchronous programming dramatically increases complexity
• 5. Challenges in async programming • Handling failed async requests • Chaining async calls • The user already closed the view • Switching threads to update UI
• 6. and more challenges • Avoiding writing blocking code in a multi-threaded app • Several consumers • Composable functions • Killing a pending Http request
• 7. Backpressure Subscriber
 Sammy A publisher generates more data than a subscriber can process Publisher
• 8. Examples of backpressure • The stock price changes 100 times a second • Accelerometer produces 50 signals a second • Iteration through a JDBC result set (rxjava-jdbc; rxjava2-jdbc) • A user drags the mouse to draw a curve. Can’t apply back pressure.
• 9. Reactive Apps • The data is processed as streams • Message-driven: notifications • Resilient: stay alive in case of failures • Data flows through your app’s algorithms • Hide complexity of multi-threading
• 10. Reactive Streams • A spec for async stream processing with non-blocking backpressure
 
 http://www.reactive-streams.org
 • Reactive Streams interfaces for JVM 
 
 https://github.com/reactive-streams/reactive-streams-jvm • Reactive Streams-based products: 
 
 RxJava2, Java 9 Flow APIs, Reactor 3, Akka Stream, MongoDB, Vert.x …
• 11. Reactive Streams: Java interfaces
• 12. Reactive Streams: Java interfaces
• 13. Reactive Streams: Java interfaces backpressure
 support
• 14. Reactive Streams: Java interfaces backpressure
 support
• 15. Main RxJava2 players • Observable or Flowable - producers of data • Observer or Subscriber - consumers of data • Subject or Processor - implements both producer and consumer • Operator - en-route data transformation • Scheduler - multi-threading support
• 16. Main Publishers and Subscribers in RxJava2 Observable
 no backpressure support 
 public interface Observer<T> {
 void onSubscribe(Disposable var1);
 
 void onNext(T var1);
 
 void onError(Throwable var1);
 
 void onComplete();
 } Publisher Subscriber Not from 
 Reactive Streams
• 17. Observable
 no backpressure support Flowable
 with backpressure support public interface Observer<T> {
 void onSubscribe(Disposable var1);
 
 void onNext(T var1);
 
 void onError(Throwable var1);
 
 void onComplete();
 } public interface Subscriber<T> {
 void onSubscribe(Subscription var1);
 
 void onNext(T var1);
 
 void onError(Throwable var1);
 
 void onComplete();
 } Not from 
 Reactive Streams From 
 Reactive Streams Main publishers and subscribers in RxJava2 Publisher Subscriber
• 18. Creating an Observable • Observable.create() • Observable.fromArray() • Observable.fromIterable() • Observable.fromCallable() • Observable.fromFuture() • Observable.range() • Observable.just() Observable.create(subscriber -> { int totalBeers = beerStock.size(); for (int i = 0; i < totalBeers; i++) {
 // synchronous push subscriber.onNext(beerStock.get(i)); } subscriber.onComplete(); });
• 19. Observable<Beer> observableBeer = Observable.create(/* data source */); observableBeer
 .skip(1)
 .take(3)
 .filter(beer -> "USA".equals(beer.country))
 .map(beer -> beer.name + ": $" + beer.price)
 .subscribe(
 beer -> System.out.println(beer),
 
 err -> System.out.println(err),
 
 () -> System.out.println("Streaming is complete”),
 
 disposable -> System.out.println( 
 "Someone just subscribed to the beer stream!!!”)
 );
 ); Observable push O b s e r v e r Subscription
• 20. Creating an Observer and subscribing Observable<Beer> beerData = BeerServer.getData(); // returns an Observable
 
 Observer beerObserver = new Observer<Beer>() {
 
 public void onSubscribe(Disposable d) {
 System.out.println( " !!! Someone just subscribed to the bear stream!!! ");
 
 // If the subscriber is less than 21 year old, cancel subscription
 // d.dispose();
 }
 
 public void onNext(Beer beer) {
 System.out.println(beer);
 }
 
 public void onError(Throwable throwable) {
 System.err.println("In Observer.onError(): " + throwable.getMessage());
 }
 
 public void onComplete() {
 System.out.println("*** The stream is over ***");
 }
 };
 
 beerData
 .subscribe(beerObserver); // Streaming starts here
• 21. Subscription subscription = Observable.create(new Observable.OnSubscribe<Response>() {
 OkHttpClient client = new OkHttpClient();
 
 @Override public void call(Subscriber<? super Response> subscriber) { // invoked on subscription try { Response response = client.newCall( // prepare the call for future execution new Request.Builder().url(“http://localhost:8080/beers“) .build()) .execute(); // use enqueue() for async requests 
 subscriber.onNext(response);
 
 subscriber.onComplete(); 
 if (!response.isSuccessful()) { subscriber.onError(new Exception(“Can’t get beers”)); } } catch (IOException e) { subscriber.onError(e); } } })
 .subscribe(...); // pass Observer; use observeOn/SubscribeOn to switch threads Pushing HTTP responses https://square.github.io/okhttp
• 22. Controlling the flow with request() request(1); request(1);
• 23. Handling backpressure Publisher Subscriber request(1) request(3) … request() is non-blocking onNext(value1) onNext(value2) onNext(value3) onNext(value4)
• 24. BackpressureStrategy.BUFFER BackpressureStrategy.BUFFER
• 25. BackpressureStrategy.DROP BackpressureStrategy.Drop
• 26. BackpressureStrategy.LATEST BackpressureStrategy.Latest
• 27. Creating a Flowable • Flowable.create() • Flowable.fromArray() • Flowable.fromIterable() • Flowable.fromCallable() • Flowable.empty() • Flowable.range() • Flowable.just()
• 28. Flowable.create() and Observable.toFlowable() myObservable
 .toFlowable(BackpressureStrategy.BUFFER); Flowable<Beer> myFlowable
 .create(beerEmitter ->{…},
 BackpressureStrategy.BUFFER); Create Convert from Observable
• 29. Requesting data from Flowable public class FlowableRange {
 
 static DisposableSubscriber<Integer> subscriber;
 
 public static void main(String[] args) {
 
 subscriber = new DisposableSubscriber<Integer>() {
 
 public void onStart() {
 request(5);
 
 while (true){ // Emulate 1-sec processing
 try {
 Thread.sleep(1000);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 request(1);
 }
 }
 
 public void onNext(Integer t) {
 System.out.println("processing "+ t);
 if (t==8) { // just to demo unsubscribing
 subscriber.dispose();
 }
 }
 
 public void onError(Throwable thr) {
 System.err.println("In onError(): " + thr.getMessage()); 
 }
 
 public void onComplete() {
 System.out.println("Done");
 }
 };
 
 Flowable.range(1, 10)
 .subscribe(subscriber);
 }
 }
• 30. Demo 
 1. FlowableRange
 2. BeerClientFlowable Code samples: https://github.com/yfain/rxjava2
• 31. An Operator Observable Observable A transforming
 function observableBeer
 .filter(b -> "USA".equals(b.country)) Docs: http://reactivex.io/documentation/operators
• 32. QUIZ: What value(s) this observable emits? Observable
 .just(5, 9, 10) // emits 5, 9, 10
 
 .filter(i -> i % 3 > 0)
 
 .map(n -> "$" + n * 10)
 
 .filter(s -> s.length() < 4);
• 33. Observable
 .just(5, 9, 10) // emits 5, 9, 10
 
 .filter(i -> i % 3 > 0)
 
 .map(n -> "$" + n * 10)
 
 .filter(s -> s.length() < 4) 
 .subscribe(System.out::println);
• 34. Composing observables
• 35. merge: combining observables
• 36. concat: combining observables in order
• 37. zip: combining observables of different types
• 38. flatMap
• 39. switchMap
• 40. Types of Observables Hot Cold Push Produce a steam even
 if no-one cares r Produce a stream when 
 someone asks for it ✔
• 41. Hot Observables • Mouse events • Publishing stock prices • An accelerometer in a smartphone
• 42. Making observables hot
• 43. Turning a cold observable into hot ConnectableObservable<Long> numbers = (ConnectableObservable<Long>) Observable
 .interval(1, TimeUnit.SECONDS) // generate seq numbers every second
 .publish(); // make it hot
 
 numbers.connect(); // creates an internal subscriber to start producing data
 numbers.subscribe(n ->System.out.println("First subscriber: "+ n ));
 
 Thread.sleep(3000);
 
 numbers.subscribe(n ->System.out.println(" Second subscriber: "+ n ));

• 44. Demo 
 HotObservable
• 45. Schedulers
• 46. Concurrency with Schedulers • subscribeOn(strategy) - run Observable in a separate thread: 
 Operations with side effects like files I/O;
 Don’t hold off the UI thread
 • observeOn(strategy) - run Observer in a separate thread,
 Update Swing UI on the Event Dispatch Thread
 Update Android UI on the Main thread
• 47. Multi-threading strategies • Schedulers.computation() - for computations: # of threads <= # of cores • Schedulers.io() - for long running communications; backed by a thread pool • Schedulers.newThread() - new thread for each unit of work • Schedulers.from(Executor) - a wrapper for Java Executor • Schedulers.trampoline() - queues the work on the current thread • AndroidSchedulers.mainThread() - handle data on the main thread (RxAndroid)
• 48. Switching threads Operator1() Operator2() ObserveOn() Observable Subscriber Thread 1 Thread 2 subscribeOn() observeOn()
• 49. Multi-threaded processing with flatMap() Operator1() Operator2() flatMap() Observable Subscriber Thread 1 Observable/Thr2 Observable/Thr3 Observable/ThrN Spawn a separate thread for each observable …
• 50. Turning a value into
 an observable Observable.range(1, 1000) .flatMap(n->Observable.just(n)
 .subscribeOn(Schedulers.computation()))
 .map(n->n*2)
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(myView.update()); Subscribing to each observable on the computation thread Switching to the main thread Updating the UI
• 51. Demo 
 schedulers/SubscribeOnObserveOn
 
 ParallelStreams
• 52. Parallel operations with ParallelFlowabe • Parallel execution of some operators
 • The source sequence is dispatched into N parallel “rails” • runOn() —-> sequential() is more efficient fork/join than flatMap()
 • Each rail can spawn multiple async threads with Schedulers
• 53. Parallel Execution int numberOfRails = 4; // can query #processors with parallelism()
 
 ParallelFlowable
 .from(Flowable.range(1, 10), numberOfRails)
 .runOn(Schedulers.computation())
 .map(i -> i * i)
 .filter(i -> i % 3 == 0)
 .sequential()
 .subscribe(System.out::println); Tasks run simultaneously on different CPUs or computers. ParallelFlowableRange.java
• 54. Summary • Observable: no backpressure support • Flowable: backpressure support • Operators can be chained • flatmap() used for handling observable of observables • Schedulers support multi-threading • subscribeOn()/observeOn() - switching between threads • ParallelFlowable - initiate parallel processing
• 55. Links • Slides: http://bit.ly/2q3Ovt4 • Code samples: 
 https://github.com/yfain/rxjava2 • Our company: faratasystems.com • Blog: yakovfain.com • Twitter: @yfain