如何在Vert.x中实现同步事务及同步获取数据库表响应？

嘿，我来帮你梳理下在Vert.x里怎么实现同步获取数据库响应和事务处理～

首先得说明下：Vert.x本身是异步非阻塞的设计，但我们可以通过Future和awaitAPI来写出同步风格的代码，同时避开阻塞事件循环的坑。下面分步骤给你讲具体实现：

1. 先准备好依赖 #

如果用JDBC客户端操作数据库，需要在项目里引入Vert.x JDBC客户端和对应数据库的驱动，比如PostgreSQL的依赖：

<!-- Vert.x JDBC客户端 -->
<dependency>
  <groupId>io.vertx</groupId>
  <artifactId>vertx-jdbc-client</artifactId>
  <version>4.5.1</version>
</dependency>
<!-- PostgreSQL驱动 -->
<dependency>
  <groupId>org.postgresql</groupId>
  <artifactId>postgresql</artifactId>
  <version>42.6.0</version>
</dependency>

2. 用Future+await实现同步响应 #

Vert.x的异步操作都会返回Future对象，我们可以用await()方法阻塞当前线程直到结果返回——但绝对不能在事件循环线程里这么做，必须把同步逻辑放到worker线程或者虚拟线程（Java 19+）里执行。

举个同步查询用户信息的例子：

import io.vertx.core.AbstractVerticle;
import io.vertx.core.Future;
import io.vertx.core.Promise;
import io.vertx.jdbcclient.JDBCPool;
import io.vertx.sqlclient.Row;
import io.vertx.sqlclient.RowSet;
import io.vertx.core.json.JsonObject;

public class SyncDbVerticle extends AbstractVerticle {

  private JDBCPool jdbcPool;

  @Override
  public void start() {
    // 初始化JDBC连接池
    jdbcPool = JDBCPool.pool(vertx, new JsonObject()
      .put("url", "jdbc:postgresql://localhost:5432/mydb")
      .put("driver_class", "org.postgresql.Driver")
      .put("user", "postgres")
      .put("password", "your_password")
      .put("max_pool_size", 10));

    // 用executeBlocking把同步逻辑放到worker线程执行
    vertx.executeBlocking(this::fetchUserSync, false, res -> {
      if (res.succeeded()) {
        Row user = res.result().iterator().next();
        System.out.println("查询到的用户：" + user.toJson());
      } else {
        res.cause().printStackTrace();
      }
    });
  }

  private Future<RowSet<Row>> fetchUserSync(Promise<RowSet<Row>> promise) {
    try {
      // 用await同步获取查询结果
      RowSet<Row> result = jdbcPool.query("SELECT * FROM users WHERE id = 1")
        .execute()
        .await();
      promise.complete(result);
    } catch (Exception e) {
      promise.fail("查询失败：" + e.getMessage());
    }
    return promise.future();
  }
}

3. 实现同步事务处理 #

Vert.x的JDBC客户端支持事务，我们同样可以用await()把异步的事务流程转换成同步风格：

private Future<Void> performSyncTransaction(Promise<Void> promise) {
  try {
    // 同步获取数据库连接
    var connection = jdbcPool.getConnection().await();
    try {
      // 开启事务
      connection.begin().await();

      // 执行第一个操作：插入订单
      connection.query("INSERT INTO orders(user_id, amount) VALUES (1, 150)")
        .execute()
        .await();

      // 执行第二个操作：扣减用户余额
      connection.query("UPDATE users SET balance = balance - 150 WHERE id = 1")
        .execute()
        .await();

      // 提交事务
      connection.commit().await();
      promise.complete();
      System.out.println("事务执行成功");
    } catch (Exception e) {
      // 出错则回滚事务
      connection.rollback().await();
      promise.fail("事务执行失败：" + e.getMessage());
    } finally {
      // 释放连接
      connection.close();
    }
  } catch (Exception e) {
    promise.fail("获取数据库连接失败：" + e.getMessage());
  }
  return promise.future();
}

几个关键注意点 #

• 禁止在事件循环线程用await：事件循环是Vert.x处理请求的核心，阻塞它会导致整个应用响应变慢甚至卡死，必须用executeBlocking或者worker verticle承载同步逻辑。
• Java 19+可以用虚拟线程：虚拟线程比传统worker线程更轻量，不需要executeBlocking，直接在虚拟线程里调用await即可：

  vertx.createVirtualThreadWorkerExecutor().execute(() -> {
    try {
      var result = jdbcPool.query("SELECT * FROM users WHERE id = 1").execute().await();
      // 处理结果
    } catch (Exception e) {
      e.printStackTrace();
    }
  });
  

• Reactive客户端也支持：如果用Vert.x Reactive PostgreSQL/MySQL客户端，同样可以用await实现同步逻辑，API用法和JDBC客户端类似。

这样就能在Vert.x里实现你需要的同步响应和事务处理啦～

内容的提问来源于stack exchange，提问作者Mateus Galasso