Eclipse Vert.x

Vert.x es un framework políglota que se ejecuta en la JVM. Permite crear microservicios basados en el paradigma de programación reactiva.

¿Qué es la programación reactiva?

Se trata de un paradigma que se centra en los flujos de datos y la propagación del cambio.

Se enfoca en reaccionar a cambios en el flujo de datos de forma asíncrona y eficiente. En lugar de ejecutar instrucciones de manera secuencial, los sistemas reactivos responden automáticamente cuando ocurre un evento, como una nueva entrada de datos o una actualización en tiempo real,

Es como suscribirse a un canal de noticias: no sabes cuándo llegarán nuevos artículos, pero cuando lo hagan, recibirás una notificación instantánea. Aborda las ineficiencias de los mecanismos de sondeo tradicionales, que buscan constantemente actualizaciones, incluso cuando no las hay. Esto puede generar un desperdicio de recursos y tráfico de red innecesario.

Al suscribirse a un flujo de datos, la programación reactiva garantiza que su código solo reciba notificaciones cuando haya nuevos datos disponibles, lo que mejora significativamente el rendimiento y la utilización de recursos.

Vert.x es similar a Node JS y se centra en los microservicios.

Es como una caja de herramientas mágica para construir aplicaciones que reaccionan rápido, como cuando juegas y el videojuego responde al instante cuando presionas un botón.

Además podremos usar estos lenguajes (ya que no es exclusivo para Java):

• Java, obviamente. 
• Kotlin. 
• Javascript. 
• Python. 
• Groovy. 
• Ruby. 
• Scala. 
• Clojure. 
• Y mezclar varios en una sola aplicación.

Veamos un ejemplo en Kotlin:

class Server : VerticleBase() {
  override fun start(): Future<*> {
    return vertx.createHttpServer()
      .requestHandler { req ->
        req.response()
          .putHeader("content-type", "text/plain")
          .end("¡Hola, mundo desde Vert.x!")
      }
      .listen(8080)
  }
}

Y en Java:

public class Server extends VerticleBase {
  public Future<?> start() {
    return vertx.createHttpServer()
      .requestHandler(req ->
        req.response()
          .putHeader("content-type", "text/plain")
          .end("¡Hola, mundo desde Vert.x!")
      )
      .listen(8080);
  }
}

Trabajando con Vert.x

Para trabajar con esta herramienta necesitamos:

• JDK en su versión 11 o más actual. 
• Maven 3. 
• Contar con la herramienta curl, HTTPie o cualquier herramienta que permita solicitudes HTTP.

La dependencia que usaremos será: vertx-web

Al generar el proyecto debemos descomprimirlo en algún directorio. La clase principal es:

MainVerticle.java

package com.inforhomex.aprendevertx.holamundo;

import io.vertx.core.Future;
import io.vertx.core.VerticleBase;

public class MainVerticle extends VerticleBase {

  @Override
  public Future<?> start() {
    return vertx.createHttpServer().requestHandler(req -> {
      req.response()
        .putHeader("content-type", "text/plain")
        .end("Hola, mundo desde Vert.x!");
    }).listen(8888).onSuccess(http -> {
      System.out.println("El servidor escucha desde el puerto 8888");
    });
  }
}

Construimos el proyecto con Maven:

$ mvn clean package

Entramos al directorio ``target`` y ejecutamos la aplicación:

$ java -jar holamundo-1.0.0-SNAPSHOT-fat.jar 

Abrimos el navegador en la url de hhtp://localhost:8888/

Salida:

Hola, mundo desde Vert.x! 

¡Hemos creado nuestro primera aplicación con Vert.x!

Concluyendo, al usar Vert.x se espera construir aplicaciones que reaccionan a los cambios, manteniendo tiempos de respuesta rápidos, alta escalabilidad y resiliencia.

Enlaces:

https://vertx.io/
https://www.arquitecturajava.com/introduccion-a-vertx/
https://solutionsarchitecture.medium.com/reactive-programming-in-java-a-simplified-guide-dd24d7f440d4
https://www.reddit.com/r/java/comments/nlzpkq/why_vertx_javas_library_for_reactiveasync/?tl=es-es