Development with Vert.x: an event-driven application framework for the JVM

Development with Vert.x:
an event-driven application
framework for the JVM
David Wu
@wuman
blog.wu-man.com
Taiwan Java User Group (2013/06/29)
1Monday, July 1, 13

about.me/wuman
2Monday, July 1, 13

What is Vert.x?
3Monday, July 1, 13

What most people will tell you about Vert.x
• A general-purpose application framework
running on JVM
• Performant: asynchronous APIs, event-driven,
non-blocking, etc.
• Highly scalable but also easy to implement
concurrency
• Polyglot: intermix Java, JS, Ruby, Groovy,
Python, etc.
4Monday, July 1, 13

What I think about Vert.x
• All-in-one framework that allows you to focus
on your application rather than ﬁddling with
different technologies
• Business friendly Apache License 2.0
• Loose coupling modules that interoperate in a
system
5Monday, July 1, 13

Background on the
C10K Problem
6Monday, July 1, 13

Shift from Threading
to Asynchronous
the story of switching from Apache to Node.js
7Monday, July 1, 13

The inevitable comparison to Node.js
• A single event loop serving a high volume of
connections via an asynchronous
programming model
• Most of the real work are done in a pool of
background threads
8Monday, July 1, 13

Asynchronous Programming Model
vertx.createHttpServer().requestHandler(
new Handler<HttpServerRequest>() {
public void handle(HttpServerRequest request) {
log.info("A request has arrived on the server!");
request.response().end();
}
}
).listen(8080, "localhost");
9Monday, July 1, 13

But there are 3
problems with Node.js
10Monday, July 1, 13

Problems with Node.js
• Well, it’s not Java (and this is a Java User
Group)
• Does not easily scale both vertically and
horizontally
• Single event loop fails when you have CPU-
intensive tasks or 3rd-party blocking APIs

Vert.x to the rescue
• Use all available cores on a single machine
• Horizontally scale out to multiple boxes
• Allow blocking calls to NOT run on an event
loop

Introduction to Vert.x instance and Verticles
Verticle
Verticle
WorkerVerticle
WorkerVerticle
Vert.x instance

Verticles are extremely isolated
• Verticles are isolated with separate class
loaders
• A verticle never gets executed by more than
one thread concurrently
• No race conditions, no deadlocks. You write
your code as single threaded.

What about
communication?

Message Passing via the Event Bus
Verticle
Verticle
Worker
Verticle
Worker
Verticle
Vert.x instance

Very Powerful Event Bus
Verticle
Verticle
WorkerVerticle
Verticle
Verticle
WorkerVerticle

Registering a Message Handler
EventBus eb = vertx.eventBus();
Handler<Message> myHandler = new Handler<Message>() {
public void handle(Message message) {
System.out.println("I received a message " + message.body);
}
};
eb.registerHandler("test.address", myHandler);

Message Types
• Primitives and their boxed types
• String
• org.vertx.java.core.json.JsonObject
• org.vertx.java.core.json.JsonArray
• org.vertx.java.core.buffer.Buffer

Pub/Sub Model
eb.publish("test.address", "hello world");

Point-to-Point Model
eb.send("test.address", "This is a message",
new Handler<Message<String>>() {
public void handle(Message<String> message) {
System.out.println("I received a reply " + message.body);
}
});
EventBus eb = vertx.eventBus();
Handler<Message> myHandler = new Handler<Message>() {
public void handle(Message message) {
System.out.println("I received a message " + message.body);
message.reply("This is a reply");
}
};
eb.registerHandler("test.address", myHandler);

Shared Maps and Sets
ConcurrentMap<String, Integer> map = vertx.sharedData().getMap("demo.mymap");
map.put("some-key", 123);
Set<String> set = vertx.sharedData().getSet("demo.myset");
set.add("some-value");

Module System

Writing Verticles
import org.vertx.java.core.Handler;
import org.vertx.java.core.net.NetSocket;
import org.vertx.java.core.streams.Pump;
import org.vertx.java.platform.Verticle;
public class Server extends Verticle {
public void start() {
vertx.createNetServer().connectHandler(new Handler<NetSocket>() {
public void handle(final NetSocket socket) {
Pump.createPump(socket, socket).start();
}
}).listen(1234);
}
}
vertx run Server.java

Deploying Verticles programmatically
// For example - deploy some other verticle
container.deployVerticle("foo.js", new AsyncResultHandler<String>() {
public void handle(AsyncResult<String> deployResult) {
if (deployResult.succeeded()) {
System.out.println(“Yay!”);
} else {
System.out.println(“Error: “ + deployResult.cause());
}
}
});

Modules
• Package verticles into re-usable modules
• Simply a zip ﬁle containing module deﬁnition,
code, and resources
• Very similar to the module system in Node.js
• Modules can be “zip” artifacts released in
Maven Central
• Vert.x web site maintains a listing of Vert.x
modules

Example Modules
• JDBC, Redis, MongoDB Persistors
• AMQP
• Mailer
• Persistent work queue
• Authentication Manager
• Session Manager
• Web framework
• Language implementations

Programming
Experience

Core APIs
• TCP/SSL servers
and clients
• HTTP/HTTPS
servers and clients
• WebSockets
servers and clients
• SockJS
• EventBus
• Shared Maps and
Sets
• Buffers
• Flow control
• Timers
• Files
• Conﬁguration

Container API
• Deploying and undeploying verticles
• Deploying and undeploying modules
• Logging
• Retrieve verticle conﬁguration

Easy development
• Gradle template
• Maven archetype and plugin
• IDE debugging and testing

What is it good for?

Applications
• Realtime analytics dashboard
• Big data queries and task coordination
• Polyglot integration

Some Pain Points

Real life caveats
• Content assist in IDEs don’t work for busmod APIs
• You often ﬁnd yourself tracing errors in the busmods,
which can be difﬁcult because the stack trace stops
at message passing
• People writing in other languages often get frustrated
by not being able to use native extensions that they
are already used to.
• Hell of anonymous inner class callbacks and no good
Java flow control libraries
• Java7 only. Doesn’t work on Android.

Conclusion

“Using a bleeding-edge
framework is exciting at ﬁrst.
Not so much afterwards.”
David Wu

Make it better.
Contribute.
http://vert-x.github.io/

Thank you

Development with Vert.x: an event-driven application framework for the JVM

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Development with Vert.x: an event-driven application framework for the JVM (20)

Recently uploaded (20)

Development with Vert.x: an event-driven application framework for the JVM