1. Creating a Verticle Component

package jdbcConnection;

import io.vertx.core.AbstractVerticle;
import io.vertx.core.AsyncResult;
import io.vertx.core.Future;
import io.vertx.core.Handler;
import io.vertx.core.json.JsonArray;
import io.vertx.core.json.JsonObject;
import io.vertx.ext.asyncsql.MySQLClient;
import io.vertx.ext.sql.SQLClient;
import io.vertx.ext.sql.SQLConnection;
import io.vertx.ext.sql.SQLRowStream;

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

public class MyFirstVerticle extends AbstractVerticle {

    private String sql = "SELECT id, name FROM t_school WHERE id IN (";
    private SQLClient sqlClient;

    @Override
    public void start(Future<Void> startFuture) throws Exception {
        JsonObject config = new JsonObject();
        config.put("username", "root")
              .put("password", "your_password")
              .put("host", "192.168.100.91")
              .put("database", "user");

        sqlClient = MySQLClient.createShared(vertx, config);

        Future<SQLConnection> connFuture = Future.future();
        sqlClient.getConnection(connFuture);

        connFuture.setHandler(connection -> {
            if (connection.succeeded()) {
                SQLConnection conn = connection.result();

                Future<SQLRowStream> streamFuture1 = Future.future();
                Future<List<User>> userFuture = Future.future();
                Future<List<JsonArray>> schoolFuture = Future.future();

                conn.queryStream("SELECT id, name, t_school_id FROM t_user", streamFuture1);

                streamFuture1.compose(sqlRowStream -> {
                    List<User> users = new ArrayList<>();
                    sqlRowStream.handler(jsonArray -> {
                        System.out.println(jsonArray);
                        users.add(new User(jsonArray));
                    });
                    System.out.println("User count: " + users.size());
                    userFuture.complete(users);
                    return userFuture;
                }).compose(users -> {
                    List<JsonArray> schoolList = new ArrayList<>();
                    JsonArray schoolIds = users.parallelStream()
                            .map(User::getSchoolId)
                            .collect(JsonArray::new, JsonArray::add, JsonArray::addAll);

                    String sql2 = sql + Utils.placeholder("?", schoolIds.size(), ", ") + ")";

                    conn.queryStreamWithParams(sql2, schoolIds, schoolResult -> {
                        if (schoolResult.failed()) {
                            schoolResult.cause().printStackTrace();
                            return;
                        }
                        schoolResult.result().handler(jsonArray1 -> {
                            if (jsonArray1 != null && jsonArray1.size() > 0) {
                                schoolList.add(jsonArray1);
                            }
                        });
                        schoolFuture.complete(schoolList);
                    });
                    return schoolFuture;
                });

                schoolFuture.setHandler(schoolList -> {
                    conn.close();
                    if (schoolList.failed()) {
                        schoolList.cause().printStackTrace();
                        return;
                    }
                    System.out.println("--- School Data ---");
                    schoolList.result().forEach(System.out::println);
                });

            } else {
                connection.cause().printStackTrace();
                System.err.println(connection.cause().getMessage());
            }
        });
        startFuture.complete();
    }
}

2. User Class

package jdbcConnection;
import io.vertx.core.json.JsonArray;

public class User {

    private String id;
    private String name;
    private String schoolId;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSchoolId() {
        return schoolId;
    }

    public void setSchoolId(String schoolId) {
        this.schoolId = schoolId;
    }

    public User() {
    }

    public User(String id, String name) {
        this.id = id;
        this.name = name;
    }

    public User(JsonArray jsonArray) {
        this.id = jsonArray.getString(0);
        this.name = jsonArray.getString(1);
        this.schoolId = jsonArray.getString(2);
    }

    @Override
    public String toString() {
        return "User{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", schoolId='" + schoolId + '\'' +
                '}';
    }
}

3. Utils Class

package jdbcConnection;

public class Utils {

    private Utils() {}

    /**
     * Generate placeholders for SQL IN clause.
     * Example: placeholder("?", 5, ",") → "?,?,?,?,?"
     *
     * @param symbol    the placeholder symbol (e.g., "?")
     * @param count     number of placeholders
     * @param delimiter delimiter between placeholders (e.g., ",")
     * @return the joined placeholder string
     */
    public static String placeholder(String symbol, Integer count, String delimiter) {
        String[] parts = new String[count];
        for (int i = 0; i < count; i++) {
            parts[i] = symbol;
        }
        return String.join(delimiter, parts);
    }
}

4. Runnner Class

The runner class is a stendard Vert.x bootstrap class providded officially. For more details, refer to the Vert.x documentation.

// Example runner (simplified)
import io.vertx.core.Vertx;

public class Runner {
    public static void runExample(Class<?> clazz) {
        Vertx.vertx().deployVerticle(clazz.getName());
    }
}