ciao!

cerco si spiegarvi il problema con un esempio semplice.
quindi non ho messo i vari controlli su eventuali errori, perchè so che in questo caso errori di connessione non ci stanno, ecc...

sostanzialmente dovrei ottenere un json del genere da un db, collegandomi con vertx.:
codice:
{
    "data": [
        {
            "nome": "Dance",
            "canzoni": [
                {
                    "titolo": "titolo1"
                },
                {
                    "titolo": "titolo1"
                }
            ]
        },
        {
            "nome": "Straniera",
            "canzoni": [
                {
                    "titolo": "titolo3"
                },
                {
                    "titolo": "titolo4"
                }
            ]
        }
    ]
}
al momento ottengo questo:
codice:
{
    "data": [
        {
            "nome": "Dance",
            "canzoni": null
        },
        {
            "nome": "Straniera",
            "canzoni": null
        }
    ]
}
il mio codice è questo:
codice:
package com.vertx.test_vertx;


import io.vertx.core.AbstractVerticle;
import io.vertx.core.Promise;
import io.vertx.core.http.HttpServerResponse;
import io.vertx.core.json.Json;
import io.vertx.core.json.JsonObject;
import io.vertx.ext.web.Router;
import io.vertx.mysqlclient.MySQLConnectOptions;
import io.vertx.mysqlclient.MySQLPool;
import io.vertx.sqlclient.PoolOptions;
import io.vertx.sqlclient.Row;
import io.vertx.sqlclient.RowSet;


import java.util.ArrayList;
import java.util.List;


public class MainVerticle extends AbstractVerticle {


  private MySQLPool getClient() {
    MySQLConnectOptions connectOptions = new MySQLConnectOptions()
      .................;


    PoolOptions poolOptions = new PoolOptions().setMaxSize(5);
    return MySQLPool.pool(vertx, connectOptions, poolOptions);
  }


  @Override
  public void start(Promise<Void> startPromise) {
    Router router = Router.router(vertx);


    router.route("/").handler(routingContext -> {
      HttpServerResponse response = routingContext.response();


      getClient()
        .query("SELECT DISTINCT canzone_genere AS nome FROM canzoni")
        .execute(ar -> {
          RowSet<Row> rowSet = ar.result();
          List<Genere> list = new ArrayList<>();


          for (Row row : rowSet) {
            JsonObject jsonObject = row.toJson();
            Genere genere = jsonObject.mapTo(Genere.class);


            getClient()
              .query("SELECT canzone_titolo AS titolo FROM canzoni WHERE canzone_genere = '" + genere.nome + "'")
              .execute(ar2 -> {
                RowSet<Row> rowSet2 = ar2.result();
                List<Canzone> list2 = new ArrayList<>();


                for (Row row2 : rowSet2) {
                  JsonObject jsonObject2 = row2.toJson();
                  Canzone canzone = jsonObject2.mapTo(Canzone.class);
                  list2.add(canzone);


                  genere.canzoni = list2;
                }
              });


            list.add(genere);
          }


          JsonObject jsonObject = new JsonObject();
          jsonObject.put("data", list);


          response
            .putHeader("content-type", "application/json; charset=utf-8")
            .end(Json.encodePrettily(jsonObject));
        });
    });


    vertx.createHttpServer()
      .requestHandler(router)
      .listen(8888, http -> {
        if (http.succeeded()) {
          startPromise.complete();
          System.out.println("In ascolto su http://localhost:8888/");
        } else {
          startPromise.fail(http.cause());
        }
      });


  }


}
vorrei capire due cose:
1) se la strada che ho scelto per ottenere i vari "sotto-records" è corretta
2) se si -> dove sbaglio?
3) se no -> se per favore potete indicarmi una strada migliore!