Vert.x RxJava2 extension examples

A simple web client.

The client creates an Single<HttpRequest<String>> and then subscribe multiple times to the single to send the request.

RxJava 2 simple web client

A variation of the simple example with two client requests mapped to an Single<JsonObject> and then zipped in a single json object.

The main interest is to get the final result when the two responses are delivered.

RxJava 2 zip web client

The web client json response is unmarshalled to a Java object using the web client unmarshalling features.

RxJava 2 unmarshalling web client

This example demonstrates how an RxJava Flowable source can be sent real-time to the browser via a SockJSSocket.

RxJava 2 real-time web

SocksJS gives a WebSocket-like API in client side JavaScript even if the browser or network doesn’t support WebSockets.

This is ideal for so-called real-time web applications where you want quick, responsive communication between server and client and you’re probably rendering the user interface on the client side.

Run the server either in your IDE or on the command line, then open your browser and hit link:http://localhost:8080

This serves the index page which contains some JavaScript which opens an event bus connection to the server.

When the connection is open, a SockJS connection is opened on the /news-feed uri. When data arrives in the handler the script just uses some simple JQuery to write the message to the page.

On the server side, in the server when a SockJS connection arrives, we subscribe to an Flowable<String> (that is created from the EventBus, but it would be another source of data) and send to the browser the observed items.

When you get the index page in your browser you should see it update every second as it receives a message.

A simple http server and client.

The server uses an Flowable<HttpServerRequest> to serve request:

RxJava 2 simple HTTP server

The client uses an Flowable<HttpClientRequest and applies flatMap to get a Flowable<Buffer>

RxJava 2 simple HTTP client

Same as simple example however the client applies several operations on this flowable to end with the http client response:

• flatMap transforms the Flowable<HttpClientResponse> → Flowable<Buffer>

• reduce merge all response buffers in a single buffer

• map transform the buffer to a string

• subscribe delivers the response content

RxJava 2 reduce HTTP client

A variation of the simple example with two client requests mapped to an Flowable<JsonObject> and then zipped in a single json object.

The main interest is to get the final result when the two responses are delivered.

RxJava 2 zip HTTP client

The http client json response is unmarshalled to a Java object: the RxHelper.unmarshaller static method creates an Rx operator applied to the response via the lift.

RxJava 2 unmarshalling HTTP client

The http server which uses Vert.x-Web router and defines a "drop" strategy when the server is overloaded (backpressure).

RxJava 2 backpressure HTTP server

A reinterpreation of the core publish / subscribe example with the subscriber using the Rx api.

RxJava 2 event bus pubsub receiver RxJava 2 event bus pubsub sender

An example of sending, receiving and replying to messages using the Rx api.

RxJava 2 simple ping-pong

The example Sender sends two messages over the event bus and wait for replies, the zip operation is applied to deliver a single reply when the two replies are received.

RxJava 2 zipreplies eventbus receiver RxJava 2 zipreplies eventbus sender

An example showing the SQL client Rxified api, after the client connected to the database, it chains operations via the flatMap operation and then subscribes to the result.

RxJava 2 SQL client

An example showing an Rxified SQL client api to handle simplified transaction that commits if all succeeded or rollback with exception propagation to the caller in case of anyone failed.

RxJava SQL transaction

An example showing the Mongo Service Rxified api, after the client connected to Mongo, it chains createCollection and insert via flatMap and then subscribes to the result to do a query in the onComplete.

RxJava 2 Mongo client

RxJava timer can use Vertx scheduler for scheduling actions on the event loop, this example shows a 1 second periodic flowable scheduled on Vertx event loop.

Periodic scheduled action

When an Flowable operation is blocking, a blocking Vertx scheduler can be used to perform the action, this examples shows how blocking operation can be scheduled on Vert.x

Blocking scheduled action Blocking scheduled action

This example combines RecordParser and RxJava2 for a TCP client/server exchange. When the client sends a name to the server, it replies with a greeting. Names and greetings are line-separated.

Greeting client Greeting Server

This example shows you how to make your service proxy Rxified with RxJava2.

Service Proxy interface Service Provider Verticle Service Consumer Verticle