Upload
jobaer-chowdhury
View
504
Download
3
Embed Size (px)
Citation preview
Reactive Programming with RxJava
Jobaer ChowdhuryTechnical Project Manager, Cefalo
Presented @ JUGBD 6.0 (25/02/2017)
Writing concurrent code in Java is hard.
Writing correct concurrent code is even harder
Unless you’ve read this from cover to cover, twice :-)
What is RxJava?
What is RxJava?- A library for composing asynchronous and event based programs
We can write concurrent code using RxJava library without worrying about low level threads, locks and synchronization.
Brief history or RxReactive Extensions: first introduced by Microsoft
RxJava: the jvm implementation was first developed by Netflix
Current version is 2.x
(I’ll talk about version 1.x here)
RxJava: Most starred java repository on Github
Many implementationsRx.NET
RxJava
RxJS
RxScala
RxClojure
…. And some others
So let’s get started ...
Observable<T> is the heart of RxJava
Observable<T>… a flowing sequence of values
… a stream of events
An observer can subscribe to the Observable
The Observable may call onNext(), onError() or onCompleted() on the observer
Let’s compare Observables to Iterables
We all know Iterables, right?Iterable<T> { Iterator<T> iterator();}
Iterator<T> {Boolean hasNext();T next();
}
Observable duality with Iterable Iterable<T>, Iterator<T>
● Get an iterator● hasNext(), next()● Pull based● Sync
Observable<T>, Observer<T>
● Subscribe an observer● onNext(), onError(), onCompleted()● Push based ● Async
Observable<T> examples● Observable<Tweet> ● Observable<Temperature> ● Observable<Person>● Observable<HttpResponse>● Observable<MouseEvent>
….. and so on
Hello Observable!Let’s create an Observable<String> that will emit “Hello, world!”
Observable<String> hello = Observable.create(obs -> {obs.onNext(“Hello, world!”);
});
And we can subscribe to it ...Observable<String> hello = Observable.create(obs -> {
obs.onNext(“Hello, world!”);});
hello.subscribe(s -> {System.out.println(s);
});
We can simplify the creation here Observable<String> hello = Observable.just(“Hello, World!”);
We can also handle errors and completed eventObservable<String> hello = Observable.just(“Hello, World!”);hello.subscribe( val -> {System.out.println(val);}, error -> {System.out.println(“Error occurred”);}, () -> { System.out.println(“Completed”)};})
We’ve seen how we can create Observables, and how to consume them.
Let’s see how we can modify/operate on Observables
Observable.filter exampleObservable<Integer> numbers = Observable.just(1, 2, 3, 4, 5, 6);Observable<Integer> result = numbers.filter(num -> num % 2 == 0);
// the result will contain 2, 4, 6 inside the Observables
Observable.map example// We have a function that gives us an Observable of intsObservable<Integer> ids = searchForArticles(“dhaka”);
// another function that takes an int, and returns an articleArticle loadArticle(Integer articleId) {...}
Observable<Article> result = ids.map(id -> loadArticle(id));
Observable.flatMap example// We have a function that gives us an Observable of intsObservable<Integer> ids = searchForArticles(“dhaka”);
// and a function returns an article wrapped inside ObservableObservable<Article> loadArticle(Integer articleId) {...}
Observable<Article> result = ids.flatMap(id -> loadArticle(id));
Map vs. flatMap
Map vs. flatMap exampleObservable<Integer> ids = searchForArticles(“dhaka”);Observable<Article> loadArticle(Integer articleId) {...}
Observable<Observable<Article>> res = ids.map(this::loadArticle);Observable<Article> result = ids.flatMap(this::loadArticle);
There are many more operators ...
Let’s use Observables to solve a real world problem
A real world example Let’s assume we are working for a news service. And we have the following requirements.
● Do a search for a term on the search server. The search server will return some ids
● For each id load the news article from db.● For each id find out how many likes the article has on social network● Merge the result from above two steps and send it to view layer
Let’s assume we have the following (sync) APIList<Integer> searchForArticles(String query)PersistentArticle loadArticle(Integer articleId)Integer fetchLikeCount(Integer articleId)
…. and we can create article by using the db object and like count Article result = new Article(PersistentArticle, Integer)
One way of solving itList<Integer> searchResult = searchForArticles(“dhaka”);List<Article> result = new ArrayList<>();for(Integer id : searchResult) { PersistentArticle pa = loadArticle(id) Integer likes = fetchLikeCount(id) result.add(new Article(pa, likes));}return result;
Do you see any problem with this code?
It’s sequential, and may take some time to run.
When an article is loading, nothing prevents us from fetching the like count
of that article, or loading another article, right?
A concurrent solution may save us running time. And we can use
Observables to do so.
Let’s try to use Observables now
Let’s assume now we have an async APIObservable<Integer> searchForArticles(String query)Observable<PersistentArticle> loadArticle(Integer articleId)Observable<Integer> fetchLikeCount(Integer articleId)
And we need to come up with the result as the following type.
Observable<Article> result = … ;
// We can use the result like following result.subscribe(article -> {//update the view with it});
Don’t worry about how the async API was implemented. Just assume it is
present.
(If we only have a sync api, we can still make it async by wrapping things inside Observables, using Observable.create, just etc.)
First step: do the searchObservable<Integer> ids = searchForArticles(String query);
….
For each id we need to load the article and fetch the like count.
How do we get the ids out from the Observable?
We don’t, instead we apply some operator to transform the source
Observable to a different one
Let’s go back to few slides ago, and see how we solved the problem sequentially
The traditional solution ... List<Integer> searchResult = searchForArticles(“dhaka”);List<Article> result = new ArrayList<>();for(Integer id : searchResult) { PersistentArticle pa = loadArticle(id) Integer likes = fetchLikeCount(id) result.add(new Article(pa, likes));}return result;
But we don’t do it like this in rx
Many Observable operators take lambda as parameter.
And we can get the item from inside the Observable box as a parameter of our
supplied lambda.
In case of Observable.filterObservable<Integer> numbers = Observable.just(1, 2, 3, 4, 5, 6);numbers.filter(num -> num % 2 == 0);
// The Observable.filter operator takes a lambda as parameter// We pass it a lambda// Our supplied lambda will be called for each of the item// So here the parameter “num” will represent an item inside the box// This is how we get things out from Observable box.
So, let’s get back to the original questionObservable<Integer> ids = searchForArticles(String query);
….
For each id we need to load the article and fetch the like count.
Now we know we need to apply some operator, which one?
We have to apply flatMapObservable<Integer> ids = searchForArticles(query);ids.flatMap(id -> {
// do something with the id ... });
So, by applying flatMap, we somehow get the item from inside the Observable box, as the parameter of our lambda.
We have to apply flatMapObservable<Integer> ids = searchForArticles(query);ids.flatMap(id -> {
Observable<PersistentArticle> arts = loadArticle(id);Observable<Integer> likes = fetchLikeCount(id);
//how do we get the article out from inside Observable?});
We need to apply flatMap again ...Observable<Integer> ids = searchForArticles(query);ids.flatMap(id -> {
Observable<PersistentArticle> arts = loadArticle(id);Observable<Integer> likes = fetchLikeCount(id);
return arts.flatMap(art -> {// and now we need to get the likes out
});})
And flatMap again ...Observable<Integer> ids = searchForArticles(query);ids.flatMap(id -> {
Observable<PersistentArticle> arts = loadArticle(id);Observable<Integer> likes = fetchLikeCount(id);return arts.flatMap(art -> {
return likes.flatMap(like -> { // now we have everything to make an Article object// so what do we return here? A new Article()?});
});})
We need to wrap the result inside ObservableObservable<Integer> ids = searchForArticles(query);ids.flatMap(id -> {
Observable<PersistentArticle> arts = loadArticle(id);Observable<Integer> likes = fetchLikeCount(id);return arts.flatMap(art -> {
return likes.flatMap(like -> { return Observable.just(new Article(art, like));
}); });
})
We can remove some nesting here ...
Alternate version using zipObservable<Integer> ids = searchForArticles(query);ids.flatMap(id -> {
Observable<PersistentArticle> arts = loadArticle(id);Observable<Integer> likes = fetchLikeCount(id);return Observable.zip(arts, likes, (art, lc) -> {
return new Article(art, lc);});
});})
Using the full power of Java 8 … searchForArticles(query).flatMap(id -> {
return zip(loadArticle(id), fetchLikeCount(id), Article::new); });});
Using the full power of Java 8 … searchForArticles(query).flatMap(id -> {
return zip(loadArticle(id), fetchLikeCount(id), Article::new); });});
This is the solution we desire. I find this code beautiful. And it’s (mostly) concurrent (depending on the implementation of the search, load, etc.).
Keep these in mind while using RxJava ● Observables can emit zero, one or more items ● Observables can be of infinite stream of values/events ● Observables can complete without returning anything, Observable.empty().● Observables can emit some items and then call onError() to terminate
abnormally● If onError() is called, then onCompleted will not be called
Keep these in mind while using RxJava ● Observables are by default lazy. If no subscriber is subscribed, then nothing
will be executed. ● By default they run in the same thread from which the subscriber is called ● You can change the subscriber thread by calling subscribeOn()● You can change the observer thread by calling observeOn()● There are some built in Schedulers (similar to thread pool). For example
Schedulers.io(), Schedulers.computation().● A single Observable issues notifications to observers serially (not in parallel).
A better version of the previous code
searchForArticles(query).flatMap(id -> {return Observable.just(id)
.subscribeOn(Schedulers.io())
.flatMap(i ->{return zip(loadArticle(i),
fetchLikeCount(i), Article::new);
}); });});
In fact this is the concurrent version, although it lost it’s beauty a bit :-) Hoping to cover this in a future session.
When you have multiple async or concurrent things, depending on each
other, RxJava may be a good candidate.
I only covered the basics, there are way more to learn …
Advanced topics (maybe in some future sessions) A whole lot more operators
Subjects
Schedulers
Backpressure
Implementing custom operators
Have a look into● CompletableFuture (introduced in java 8)● Reactive streams specification (which RxJava 2.x implemented)● java.util.concurrent.Flow api (coming in java 9)
Reference● Collection of all tutorials, http://reactivex.io/tutorials.html● Reactive programming with RxJava book,
http://shop.oreilly.com/product/0636920042228.do● The RxJava contract, http://reactivex.io/documentation/contract.html
Thank you!