Vert.x学习笔记-Vert.x中的Future接口详解

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->{returnFuture.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实现链式调用，提升可读性。

六、示例代码

// 创建 FutureFuture<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