RxJava Applied

RxJava Applied:
Concise Examples where It Shines
Igor Lozynskyi
JEEConf - May 20-21, 2016
Software Engineer at GlobalLogic

Presentation’s home
https://github.com/aigor/rx-presentation

Modern apps
Created with draw.io

Options to deal with integration complexity
JDeferred
CompletableFuture<T>
Scala.Rx
Scala Actors
RxJava

RxJava
http://reactivex.io
https://github.com/ReactiveX/RxJava

Short history
● From 2009 for .NET
● From 2013 for JVM (latest: 1.1.5, May 5, 2016)
● Now a lot of other languages

Use case: Stream of tweets
Created with Balsamiq Mockups

Twitter API
Twitter Stream API (WebSocket alike):
● Doc: https://dev.twitter.com/streaming/overview
● Library: com.twitter:hbc-core:2.2.0
Twitter REST API:
● GET https://api.twitter.com/1.1/users/show.json?screen_name=jeeconf
● GET https://api.twitter.com/1.1/search/tweets.json?q=from:jeeconf

Observer
interface Observer<T> {
void onNext(T t);
void onCompleted();
void onError(Throwable e);
}

Observable
.create(s -> {
s.onNext("A");
s.onNext("B");
s.onCompleted();
})
.subscribe(m -> log.info("Message received: " + m),
e -> log.warning("Error: " + e.getMessage()),
() -> log.info("Done!"));
Output:
Message received: A
Message received: B
Done!

Let’s look at entities
class Tweet {
String text;
int favorite_count;
String author;
int author_followers;
}
class Profile {
String screen_name;
String name;
String location;
int statuses_count;
int followers_count;
}
class UserWithTweet {
Profile profile;
Tweet tweet;
}

Profile getUserProfile(String screenName) {
ObjectMapper om = new ObjectMapper();
return (Profile) om.readValue(om.readTree(
Unirest.get(API_BASE_URL + "users/show.json")
.queryString("screen_name", screenName)
.header("Authorization", bearerAuth(authToken.get()))
.asString()
.getBody()),
Profile.class);
}
Get user profile synchronously

Get user profile asynchronously
Observable<Profile> getUserProfile(String screenName) {
return Observable.fromCallable(() -> {
.asString()
.getBody()),
Profile.class);
});
}

Add some errors handling
Observable<Profile> getUserProfile(String screenName) {
if (authToken.isPresent()) {
return Observable.fromCallable(() -> {
.asString()
.getBody()),
Profile.class);
}).doOnCompleted(() -> log("getUserProfile completed for: " + screenName));
} else {
return Observable.error(new RuntimeException("Can not connect to twitter"));
}
}

Let’s do something concurrently
Illustration: Arsenal Firearms S.r.l.

Get data concurrently
Observable<UserWithTweet> getUserAndPopularTweet(String author){
return Observable.just(author)
.flatMap(u -> {
Observable<Profile> profile = client.getUserProfile(u)
.subscribeOn(Schedulers.io());
Observable<Tweet> tweet = client.getUserRecentTweets(u)
.defaultIfEmpty(null)
.reduce((t1, t2) ->
t1.retweet_count > t2.retweet_count ? t1 : t2)
return Observable.zip(profile, tweet, UserWithTweet::new);
});
}

Let’s subscribe on stream of tweets!

streamClient.getStream("RxJava", "JEEConf", "Java")

streamClient.getStream("RxJava", "JEEConf", "Java", "Trump")

.distinctUntilChanged()
.map(p -> p.author)
.flatMap(name -> getUserAndPopularTweet(name))
.subscribeOn(Schedulers.io())
.observeOn(Schedulers.immediate())
.subscribe(p -> log.info("The most popular tweet of user "
+ p.profile.name + ": " + p.tweet));
.scan((u1, u2) -> u1.author_followers > u2.author_followers ? u1 : u2)

.scan((u1, u2) -> u1.author_followers > u2.author_followers ? u1 : u2)
.distinctUntilChanged()
.map(p -> p.author)
.flatMap(name -> {
Observable<Profile> profile = client.getUserProfile(name)
Observable<Tweet> tweet = client.getUserRecentTweets(name)
.defaultIfEmpty(null)
.reduce((t1, t2) ->
t1.retweet_count > t2.retweet_count ? t1 : t2)
return Observable.zip(profile, tweet, UserWithTweet::new);
})
.subscribeOn(Schedulers.io())
.observeOn(Schedulers.immediate())
.subscribe(p -> log.info("The most popular tweet of user "
+ p.profile.name + ": " + p.tweet));

▸ API is big (150+ methods to remember)
▸ Requires to understand underlying magic
▸ Hard to debug
▸ Don’t forget about back pressure
Conclusions: pitfalls

▸ It is functional, it is reactive*
▸ Good for integration scenarios
▸ Allows to control execution threads
▸ Easy to compose workflows
▸ Easy to integrate into existing solutions
▸ Easy to test
* RxJava is inspired by FRP (Functional Reactive Programming), but doesn’t implement it
Conclusions: strength

Thanks
Presentation template by SlidesCarnival
@siromaha
aigooor@gmail.com

RxJava Applied

More Related Content

What's hot

Viewers also liked

Similar to RxJava Applied

Recently uploaded

RxJava Applied

Editor's Notes