Recommended
Recommended
More Related Content
Similar to Embracing Reactive Streams with Java 9 and Spring 5
Similar to Embracing Reactive Streams with Java 9 and Spring 5 (20)
More from Wilder Rodrigues
Recently uploaded
Recently uploaded (20)
Embracing Reactive Streams with Java 9 and Spring 5
- 1. Embracing Reactive Streams Java 9 & Spring 5 1
- 2. One doesn’t need to be a subject matter expert in order to share knowledge. Whilst the one sharing must be open to criticism, the one listening has to fact check, give feedback and spread what has been learned. The sharing process has to be organic. 2
- 3. Wilder Rodrigues - X-Men; A.I.; and programming geek; - 21 years hitting keyboards; - Father of 3; - Attended Computer Science for 3 years. @wilderrodrigues @ekholabs 3
- 4. What is it about? - The foundations - A glance at FP - Reactive Programming - Reactive Streams - Java 9 & Spring 5 4
- 6. A bit of history 1930s - 1960s ƛ-Calculus Kleene-Rosser Paradox Simply Typed ƛ No longer a formalism 6
- 7. Anonymously square_sum(x, y) = x2 + y2 (x, y) -> x2 + y2 id(x) = x x -> x (x, y) -> x2 + y2 x -> (y -> x2 + y2) Single input The stored-program computer Combinatory Logic Currying Curry’s Paradox Kleene-Rosser Paradox ComputabilityThesis 7
- 8. A glance at FP the old new thing 1950s: LISP 1960: APL 1970s: ML, Scheme and FP 1987: Haskell 1990s: J and K 2000s: Q 8
- 9. Concepts Higher-order functions First-class functions Pure functions Recursion Strict vs non-strict evaluation Type systems Referential Transparency 9
- 10. Reactive Programming Propagation of changes Dependency graph Propagation algorithms Back-pressure Higher-order RP Lazy evaluation 10
- 11. Propagation of Changes By assigning the result of an expression: a = b + c; The variable ‘a’ only changes once the expression is evaluated. The difference with RP is that ‘a’ will be updated at any time that ‘b’ or ‘c’ changes. 11
- 12. Essence of Implementations Dependency Graph: Nodes -> computations; edges -> dependency relationships. Propagation algorithms: Push, pull, or hybrid. 12
- 13. Essence of Implementations Higher-order RP Data flows -> Data flows Turing completeness Lazy evaluation length([2*2, 3*3, 4/0]) 13
- 14. Reactive Streams or flow-controlled components 14
- 15. Reactive Manifesto Responsive Responsiveness is the cornerstone of usability and utility. Resilient It’s achieved by replication, containment, isolation and delegation. Elastic React to changes in the input rate. Message-Driven Ensures loose coupling, isolation and location transparency. 15
- 16. Tackle the issues Fully non-blocking and asynchronous behaviour by enabling the parallel use of computer resources. 16
- 17. Reactive Generations 0th gen.: consists of j.u.Observable and its callback cousins addXXXListener() -> JDK 1.0 1st gen.: issues addressed by Meijer & MS and first libs born -> Rx.NET, Reactive4Java and RxJava. 2nd gen.: issues on synchronous cancellation and back-pressure address by the RxJava team. 17
- 18. Reactive Generations 3rd gen.: fix back-pressure properly with Reactive Stream spec -> 4 interfaces, 30 rules and 7 methods. Behold the trinity: RxJava 2.x, Project Reactor and Akka-Streams. 4th gen.: fluent libraries on top of Reactive Streams spec now called operator-fusion. 5th gen.: extensions to support reactive IO operations in the form of bi-directional channels. 18
- 19. 0th generation - DDP Customer API Observer subscribes to a Subject for a given data type. Transport Stream processing Parse header. Feed publisher. Notify subscribers - if any. 19
- 20. JDK 9 is Reactive JDK 8 was as well. :P 20
- 21. Interfaces and static methods for establishing flow- controlled components. Contains seven “one-way” message style defined methods. Non-blocking back pressure with a pull strategy, where the consumer requests a number of messages to the producer. Collaboration between people from Kaazing, Netflix, Pivotal, Red Hat, Twitter, Typesafe, and others. 21
- 22. Flow controlled components Flow defaultBufferSize() Flow.Processor extends Publisher and Subscriber Flow.Publisher subscribe(Flow.Subscriber<? super T> subscriber) 22
- 23. Flow controlled components Flow.Subscriber onSubscribe(Flow.Subscription subscription) onNext(T item) onError(Throwable throwable) onComplete() Flow.Subscription request(long n) cancel() 23
- 24. Demo part I 24
- 25. Spring 5 Web Reactive Framework 25
- 26. The 4th Generation Extends Reactive Streams spec with Mono and Flux API types. Reactive serialisation and deserialisation 4th, not 3rd! 26
- 27. Generators, Operators and Subscribers A Flux is a publisher of a sequence of events: Flux<String> flux = Flux.just("a", "b", “c”); Mono<String> mono = Mono.just(“a”); Logging to standard out by calling the .log() operator: Flux<String> upper = flux.log().map(String::toUpperCase); 27
- 28. Generators, Operators and Subscribers Calling .subscribe() will initiate the data flow: upper.log() .map(String::toUpperCase) .subscribe(); Or with a Consumer or a vanila Runnable: .subscribe(System.out::println); 28
- 29. Threads, Schedulers and Background Processing Methods to control the thread boundaries: .subscribeOn(Schedulers.parallel()) Switch processing to separate threads (splitting publisher items to another publisher): Flux.just("a", "b", "c") .log() .flatMap(value -> Mono.just(value.toUpperCase()) .subscribeOn(Schedulers.parallel()), 2) .subscribe(value -> { log.info("Consumed: " + value); }) 29
- 30. Threads, Schedulers and Background Processing Split production and consumption of the data with .publishOn(): Flux.just("a", "b", "c") .log() .map(String::toUpperCase) .subscribeOn(Schedulers.parallel("sub")) .publishOn(Schedulers.parallel("pub"), 2) .subscribe(value -> { log.info("Consumed: " + value); }); 30
- 31. Reactive Web Reactive web framework: @[Rest]Controller programming model, but on a reactive, non- blocking engine. Reactive WebClient with full back-pressure support. 31
- 32. Demo part II 32
- 34. 34