Vert.x for reactive programming in Red Hat OpenShift Application Runtimes

Have you read the announcement of the alpha release of Red Hat OpenShift Application Runtimes (RHOAR)? We also posted an introduction to the component in RHOAR earlier.

One of the curated runtimes included with RHOAR is Vert.x. Vert.x is an open source toolkit for building reactive, high concurrency, low latency applications and is well-suited for supporting the asynchronous communications required by a microservices architecture.

Vert.x is distributed as a toolkit for building reactive applications on the Java virtual machine (JVM). There are a three important points in this description: toolkit, reactive and “on the JVM.”

First, Vert.x is a toolkit. Meaning, Vert.x is not an application server, a container nor a framework. It’s not a JavaScript library either. Vert.x is a plain old jar file, so a Vert.x application is an application that uses this jar file. Vert.x does not define a packaging model, all Vert.x components are plain boring jar files. How does this impact you and your application? Let’s imagine you are using a build tool such as Maven or Gradle, to make your application a Vert.x application just add the vertx-core dependency. Wanna use another Vert.x components, just add it as a dependency. It’s simple, burden-less. Starting the application is a simple class with the public static void main(String[] args) entry point. No specific IDE or plugin to install to start using Vert.x. Therefore, to use the awesomeness provided by Vert.x, you just need to use it in your code.

Second, Vert.x is reactive. It is specifically made to build reactive applications, or more appropriately, systems. Reactive systems has been defined in the Reactive Manifesto. Although, the manifesto is not a long document to read, we can reduce it to the following 4 bullet points:

  • Responsive: a reactive system needs to handle requests in a reasonable time (I let you define reasonable).
  • Resilient: a reactive system must stay responsive in the face of failures (crash, timeout, 500 errors…​), so it must be designed for failures and deal with them appropriately.
  • Elastic: a reactive system must stay responsive under various loads. As a consequence, it must scale up and down, and be able to handle the load with minimal resources.
  • Message driven: components from a reactive system interacts using asynchronous message-passing.

The third point is that Vert.x applications run “on the JVM” (Java Virtual Machine 8+). This means Vert.x applications can be developed using any language that runs on the JVM. Including Java(of course), Groovy, Ceylon, Ruby, JavaScript, Kotlin and Scala. We can even mix and match any combination of all these languages. The polyglot nature of Vert.x application allows you use the most appropriate language for the task.

Now this article could dive deeper and deeper into what Vert.x is, but I have a better idea. Let’s provide a link to the newly released book titled “Building Reactive Microservices in Java” instead. A book you can download for free compliments of the Red Hat Developer Program! It is a great introduction to using Vert.x and designing asynchronous and event-based applications.

If a new eBook is not for you, a Vert.x cheat sheet is also available on the Red Hat Developer Program web site. It provides step by step details to let you create an application using Vert.x.

I encourage you to get started with reactive programming, or expand your understanding of such using Vert.x Will you take up the challenge? Let us know via comment and tweets. We want to hear you #RHOAR!

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s