What's all this fuss about RxJava?

A short and brief intro to RxJava

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