Exploring RxJava2

Transcript

1. Exploring RxJava 2 Fantasy
2. What is Rx? An API for asynchronous programming with observable streams
3. Reactive vs. Imperative 1.int a = 10;
 2.int b = a + 10;
 3.int c = b + 10;
 4.System.out.print(String.format(“%d,%d,%s", a, b, c));
 5.a = 20;
 6.System.out.print(String.format(“%d,%d,%s", a, b, c)); 10,20,30 20,20,30 Reactive Imperative 1.ObservableData a = new ObservableData();
 2.ObservableData b = new ObservableData();
 3.ObservableData c = new ObservableData();
 4.a.apply(10);
 5.a.onChange(v -> b.apply(v + 10));
 6.b.onChange(v -> c.apply(v + 10));
 7.System.out.printf(String.format(“%d,%d,%s", a, b, c));
 8.a.apply(20);
 9.System.out.printf(String.format(“%d,%d,%s", a, b, c)); 10,20,30 20,30,40
4. Asynchronous vs. Synchronous 1.OkhttpServiceManager ok = OkhttpServiceManager.getInstance();
 2.ok.getToken(code , new OkhttpServiceManager.OnGetAccessTokenListener() 3. @Override
 4. public void onSuccess(String accessToken) {
 5. Log.d(TAG, "onSuccess:" + accessToken);
 6. }
 7. @Override
 8. public void onFailure(String reason) {
 9. Log.d(TAG, "onFailure:" + reason);
 10. } }); Asynchronous Synchronous 1.OkhttpServiceManager ok = OkhttpServiceManager.getInstance();
 2.String accessToken = ok.getToken(code);
5. Observable pattern
6. Stream A Stream represents a sequence of data. Streams are ubiquitous, anything can be a stream: variables, user inputs,, caches, data structures, etc. 1.List<Integer> lists = Arrays.asList(new Integer[]{3, 2, 1, 50, 4});
 2.List<Integer> results = lists.stream() 3. .sorted()
 4. .filter(s -> s % 2 != 0)
 5. .collect(Collectors.toList()); Android need to set minSDKVersion to 24 to use this Java 8 function!
7. Functional programing OOP is abstraction to date. FP is abstraction to behavior. Outer iterator Inner iterator
8. How to use build.gradle //Rxjava2
 compile 'io.reactivex.rxjava2:rxjava:2.0.2'
 compile 'io.reactivex.rxjava2:rxandroid:2.0.1' Using lambda expression android {
 . . .
 defaultConfig { . . .
 jackOptions {
 enabled true
 } 
 compileOptions {
 sourceCompatibility JavaVersion.VERSION_1_8
 targetCompatibility JavaVersion.VERSION_1_8
 }
 } android thread
9. Create Observable Observable.just("Hello world!").subscribe(new Observer<String>() {
 @Override
 public void onSubscribe(Disposable d) {
 }
 @Override
 public void onNext(String value) {
 Log.d(TAG, "value:" + value);
 }
 @Override
 public void onError(Throwable e) {
 }
 @Override
 public void onComplete() { Log.d(TAG, "onComplete");
 }
 }); Use just() to create.
10. Create Observable j Observable.fromArray(new String[]{"apple","beef"}) Observable.range(1,10) Observable.intervalRange(5, 10, 3, 1, TimeUnit.SECONDS) Observable.defer(new Callable<ObservableSource<? extends String>>() Observable.create(new ObservableOnSubscribe<List<User>>() In RxJava an object that implements the Observer interface subscribes to an object of the Observable class. Then that subscriber reacts to whatever item or sequence of items the Observable object emits.
11. Operator Observable Operator Marble diagrams
12. Operator Observable.range(1, 6)
 .filter(new Predicate<Integer>() {
 @Override
 public boolean test(Integer integer) throws Exception {
 return integer % 2 == 0;
 }
 }) Filter Observable.range(1, 6)
 .filter(integer -> integer % 2 == 0) Using lambda expression Functional interface 2,4,6
13. Functional interface Interface name Argument Retrun Predicate<T> T boolean Function<T,R> T R BiFunction<T,T,R> (T,T) R Consumer<T> T void
14. Operator map Observable.range(1, 6).map(Integer -> Integer * 2) take Observable.range(1, 6).take(3) 2,4,6,8,10,12 1,2,3 skip Observable.range(1, 6).skip(2) 3,4,5,6
15. Schedulers Using in network request Observable.defer(() -> githubUserRestService.searchGithubUsers(searchTerm) // Run on a background thread
 .subscribeOn(schedulers.io()) // Be notified on the main thread
 .observeOn(AndroidSchedulers.mainThread())
16. RxJava1 vs. RxJava2 Package name and import name compile ‘io.reactivex:rxjava:1.2.1' import rx.Observable; compile 'io.reactivex.rxjava2:rxjava:2.0.2' import io.reactivex.Observer; Rxjava1 Rxjava2
17. RxJava1 vs. RxJava2 Single Single.just(new Integer[]{10, 22, 3, 4})
 .subscribe(new SingleObserver<Integer[]>() {
 @Override
 public void onSubscribe(Disposable d) {
 }
 @Override
 public void onSuccess(Integer[] value) {
 Log.d(TAG, "value:" + value);
 }
 @Override
 public void onError(Throwable e) {
 }
 });
18. RxJava1 vs. RxJava2 Completable.timer(1000, TimeUnit.MILLISECONDS)
 .subscribe(new CompletableObserver() {
 @Override
 public void onSubscribe(Disposable d) {
 }
 @Override
 public void onComplete() {
 Log.d(TAG, "onComplete:");
 }
 @Override
 public void onError(Throwable e) {
 }
 }); Completable
19. RxJava1 vs. RxJava2 Backpressure In RxJava it is not difficult to get into a situation in which an Observable is emitting items more rapidly than an operator or subscriber can consume them. Flowable
20. RxJava1 vs. RxJava2 Consume every 100 ms Result RxJava2 observable may through OutOfMemoryError Flowable outputs 0,1,2…127 and jumps to 966, 967, 968. RxJava1 observable may through MissingBackpressureException
21. RxJava1 vs. RxJava2 1.CompositeSubscription and Subscription => CompositeDisposable 2. Func1 => Function 3.Func2 => BiFunction 4.onCompleted => onComplete
22. Demo
23. Conclusion • RxJava 2 is this idea that we want to take the things which are fundamentally asynchronous in Android, whether it be the network, Android itself, a database, or even the UI, and write code that reacts to changes in these sources instead of trying to cope with changes and manage state ourselves.
24. Reference • 1.Reactive Official Document • 2.Exploring RxJava 2 for Android -Jake Wharton • 3.RxJava2-Android-Samples • 4.RxJava中backpressure這個概念念的理理解 • 5.Why-should-we-use-rxjava-on-android • 6.RxJava2 vs RxJava1
25. Thank you! Fantasy