Vert.x is a general purpose application platform for building asynchronous and reactive applications. It uses an event-driven architecture with non-blocking APIs to build distributed applications that can be composed of components written in different programming languages. Vert.x provides tools like an event bus for communication between components, as well as HTTP/TCP clients and servers that allow building reactive web and microservices applications. It aims to simplify concurrency while leveraging existing Java libraries and allowing applications to scale across multiple machines.

2. vert.x
asynchronous applications
+ big data
Pid – Stuart Williams
Consulting Architect
SpringSource
@pidster

3. Pid (Stuart Williams)
Speaker Bio
■ Consulting Architect at SpringSource / Pivotal
Application architecture, performance (and hand-waving)
■ Projects ■ Communities
■ vert.x ■ Apache Tomcat
■ Apache Oltu (OAuth) ■ Groovy
3

4. vert.x project
Project Lead
@timfox
Committers
@pidster
@normanm (netty)
4

5. What is vert.x?
 General purpose application platform
 Superficially similar to Node.js – but not a clone!
 Asynchronous APIs
 Polyglot – mix and match Java, JavaScript/CoffeeScript, Ruby, Groovy
and Python (others to follow).
 Simple but not Simplistic
 Part of the new breed of application platforms
5

6. Key Features
Hybrid Reactor
Polyglot Container
TCP/SSL clients and servers
HTTP/HTTPS clients and servers – including WebSockets
File system
Event bus
100% asynchronous
6

7. Code!
Super simple HTTP server
Serves files by matching request path
One example for each language
7

8. JavaScript – Mozilla Rhino
load('vertx.js’)
vertx.createHttpServer().requestHandler(function(req) {
var file = req.path === '/' ? 'index.html' : req.path;
req.response.sendFile('webroot/' + file);
}).listen(8080)
8

9. Python – www.jython.org
import vertx
server = vertx.create_http_server()
@server.request_handler
def request_handler(req):
file = "index.html" if req.uri == "/" else req.uri
req.response.send_file("webroot/%s"%file)
server.listen(8080)
9

10. Ruby – jruby.org
require "vertx"
Vertx::HttpServer.new.request_handler do |req|
file = req.uri == "/" ? "index.html" : req.uri
req.response.send_file "webroot/#{file}”
end.listen(8080)
10

11. Groovy – groovy-lang.org
vertx.createHttpServer().requestHandler { req ->
def file = req.uri == "/" ? "index.html" : req.uri
req.response.sendFile "webroot/$file”
}.listen(8080)
11

12. Java
import org.vertx.java.core.Handler;
import org.vertx.java.core.http.HttpServerRequest;
import org.vertx.java.deploy.Verticle;
public class Server extends Verticle {
public void start() {
vertx.createHttpServer().requestHandler(new Handler<HttpServerRequest>() {
public void handle(HttpServerRequest req) {
String file = req.path.equals("/") ? "index.html" : req.path;
req.response.sendFile("webroot/" + file);
}
}).listen(8080);
}
}
12

13. Scala – soon!
vertx.createHttpServer
.requestHandler { req: HttpServerRequest =>
val file : String = if (req.path == “/”) “/index.html” else req.uri
req.response.sendFile("webroot/" + file)
} .listen(8080)
13

14. More languages?
DynJS
100% InvokeDynamic
Alternative to Rhino for JavaScript
Node.js Compatibility for vert.x
Clojure?
What language support do you want see?
14

15. Thread Pools
Non-blocking Event Loops
Core Loop
Acceptors
Blocking
Worker Pool
15

16. Threading Model
 Vert.x implements the Multi-Reactor Pattern
 An event loop is an OS thread
 Handles events for many handlers
 Vert.x has multiple event loops. Typically one per core.
 Don't block the event loop!
16

17. Hybrid Threading Model
 Don't force everything to run on an event loop
 Worker verticles can block
 Communicate with other verticles by message passing.
 Allows us to leverage the huge ecosystem of blocking Java libs
17

18. Components
Server & Client
TCP
HTTP
WebSocket
SockJS
Event Bus
Point-to-point, publish-subscribe
Transparent clustering
18

19. Event Bus
The nervous system of Vert.x
Verticles communicate using the event bus.
Super simple API.
Point to point. Publish/Subscribe. Request/Response.
Pass simple strings, numbers or other primitive types.
JSON messages are preferred for structured data.
Transparent clustering
19

20. Event Bus – Example
var handler = function(message) {
console.log('Received message ' + message.msg)
}
vertx.eventBus.registerHandler('example.address', handler)
vertx.setPeriodic(1000, function() {
vertx.eventBus.send('example.address', { msg: 'foo’ })
})
20

21. Event Bus – Extended to Browser
Event bus extends to client side JavaScript too
Uses the same API on the client
Powerful distributed event space spanning both client and server
nodes
Ideal for modern “real-time” web applications
21

22. Modules
 Authentication Manager ■ Web Server
 Form Upload ■ Work Queue
 JDBC Persistor ■ AMQP
 Mailer ■ More…
 Mongo Persistor
 Session Manager
22

23. mod-web-server
load('vertx.js’)
var config = {
"web_root": <web_root>,
"port", <port>,
"ssl": <ssl>,
"key_store_password": <key_store_password>,
"key_store_path": <key_store_path>,
}
vertx.deployModule('vertx.web-server-v1.0', config, 1, function() {
// deployed
});
23

24. Composition
Deploy code using code
Modules are unit of composed code
Deploy modules using a verticle
Or provide multiple verticles inside a module
Remember: verticles communicate using the Event Bus.
24

25. Architecture
I/O verticles
Logic
verticles
Separation of concerns
Workers if required Event
Bus
Polyglot
Worker
verticle
25

26. Example
….
26

27. Big Fast Data
Realtime Analytics Dashboards & APIs
WebSocket
SockJS
Polyglot Integration
Use language independent format like JSON, XML for data
Exchange messages using event bus
27

28. Fast Data – RabbitMQ
AMQP message broker
Use for queuing, routing messages and WAN clustering
28

29. Big/Fast Data – Redis
“Data Structure Server”
Key-Value store
Pub-sub messaging
Use for caching verticle data, broadcasting to verticles
29

30. Big/Fast Data – GemFire
Compute Grid / Distributed Cache
Embeddable Key-Value store
Use for large partitioned caches, high performance compute,
WANs
Send data to vert.x using CacheListeners, subscriptions,
AsyncQueues
30

31. Big Data – Hadoop
Hive – of course!
SQL queries via JDBC worker verticle
Standard pattern via event bus
Use for ad-hoc queries on large datasets
31

32. Big Data – MQTT
 MQTT is a machine-to-machine (M2M) / "Internet of Things”
connectivity protocol.
 Extremely lightweight publish/subscribe messaging transport.
 It is useful for connections with remote locations where a small
code footprint is required and/or network bandwidth is at a
premium.
 Eclipse Paho
Coming soon!
32

33. Big Data – Intravert (@zznate - apigee)
 Processors, filters and procedures allow you perform arbitrary
programmatic transformations on the server side before the results are
returned to the client.
 Execute procedures and join like logic in a single RPC request
eliminating round-trips
 A simple transport and JSON API that runs over HTTP allows clients to
choose from JSON, JSON compressed by smile, & even big fat sexy
XML
 A real REST interface (ever thought about what would a Cassandra
hyper media API look like?)
 Work with simple familiar objects like String or Integer instead of bytes
33

34. v2.0 – Features
 New ClassLoader
 Netty 4.0
 Languages as modules
 Flexible Module repositories, including Maven
 Management
34

35. v2.0 – Developer experience
 Gradle template project
 Maven archetype and plugins
 Zero setup IDE debugging
 Zero setup IDE testing
 Test Tools project
35

36. Management
Management Agent
Publishes metrics on Event Bus in JSON format
Management GUI
JMX Demo
36

37. Real Deployment
vert.x provides a JSON RPC API:
 deployer.js
 JsonRpcServer.groovy
 Integration.groovy – worker
 Spring Integration message flow to RabbitMQ
Dynamically deploys components to consume queues:
 Consumer.groovy – worker, Spring Integration message flow
 JsonRpcClient.groovy
37

38. Real Deployment
I/O verticles Worker Verticles
HTTP Spring Integration
JSON RPC AMQP publisher
Event
Bus
HTTP Spring Integration (Groovy DSL)
JSON RPC Client AMQP Consumer
38

39. Summary
Write apps as set of loosely coupled components that live
anywhere
Polyglot – use the language(s) you want
Simple concurrency – wave goodbye to most race conditions
Leverage existing Java library ecosystem
Module system – empower the community
Run Node.js apps too
We believe Vert.x is the platform for the new generation of
polyglot web and enterprise applications 39

40. Q&A