IMPORTANT: These examples use the RX Java 2 API. If you are interested by RX Java 1, check the rxjava-1-examples
module.
Here you will find examples demonstrating Vert.x RxJava2 extension in action.
Vert.x RxJava 2 extension provides Rxified version of the Vert.x APIs. Please consult the Vert.x RxJava manual for detailed documentation on Vert.x core.
These examples shows the Rxified HTTP api.
A simple web client.
The client creates an Single<HttpRequest<String>> and then subscribe multiple times to the single to send the request.
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.
This example demonstrates how an RxJava Flowable source can be sent real-time to the browser
via a SockJSSocket.
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.
These examples shows the Rxified HTTP api.
A simple http server and client.
The server uses an Flowable<HttpServerRequest> to serve request:
The client uses an Flowable<HttpClientRequest and applies flatMap to get a Flowable<Buffer>
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
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.
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.
The event bus provides a natural fit with the Rx api.
A reinterpreation of the core publish / subscribe example with the subscriber using the Rx api.
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.
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.
Vertx for RxJava provides schedulers for performing delayed, periodic actions.
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.
此处可能存在不合适展示的内容,页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容,可点击提交进行申诉,我们将尽快为您处理。