Vert.x Java

An open-source polyglot platform or toolkit is referred to as Vert.x in Java. The Vert.x platform runs on JVM(Java Virtual Machine). We can say that it is an alternative to the JEE. It comes with a different approach in the market to solve the issues such as developing networked and highly concurrent applications. It shares common functionalities among all the supported languages like Java, Ruby, Kotlin, Scala, and JavaScript.

Vert.x is a toolkit, so we can embed it into our standalone Java application. We can use it by instantiating the object of Vert.x and calling the method on it. In toolkit mode, our code control vert.x. It also acts as a platform, so we can set up it using the command line and tell the components to it which want to run.

Installation

The installation of Vert.x is quite simple. It is distributed in a zip file having a bunch of Jar files. We simply unzip the file and add all the JAR files to the classpath of our Java application. After adding all the JAR files, we are ready to use Vert.x in our application.

We can download the zip file from Maven Central or from the Bintray.

Let's start with a new vert.x web project, but before that, we have to make sure that our system has the following things:

JDK 1.8 or higher.
An IDE or text editor.
Maven 3 or higher.
A browser for performing HTTP requests.

In order to create the first web project using Vert.x, we should have to follow the following steps:

1) We go to the https://start.vertx.io/ for creating a new project. We see the screen like as:

2) We choose the version of the Vert.x, which we want to use in our application. We choose language, either Java or Kotlin, as per our interest. We also choose the build from Maven and Gradle. In our case, we use Maven. We fill the Group Id and Artifact Id fields. We also add the Vert.x Web as a dependency. After adding the dependency, we click on the Generate Project button to create the project.

3) When we click on the Generate Project button, it downloads the zip file on our computer. We unzip it into a folder of our choice.

The generated folder contains the maven build descriptor, i.e., pom.xml. The pom.xml is configured to build and run our application. It contains a sample test and verticle using JUnit 5. For enforcing code style, it also contains an editor configuration. At last, for ignoring files, it contains a Git configuration.

4) Now, we will open that Vert.x project in any of the IDE or editor of our choice and navigate to the following path:

The MainVerticle.java class contains a sample verticle that starts an HTTP server. We modify that class to greet whoever performs requests to our server. We change the code as given below:

package com.example.starter;

import io.vertx.core.AbstractVerticle;
import io.vertx.core.MultiMap;
import io.vertx.core.Promise;
import io.vertx.core.json.JsonObject;
import io.vertx.ext.web.Router;

//class to understand the vert.x toolkit
public class MainVerticle extends AbstractVerticle {
	//overriding the abstract method of the AbstractVerticle class
	@Override
	  public void start() throws Exception {
	    // instantiate the object of the Router class to create router
	    Router router = Router.router(vertx);

	    //At every path and HTTP method for all incoming requests mount the handler
	    router.route().handler(context -> {
	      // Find the address of the request by using request(), connection() and remoteAddress() method
	      String address = context.request().connection().remoteAddress().toString();
	      
	      // Find the "name" query parameter from the queryParams() by using get() method
	      MultiMap queryParams = context.queryParams();
	      String name = queryParams.contains("name") ? queryParams.get("name") : "unknown";
	      // write information in JSON format as a response 
	      context.json(
	        new JsonObject()
	          .put("name", name)
	          .put("address", address)
	          .put("message", "Hello " + name + " connected from " + address)
	      );
	    });

	    // use createHttpServer() method to create Http server
	    vertx.createHttpServer()
	      // use router to handle each upcoming request
	      .requestHandler(router)
	      // use listen() method to start listening
	      .listen(8888)
	      // using actualPort() method of server to print port
	      .onSuccess(server ->
	        System.out.println(
	          "HTTP server started on port " + server.actualPort()
	        )
	      );
	  }
	}

The above code will create a vert.x web router and start an HTTP server on port 8888. It returns a JSON object on each request. The JSON object contains the query parameter names, the address of the request, and a greeting message.

5) Now, we run our Vert.x project, and before running the project, we have to make sure that the Maven is installed in our system. We open the terminal and run the following command to check whether the Maven is installed in our system or not.