Intro to Functional Programming with RxJava
Download as PPTX, PDF28 likes21,828 views
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
- 2. + Tonight’s Agenda ■What is Reactive ■Learn By Example ■Walkthrough sample app
- 4. + Reactive Programming ■“Reactive Programming is programming with asynchronous data streams.” (Andre Staltz) ■Data Stream: a sequence of values
- 5. + What does this mean? ■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 programming to the next level ■Applying functions to the data stream ■Ex. Map, Filter, Zip, Take
- 8. + ReactiveX ■Collection of helpful functions 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 of RxJava ■ 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 ■Allows for 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 To Observable
- 12. + Before Observables ■No easy way 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 ■Observable is 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 ■ Before Reactive 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 ■ The flow 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… ■ The Subscribe 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. + The Observer
- 19. + Observer Interface ■ OnNext ■ onError ■ onCompleted
- 20. + onNext ■ Observable calls this 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 calls this 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 calls this 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 that make threading a breeze ■Operators that let you transform, combine, manipulate, and work with the sequence of items emitted by Observables
- 24. + Threading Shouldn’t be Hard
- 25. + Schedulers ■ Schedulers are used 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());
- 27. + Let’s see some example
- 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 to sync Lifesaver during testing synchronously test asynchronous data streams
- 33. + Need a List? ■Be careful with long/infinite streams
- 36. + Map
- 37. + Map
- 38. + Transform One Observable into 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 map flatMap When you transform to a value When you transform to an observable
- 41. + Filter
- 42. + Filter
- 44. + Debounce/Throttle ▪ No more sending multiple requests when a user clicks too many times.
- 45. + Error Recovery
- 46. + Recovering from Errors ■ Return a different value in an error case
- 48. + How we use Rx ■ 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 ■Cold vs Hot Observables ■Subjects ■Creating Custom Operators
- 50. + Sources/Addl Reading ■Offical Wiki https://github.com/ReactiveX/RxJava/wiki ■Mastering Observables http://docs.couchbase.com/developer/java- 2.0/observables.html ■Intro To Functional Reactive Programming https://gist.github.com/staltz/868e7e9bc2a7b8c1f754
- 51. + Questions?