what's all this fuss about RxJava

Ayokunle Paul demystifies the concept of reactive programming by diving deep into RxJava and explaining its use cases

Transcript

1. What’s all this fuss about RxJava? Ayokunle Paul
2. What does it mean to be reactive?
3. • Reactivity revolves about the concept connecting different parts of the application to each other. • Such that one component can correctly react to the output of its counterpart if need be. • This way, users can see real time response of their actions. • In a nutshell, an app is said to be reactive if it responds to users action(s) in real time.
6. RxJava
7. • Reactive eXtension is the combination of the best ideas from the Observer pattern, Iterator pattern and functional programming. http://reactivex.io/ • RxJava - ReactiveX for the JVM - A library for composing asynchronous and event-based programs using observable sequences for the JVM https://github.com/ReactiveX/RxJava • Observer Pattern - A software design principle in which an Object, called the subject, maintains a list of dependents, called Observers, and notify them automatically of any state changes, usually by calling one of their methods. https://en.wikipedia.org/wiki/Observer_pattern
8. Breakdown • Observables (or Sources) • Observer • Operators
9. Observable<T>
10. Observable • Set of classes that can continuously emit stream of data. • Data emitted can range from 0 to infinity • They may or may not emit any data • Synchronously or asynchronously • Starts when you subscribe or unsubscribe • Stops either due to an error or completion
11. Observable Hot Cold Observables that start emitting data upon creation. Observables that start emitting data upon subscription.
12. Creating an Observable<T>
13. 1. Observable.just(...); 2. Observable.create(...); 3. Observable.from(...); 4. Observable.defer(...); 5. Observable.range(...); 6. Observable.interval(...); 7. ……...
14. Observer<T>
15. Observer • Set of classes (or method definition) that can asynchronously react to emissions by Observables • They do so by “subscribing” to the observable • Then override the onNext(...), onError(...), onCompleted(...) methods • onNext() is called whenever the Observable emits data • onCompleted() is called whenever the Observable stops emitting data • onError() is called if an error occurs • onCompleted() and onError() are terminal methods • To avoid memory leaks, ensure you unsubscribe after a complete transaction • This is best done in the onStop() lifecycle callback.
16. Subscribing and Unsubscribing Observable<String> observable = Observable.just(“1”, “2”, “3”, “4”); DisposableObserver observer = new DisposableObserver<String>{ @Override public void onNext(String s){ … } @Override public void onComplete(){ … } @Override public void onError(Throwable t){ … } } observable.subscribe(observer); //unsubscribe to avoid possible resource leak @Override public void onStrop(){ observer.dispose(); }
17. Subscribing and Unsubscribing Observable<String> observable = Observable.just(“1”, “2”, “3”, “4”); Disposable disposable = observable.subscribeWith(new DisposableObserver<String>{ @Override public void onNext(String s){ … } @Override public void onComplete(){ … } @Override public void onError(Throwable t){ … } } ); //unsubscribe to avoid possible resource leak @Override public void onStrop(){ disposable.dispose(); }
18. Subscribing and Unsubscribing Observable<String> observable = Observable.just(“1”, “2”, “3”, “4”); Disposable disposable = observable.subscribeWith(new DisposableObserver<String>{ @Override public void onNext(String s){ … } @Override public void onComplete(){ … } @Override public void onError(Throwable t){ … } }); CompositeDisposable compositeDisposable = new CompositeDisposable(); compositeDisposable.add(disposable); //unsubscribe to avoid possible resource leak @Override public void onStrop(){ compositeDisposable.dispose(); }
19. Operators
20. Operators • Set of methods for manipulating observables • Act on an Observable to produce another observable. • Manipulate how data are emitted • Manipulate how Observables are observed (threading) • Combine data streamed in different ways
21. 1. Observable.just(...); 2. Observable.create(...); 3. Observable.from(...); 4. Observable.defer(...); 5. Observable.range(...); 6. Observable.interval(...); 7. ……... Operators for creating observables
22. //The normal Java way String mString = “Hello, Android”; String mStringUpper = mString.toUppercase(); //The RxJava way Observable<String> mString = Observable.just(“Hello, Android”); Observable<String> mStringUpper = mString.map(v -> v.toUppercase()); Manipulating emissions
23. //The RxJava way Observable<Location> location = data.getLocation(); Observable<Location> mLocation = location.subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()); Manipulating threads
24. //Order is important Location mLocation; Observable<Location> location = Observable.fromCallable(() -> { return mLocation.getLocation(); }) .subscribeOn(Schedulers.io()) .map(location -> location.toString()) .observeOn(AndroidSchedulers.mainThread()); Manipulating threads
25. Continue exploring… • Specified types of Observables (Single, Maybe, Completable) • Other operators (flatMap, groupBy, first, debounce, …) • RxAndroid, RxBinding • Online tutorials (Jake Wharton, Annyce Davice, …)
26. Thanks! Contact me: Twitter : @__eipeks__ Email: pauleipeks@gmail.com LinkedIn: Ayokunle Paul Facebook: Ayokunle Paul