QConSP 2018: Modern app programming with Eclipse Vert.x and RxJava

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. But on the performance side, the party is over: the exponential increase promised by the Moore's law reached its limits. From now on, we need a programming paradigm switch to make the most of multicore architecture innovations.

In this presentation, we will make the case for reactive programming. Then we will guide you through the process of building a real-life web application, based on Vert.x 3 and RxJava2, 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.

Transcript

1. #QConSP @vertx_project Modern app programming with RxJava and Eclipse Vert.x
2. #QConSP @vertx_project Who am I? Vert.x core team member since 2016 Working at since 2012 Contributing specifically to monitoring and clustering @tsegismont
3. Eclipse Vert.x A toolkit to build reactive applications on the JVM Started in 2O12 Eclipse / Apache licensing 7K on Built on top of Netty @vertx_project https://vertx.io
5. #QConSP @vertx_project Pay the right price • Tiny footprint • Do one thing and do it well • Modular set of extensions
6. Why going reactive?
7. #QConSP @vertx_project A hotel room booking startup story
18. 2011 NoSQL
21. 1/ Many channels 2/ Lots of I/O
22. while (isRunning) { String line = bufferedReader.readLine(); switch (line.substring(0, 4)) { case "ECHO": bufferedWriter.write(line); break; // ... // other cases (...) // ... } }
23. x 1000 =
24. “But I don’t do Internet scale. I do enterprise!”
25. 2018 server: 28 cores, 512 GB memory
26. Microservices
27. Your container share: 2 vCPU, 512 MB memory
28. 1/ Keep the number of threads to a minimum 2/ Keep them busy
29. Thread Events Event-loop
30. Event loops in Vert.x project
31. 2 event-loops per core
32. class HttpServerVerticle extends AbstractVerticle { public static void main(String[] args) { Vertx vertx = Vertx.vertx(); vertx.deployVerticle(HttpServerVerticle.class.getName()); } @Override public void start() throws Exception { vertx.createHttpServer() .requestHandler(req -> { req.response().end("Hello world!"); }).listen(8080); } } Verticles
33. DeploymentOptions options = new DeploymentOptions() .setInstances(3); vertx.deployVerticle(httpVerticle, options); Load-balancing
34. Communication between verticles?
35. EventBus Messaging passing, not shared data Multi-paradigm Standalone or clustered Browser and mobile bridges
36. EventBus eventBus = vertx.eventBus(); eventBus.<String>consumer("greeting").handler(msg -> { String name = msg.body(); msg.reply(String.format("Hello %s!", name)); }); EventBus eventBus = vertx.eventBus(); eventBus.<String>send("greeting", "QConSP", ar -> { if (ar.succeeded()) { System.out.println(ar.result().body()); } else { ar.cause().printStackTrace(); } }); 1 2
37. Verticle Bridge
38. #QConSP @vertx_project Distributed EventBus demo
39. #QConSP @vertx_project Reactive Programming with RxJava
40. Everything is a stream: data or events
41. Java 8 streams on steroids
42. Lazy and push based Observable Observer Subscription
43. Backpressure Observable Observer Subscription Request
44. #QConSP @vertx_project Different flavors None One Many Completable Single<T> Observable<T> * plus Maybe<T> and Flowable<T> in RxJava 2
45. Composing data flows
47. Great to deal with failures and latencies in distributed systems
51. Observable<String> loadPostsFromRDBMS(LocalDate date); Observable<Comment> loadFromDocumentStore(String postId); loadPostsFromRDBMS(date) .concatMap(postId -> loadFromDocumentStore(postId)) .retry(4) .timeout(500, TimeUnit.MILLISECONDS) .subscribe(); Composition
52. No need to create your own Observables with Vert.x
53. #QConSP @vertx_project Rxified APIs import io.vertx.ext.web.Router; import io.vertx.reactivex.ext.web.Router;
54. #QConSP @vertx_project Rxified APIs Single<HttpServer> rxListen(int port); void listen(int port, Handler<AsyncResult<HttpServer>> handler);
55. #QConSP @vertx_project Rxified ReadStream<T> class AsyncFile implements ReadStream<Buffer> { // ... // RxJava1 Observable<Buffer> toObservable(); // RxJava2 Flowable<Buffer> toFlowable(); // ... }
56. #QConSP @vertx_project Music Store demo https://github.com/tsegismont/vertx-musicstore
57. Mongo Postgres Cover Art Archive
58. #QConSP @vertx_project Learning
59. #QConSP @vertx_project Learning
60. Thank you! More questions? Come to the Red Hat booth!