如何在Vert.x Cassandra客户端中规范使用PreparedStatement？

官方示例中CassandraClient.prepare()采用回调式设计，预编译语句仅能在回调内部使用，但实际业务中常需将其作为类成员供外部方法调用。异步初始化的特性会导致外部方法可能在预编译完成前被触发，引发空指针或未就绪问题。以下是几种规范的解决方案：

方案1：基于Vert.x Future API封装（推荐） #

Vert.x原生的Future/Promise更贴合异步编程模型，可将预编译逻辑封装为Future，确保外部方法仅在预编译完成后执行：

public final class MyClass {
    private final CassandraClient client;
    private final Future<PreparedStatement> queryFuture;

    public MyClass(Vertx vertx, CassandraClientOptions options) {
        client = CassandraClient.create(vertx, options);
        // 用Future封装预编译操作，统一处理失败逻辑
        queryFuture = client.prepare("SELECT * FROM my_keyspace.my_table where my_key = ?")
            .onFailure(cause -> {
                System.err.println("预编译查询失败");
                cause.printStackTrace();
            });
    }

    public Future<Foo> foo(String key) {
        // 等待预编译完成后执行查询逻辑
        return queryFuture.compose(preparedStatement -> {
            return client.executeWithFullFetch(preparedStatement.bind(key))
                .map(resultSet -> {
                    // 转换结果为Foo实例
                    return new Foo(resultSet.one());
                });
        });
    }
}

说明：

• queryFuture保存预编译的异步结果，外部方法通过compose串联异步操作，避免空指针风险。
• 对外方法均返回Future，符合Vert.x异步范式，调用方可通过onSuccess/onFailure处理结果或异常。

方案2：延迟初始化+双重检查锁定 #

若需同步风格调用，可采用延迟初始化，仅在首次调用时触发预编译，通过双重检查锁定保证线程安全：

public final class MyClass {
    private final CassandraClient client;
    private volatile PreparedStatement query;

    public MyClass(Vertx vertx, CassandraClientOptions options) {
        client = CassandraClient.create(vertx, options);
    }

    public void foo(String key, Handler<AsyncResult<Foo>> handler) {
        if (query == null) {
            synchronized (this) {
                if (query == null) {
                    client.prepare("SELECT * FROM my_keyspace.my_table where my_key = ?", prepareResult -> {
                        if (prepareResult.succeeded()) {
                            query = prepareResult.result();
                            executeQuery(key, handler);
                        } else {
                            handler.handle(Future.failedFuture(prepareResult.cause()));
                        }
                    });
                    return;
                }
            }
        }
        executeQuery(key, handler);
    }

    private void executeQuery(String key, Handler<AsyncResult<Foo>> handler) {
        client.executeWithFullFetch(query.bind(key))
            .map(resultSet -> new Foo(resultSet.one()))
            .onComplete(handler);
    }
}

说明：

• 首次调用foo()时触发预编译，后续直接复用已初始化的预编译语句。
• volatile保证多线程环境下的变量可见性，双重检查锁定避免重复初始化。

方案3：Verticle启动阶段完成预编译 #

若类属于Verticle组件，可在start()方法中完成预编译，确保服务就绪后再处理请求：

public class MyVerticle extends AbstractVerticle {
    private CassandraClient client;
    private PreparedStatement query;

    @Override
    public void start(Promise<Void> startPromise) {
        CassandraClientOptions options = new CassandraClientOptions();
        client = CassandraClient.create(vertx, options);

        client.prepare("SELECT * FROM my_keyspace.my_table where my_key = ?")
            .onSuccess(preparedStatement -> {
                query = preparedStatement;
                startPromise.complete(); // 预编译完成后标记Verticle启动成功
            })
            .onFailure(cause -> {
                System.err.println("预编译失败，Verticle启动终止");
                startPromise.fail(cause);
            });
    }

    public void foo(String key, Handler<AsyncResult<Foo>> handler) {
        // Verticle启动完成后，query必已初始化
        client.executeWithFullFetch(query.bind(key))
            .map(resultSet -> new Foo(resultSet.one()))
            .onComplete(handler);
    }
}

说明：

• Verticle启动是异步过程，仅当startPromise.complete()调用后，服务才会开始处理请求，此时预编译已完成。
• 适合服务端场景，确保服务就绪状态与预编译完成强绑定。

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