ALLA SCOPERTA DI VERT.X - PARTE 2

Nel precedente articolo abbiamo introdotto Vert.x e visto come creare una semplice API REST. In questa seconda parte entriamo più nel dettaglio di alcuni concetti fondamentali del framework, mostrando esempi pratici di utilizzo dei Verticles e dell’Event Bus, elementi chiave dell’architettura reattiva di Vert.x.

Verticles

I Verticles rappresentano le unità fondamentali di esecuzione in Vert.x. Un verticle è una classe che estende AbstractVerticle e contiene la logica dell’applicazione. Ogni verticle viene eseguito all’interno di un event loop, garantendo un modello di programmazione non bloccante e thread-safe senza l’uso esplicito di lock o sincronizzazioni.

Un semplice esempio di verticle è il seguente:

import io.vertx.core.AbstractVerticle;

public class HelloVerticle extends AbstractVerticle {

  @Override
  public void start() {
    vertx.createHttpServer()
      .requestHandler(req -> req.response().end("Hello from Verticle!"))
      .listen(8080);
  }
}

Il verticle può essere deployato tramite il metodo deployVerticle:

Vertx vertx = Vertx.vertx();
vertx.deployVerticle(new HelloVerticle());

Questo approccio consente di suddividere l’applicazione in componenti indipendenti, facilmente scalabili e manutenibili.

Event Bus

Uno dei componenti più potenti di Vert.x è l’Event Bus, un sistema di messaggistica leggero che consente la comunicazione tra verticles in modo asincrono. L’Event Bus supporta tre modalità principali:

• Point-to-point

• Publish/Subscribe

• Request/Reply

Vediamo un esempio semplice di comunicazione tra due verticles.

Verticle Producer:

import io.vertx.core.AbstractVerticle;

public class ProducerVerticle extends AbstractVerticle {

  @Override
  public void start() {
    vertx.setPeriodic(1000, id -> {
      vertx.eventBus().send("example.address", "Hello Event Bus!");
    });
  }
}

Verticle Consumer:

import io.vertx.core.AbstractVerticle;

public class ConsumerVerticle extends AbstractVerticle {

  @Override
  public void start() {
    vertx.eventBus().consumer("example.address", message -> {
      System.out.println("Messaggio ricevuto: " + message.body());
    });
  }
}

In questo esempio, i due verticles comunicano tramite l’indirizzo "example.address" senza conoscere direttamente l’uno l’esistenza dell’altro, favorendo un forte disaccoppiamento.

Configurazione e gestione asincrona

Vert.x fornisce diversi strumenti per la gestione della configurazione, come il Config Retriever, che permette di caricare configurazioni da file JSON, YAML, variabili d’ambiente o servizi esterni. Inoltre, tutte le operazioni I/O (database, filesystem, chiamate HTTP) sono pensate per essere eseguite in modo asincrono, evitando il blocco dei thread.

Client HTTP e comunicazione tra servizi

Per la comunicazione tra microservizi, Vert.x mette a disposizione il WebClient, un client HTTP reattivo e non bloccante:

WebClient client = WebClient.create(vertx);

client.get(8080, "localhost", "/hello")
  .send(ar -> {
    if (ar.succeeded()) {
      System.out.println("Risposta: " + ar.result().bodyAsString());
    }
  });

Questo rende Vert.x particolarmente adatto allo sviluppo di architetture a microservizi e sistemi distribuiti.

Conclusione

In questa seconda parte abbiamo approfondito alcuni concetti fondamentali di Vert.x, come i verticles e l’event bus, mostrando come costruire applicazioni modulari, reattive e altamente scalabili. Nei prossimi articoli potremo esplorare argomenti più avanzati come la persistenza dei dati, l’integrazione con database reattivi e il clustering di Vert.x per applicazioni distribuite.

Risorse utili:

• Alla scoperta di Vert.x - parte 1
• Risorse didattiche su programmazione e ingegneria del software
• Github progetto Vert.x