---

Vert.x学习笔记

---

---

Vert.x 中的 Future 接口 是异步编程的核心组件，用于表示一个可能尚未完成的操作结果，并支持结果回调、状态查询和组合操作。以下是其核心功能与设计逻辑的详细解析：

一、核心功能

1. 异步结果表示

   • Future 是一个占位符，表示异步操作的结果（成功或失败）。
   • 通过 result() 获取成功结果，cause() 获取失败异常。
   • 提供 succeeded() 和 failed() 方法快速判断状态。

2. 回调机制

   • onComplete(Handler<AsyncResult<T>> handler)
     注册回调，操作完成时触发，无论成功或失败。
   • onSuccess(Handler<T> handler)
     仅操作成功时触发，处理结果。
   • onFailure(Handler<Throwable> handler)
     仅操作失败时触发，处理异常。

3. 结果设置

   • complete(T result)
     标记操作成功，并设置结果。
   • fail(Throwable cause)
     标记操作失败，并设置异常。
   • tryComplete(T result) 和 tryFail(Throwable cause)
     尝试设置结果或异常，若已设置则返回 false。

4. 状态查询

   • isComplete()
     检查操作是否完成（无论成功或失败）。

二、组合操作

Future 支持通过组合操作协调多个异步任务，简化复杂逻辑：

1. compose(Function<T, Future<U>> mapper)

   • 顺序执行多个异步操作，前一个操作的结果作为下一个的输入。
   • 若任一操作失败，最终 Future 标记为失败。
   • 示例：

     Future<String> future1 = Future.future();
     Future<Integer> future2 = future1.compose(result -> {
         return Future.succeededFuture(result.length());
     });
     

2. map(Function<T, U> mapper)

   • 转换操作结果类型，不改变 Future 的完成状态。
   • 示例：

     Future<String> future = Future.succeededFuture("hello");
     Future<Integer> mappedFuture = future.map(String::length);
     

3. CompositeFuture 组合

   • all(List<Future<?>> futures)
     所有 Future 成功时，返回成功的 CompositeFuture；任一失败则返回失败。
   • any(List<Future<?>> futures)
     任一 Future 成功时，返回成功的 CompositeFuture；全部失败则返回失败。
   • join(List<Future<?>> futures)
     等待所有 Future 完成，无论成功或失败。
   • 示例：

     Future<String> future1 = Future.future();
     Future<Integer> future2 = Future.future();
     CompositeFuture.all(future1, future2).onComplete(ar -> {
         if (ar.succeeded()) {
             System.out.println("All futures succeeded");
         }
     });
     

三、线程安全与实现

• FutureImpl 是 Future 的默认实现，通过 synchronized 保证线程安全。
• 关键逻辑：
  • 设置回调时检查操作是否已完成，若已完成则立即触发回调。
  • 完成操作时检查是否已设置回调，若已设置则触发回调。

四、与 Promise 的关系

• Promise 是 Future 的子接口，提供写入端（设置结果或异常）。
• Future 是读取端（获取结果或状态）。
• 典型模式：

  Promise<String> promise = Promise.promise();
  Future<String> future = promise.future();
  future.onComplete(ar -> {
      if (ar.succeeded()) {
          System.out.println("Result: " + ar.result());
      }
  });
  promise.complete("Done"); // 设置结果，触发回调
  

五、使用场景

1. 异步任务协调
   • 合并多个异步操作的结果（如并行查询数据库）。
2. 错误处理
   • 通过 onFailure 集中处理异常，避免嵌套回调。
3. 流式编程
   • 结合 compose 和 map 实现链式调用，提升可读性。

六、示例代码

// 创建 Future
Future<String> future = Future.future();

// 设置回调
future.onComplete(ar -> {
    if (ar.succeeded()) {
        System.out.println("Result: " + ar.result());
    } else {
        System.out.println("Error: " + ar.cause().getMessage());
    }
});

// 模拟异步操作
vertx.setTimer(1000, tid -> {
    future.complete("Success"); // 或 future.fail(new RuntimeException("Failed"));
});

七、方法列表

在 Vert.x 中，Future 接口是异步编程的核心组件，它扩展了 AsyncResult 接口，提供了丰富的功能来处理异步操作的结果。以下是 Future 接口的主要方法及其功能：

状态检查与结果获取

1. isComplete()
   检查异步操作是否完成（无论成功或失败）。

2. succeeded()
   检查异步操作是否成功完成。

3. failed()
   检查异步操作是否失败。

4. result()
   获取异步操作的成功结果。若操作失败，调用此方法会抛出异常。

5. cause()
   获取异步操作失败的异常。若操作成功，调用此方法会抛出异常。

结果设置

1. complete(T result)
   标记异步操作成功，并设置结果。

2. complete()
   标记异步操作成功，但没有设置具体结果（结果为 null）。

3. fail(Throwable cause)
   标记异步操作失败，并设置失败原因。

4. fail(String failureMessage)
   标记异步操作失败，并设置失败消息（内部会创建一个 Throwable 对象）。

5. tryComplete(T result)
   尝试设置异步操作的成功结果。若操作已完成，则返回 false；否则设置结果并返回 true。

6. tryComplete()
   尝试标记异步操作成功，但没有设置具体结果。若操作已完成，则返回 false；否则标记成功并返回 true。

7. tryFail(Throwable cause)
   尝试设置异步操作的失败原因。若操作已完成，则返回 false；否则设置失败原因并返回 true。

8. tryFail(String failureMessage)
   尝试标记异步操作失败，并设置失败消息。若操作已完成，则返回 false；否则标记失败并返回 true。

回调与监听

1. onComplete(Handler<AsyncResult<T>> handler)
   注册一个回调，当异步操作完成时（无论成功或失败）触发。

2. onSuccess(Handler<T> handler)
   注册一个回调，仅当异步操作成功时触发，处理成功结果。

3. onFailure(Handler<Throwable> handler)
   注册一个回调，仅当异步操作失败时触发，处理失败异常。

组合操作

1. compose(Function<T, Future<U>> mapper)
   顺序组合多个异步操作。前一个操作的结果作为下一个操作的输入。若任一操作失败，最终 Future 标记为失败。

2. map(Function<T, U> mapper)
   转换异步操作的结果类型。不改变 Future 的完成状态。

3. flatMap(Function<T, Future<U>> mapper)
   与 compose 类似，但通常用于更复杂的转换场景。

静态工厂方法

1. Future.future()
   创建一个未完成的 Future 对象。

2. Future.succeededFuture()
   创建一个已成功完成的 Future 对象，结果为 null。

3. Future.succeededFuture(T result)
   创建一个已成功完成的 Future 对象，并设置结果。

4. Future.failedFuture(Throwable cause)
   创建一个已失败的 Future 对象，并设置失败原因。

5. Future.failedFuture(String failureMessage)
   创建一个已失败的 Future 对象，并设置失败消息。

组合 Future 工具

CompositeFuture 类提供了多个 Future 的组合操作：

1. CompositeFuture.all(List<? extends Future<?>> futures)
   等待所有 Future 成功完成。若任一失败，则返回失败的 CompositeFuture。

2. CompositeFuture.any(List<? extends Future<?>> futures)
   等待任一 Future 成功完成。若全部失败，则返回失败的 CompositeFuture。

3. CompositeFuture.join(List<? extends Future<?>> futures)
   等待所有 Future 完成（无论成功或失败）。

总结

Vert.x 的 Future 接口通过回调机制、组合操作和线程安全设计，为异步编程提供了简洁而强大的工具。其与 Promise 的协作模式，进一步简化了结果传递和错误处理，是构建高性能、可维护异步应用的关键组件。

---

Vert.x学习笔记-什么是Handler

spring中的@EnableAutoConfiguration注解详解

Vert.x学习笔记-什么是EventLoop