RxJava 2 - Should I use it now? Pros and cons. 10.05.2017 presentation

1. RxJava2
Should I use it?

2. RxJava2
1. What’s new?
2. Performance
3. Libraries compatibility
4. RxJava1 compatibility
5. Summary

3. What’s new?
● Reactive Streams compatibility
● Observable types
● Null handling
● Backpressure handling
● Testing

4. Reactive Streams
“Reactive Streams is an initiative to provide a standard for asynchronous
stream processing with non-blocking back pressure. This encompasses efforts
aimed at runtime environments (JVM and JavaScript) as well as network
protocols.”

5. Reactive Streams
public interface Publisher<T> {
public void subscribe(Subscriber<? super T> s);
}
public interface Subscriber< T> {
public void onSubscribe (Subscription s) ;
public void onNext(T t);
public void onError(Throwable t) ;
public void onComplete();
}

6. Reactive Streams
public interface Subscription {
public void request(long n);
public void cancel();
}
public interface Processor<T, R> extends Subscriber<T>, Publisher<R> {
}

7. Observable types
Type Description
Flowable<T> Emits 0 or n items and terminates with complete or an
error. Supports backpressure, which allows to control
how fast a source emits items.
Observable<T> Emits 0 or n items and terminates with complete or an
error.
Single<T> Emits either a single item or an error. The reactive
version of a method call. You subscribe to a Single and
you get either a return value or an error.
Maybe<T> Succeeds with an item, or no item, or errors. The
reactive version of an Optional.
Completable Either completes or returns an error. It never return
items. The reactive version of a Runnable.

8. Null handling
Observable.just(null);
Single.just(null);
Observable.fromCallable(() -> null)
.subscribe(System. out::println, Throwable::printStackTrace) ;
Observable.just(1).map(v -> null)
.subscribe(System. out::println, Throwable::printStackTrace) ;

9. Null handling
Solution:
enum Irrelevant { INSTANCE }
Single.just(1).map(v -> Irrelevant. INSTANCE);

10. Backpressure handling
private Flowable<Integer> createFlowable (int items,
BackpressureStrategy backpressureStrategy) {
return Flowable.create(subscriber -> {
for (int i = 0; i < items; i++) {
if (subscriber.isCancelled()) {
return;
}
subscriber.onNext(i) ;
}
subscriber.onComplete() ;
}, backpressureStrategy) ;
}

11. Backpressure handling
● BackpressureStrategy.BUFFER
● BackpressureStrategy.DROP
● BackpressureStrategy.LATEST
● BackpressureStrategy.ERROR
● BackpressureStrategy.MISSING

12. Testing
@Test
public void testUsingTestObserver () {
//given
TestObserver<String> observer = new TestObserver<>() ;
Observable<String> observable = Observable. fromIterable(WORDS)
.zipWith(Observable. range(1, Integer.MAX_VALUE),
(string, index) -> String. format("%2d. %s", index, string));
//when
observable.subscribe(observer) ;
//then
observer.assertComplete() ;
observer.assertNoErrors() ;
observer.assertValueCount( 9);
assertThat(observer.values() , hasItem(" 4. fox"));
}

13. Testing
//given
TestObserver<String> observer = new TestObserver<>() ;
Observable<String> observable = Observable. fromIterable(WORDS)
.zipWith(Observable. range(1, Integer.MAX_VALUE),
(string, index) -> String. format("%2d. %s", index, string))
.subscribeOn(Schedulers. computation());
//when
observable.subscribe(observer) ;
//then
observer.assertComplete() ;
observer.assertNoErrors() ;
observer.assertValueCount( 4);
assertThat(observer.values() , hasItem(" 4. fox"));

14. Testing
public class ImmediateSchedulerRule implements TestRule {
@Override
public Statement apply(final Statement base , Description description) {
return new Statement() {
@Override
public void evaluate() throws Throwable {
RxJavaPlugins. setIoSchedulerHandler(build(Schedulers. trampoline()));
RxJavaPlugins. setComputationSchedulerHandler(build(Schedulers. trampoline()));
RxJavaPlugins. setNewThreadSchedulerHandler(build(Schedulers. trampoline()));
try {
base.evaluate() ;
} finally {
RxJavaPlugins. reset();
}
}
};

15. Testing
@Rule
public final ImmediateSchedulerRule testSchedulerRule
= new ImmediateSchedulerRule() ;

16. Testing
@Test
public void testUsingTestObserver () {
//given
TestObserver<String> observer ;
Observable<String> observable = Observable. fromIterable(WORDS)
.zipWith(Observable. range(1, Integer.MAX_VALUE),
(string, index) -> String. format("%2d. %s", index, string))
.subscribeOn(Schedulers. computation());
//when
observer = observable.test() ;
//then
observer.assertComplete() ;
observer.assertNoErrors() ;
observer.assertValueCount( 4);
assertThat(observer.values() , hasItem(" 4. fox"));
}

17. Performance

18. Libraries compatibility
● Retrofit READY
● Realm NOT
● Requery READY
● SugarOrm NOT
● Ormlite NOT
● GreenDao NOT
● Firebase NOT (wrapper libraries)
● SqlBrite NOT

19. RxJava 1 compatibility
github.com/akarnokd/RxJava2Interop

20. RxJava 1 compatibility
github.com/akarnokd/RxJava2Interop

21. Should I switch to RxJava2?