Vert.x is an open-source toolkit for building reactive applications on the JVM, featuring a lightweight and polyglot framework that supports multiple languages. Key components include verticles for event-driven programming, an event bus for messaging between verticles, and various services for handling files, HTTP servers, and databases. The document also covers installation, threading models, deployment, and service discovery within the Vert.x ecosystem.

1. Introducing Vertx
By: Vijay Shukla & Vishal
Sahu

2. Agenda
1. Introduction
2. Main Component
3. Threading and Programming Model
4. Installation
5. Event Bus
6. Verticle
7. Services
8. Templates

3. Introduction
● Vert.x is a toolkit or platform for implementing reactive applications on the
JVM.
● Vert.x is an open-source project at the Eclipse Foundation. Vert.x was
initiated in 2012 by Tim Fox.
● General Purpose Application Framework
● Polyglot (Java, Groovy, Scala, Kotlin, JavaScript, Ruby and Ceylon)
● Event Driven, non-blocking
● Lightweight & fast
● Reusable modules.

4. vertx.createHttpServer().requestHandler({
req ->
req.response()
.putHeader("content-type", "text/plain")
.end("Hello from Vert.x!")
}).listen(8080)
Hello World

5. Main Components
1. Verticles - the building blocks
2. Event Bus & Event Loop
3. Future
4. Routes

6. Threading and Programming Model
1. The synchronous I/O threading model are simple to understand, but it hurts
scalability with too many concurrent connections.
2. Operating System spends significant time just on thread scheduling
management.
3. The unit of deployment in Vert.x is called a Verticle. A verticle processes
incoming events over an event-loop.
4. Event-loops are typical in asynchronous programming models.
5. Every loop is attached to a thread. By default Vert.x attaches 2 event loops
per CPU core thread.
6. The direct consequence is that a regular verticle always processes events on
the same thread, so there is no need to use thread coordination mechanisms
to manipulate a verticle state

7. 7. Verticles run in single thread mode.
8. A verticle is only ever executed by a single thread, and always by the
same thread.
9. It is capable of using all the CPUs in machine, or cores in CPU.
10.It does this by creating one thread per CPU.
11.Each thread can send message to multiple verticles.
12.Verticles are event driven and are only running when receiving message,
so a verticles does not need to have its own exclusive thread.

8. Comparison of Performance When Only 200/OK Response Has Been Returned.

9. Comparison of Performance When a 72-byte Static HTML File is Returned.

10. Event Loop

14. Installation
Download Minimal Distribution or Full Distribution

15. Vertx Command Line
The vertx command is used to interact with Vert.x from the command line.
Download and set PATH environment variable. (Make sure Java 8 installed and
used)
vertx run my-verticle.groovy
OR
vertx run groovy:com.nexthoughts.MyGroovyVerticle

16. Dependency Management

17. Create Vertx Instance
You can create a Vertx instance by calling Vertx.vertx().
1. The Vertx instance creates a number of threads internally to handle the
exchange of messages between verticles.
2. These threads are not daemon threads, so they prevent the JVM from
shutting down, event of the main thread creating the Vertx instance
terminates.
3. When creating the Vertx Object you can also provide options if the default
is not right for you.
4. The VertxOptions object has many settings and allows you to configure
things like clustering, high availability, pool sizes etc.

18. Event Bus - Introduction
1. Verticles are event driven, meaning they do not run
unless they receive a message.
2. Verticles can communicate with each other via the Vert.x
event Bus.

19. 3. Message can be simple objects (e.g. Java Objects), Strings, CSV, JSON,
binary data or whatever else you need.
4. Verticles can send and listen to addresses.
5. An address is like a named channel.
6. When a message is sent to a given address, all verticles that listen on
that address receive the message.
7. Verticles can subscribe and unsubscribe to address without the ender
knowing.
8. This results in a very loose coupling between message senders and
message receivers.

21. Using The Event Bus
Is is very common for verticles to either listen for incoming messages from the
event bus, or to write messages to other verticles via the event bus.
Listening for Message
1. When a verticle wants to listen for message from the bus, it listen on certain
address. An address is just a name.
2. Multiple verticles can listen for messages on the same address and multiple
verticles can send messages to an address.
3. A verticle can obtain a reference to the event bus via the vertx instance
inherited from AbstractVerticle

22. Registering Handlers
1. When a message arrives for your handler, you handler will be called, passing
in the message.
2. The object returned from call to consumer() is an instance of
MessageConsumer.
3. When registering a handler on a clustered event bus, it can take some time
for the registration to reach all nodes of the cluster. You can
register/unregister a completion handler to be notified.

23. Publishing/Sending Message
eventBus.publish(“address”,”Send Some message here”)
eventBus.send(“address”,”Send Some message here”)
Sending a message will result in only one handler registered at the address
receiving the message. You can also send message on event bus with headers.
def options=[headers:[“some-header-key”:”some-header-value”]]
vertx.eventBus().send(“address”,”Some Message to be sent”,options)
To acknowledge that the message has been processed the consumer can reply
to the message by calling reply.

24. Verticles
1. Introduction
2. Create Verticle
3. Start and Stop Verticle Asynchronous
4. Accessing Vert.x instance from Verticle
5. Vert.x type
a. Standard
b. Worker
c. Multi-Threaded
6. Deployment Verticle Programmatically
7. Rules for mapping verticle instance to Verticle Factory.

25. Introduction
Vert.x can deploy and execute components called Verticles.

26. A Verticle can be passed some configuration (e.g, credentials, network addresses,
etc).

27. 1. Incoming network data can be received from accepting threads then passed as events
to corresponding Verticles.
2. If the Verticle deployed more than once, then the events are being distributed to
verticles instances in a round-robin fashion.

28. 1. The Vertx instance by itself doesn’t do much except all thread management, creating
an event bus etc.
2. In order to get the application to do something useful, you need to deploy one or
more verticles (component) inside the Vertx instance.
3. Before you can deploy a verticles you need to create it.
4. You can create a verticle by extending a class AbstractVerticle.
5. A verticle has a start() and a stop() method which are called when the verticles is
deployed and undeployed respectively.
6. Perform any necessary initialization work inside the start() and necessary cleanup in
stop().
Create Verticle

29. An application would typically be composed of many verticle instances running in the
same Vert.x instance at same time.
The different Verticle Instance communicate with each other by sending message
on the event bus.
Two alternatives to create verticles:
1. A plain groovy script
2. A groovy class implementing the Verticle interface or extending the
AbstractVerticle class.

30. Asynchronous Verticle Start and Stop
1. Sometimes we want to do some task in the start-up which takes some time
and you don’t want considered that verticle to be deployed until that happens.
2. There is an asynchronous start method, it takes Future as parameter. When
method return verticle will not be considered deployed.
3. When you finish your work then you have to call either complete or fail to
signal that you’re done.

31. Accessing Vert.x instance from verticle
You can access by using vertx variable/field.
◉ Access to Vert.x instance in Groovy Class
Verticle Types
◉ Standard Verticle
➢ They always executed using an event loop thread.
◉ Worker Verticle
➢ These run using a thread from worker pool. An instance is never
executed concurrent by more than one thread.
◉ Multi-Threaded Worker Verticle
➢ These run using a thread from the worker pool. An instance can be
executed concurrently by more than one thread.

32. Standard Verticles
◉ Standard Verticles are assigned and event loop thread when they are created
and the start method is called with that event loop.
◉ Vert.x will guarantee that all our code on Verticle instance is always executed
on the same event loop.
◉ Vert.x take care of:-
➢ Threading
➢ Scaling
➢ Synchronized
➢ Volatile
➢ Race Condition
➢ Deadlock

33. Worker Verticle
1. A worker verticle is just like Standard Verticle but it’s executed not using the
an event loop, but using a thread from the Vert.x worker thread pool.
2. It has been designed for calling blocking code, as they won’t block any
event’s loop.
3. You can also run inline blocking code directly while on an event loop.
4. It never executed concurrently by Vert.x by more than one thread, but can be
by different threads at different times.
5. To deploy Verticle as a worker you do that with setWorker.

34. Deploying Verticle programmatically
You can deploy a verticle using one of the method deployVerticle, specifying a
verticle name or you can pass in a verticle instance.
def myVerticle = new com.nexthoughts.MyVerticle()
vertx.deployVerticle(myVerticle)
You can also deploy by specifying verticle fully qualified name.
vertx.deployVerticle(‘com.nexthoughts.MyVerticle’)
The verticle name is used to look up specific VerticleFactory that will be used to
instantiate the actual verticle instances.

35. Rules for mapping a verticle name to a Verticle Factory
When deploying verticle using a name, the name is used to select the actual
verticle factory that will instantiate the verticle.
Verticle can have prefix which is a string followed by colon, which if present will
be used to look-up the factory.
js:foo.js //Use the JavaScript Verticle Factory.
groovy:com.nexthoughts.MyVerticle //Use the Groovy Verticle Factory

36. If no prefix present, Vert.x will look for a suffix and use that to lookup the factory.
Foo.js //Will also use the JavaScript verticle factory
MyVerticle.groovy //Will also use the Groovy verticle factory
If no prefix or suffix present then it by default Java fully qualified class name.
Most Verticles factories are loaded from the classpath and registered at Vert.x
startup.
We can programmatically register and unregister verticles factories using
registerVerticleFactory and unregisterVerticleFactory respectively.

37. The Context Object
1. When Vert.x provides an event to a handler or calls the start and stop method
of Verticle, the execution is associated with a Context.
2. A context is an event-loop context and is tied to a specific event loop thread.
3. To retrieve the context use the getOrCreateContext method.

38. Executing periodic and delayed actions
It’s very common in Vert.x to want to perform an action after a delay, or
periodically.
One-shot Timers
1. A one shot timer calls an event handler after a certain delay, expressed in
milliseconds.
2. To set a timer to fire once you use setTimer method passing in the delay and
a handler.
Periodic Timers
You can also set a timer to fire periodically by using setPeriodic()
Cancelling Timers
vertx.cancelTime(timerId)

39. Vert.x Services
i. Handling files
ii. Http Server
iii. JDBC Connector
iv. Mongo Client
v. SMTP Mail
vi. REST APIs

40. File Handling
1. The Vert.x FileSystem object provides many operations for manipulating the
file system.
2. There is one file system instance object per Vert.x instance, fileSystem.
3. Blocking and Non-Blocking version of each operations is provided. Non-
blocking version takes a handler which is called when operations completes
or fails.
4. Vert.x provides an asynchronous file abstraction that allows you to manipulate
a file on the file system.
5. AsyncFile implements ReadStream and WriteStream so you can pump files
to and from other stream objects such as net sockets, http requests and
responses and WebSockets.

41. Code for Simple File Handling
def fs = vertx.fileSystem()
fs.copy("$path/foo.txt", "$path/bar.txt", { res ->
if (res.succeeded()) {
println("File has been copied")
} else {
println("Failed to Copy")
}
})

42. HTTP Server (Vert.x Web)
1. Vert.x Web is a great fit for writing RESTful HTTP micro-services.
2. Key Features:- Routing, Regular expression pattern matching for paths,
Extraction of parameter from path, Content Negotiation, Request Body
Handling, Body Size Limits, Cookie parsing, Multipart Form, Session, Error
Page Handler, Basic Authentication, Redirect based Authentication,
User/Role/Permission authorisation, Favicon handling, Templates
(Thymeleaf, Response Time Handler)
3. compile 'io.vertx:vertx-web:3.5.0'
4. A Router is one of the core concept of Ver.x Web. It can maintain 0 to n
Routes.
5. A router take HTTP request and finds the first matching route for that request,
and passes the request to that route.
6. When Vert.x Web decides to route a request to a matching route, it calls the
handler of the route passing in an instance of RoutingContext.

43. 7. If you don’t end the response in your handler, you should call next so another
matching route can handle the request.
8. Handling
a. Routing by exact path
b. Routing with path that begins with something
c. Capturing Path parameter
d. Routing with Regular Expression.
e. Capturing path parameter with regular expression
f. Routing by HTTP Method
For more info

44. Code for simple http server
def server = vertx.createHttpServer()
server.requestHandler({ request ->
// This handler gets called for each request that arrives on the server
def response = request.response()
response.putHeader("content-type", "text/plain")
// Write to the response and end it
response.end("Hello World!")
})
server.listen(8080)

45. Vert.x JDBC Client
1. The client API is represented with the interface JDBCClient.
2. compile 'io.vertx:vertx-jdbc-client:3.5.0'
3. Creating the Client
a. Using default shared data source
b. Specifying a data source name
c. Creating a client with a non shared data source
d. Specifying a data source.
For more info

46. JDBC Demo
def client = JDBCClient.createShared(vertx, config, "MyDataSource")
client.getConnection({ res ->
if (res.succeeded()) {
def connection = res.result()
connection.query("SELECT * FROM some_table", { res2 ->
if (res2.succeeded()) {
def rs = res2.result()
// Do something with results
}
})
} else {
// Failed to get connection - deal with it
}
})

47. Vert.x Mail Client
1. Vert.x client for sending SMTP emails via a local mail server or by
external mail server.
2. compile 'io.vertx:vertx-mail-client:3.5.0'
3. Mail can be sent by creating a client that opens SMTP connections from
Local JVM
For more info

48. Mail Client Demo
def config = [:]
def mailClient = MailClient.createShared(vertx, config, "exampleclient")
def message = [:]
message.from = "user@example.com (Example User)"
message.to = "recipient@example.org"
message.cc = "Another User <another@example.net>"
message.text = "this is the plain message text"
message.html = "this is html text <a href="http://vertx.io">vertx.io</a>"
mailClient.sendMail(message, { result ->
if (result.succeeded()) {
println(result.result())
} else {
result.cause().printStackTrace()
}
})

49. Service Discovery
1. In order to communicate with another peer, a microservice needs to know its
address.
2. We hard coded the addresses (eventbus address, URLs, location details) etc,
but this solution does not enable mobility.
3. Location transparency can be addressed by a pattern called service
discovery.
4. Each microservice should announce (how to be invoked, characteristics,
location, metadata, securities and policies), this announcement are stored in
service discovery infrastructure known as service registry.
5. Two types of patterns can be used to consume services.
a. Client Side Server Discovery
b. Server Side Server Discovery

52. Vert.x Service Discovery
1. Vert.x provides an extensible service discovery mechanism, we can use
client-side or server-side service discovery using the same API.
2. It uses a distributed data structure shared on the Vert.x cluster.

54. Vertx in action

57. References
1. Guide for Java Devs
2. Groovy Doc
3. Node.js vs Vert.x
4. Vert.x Simple Tutorial
5. Vert.x Implementation
6. Vert.x Study Materials