Mario Fusco - Reactive programming in Java - Codemotion Milan 2017
Download as pptx, pdf2 likes1,112 views
Reactive programming è un paradigma di programmazione basato sulla processazione asincrona di eventi. La sua cresente importanza è confermata dall'introduzione in Java 9 delle Flow API che definiscono un contratto che tutte le librerie di reacrive programming dovranno implementare. Lo scopo di questo talk è chiarire i principi del reactive programming definite dal reactive manifesto e formalizzate dalle Flow API insieme alle feature più avanzate di processazione, trasformazione e combinazione di eventi offerti da RxJava.
![[Tokyo Scala User Group] Akka Streams & Reactive Streams (0.7)](https://cdn.slidesharecdn.com/ss_thumbnails/2014-akka-streams-tokyo-140914201812-phpapp01-thumbnail.jpg?width=560&fit=bounds)
More Related Content
What's hot (20)
Similar to Mario Fusco - Reactive programming in Java - Codemotion Milan 2017 (20)
More from Codemotion (20)
Recently uploaded (20)
Mario Fusco - Reactive programming in Java - Codemotion Milan 2017
- 1. by Mario Fusco [email protected] @mariofusco Reactive Programming in Java
- 2. Reactive “readily responsive to a stimulus” Merriam-Webster dictionary
- 3. Why reactive? What changed? ➢ Usage patterns: Users expect millisecond response times and 100% uptime A few years ago largest applications had tens of servers and gigabytes of data Seconds of response time and hours of offline maintenance were acceptable Today ➢ Big Data: usually measured in Petabytes and increasing with an extremely high frequency ➢ Heterogeneous environment: applications are deployed on everything from mobile devices to cloud-based clusters running thousands of multi-core processors Today's demands are simply not met by yesterday’s software 640K ought to be enough for anybody
- 4. The Reactive Manifesto The system responds in a timely manner if at all possible. Responsiveness is the cornerstone of usability The system stays responsive in the face of failure The system stays responsive under varying workload. It can react to changes in the input rate by increasing or decreasing the resources allocated to service these inputs The system rely on asynchronous message passing to establish a boundary between components that ensures loose coupling, isolation and location transparency
- 5. Rethinking programming the Reactive way ➢ Reactive programming is a programming paradigm about data- flow ➢ Think in terms of discrete events and streams of them ➢ React to events and define behaviors combining them ➢ The system state changes over time based on the flow of events ➢ Keep your data/events immutable Never block!
- 6. Reactive programming is programming with asynchronous data streams ➢ A stream is a sequence of ongoing events ordered in time ➢ Events are processed asynchronously, by defining a function that will be executed when an event arrives
- 7. See Events Streams Everywhere stock prices weather shop's orders flights/trains arrivals time mouse position
- 9. Streams are not collections Streams are ➢ potentially unbounded in length ➢ focused on transformation of data ➢ time-dependent ➢ ephemeral ➢ traversable only once «You cannot step twice into the same stream. For as you are stepping in, other waters are ever flowing on to you.»
- 10. The Reactive Streams Initiative Reactive Streams is an initiative to provide a standard for asynchronous stream processing with non-blocking back pressure on the JVM Problem Handling streams of (live) data in an asynchronous and possibly non-blocking way Scope Finding a minimal API describing the operations available on Reactive Streams Implementors Akka Streams Reactor RxJava Ratpack Vert.x
- 11. The Java 9 Flow API @FunctionalInterface public interface Publisher<T> { void subscribe(Subscriber<? super T> s); } public interface Subscriber<T> { void onSubscribe(Subscription s); void onNext(T t); void onError(Throwable t); void onComplete(); } public interface Subscription { void request(long n); void cancel(); } public interface Processor<T, R> extends Subscriber<T>, Publisher<R> { }
- 12. Reactive Application Lifecycle Publisher Subscriber subscribe(Subscriber) Main onSubscribe(Subscription) Subscription onNext(data) onNext(data) request(int) onNext(data) onComplete/onError onSubscribe onNext* (onError | onComplete)? backpressure request(int)
- 13. Enough speaking Show me the code!
- 14. RxJava Reactive Extension for async programming➢ A library for composing asynchronous and event-based programs using observable sequences for the Java VM ➢ Supports Java 6 or higher and JVM-based languages such as Groovy, Clojure, JRuby, Kotlin and Scala ➢ Includes a DSL providing extensive operations for streams transformation, filtering and recombination ➢ Implements pure “push” model ➢ Decouple events production from consumption ➢ Allows blocking only for back pressure ➢ First class support for error handling, ➢ scheduling & flow control ➢ Used by Netflix to make the entire service ➢ layer asynchronous http://reactivex.io http://github.com/ReactiveX/RxJava
- 15. Observable The Observable interface defines how to access asynchronous sequences of multiple items single value multiple values synchronous T getData() Iterable<T> getData() asynchronous Future<T> getData() Observable<T> getData() An Observable is the asynchronous/push “dual” to the synchronous/pull Iterable Iterable (pull) Obesrvable (push) retrieve data T next() onNext(T) signal error throws Exception onError(Exception) completion !hasNext() onCompleted()
- 16. Observable as async Stream // Stream<Stock> containing 100 Stocks getDataFromLocalMemory() .skip(10) .filter(s -> s.getValue > 100) .map(s -> s.getName() + “: ” + s.getValue()) .forEach(System.out::println); // Observable<Stock> emitting 100 Stocks getDataFromNetwork() .skip(10) .filter(s -> s.getValue > 100) .map(s -> s.getName() + “: ” + s.getValue()) .forEach(System.out::println);
- 17. Marble diagrams: Representing events' streams ... A stream is a sequence of ongoing events ordered in time. It can emit three different things: 1. a value (of some type) 2. an error 3. "completed" signal
- 18. … and events' transformations
- 19. RxJava operations as marble diagrams
- 20. What do you want? More code! When do you it? Now!
- 21. Observable and Concurrency An Observable is sequential → No concurrent emissions Scheduling and combining Observables enables concurrency while retaining sequential emission
- 22. How is the Observable implemented? ➢ Maybe it executes its logic on subscriber thread? ➢ Maybe it delegates part of the work to other threads? ➢ Does it use NIO? ➢ Maybe it is an actor? ➢ Does it return cached data? Observer does not care! public interface Observer<T> { void onCompleted(); void onError(Throwable var1); void onNext(T var1); }
- 23. Non-Opinionated Concurrency Observable Observer Calling Thread Callback Thread onNext Work synchronously on calling thread Observable Observer Calling Thread Callback Thread onNext Work asynchronously on separate thread Thread pool Observable Observer Calling Thread Callback Threads onNext Work asynchronously on multiple threads Thread pool Could be an actor or an event loop
- 24. Reactive Programming requires a mental shift from sync to async from pull to push from imperative to functional
- 25. Mario Fusco Red Hat – Senior Software Engineer [email protected] twitter: @mariofusco Q A Thanks … Questions?