Downloaded 159 times
Uploaded byMike Nakhimovich
Intro to Functional Programming with RxJava
The document provides an overview of reactive programming using RxJava, emphasizing its asynchronous data streaming capabilities. It explains key concepts such as observables, observers, and the observer pattern, highlighting how this approach improves concurrency and streamlines asynchronous operations. Additionally, it covers practical aspects of using RxJava, including transformation, filtering, error recovery, and threading management through schedulers.
Intro to Functional Programming with RxJava
- 1.
- 2. + Tonight’s Agenda ■What isReactive ■Learn By Example ■Walkthrough sample app
- 3.
- 4. + Reactive Programming ■“Reactive Programmingis programming with asynchronous data streams.” (Andre Staltz) ■Data Stream: a sequence of values
- 5. + What does thismean? ■Programming Model based on the principle of push rather than pull ■Values are emitted when ready, not when asked for in a non- blocking manner ■Allows for actions to be performed in parallel, rather than in serial ■ie: shopping in person vs online
- 6. + Functional Reactive Programming ■Takes reactive programmingto the next level ■Applying functions to the data stream ■Ex. Map, Filter, Zip, Take
- 7.
- 8. + ReactiveX ■Collection of helpfulfunctions that let you do reactive programming ■ReactiveX exists in more than 10 languages (JavaScript, .Net, Objective-C, etc.) ■RxJava is the Java implementation of ReactiveX ■Ported by Netflix team
- 9. + Building Blocks ofRxJava ■ Observable: source of data stream (sender) ■ Observer: listens for emitted values (receiver) ■ The Observer subscribes (listens) to the Observable ■ Observers react to whatever item or sequence of items the Observable emits ■ Many observers can subscribe to the same observable
- 10. + Observable Observer Pattern ■Allowsfor Concurrent Operations: the observer does not need to block while waiting for the observable to emit values ■Observer waits to receive values when the observable is ready to emit them ■Based on push rather than pull
- 11. + From Iterable ToObservable
- 12. + Before Observables ■No easyway to perform asynchronous operations if you needed multiple items ■Observables fill the gap as the ideal way to access asynchronous sequences of multiple items
- 13. + Iterable vs. Observable Interface ■Observableis the asynchronous/push dual to the synchronous pull iterable
- 14. + Observables are… ■ Composable:Easily chained together or combined ■ Flexible: Can be used to emit: ■ A scalar value (network result) ■ Sequence (items in a list) ■ Infinite streams (weather sensor) ■ Free from callback hell: Easy to transform one asynchronous stream into another
- 15. + Iterable Architecture ■ BeforeReactive 1. Call a method 2. Wait for result 3. Store the return value from that method in a variable 4. Use that variable and its new value to do something useful
- 16. + Observable Architecture ■ Theflow goes like this: 1. Define an Observer that specifies what to do with each emitted value 2. Call a method that returns an Observable 3. Subscribe the Observer to the Observable. This tells the Observable that it has a subscriber waiting to receive values when they’re available.
- 17. + In RxJava… ■ TheSubscribe method connects an Observer to an Observable ■ Once you Subscribe, no need to block the thread ■ Values will come to your Observer when they are ready
- 18.
- 19. + Observer Interface ■ OnNext ■onError ■ onCompleted
- 20. + onNext ■ Observable callsthis method whenever the Observable emits an item. ■ This method can be called any number of times (zero to many) ■ Always followed by onError or onComplete (but not both)
- 21. + onError ■ Observable callsthis method to indicate that it has failed to generate the expected data or has encountered some other error ■ This stops the Observable and it won’t make further calls. ■ Takes as its parameter an indication of what caused the error
- 22. + onComplete ■ Observable callsthis method after it has called onNext for the final time and it has not encountered any errors. ■ A call to onComplete ends the subscription.
- 23. + Why RxJava? ■Schedulers thatmake threading a breeze ■Operators that let you transform, combine, manipulate, and work with the sequence of items emitted by Observables
- 24.
- 25. + Schedulers ■ Schedulers areused to manage and control concurrency ■ observeOn: thread observable is executed on ■ subscribeOn: thread subscribe is executed on api.users() .observeOn(AndroidSchedulers.mainThr ead()) .subscribeOn(Schedulers.io());
- 26.
- 27. + Let’s see someexample
- 28.
- 29.
- 30. + doOn Operators ■ Note:if only passing on onNext action (without a doOnError) to the subscribe method OnErrorNotImplementedException will be thrown if an error occurs
- 31. + Explicitly Creating Observables ■You can make an endless Observable by never calling subscriber.onCompleted()
- 32. + From async tosync Lifesaver during testing synchronously test asynchronous data streams
- 33. + Need a List? ■Becareful with long/infinite streams
- 34.
- 35.
- 36.
- 37.
- 38. + Transform One Observableinto Another 1. Create on observable from a click event 2. Use flatMap to change that Observable to another Observable 3. Subscribe to the result of the second Observable (will emit 3 users)
- 39. + map vs. flatMap mapflatMap When you transform to a value When you transform to an observable
- 40.
- 41.
- 42.
- 43.
- 44. + Debounce/Throttle ▪ No moresending multiple requests when a user clicks too many times.
- 45.
- 46. + Recovering from Errors ■Return a different value in an error case
- 47.
- 48. + How we useRx ■ Treat all data as immutable singleton Observable Stores that know how to self-update and are backed on disk ■ Since we treat data as a stream, we can return 1 or more results for each subscription (if a cached value is available) ■ We can cross subscribe one Store to another ■ RxJava lets us transform and combine data on any thread and subscribe to updates for related values/collections
- 49. + Next to Explore ■Coldvs Hot Observables ■Subjects ■Creating Custom Operators
- 50. + Sources/Addl Reading ■Offical Wiki https://github.com/ReactiveX/RxJava/wiki ■MasteringObservables http://docs.couchbase.com/developer/java- 2.0/observables.html ■Intro To Functional Reactive Programming https://gist.github.com/staltz/868e7e9bc2a7b8c1f754
- 51.