RxJava: the observer pattern on steroids

Transcript

1. RxJava: observer pattern on steroids Alexey Vakhrenev vakhrenev@devexperts.com
2. Agenda • The observer pattern ◦ usages ◦ problems and limitations • Towards a better observer • RxJava to the rescue
3. Observer pattern • Behavioral pattern • Used in UI toolkits • Key component of MVC
4. Observer pattern Model Notifications
5. Observer pattern https://en.wikipedia.org/wiki/Observer_pattern
6. Pros • Asynchronous • Loose coupling ◦ between observer and subject
7. Drag-and-drop
8. Drag-and-drop 1. Mouse down 2. Mouse move ◦ until mouse up calculating Δ‘s while moving
9. Drag-and-drop interface MouseController { void addMouseUpListener(MouseUpListener listener); void addMouseDownListener(MouseDownListener listener); void addMouseMoveListener(MouseMoveListener listener); void removeMouseUpListener(MouseUpListener listener); void removeMouseDownListener(MouseDownListener listener); void removeMouseMoveListener(MouseMoveListener listener); }
10. Drag-and-drop interface DragListener { void onMouseDragged(Line drag); }
11. Drag-and-drop void listenToTheDrag(MouseController mouse, DragListener listener) { ??? }
12. Drag-and-drop Line line = null; MouseDownListener downListener = e -> { line = new Line(e.position); mouse.addMouseUpListener(upListener); mouse.addMouseMoveListener(moveListener); };
13. Drag-and-drop MouseMoveListener moveListener = e -> { line = line.endAt(e.position); listener.onMouseDragged(line); };
14. Drag-and-drop MouseUpListener upListener = new MouseUpListener() { public void onMouseUp(MouseEvent e) { mouse.removeMouseMoveListener(moveListener); mouse.removeMouseUpListener(this); line = null; } };
15. Drag-and-drop void listenToTheDrag(MouseController mouse, final DragListener listener) { AtomicReference<Line> line = new AtomicReference<>(null); MouseMoveListener moveListener = e -> { line.set(line.get().endAt(e.position)); }; MouseUpListener upListener = new MouseUpListener() { public void onMouseUp(MouseEvent e) { mouse.removeMouseMoveListener(moveListener); mouse.removeMouseUpListener(this); line.set(null); } }; MouseDownListener downListener = e -> { line.set(new Line(e.position)); listener.onMouseDragged(line.get()); mouse.addMouseUpListener(upListener); mouse.addMouseMoveListener(moveListener); }; mouse.addMouseDownListener(downListener); }
16. Cons • Tight coupling ◦ between observers dealing with single concern • Promotes shared mutable state
17. Cons • Resource management https://en.wikipedia.org/wiki/Lapsed_listener_problem
18. Cons • Abstraction ◦ no way to abstract over event source • Code reuse ◦ no way to express common patterns in reusable fasion
19. Cons • High semantic distance ◦ similarity between problem definition and solution ◦ makes code hard to understand ◦ makes problem definition hard to infer from code
20. Can we do better?
21. Let’s improve it Step by step
22. 1.Generic observer interface Observer<T> { void onEvent(T event); }
23. 1.Generic observer static <T> Observer<T> dropRepeated(Observer<? super T> self) { AtomicReference<T> old = new AtomicReference<>(); return event -> { if (!Objects.equals(event, old.getAndSet(event))) self.onEvent(event); }; }
24. 1.Generic observer //transforms events static <T, R> Observer<R> map(Observer<? super T> self, Func1<? super R, ? extends T> fn) { return event -> self.onEvent(fn.call(event)); } //filter out some events static <T> Observer<T> filter(Observer<? super T> self, Func1<? super T, Boolean> predicate) { return (event) -> { if (predicate.call(event)) self.onEvent(event); }; }
25. 1.Generic observer //with default methods Observer<String> original = System.out::println; Observer<String> decorated = original .dropRepeated() .filter((s) -> !s.isEmpty()) .map(String::toLowerCase);
26. 2.Generic Observable interface Observable<T> { void subscribe(Observer<? super T> observer); void unsubscribe(Observer<? super T> observer); }
27. 2.Generic Observable default Observable<T> dropRepeated() { Observable<T> self = this; return new Observable<T>() { Map<Observer, Observer> observers = new HashMap<>(); public void subscribe(Observer<? super T> observer) { Observer<? super T> decorated = observer.dropRepeated(); observers.put(observer, decorated); self.subscribe(decorated); } public void unsubscribe(Observer<? super T> observer) { Observer decorated = observers.get(observer); self.unsubscribe(decorated); } }; }
28. 2.Generic Observable default <R> Observable<R> map(Func1<? super T, ? extends R> fn) { Observable<T> self = this; return new Observable<R>() { Map<Observer, Observer> observers = new HashMap<>(); public void subscribe(Observer<? super R> observer) { Observer<? super T> decorated = observer.map(fn); observers.put(observer, decorated); self.subscribe(decorated); } public void unsubscribe(Observer<? super R> observer) { Observer decorated = observers.get(observer); self.unsubscribe(decorated); } }; }
29. 2.Generic Observable default <R> Observable<R> map(Func1<? super T, ? extends R> fn) { Observable<T> self = this; return new Observable<R>() { Map<Observer, Observer> observers = new HashMap<>(); public void subscribe(Observer<? super R> observer) { Observer<? super T> decorated = observer.map(fn); observers.put(observer, decorated); self.subscribe(decorated); } public void unsubscribe(Observer<? super R> observer) { Observer decorated = observers.get(observer); self.unsubscribe(decorated); } }; } See the pattern?
30. 3.First-class subscription public void subscribe(Observer<? super T> observer) { //... } public void unsubscribe(Observer<? super T> observer) { //... } public Runnable subscribe(Observer<? super T> observer) { //... return () -> unsubscribe(observer); } private void unsubscribe(Observer<? super T> observer) { //... }
31. 3.First-class subscription interface Observable<T> { /** * @param observer observer to subscribe * @return handle to free all the resources * associated with the observer */ Runnable subscribe(Observer<? super T> observer); }
32. 3.First-class subscription default Observable<T> dropRepeated() { Observable<T> self = this; return observer -> self.subscribe(observer.dropRepeated()); } default <R> Observable<R> map(Func1<? super T, ? extends R> fn) { Observable<T> self = this; return observer -> self.subscribe(observer.map(fn)); }
33. 3.First-class subscription static <T> Observable<T> merge(Observable<? extends T> obs1, Observable<? extends T> obs2) { return observer -> { Runnable r1 = obs1.addListener(observer); Runnable r2 = obs2.addListener(observer); return () -> { r1.run(); r2.run(); }; }; }
34. 3.First-class subscription static <T1, T2, R> Observable<R> zip(Observable<T1> obs1, Observable<T2> obs2, Func2<? super T1, ? super T2, R> fn) { return observer -> { Queue<T1> q1 = new ArrayDeque<>(); Queue<T2> q2 = new ArrayDeque<>(); Runnable r1 = obs1.subscribe(t1 -> { T2 t2 = q2.poll(); if (t2 == null) { q1.add(t1); } else { observer.onEvent(fn.call(t1, t2)); } }); Runnable r2 = obs2.subscribe(t2 -> { T1 t1 = q1.poll(); if (t1 == null) { q2.add(t2); } else { observer.onEvent(fn.call(t1, t2)); } }); return () -> {r1.run(); r2.run();}; }; }
35. 3.First-class subscription default Observable<T> take(int max_elements) { Observable<T> self = this; AtomicInteger counter = new AtomicInteger(max_elements); return observer -> { RunnableHolder holder = new RunnableHolder(); holder.hold(self.subscribe(event -> { observer.onEvent(event); if (counter.decrementAndGet() == 0) { holder.run(); } })); return holder; }; }
36. 3.First-class subscription But what if Observable<T> obs = ... Observable<Boolean> testZip = Observable.zip( obs, obs.take(5), (left, right) -> left == right );
37. 3.First-class subscription But what if Observable<T> obs = ... Observable<Boolean> testZip = Observable.zip( obs, obs.take(5), (left, right) -> left == right ); );
38. 4.Unsubscribe signal interface Observer<T> { void onEvent(T event); void onCompleted(); void onError(Throwable e); }
39. 4.Unsubscribe signal signal ::= onEvent* (onCompleted | onError)? V V X
40. A lot can be implemented once and for all
41. We don’t have to do it ourselves
42. RxJava • The observer pattern done right • Foundational interfaces and contracts • Extensive set of operations
43. RxJava public interface Observer<T> { public void onCompleted(); public void onError(Throwable e); public void onNext(T t); }
44. RxJava rx.Subscription • Encapsulates unsubscribe action • Idempotent public interface Subscription { public void unsubscribe(); public boolean isUnsubscribed(); }
45. RxJava rx.Subscriber<T> • Observer & Subscription • Attach dispose callbacks via add public abstract class Subscriber<T> implements Observer<T>, Subscription { public final void add(Subscription s) { //... } }
46. RxJava rx.Observable<T> • Subscriber<? super T> -> void Observable<ActionEvent> actionsOf(JButton button) { return Observable.create((subscriber) -> { ActionListener listener = subscriber::onNext; button.addActionListener(listener); subscriber.add(Subscriptions.create(() -> button.removeActionListener(listener) )); }); }
47. RxJava rx.Observable<T> • More than 300 methods
48. RxJava rx.Observable<T> • ...most of them are implemented via lift public interface Operator<R, T> extends Func1<Subscriber<? super R>, Subscriber<? super T>> { // cover for generics insanity } public final <R> Observable<R> lift(final Operator<? extends R, ? super T> lift) { //... }
49. RxJava rx.Subject<T, R> • Observable & Observer • Acts as multicaster public abstract class Subject<T, R> extends Observable<R> implements Observer<T>{ }
50. Drag-and-drop interface RxMouseController { Observable<MouseEvent> mouseUps(); Observable<MouseEvent> mouseDowns(); Observable<MouseEvent> mouseMoves(); }
51. Drag-and-drop static Observable<Line> dragsRx(RxMouseController mouse) { return mouse.mouseDowns(). }
52. Drag-and-drop static Observable<Line> dragsRx(RxMouseController mouse) { return mouse.mouseDowns(). }
53. Drag-and-drop static Observable<Line> dragsRx(RxMouseController mouse) { return mouse.mouseDowns().flatMap(start -> { return mouse.mouseMoves(). });}
54. Drag-and-drop static Observable<Line> dragsRx(RxMouseController mouse) { return mouse.mouseDowns().flatMap(start -> { return mouse.mouseMoves(). });}
55. Drag-and-drop static Observable<Line> dragsRx(RxMouseController mouse) { return mouse.mouseDowns().flatMap(start -> { return mouse.mouseMoves() .map(end -> new Line(start.position, end.position)) });}
56. Drag-and-drop static Observable<Line> dragsRx(RxMouseController mouse) { return mouse.mouseDowns().flatMap(start -> { return mouse.mouseMoves() .map(end -> new Line(start.position, end.position)) });}
57. Drag-and-drop static Observable<Line> dragsRx(RxMouseController mouse) { return mouse.mouseDowns().flatMap(start -> { return mouse.mouseMoves() .map(end -> new Line(start.position, end.position)) .takeUntil(mouse.mouseUps()); });}
58. Resolve instrument • Take instrument by symbols • If not found: search futures product ◦ if found: find front futures by trading day Instrument Futures Product Futures Trading day Changes over time
59. Resolve instrument Observable<Instrument> resolveToInstrument(String symbol) { return getInstrumentBySymbol(symbol) .onErrorResumeNext( getFuturesProduct(symbol) .switchMap(product -> getTradingDay() .map(day -> product.getFrontSymbol(day)) .switchMap(front -> getInstrumentBySymbol(front)) ) ); }
60. Schedulers • observables are asynchronous • so they have a notion of time • we can parametrize ◦ when and ◦ where operaion happen
61. Schedulers
62. Schedulers Scheduler AWT_THREAD = Schedulers.from(SwingUtilities::invokeLater); observable.observeOn(AWT_THREAD);
63. Demo
64. Overloading observeQuote("MSFT") .observeOn(AWT_THREAD) .map((quote) -> quote.getBidPrice()) .filter((bid) -> !Double.isNaN(bid)) .map((bid) -> Double.toString(bid)) .subscribe((bid) -> label.setText(bid));
65. Overloading observeQuote("MSFT") .observeOn(AWT_THREAD) .map((quote) -> quote.getBidPrice()) .filter((bid) -> !Double.isNaN(bid)) .map((bid) -> Double.toString(bid)) .subscribe((bid) -> label.setText(bid));
66. MissingBackpressureException
67. Overloading observeQuote("MSFT") .observeOn(AWT_THREAD) .map((quote) -> quote.getBidPrice()) .filter((bid) -> !Double.isNaN(bid)) .map((bid) -> Double.toString(bid)) .subscribe((bid) -> label.setText(bid));
68. Overloading observeQuote("MSFT") .observeOn(AWT_THREAD) .map((quote) -> quote.getBidPrice()) .filter((bid) -> !Double.isNaN(bid)) .map((bid) -> Double.toString(bid)) .subscribe((bid) -> label.setText(bid)); Ignores backpressure
69. Overloading
70. Overloading observeQuote("MSFT") .onBackpressureLatest() .observeOn(AWT_THREAD) .map((quote) -> quote.getBidPrice()) .filter((bid) -> !Double.isNaN(bid)) .map((bid) -> Double.toString(bid)) .subscribe((bid) -> label.setText(bid)); Handles backpressure
71. Summary • Observer pattern has drawbacks • It can be improved • Try RxJava instead
72. Questions?
73. Thank you!