Reactive Programming with RxJava

Reactive Programming with RxJava for handling stream data

Transcript

1. Reactive Programming with RxJava Catalog Tribe in Shanghai debop@coupang.com 2018.01.18 1
2. Agenda • Why Reactive Programming? • RxJava Observable • RxJava Operators • RxJava Schedulers • References 2
3. Why Reactive
4. High available system Service Infinite streams Many slow connections Depends A Depends B Slow remote services
5. Blocking vs Non-Blocking
6. ReactiveX • Started by Microsoft Rx Lib (Reactive Extensions) • For composing asynchronous and event-based programs by using observable sequences • Easy way to implement complicated non-blocking system • Easy to combine multiple data source responses • Resiliency / Fault tolerance / Deal heavy load • Why Reactive
7. Reactive Streams Publisher Subscriber
8. Reactive Streams Publisher Subscriber
9. Reactive Streams Publisher Subscriber Subscribe then request data (Backpressure)
10. Reactive Streams Publisher Subscriber Subscribe then request data (Backpressure)
11. Reactive Streams Publisher Subscriber Subscribe then request data (Backpressure)
12. Reactive Streams Publisher Subscriber Subscribe then request data (Backpressure) 0..N Data published then 0..1 (Error or Completed)
13. Reactive Streams Publisher Subscriber Subscribe then request data (Backpressure) 0..N Data published then 0..1 (Error or Completed) Example : Using Message Queue 1. Polling message queue for new message (traditional Kafka client) 2. Listener or callback for new message (spring-kafka use listener) 3. Reactive stream (kakfa streams) is reactive streams
14. Observable RxJava
15. Iterable vs Observable Event Iterable (pull) Observable (push) Receive data T next() onNext(T) Discover error Throw Exception onError(Exception) Complete !hasNext() onCompleted()
16. Use Observable getDataFromLocalMemory() .skip(10) .take(5) .map { s -> s + " transformed" } .forEach { println(“next => " + it) } Iterable Observable getDataFromNetwork() .skip(10) .take(5) .map { s -> s + " transformed" } .subscribe { println(“next => " + it) }
17. Why Use Observable • Observables are composable • Observables are Flexible • Observables are less opinionated • Various implementation (thread-pool, event loops, non- blocking I/O) • Callback is hard to implement and maintain • Not only for UI, Useful for Distributed System
18. Structure of Observable
19. Cold vs Hot Observable • Cold Observable • Like VOD (Video on demand) (Finite stream) • At time to subscribe, you can receive first data • Other subscribe, receive first data also • Hot Observable • Like TV or Radio (Infinite Stream) • At time to subscribe, you can receive published data at that time
20. Other Objects • Flowable (RxJava2) • Observable with back pressure • Single • onSuccess/onFailure • Completable • onCompleted with no returns • Maybe (RxJava2) • Single + Completable
21. Subject • Observable + Observer • Varieties of Subject • AsyncSubject - take last elements • BehaviorSubject - like hot observable + latest element • PublishSubject - like hot observable • ReplaySubject - cold observable
22. Operators RxJava
23. Operators example
24. Operators example fun fetchWeather(city:String):Single<Weather>
25. Operators example fun fetchWeather(city:String):Single<Weather>
26. Operators example fun fetchWeather(city:String):Single<Weather>
27. Operators example
28. Operators example
29. Operators example
30. Operators example
31. Operators example Times out and emits an error after 2 sec
32. Operators example Times out and emits an error after 2 sec
33. Operators example
34. Operators example
35. Operators example Logs a message in case of error
36. Operators example Logs a message in case of error
37. Operators example
38. Operators example
39. Operators example Switches to a different service in case of error
40. Operators example Switches to a different service in case of error
41. Operators example
42. Operators example
43. Operators example Transform a weather instance into a string message
44. Operators example Transform a weather instance into a string message
45. Operators example
46. Operators example
47. Operators example Triggers the processing of the chain
48. Marble Diagram - zip
49. Marble Diagram - zip UpStream
50. Marble Diagram - zip UpStream Operator
51. Marble Diagram - zip UpStream DownStream Operator
52. Marble Diagram - flatMap
53. Marble Diagram - retry
54. Reactive Server Observer Observer Streaming API REST API
55. Reactive Server Observer Observer Streaming API REST API
56. Reactive Server Observer Observer Streaming API REST API
57. Reactive Server Observer Observer Streaming API REST API
58. Reactive Server Observer Observer Streaming API REST API
59. Reactive Server Observer Observer Streaming API REST API Observable.zip(tweets, issues)
60. Reactive Server Observer Observer Streaming API REST API Observable.zip(tweets, issues)
61. RxJava Operators • Factory operators • create, defer, from, interval, just, range, repeat … • Transform • buffer, flatMap, groupBy, map, scan, window • Filtering • debounce, distinct, elementAt, filter, first, ignoreElements, last, sample, skip, skipLast, take, takeLast • Combine • and, then, when, combineLatest, join, merge, startWith, switch, zip
62. RxJava Operators • Error handling (catch, retry) • Utility • delay, do, materialize/dematerialize, observeOn, serialize, subscribe, subscribeOn, timeInterval, timeout, timestamp, using • Conditional • all, amb, contains, defaultIfEmpty, sequenceEqual, skipUntil, skipWhile, takeUntil, takeWhile • Math/Aggregator • average, concat, count, max, min, reduce, sum
63. RxJava Operators • ConnectableObservable operators • connect, publish, refcount, replay • Convert • to • Backpressure • onBackPressureBuffer, onBackpressureDrop, onBackpressureLatest
64. Schedulers RxJava
66. Schedulers • Observable is single thread in default • Scheduling emit data - subscribeOn(scheduler) • Scheduling subscribe data - observeOn(scheduler) • Type of schedulers • computation, io, newThread, single, trampoline, from … • TestScheduler for simulate Observable timely emit
67. Migration strategy - Strangler pattern
68. References • Books • Reactive Programming with RxJava • Articles • Why Reactive • Advanced Reactive Java • RxJava Part1, Part 2, Part 3 • Testing RxJava, RxJava2
69. Thank you!