The Reactive Revolution

The Reactive Revolution - Introduction to Reactive Programming & Project Reactor

Transcript

1. The Reactive Revolution Shai Gabai https://speakerdeck.com/shagaba/the-reactive-revolution
2. The Reactive Revolution • Reactive System • Reactive Streams • Reactive Programming • Reactive Manifesto • Reactive Spring • RX Java • Project Reactor • Vert.x • Akka • Responsive • Resilient • Elastic • Message Driven • Asynchronous • Back Pressure • Non Blocking • Callback Hell • Scalable
3. • Why going reactive? • What does Reactive mean? • Reactive Streams • Project Reactor • Building Reactive Application • Q&A Agenda
4. Why Going Reactive? • Modern software • Distributed systems • Blocking is evil
5. Once upon a time there was a System Monolithic Application
6. Distributed Systems
7. Distributed Systems
8. Distributed Systems
9. Distributed Systems
10. Distributed Systems
11. Distributed Systems can Fail • Slow services • Unavailable services • Hardware failure
12. Distributed Systems can Fail
13. Distributed Systems can Fail
14. Distributed Systems can Fail
15. Distributed Systems can Fail
16. The Blocking Approach • Sync and Blocking • Async and Blocking
17. Sync - Blocking Main Thread Task Does Nothing
18. Sync - Blocking Main Thread Task A Task B Does Nothing
19. Async and Blocking • Huge numbers of concurrent users • Application performance improvements • Parallelization approach: • Use more threads and hardware resources
20. Async and Blocking Main Thread Task A New Thread Task B New Thread Does Nothing
21. Blocking can be Wasteful • Blocking wastes resources • DB requests • Network call • Threads sits idle and waiting for data • Memory consumption Memory Number of Treads
22. Asynchronous • Java offers two models of asynchronous programming • Callbacks • Callbacks are hard to compose together - known as "Callback Hell" • Futures • Easy to block – get • Complex orchestrating beyond one level of composition • No support for multiple values and advanced error handling
23. Asynchronous – Callback Hell userService.getFavorites(userId, new Callback<List<String>>() { public void onSuccess(List<String> list) { if (list.isEmpty()) { suggestionService.getSuggestions(new Callback<List<Favorite>>() { public void onSuccess(List<Favorite> list) { UiUtils.submitOnUiThread(() -> { list.stream().limit(5).forEach(uiList::show); }); } public void onError(Throwable error) { UiUtils.errorPopup(error); } }); } else { list.stream().limit(5).forEach(favId -> favoriteService.getDetails(favId, new Callback<Favorite>() { public void onSuccess(Favorite details) { UiUtils.submitOnUiThread(() -> uiList.show(details)); } public void onError(Throwable error) { UiUtils.errorPopup(error); } } )); } } public void onError(Throwable error) { UiUtils.errorPopup(error); } });
24. What does Reactive mean? • Reactive manifesto • Reactive system • Reactive programming • Event loop
25. The Reactive Manifesto • Reactive System definition • https://www.reactivemanifesto.org
26. The Reactive Manifesto • Responsive • a reactive system needs to handle requests in a reasonable time. • Resilient • a reactive system must stay responsive in the face of failures. • it must be designed for failures and deal with them appropriately. • Elastic • a reactive system must stay responsive under various loads. • it must scale up/down and be able to handle the load with minimal resources. • Message Driven • components from a reactive system interacts using asynchronous message passing.
27. Reactive System
28. Reactive Programming
29. Reactive Programming • Event driven • Data flow Producer Consumer Observer Pattern
30. Reactive Programming • Back pressure Producer Consumer Observer Pattern
31. Reactive Programming • Back pressure Producer Consumer Observer Pattern request(n)
32. Reactive Programming • Event driven • Failures as messages • Backpressure • Non blocking • Asynchronous
33. Event Loop Single Thread
34. Event Loop Single Thread Request
35. Event Loop Single Thread Event Event Event Event Queue Request
36. Event Loop Single Thread Event Event Event Event Queue Request Operation
37. Event Loop Single Thread Event Event Event Event Queue Event Handlers Handler Handler Handler Request Operation
38. Event Loop Single Thread Event Event Event Request Event Queue Event Handlers Handler Handler Handler Operation Blocking Operation
39. Event Loop Single Thread Event Event Event Event Queue Event Handlers Operation Completed Handler Handler Handler Request Operation Blocking Operation
40. Asynchronous and Non-blocking Task A Task B Task C Task A Task B Task C
41. Reactive Programming • Declarative • Readable • Maintainable • Testable userService.getFavorites(userId) .flatMap(favoriteService::getDetails) .switchIfEmpty(suggestionService.getSuggestions()) .take(5) .publishOn(UiUtils.uiThreadScheduler()) .subscribe(uiList::show, UiUtils::errorPopup);
42. Zootopia – Sloth scene https://youtu.be/HHKwnUa3txo?t=12s When a reactive service is needed
43. Reactive Streams • Contract • Components • Data flow
44. Reactive Streams • Contract between implementors • Non blocking • Asynchronous • Backpressure • Data flow • Specification - API • TCK – Technology Compatibility Kit • http://www.reactive-streams.org/
45. Reactive Streams • API Components (interfaces): • Publisher • Subscriber • Subscription • Processor • https://github.com/reactive-streams/reactive-streams-jvm
46. Reactive Streams • Publisher public interface Publisher<T> { public void subscribe(Subscriber<? super T> s); }
47. Reactive Streams • Subscriber public interface Subscriber<T> { public void onSubscribe(Subscription s); public void onNext(T t); public void onError(Throwable t); public void onComplete(); }
48. Reactive Streams • Subscription public interface Subscription { public void request(long n); public void cancel(); }
49. Reactive Streams • Processor public interface Processor<T, R> extends Subscriber<T>, Publisher<R> { }
50. Reactive Streams – Data Flow Publisher • subscribe Subscriber • onSubscribe • onNext • onError • onComplete Subscription • request(n) • cancel
51. Publisher Subscriber subscribe Reactive Streams – Data Flow
52. Publisher Subscriber onSubscribe Subscription Reactive Streams – Data Flow
53. Publisher Subscriber Subscription request(n) Reactive Streams – Data Flow
54. Publisher Subscriber onNext Subscription Reactive Streams – Data Flow
55. • Subscriber request canceled • Publisher completed the process • Error occurred Reactive Streams – Data Flow
56. Data Flow – Subscriber request canceled Publisher Subscriber Subscription request(n) • Request more data
57. Data Flow – Subscriber request canceled Publisher Subscriber onNext Subscription • Receive next data
58. Data Flow – Subscriber request canceled Publisher Subscriber Subscription cancel • Cancel
59. Data Flow – Subscriber request canceled Publisher Subscriber • Subscription is canceled
60. Data Flow – Publisher completed the process Publisher Subscriber onComplete Subscription
61. Data Flow – Publisher completed the process Publisher Subscriber • Subscription is canceled
62. Data Flow – Error occurred Publisher Subscriber onError Subscription
63. Data Flow – Error occurred Publisher Subscriber • Subscription is canceled
64. Publisher Operator Operator Operator Subscriber Data Flow – Chain Declaration
65. Publisher Operator Operator Operator Subscriber subscribe Data Flow – Chain Declaration Nothing Happens Until You subscribe()
66. Publisher Subscriber Data Flow – Chain Declaration onNext onComplete onError Operator Sub Pub Operator Sub Pub Operator Sub Pub
67. Reactive Streams – Java 9 Flow • Flow.Publisher<T> • subscribe • Flow.Subscriber<T> • onSubscribe • onNext • onError • onComplete • Flow.Sucscription • request n • cancel • Flow.Processor<T,R> extends Flow.Subscriber<T>, Flow.Publisher<R>
68. Reactive Streams • http://ReactiveX.io/ • RxJava • RxJS • Rx.NET • RxColjure • RxSwift • Others
69. Reactive Streams – Java Implementations • RxJava • David Karnok – a key committer • Reactor • David Karnok – a committer • Akka Streams • Ratpack • Vert.x
70. Reactive Streams – Java Implementations
71. Project Reactor • Contract • Components • Data flow • Schedulers and Threading
72. Project Reactor • The default reactive programming library of Spring 5 • Based on java 8 (CompletableFuture, Streams, Duration) • Two publishers: • Flux<T> • Mono<T> • Reactive Streams all the way
73. Project Reactor – Flux • Asynchronous Sequence of 0-N Items • Collection or infinite items • A Flux<T> is a standard Publisher<T> • Calls to a downstream object’s onNext, onComplete or onError
74. Project Reactor – Mono • Asynchronous 0-1 Result • Void or Single Object • A Mono<T> is a specialized Publisher<T> • Terminates with an onComplete or onError
75. Publisher Flux/Mono Operator Operator Operator Subscriber Project Reactor – Data Flow
76. Flux.range map distinct filter Subscriber Project Reactor – Data Flow
77. Project Reactor – range
78. Project Reactor – map
79. Project Reactor – filter
80. Project Reactor – distinct
81. Flux.range (2, 3) map (i -> i * 3) distinct() filter (i -> i % 2 == 0) Subscriber Project Reactor – Data Flow
82. Flux.range (2, 3) map (i -> i * 3) distinct() filter (i -> i % 2 == 0) Subscriber Project Reactor – Data Flow 2
83. Flux.range (2, 3) map (i -> i * 3) distinct() filter (i -> i % 2 == 0) Subscriber Project Reactor – Data Flow 3 6
84. Flux.range (2, 3) map (i -> i * 3) distinct() filter (i -> i % 2 == 0) Subscriber Project Reactor – Data Flow 4 9 6
85. Flux.range (2, 3) map (i -> i * 3) distinct() filter (i -> i % 2 == 0) Subscriber Project Reactor – Data Flow 12 6 onComplete
86. Flux.range (2, 3) map (i -> i * 3) distinct() filter (i -> i % 2 == 0) Subscriber Project Reactor – Data Flow 12 onComplete
87. Flux.range (2, 3) map (i -> i * 3) distinct() filter (i -> i % 2 == 0) Subscriber Project Reactor – Data Flow onComplete 12
88. Flux.range (2, 3) map (i -> i * 3) distinct() filter (i -> i % 2 == 0) Subscriber Project Reactor – Data Flow onComplete
89. Flux.range (2, 3) map (i -> i * 3) distinct() filter (i -> i % 2 == 0) Subscriber Project Reactor – Data Flow
90. Project Reactor – Data Flow Flux.range(2, 3) .map(i -> i * 3) .filter(i -> i % 2 == 0) .distinct() .subscribe() 2, 3, 4 | 6, 9, 12 | 6, 12 | 6, 12 |
91. Project Reactor – flatMap
92. Project Reactor – flatMap Flux.range(2, 3) .flatMap(i -> Flux.range(i*10, 2)) .subscribe() 2, 3, 4 | 20, 21 | 30, 31 | 40, 41 | 20, 21, 30, 31, 40, 41 |
93. Project Reactor – concat
94. Project Reactor – concat Flux f1 = Flux.range(1, 3) Flux f2 = Flux.range(4, 3) Flux.concat(f1, f2) .subscribe() 1, 2, 3 | 4, 5, 6 | 1, 2, 3, 4, 5, 6 |
95. Project Reactor – merge
96. Project Reactor – merge Flux f1 = Flux.range(1, 3) Flux f2 = Flux.range(4, 3) Flux.merge(f1, f2) .subscribe() 1, 2, 3 | 4, 5, 6 | 1, 4, 5, 2, 3, 6 |
97. Project Reactor – zip
98. Project Reactor – zip Flux f1 = Flux.range(1, 3) Flux f2 = Flux.range(4, 3) Flux.zip(f1, f2) .subscribe() 1, 2, 3 | 4, 5, 6 | [1,4],[2,5],[3,6] |
99. • Reactor is Concurrency Agnostic • it does not enforce a concurrency model • Scheduler – the execution model and where the execution happens • immediate – current thread • single – reuses the same thread for all callers • newSingle – a per-call dedicated thread • elastic – elastic thread pool • creates new worker pools as needed • reuse idle ones • worker pools that stay idle for long time are disposed • parallel – fixed thread pool • creates as many workers as you have CPU cores Schedulers and Threading
100. • Reactor offers two means of switching the execution context: subscribeOn and publishOn operators • subscribeOn • applies to the subscription process, when that backward chain is constructed. • it always affects the context of the source emission. • publishOn • applies in the same way as any other operator, in the middle of the subscriber chain. • it affects where the subsequent operators will execute Schedulers and Threading
101. Schedulers and Threading – Data Flow Publisher Flux/Mono Operator Subscriber Operator Operator subscribeOn publishOn
102. Schedulers and Threading – Data Flow Publisher Flux/Mono Operator Subscriber Operator Operator subscribeOn publishOn
103. Schedulers and Threading – Data Flow Publisher Flux/Mono Operator Subscriber Operator Operator subscribeOn publishOn
104. Schedulers and Threading – Data Flow Publisher Flux/Mono Operator Subscriber Operator Operator subscribeOn publishOn
105. Schedulers and Threading – Data Flow Publisher Flux/Mono Operator Subscriber Operator Operator subscribeOn publishOn
106. Building Reactive Application • Reactive all the way • WebFlux • Reactive Messages • Reactive Repository
107. The Reactive Rush • Reactive all the way • Web layer • Server layers • Database • MongoDB • Cassandra • Redis • Couchbase
108. Blocking Repository interface UserRepository { User findOne(String id); List<User> findAll(); void save(User user); }
109. Blocking Repository List<User> findAll(); • Method returns when whole list is received void save(User user); • Throws exception if an error happens
110. Reactive Repository interface ReactiveUserRepository { Mono<User> findOne(String id); Flux<User> findAll(); Mono<Void> save(Mono<User> user); }
111. Mono<User> findOne(String id); • Mono<User> means error or success "onComplete" event. • One element received Flux<User> findAll(); • Method returns immediately • Elements are received as soon as they are available, ending with a success "onComplete" event. Reactive Repository
112. Mono<Void> save(Mono<User> user); • Mono<Void> means error or success, • no data will be received Reactive Repository
113. Reactor Kafka • Publish and Consume messages • Backpressure-ready • https://github.com/reactor/reactor-kafka
114. Reactor RabbitMQ • Publish and Consume messages • Backpressure-ready • https://github.com/reactor/reactor-rabbitmq
115. Summary • Modern software • Blocking is evil • What does Reactive mean • Reactive Manifesto • Reactive Streams • Project Reactor • Building Reactive Application • Reactive all the way
116. Q & A
117. https://www.reactivemanifesto.org/ http://www.reactive-streams.org/ https://github.com/reactive-streams/reactive-streams-jvm/ http://reactivex.io/ https://projectreactor.io/ https://projectreactor.io/docs/core/release/api/ https://projectreactor.io/docs/core/release/reference/ https://tech.io/playgrounds/929/reactive-programming-with-reactor-3/Intro https://github.com/reactor/lite-rx-api-hands-on Links
118. Zootopia – Sloth scene car chase https://youtu.be/dM-li2Cn5Pw
119. Thanks Hope you’re inspired Shai Gabai