Softshake 2015 Talk Vert.x 3 is a toolkit to create reactive applications on the Java Virtual Machine. Vert.x 3 takes the JVM to new levels of reactive awesomeness: it lets you build scalable applications transparently distributed in Java, JavaScript, Ruby and Groovy. And, you don’t have to choose a single language, but mix them! This talk presents the key concepts of Vert.x and how you can use it to build your next application. This session explains how the simple model promoted by Vert.x enables the construction of concurrent, scalable and efficient micro-service based applications. Several examples are developed during the talk and demonstrates Vert.x features such as the distributed event bus, the high availability, the polyglot aspect and vert.x web.

1. Be reactive on the JVM but not only in Java

2. Clement Escoffier, Red Hat

4. Reactive
§Responsiveness
§On various workload (elasticity)
§In the face of failures (resilience)
§Message-driven
§Asynchronous message-passing
Polyglot
§Not only Java
§Groovy, Ruby, JavaScript
§Run on top of a JVM

5. Handler

6. Event Loop
Handlers
Handlers are always
called in the same
thread (the event loop)

7. Event Loop
Handlers
Handlers must never
block the thread calling
them.

8. Event Loop

9. Event Loop

10. Handlers are always
executed in the same
event loop.
Event Loops

11. A Message
A Notification
A HTTP Request
A command, an instruction
A file
A result, a report, an error
void operation(param 1, param2,
Handler< > handler) {
//…
handler.handle( )
//…
}
void handle( ) {
// do something with
}

12. vertx.createHttpServer()
.requestHandler(
req -­‐> req.response().end("Hello there!")
)
.listen(8080,
ar -­‐> {
if (ar.failed()) {
System.out.println("The HTTP Server has failed to start");
} else {
System.out.println("The HTTP Server is up");
}
}
);

13. void add(int a, int b, Handler<Integer> handler) {
int r = a + b;
handler.handle(r);
}
void doSomething() {
add(1, 1, i -­‐> {
System.out.println("result : " + i);
});
//…
}
2
1
3

14. Event Bus
Point to Point
Publish / Subscribe
Request / Response

15. Event Bus
Messages are received
using Handlers and
delivered using the
event loop.

16. Event Bus
Each vert.x instance
has access to the event
bus.

17. Event Bus
The event bus allows
distributed
communication.
Machine 1
Machine 2
Machine 3

18. Almost anything can
send / receive messages
Machine 1
Machine 2
Machine 3
bin
node

19. Verticles are chunks of
code that get deployed
and run by Vert.x.
Verticle
Event Bus
Handler
vertx.deployVerticle(
"my.verticle");

20. Verticles have a
lifecycle (start, stop)
Verticle
Event Bus
Handler

21. Verticles interact using
events / messages.
Verticle
Event Bus
Handler

22. Verticles can be
instantiated multiple
times.
vertx.deployVerticle(
"my.verticle",
new DeploymentOptions()
.setInstances(3));

23. Dead verticles are
restarted on a running
node.
Verticles
fail-over
vertx.deployVerticle(
"my.verticle",
new DeploymentOptions()
.setHA(true));

24. Verticles can be
written in any
supported language
Groovy
Verticle
JS
Verticle
Java
Verticle
Ruby
Verticle

25. Polyglot
Event Bus
Distributed
Verticle
puts "Hello"
Events
Event Loops
Handlers

27. Core
Web
Auth
JDBC Redis
Mongo
Stomp
Mail JCA RX
Metrics
JS Client
Docker
OpenShift
Shell
Sync

28. Svc
Svc
Svc
Micro-services interact
using the event bus
Packaged in a fat jar

29. Svc
Svc
Svc
HTTP /
REST
TCP
or using HTTP,
TCP, STOMP,
AMQP

30. Svc
Svc
Svc
Proxy generation for
the event bus
Service exposed on the event bus
Client

31. Svc
Svc Consumption of services
from node.js or the
browser
JavaScript
Client
JS

32. Svc
Svc
Svc
Each service scales up
and down, and
supports fail-over
HTTP /
REST

34. http://vertx.io
http://vertx.io/blog/my-first-vert-x-3-application
https://github.com/vert-x3/vertx-examples