With the advent of mobile web and IoT (Internet of Things), today's applications need to handle a lot of concurrent requests while staying responsive and easy to scale. Infrastructure plays a role in achieving these goals, but changing your programming style can help too. In this presentation, we will make the case for reactive programming, and introduce RxJava in particular. Then we will guide you through the process of building a real-life web application, based on Vert.x 3 and RxJava, communicating with databases, external services and modern datastores. You will learn how Vert.x integrates with RxJava, and why its simplicity makes it a perfect runtime for reactive applications.

1. Modern app programming
with RxJava & Eclipse Vert.x

2. Who am I?
● Thomas Segismont
● tsegismont on GitHub, Twitter, Gmail, Freenode...
● Vert.x core team since August 2016
● At Red Hat since November 2012 (RHQ and Hawkular)
#RivieraDev @vertx_project

3. Expectations
● Goals
– Why is reactive programming important?
– What are RxJava and Vert.x?
– How can I combine them to build scalable, efficient and resilient
apps?
● Non goals
– In-depth study of RxJava or Vert.x
#RivieraDev @vertx_project

4. Back to the late 90s…
A hotel room booking engine

5. http://example.com
http://example.com
http://example.com

6. Such apps are mainstream today!
● Microservices
● API economy
#RivieraDev @vertx_project

7. Alexandre Duret-Lutz (CC BY-SA 2.0)

8. Event loop systems

9. Reactor pattern
Single
thread

10. New stuff?
● Browser (AJAX, #setTimeout)
● GUI
● Node.js
#RivieraDev @vertx_project

11. Event loop benefits
● Simple concurrency model
● Mechanical sympathy http://bit.ly/2cJMBsG
– Higher throughput
– Predictable latency
#RivieraDev @vertx_project

12. Vert.x

13. What is Vert.x
● A toolkit (lib)
● … to build polyglot (on the JVM)
– JS, Groovy, Ruby, Scala (3.4), Kotlin (3.4)
● … reactive systems
#RivieraDev @vertx_project

14. Demo
Damn simple verticle

16. Multi-Reactor
#RivieraDev @vertx_project

17. Event Bus
● Nervous system of Vert.x
● Message passing style
● Different messaging paradigms:
– Point to point
– Publish/Subscribe
– Request/Reply
#RivieraDev @vertx_project

18. Running blocking code
● In the real world, most JVM libraries have blocking APIs
– JDBC
– io.File
– Your legacy libs
● With Vert.x you can interact with blocking parts easily
● You won’t throw away your code assets!
#RivieraDev @vertx_project

20. Callback based (reactive imperative)

21. CALLBACK HELL !

22. RxJava

23. Data and events flows
● It is great at organizing transformation of data and coordination
of events
● It makes most sense when many sources of events are
involved (modern apps!)
#RivieraDev @vertx_project

24. Push based
Observable Observer
Subscription
● OnNext 0..∞
● Terminal event 0..1
– OnComplete
– OnError
#RivieraDev @vertx_project

25. Reactive pull backpressure
Observable Observer
Subscription
Request
#RivieraDev @vertx_project

26. Observable / Single / Completable
Zero One Many
Sync void T Iterable<T>
Async Completable Single<T> Observable<T>
#RivieraDev @vertx_project

27. Demo
Damn simple Rx Verticle

28. Music Store Demo
https://github.com/tsegismont/vertx-musicstore

29. http://example.com
http://example.com
http://example.com
https://coverartarchive.org/
Postgres
Couchbase
Vert.x RxJava
Vert.x
Web Client
HTTP
Vert.x
JDBC Client
Couchbase
RxJava driver
Event Bus Bridge
(WebSocket)
Vert.x
Local Cache

30. Observable#map
ReactiveX.io Creative Commons Attribution 3.0 License

31. Observable#map
private Single<JsonArray> findAlbums(SQLConnection sqlConnection, Long artistId) {
return sqlConnection.rxQueryStreamWithParams(findAlbumsByArtist, new JsonArray().add(artistId))
.flatMapObservable(SQLRowStream::toObservable)
.map(row -> new JsonObject().put("id", row.getLong(0)).put("title", row.getString(1)))
.collect(JsonArray::new, JsonArray::add)
.toSingle();
}
#RivieraDev @vertx_project

32. Observable#flatMap
ReactiveX.io Creative Commons Attribution 3.0 License

33. Single#flatMap
public void handle(RoutingContext rc) {
dbClient.rxGetConnection().flatMap(sqlConnection -> {
return findGenres(sqlConnection).doAfterTerminate(sqlConnection::close);
}).flatMap(genres -> {
rc.put("genres", genres);
return templateEngine.rxRender(rc, "templates/index");
}).subscribe(rc.response()::end, rc::fail);
}
#RivieraDev @vertx_project

34. Single#zip
ReactiveX.io Creative Commons Attribution 3.0 License

35. Single#zip
Single<JsonObject> as = findAlbum(sqlConnection, albumId);
Single<JsonArray> ts = findTracks(sqlConnection, albumId);
return Single.zip(as, ts, (album, tracks) -> {
Map<String, Object> data = new HashMap<>(2);
data.put("album", album);
data.put("tracks", tracks);
return data;
}).doAfterTerminate(sqlConnection::close);
#RivieraDev @vertx_project

36. Observable#observeOn
ReactiveX.io Creative Commons Attribution 3.0 License

37. Observable#observeOn
#RivieraDev @vertx_project
albumCommentsBucket.query(Query.parametrized(findRecentCommentsByAlbum, params))
.observeOn(RxHelper.scheduler(rc.vertx()))
.flatMap(AsyncQueryResult::rows)
.limit(5)
.collect(JsonArray::new, (jsonArray, row) -> jsonArray.add(new JsonObject(row.value().toMap())))
.toSingle()
.flatMap(data -> {
rc.put("comments", data);
return templateEngine.rxRender(rc, "templates/partials/album_comments");
}).subscribe(rc.response()::end, rc::fail);

38. #RivieraDev @vertx_project
http://red.ht/2pgMEoA

39. Thank you!
http://vertx.io
Come get your sticker!
#RivieraDev @vertx_project