Vert.x core examples

Group ID: io.vertx
Artifact ID: vertx-core

This example consists of an echo server verticle which serves TCP connections, and simply echoes back on the connection whatever it receives.

You can run the echo server then run telnet localhost 1234 from a console to connect to it. Type some stuff and see it echoed back to you.

It also contains an echo client, which creates a connection to the server, sends some data and logs out what it receives back. You can use that as an alternative to connecting via telnet.

Java echo server Java echo client

This is the same as the Echo example but using SSL to encrypt connections

Java echo ssl server Java echo ssl client

A very simple HTTP server which always responds with the same response:

Java simple HTTP server

You can run the server then open a browser and point it at http://localhost:8080

And a simple HTTP client which makes a request to the server.

Java simple HTTP client

Like the simple example, but using HTTPS instead of HTTP

Java simple HTTPS server

You can run the server then open a browser and point it at http://localhost:4443

And a simple HTTPS client which makes a request to the server.

Java simple HTTPS client

Connecting to a web server using an proxy. The proxy receives requests and connects to the endpoint server using a socket, then pass all the events between the client and the proxied server.

The Java endpoint server The Java proxy The client

A simple toy HTTP proxy. The proxy receives requests and forwards them to the endpoint server, it also takes responses from the other server and passes them back to the client.

The Java endpoint server The Java proxy The client

This example demonstrates how you can serve static files from disk using a Vert.x http server.

Java static file server example

You can run the server then open a browser and point it at http://localhost:8080

This example demonstrates how you can handle an HTML form on the server.

Java simple form server example

You can run the server then open a browser and point it at http://localhost:8080

This example demonstrates how you can handle file uploads from an HTML form submission.

Java simple form file upload server example

You can run the server then open a browser and point it at http://localhost:8080

This examples demonstrates an HTTP server receiving a request and pumping the request body to a file on disk without ever storing the entire request body fully in memory.

There’s also a client which sends a request to the server and pumps a file from disk to the HTTP request body. The file is uploaded successfully even if the file is very large (GigaBytes).

Java upload server example Java upload client example

A server that illustrates the round robin orchestrated by vert.x when several verticles are opening HTTP servers on the same port:

Server Launcher

HTTP Server Verticle

The GatewayVerticle deploys two instances of the HttpServerVerticle verticle.

You can run the server then open a browser and point it at http://localhost:8080. Requests will be handled by an instance after the other.

The Client illustrates the round robin by periodically requesting the server and displays the response content.

Java simple HTTP client

You can directly launch the HTTPServerVerticle using the vertx run command. Then you can set the number of instance you want:

This example shows a Vert.x HTTP server which handles websockets connections. This example simply echoes back to the client whatever it receives on the websocket.

There’s also a client which connects to the server, sends some data and logs out what it receives.

Java WebSockets server example Java WebSockets client example

Javascript WebSockets client example

You can run the server then open a browser and point it at http://localhost:8080

A very simple HTTP/2 server which always responds with the same response:

Java simple HTTP/2 server

You can run the server then open a browser and point it at http://localhost:8080

And a simple HTTP/2 client which makes a request to the server.

Java simple HTTP client

This example shows HTTP/2 push.

The server pushes script.js along with index.html:

Java HTTP/2 server pushing content

You can run the server then open a browser and point it at http://localhost:8080

And a client sets a push handler to be notified of the incoming server side pushes:

Java HTTP client push aware

Like the simple server but using clear text, also known as h2c, without TLS:

Java simple HTTP/2 server in clear text Java simple HTTP client in clear text

HTTP/2 can be extended with custom frames, this example shows how to write and receive custom frames:

Java HTTP/2 server Java simple HTTP client

This example demonstrates point to point messaging between a receiver and a sender.

The receiver listens on an address on the event bus for incoming messages. When it receives a message it replies to it.

The sender sends a message to that address every second, when it receives a reply it logs it.

Java event bus receiver Java event bus sender

You can run the Java sender and receiver in your IDE or at the command line.

At the command line you should run Sender and Receiver in different consoles using the -cluster flag:

The -cluster flag allows different Vert.x instances on the network to cluster the event bus together into a single event bus.

This example demonstrates publish / subscribe messaging between a receivers and a sender. With pub/sub messaging you can have multiple subscribers who all receive messages from publishers.

A receiver listens on an address on the event bus for incoming messages. When it receives a message it logs it.

The sender sends a message to that address every second, when it receives a reply it logs it.

Java event bus pubsub receiver Java event bus pubsub sender

You can start as many senders or receivers as you like in your IDE or at the command line.

At the command line you should run Sender and Receiver in different consoles using the -cluster flag:

The -cluster flag allows different Vert.x instances on the network to cluster the event bus together into a single event bus.

This example demonstrates how to write custom MessageCodec for send / publish / receive any type of object. It means you can send or receive custom data type objects directly through EventBus as well as primitive types like String.

In this example, there are two type of receivers. The first one is a local type which is deployed from sender, the other one is a cluster-wide type that launched from another instance of cluster. So you can see how MessageCodec works differently on the local EventBus and clustered EventBus.

Java event bus sender Java event bus local receiver Java event bus cluster-wide receiver Java event bus custom message codec

You can start as many senders or receivers as you like in your IDE or at the command line.

At the command line you should run Sender and Receiver in different consoles using the -cluster flag:

The -cluster flag allows different Vert.x instances on the network to cluster the event bus together into a single event bus.

This example demonstrates point to point messaging between a receiver and a sender with a transport level encryption.

The receiver listens on an address on the event bus for incoming messages. When it receives a message it replies to it.

The sender sends a message to that address every second, when it receives a reply it logs it.

Java event bus receiver Java event bus sender

You can run the Java sender and receiver in your IDE or at the command line.

At the command line you should run Sender and Receiver in different consoles using the -cluster flag:

The -cluster flag allows different Vert.x instances on the network to cluster the event bus together into a single event bus. Depending of your configuration you may need to append to both command: ` -cp ../../../../../../../resources` in order to configure the cluster.

This example shows a verticle deploying another verticle in several different ways including:

• Deploying without waiting for it to deploy

• Deploying and waiting for it to deploy

• Passing configuration to another verticle during deploy

• Deploying more than one instance

• Deploying as a worker verticle

• Undeploying a verticle deployment explicitly

Java verticle deployment example The verticle that will be deployed

This example shows a verticle deploying another language verticle that depends on a NPM module:

Java verticle deployment example The verticle that will be deployed link:src/main/resources/package.json

This is similar to the deployment example, but it shows how the start and stop of a verticle can be asynchronous. This is useful if the verticle has some startup or cleanup to do that takes some time, and we wish to avoid blocking the an event loop.

Java verticle deployment example The verticle that will be deployed

A simple example illustrating how worker verticle can be created and the thread switches when interacting with them. The worker verticle is not System.out.println(Thread.currentThread()); ed in the event loop and so can do blocking operations.

Java verticle deploying the worker verticle and interacting with it Java verticle deployed as a worker verticle

vertx run io.vertx.example.core.ha.Server -ha -cp target/classes

Happily served by 97284@Macintosh.local

vertx bare -cp target/classes/

> jps | grep Launcher
97297 Launcher
97284 Launcher
> kill -9 97284

Happily served by 97297@Macintosh.local

Length  : uInt32
Type    : byte ['O' for JsonObject | 'A' for JsonArray | 'B' for Buffer]
Payload : Buffer