摘要：本文章是藍圖系列的第一篇教程。是事件驅(qū)動的，同時也是非阻塞的。是一組負責分發(fā)和處理事件的線程。注意，我們絕對不能去阻塞線程，否則事件的處理過程會被阻塞，我們的應(yīng)用就失去了響應(yīng)能力。每個負責處理請求并且寫入回應(yīng)結(jié)果。

本文章是 Vert.x 藍圖系列 的第一篇教程。全系列：

Vert.x Blueprint 系列教程(一) | 待辦事項服務(wù)開發(fā)教程

Vert.x Blueprint 系列教程(二) | 開發(fā)基于消息的應(yīng)用 - Vert.x Kue 教程

Vert.x Blueprint 系列教程(三) | Micro-Shop 微服務(wù)應(yīng)用實戰(zhàn)

本系列已發(fā)布至Vert.x官網(wǎng)：Vert.x Blueprint Tutorials

在本教程中，我們會使用Vert.x來一步一步地開發(fā)一個REST風格的Web服務(wù) - Todo Backend，你可以把它看作是一個簡單的待辦事項服務(wù)，我們可以自由添加或者取消各種待辦事項。

通過本教程，你將會學習到以下的內(nèi)容：

Vert.x 是什么，以及其基本設(shè)計思想

Verticle是什么，以及如何使用Verticle

如何用 Vert.x Web 來開發(fā)REST風格的Web服務(wù)

異步編程風格 的應(yīng)用

如何通過 Vert.x 的各種組件來進行數(shù)據(jù)的存儲操作（如 Redis 和 MySQL）

本教程是Vert.x 藍圖系列的第一篇教程，對應(yīng)的Vert.x版本為3.3.0。本教程中的完整代碼已托管至GitHub。

朋友，歡迎來到Vert.x的世界！初次聽說Vert.x，你一定會非常好奇：這是啥？讓我們來看一下Vert.x的官方解釋：

Vert.x is a tool-kit for building reactive applications on the JVM.

(⊙o⊙)哦哦。。。翻譯一下，Vert.x是一個在JVM上構(gòu)建 響應(yīng)式 應(yīng)用的 工具集 。這個定義比較模糊，我們來簡單解釋一下：工具集 意味著Vert.x非常輕量，可以嵌入到你當前的應(yīng)用中而不需要改變現(xiàn)有的結(jié)構(gòu)；另一個重要的描述是 響應(yīng)式 —— Vert.x就是為構(gòu)建響應(yīng)式應(yīng)用（系統(tǒng)）而設(shè)計的。響應(yīng)式系統(tǒng)這個概念在 Reactive Manifesto 中有詳細的定義。我們在這里總結(jié)4個要點：

響應(yīng)式的(Responsive)：一個響應(yīng)式系統(tǒng)需要在 合理 的時間內(nèi)處理請求。

彈性的(Resilient)：一個響應(yīng)式系統(tǒng)必須在遇到 異常 （崩潰，超時， 500 錯誤等等）的時候保持響應(yīng)的能力，所以它必須要為 異常處理 而設(shè)計。

可伸縮的(Elastic)：一個響應(yīng)式系統(tǒng)必須在不同的負載情況下都要保持響應(yīng)能力，所以它必須能伸能縮，并且可以利用最少的資源來處理負載。

消息驅(qū)動：一個響應(yīng)式系統(tǒng)的各個組件之間通過 異步消息傳遞 來進行交互。

Vert.x是事件驅(qū)動的，同時也是非阻塞的。首先，我們來介紹 Event Loop 的概念。Event Loop是一組負責分發(fā)和處理事件的線程。注意，我們絕對不能去阻塞Event Loop線程，否則事件的處理過程會被阻塞，我們的應(yīng)用就失去了響應(yīng)能力。因此當我們在寫Vert.x應(yīng)用的時候，我們要時刻謹記 異步非阻塞開發(fā)模式 而不是傳統(tǒng)的阻塞開發(fā)模式。我們將會在下面詳細講解異步非阻塞開發(fā)模式。

我們的應(yīng)用是一個REST風格的待辦事項服務(wù)，它非常簡單，整個API其實就圍繞著 增刪改查 四種操作。所以我們可以設(shè)計以下的路由：

添加待辦事項: POST /todos

獲取某一待辦事項: GET /todos/:todoId

獲取所有待辦事項: GET /todos

更新待辦事項: PATCH /todos/:todoId

刪除某一待辦事項: DELETE /todos/:todoId

刪除所有待辦事項: DELETE /todos

注意我們這里不討論REST風格API的設(shè)計規(guī)范（仁者見仁,智者見智），因此你也可以用你喜歡的方式去定義路由。

下面我們開始開發(fā)我們的項目！High起來～～～

Vert.x Core提供了一些較為底層的處理HTTP請求的功能，這對于Web開發(fā)來說不是很方便，因為我們通常不需要這么底層的功能，因此Vert.x Web應(yīng)運而生。Vert.x Web基于Vert.x Core，并且提供一組更易于創(chuàng)建Web應(yīng)用的上層功能（如路由）。

首先我們先來創(chuàng)建我們的項目。在本教程中我們使用Gradle作為構(gòu)建工具，當然你也可以使用其它諸如Maven之類的構(gòu)建工具。我們的項目目錄里需要有：

src/main/java 文件夾（源碼目錄）

src/test/java 文件夾（測試目錄）

build.gradle 文件（Gradle配置文件）

.
├── build.gradle
├── settings.gradle
├── src
│   ├── main
│   │   └── java
│   └── test
│       └── java

我們首先來創(chuàng)建 build.gradle 文件，這是Gradle對應(yīng)的配置文件：

apply plugin: "java"

targetCompatibility = 1.8
sourceCompatibility = 1.8

repositories {
  mavenCentral()
  mavenLocal()
}

dependencies {

  compile "io.vertx:vertx-core:3.3.0"
  compile "io.vertx:vertx-web:3.3.0"

  testCompile "io.vertx:vertx-unit:3.3.0"
  testCompile group: "junit", name: "junit", version: "4.12"
}

你可能不是很熟悉Gradle，這不要緊。我們來解釋一下：

我們將 targetCompatibility 和 sourceCompatibility 這兩個值都設(shè)為1.8，代表目標Java版本是Java 8。這非常重要，因為Vert.x就是基于Java 8構(gòu)建的。

在dependencies中，我們聲明了我們需要的依賴。vertx-core 和 vert-web 用于開發(fā)REST API。

注： 若國內(nèi)用戶出現(xiàn)用Gradle解析依賴非常緩慢的情況，可以嘗試使用開源中國Maven鏡像代替默認的鏡像（有的時候速度比較快）。只要在build.gradle中配置即可：

repositories {
    maven {
            url "http://maven.oschina.net/content/groups/public/"
        }
    mavenLocal()
}

搞定build.gradle以后，我們開始寫代碼！

首先我們需要創(chuàng)建我們的數(shù)據(jù)實體對象 - Todo 實體。在io.vertx.blueprint.todolist.entity包下創(chuàng)建Todo類，并且編寫以下代碼：

package io.vertx.blueprint.todolist.entity;

import io.vertx.codegen.annotations.DataObject;
import io.vertx.core.json.JsonObject;

import java.util.concurrent.atomic.AtomicInteger;


@DataObject(generateConverter = true)
public class Todo {

  private static final AtomicInteger acc = new AtomicInteger(0); // counter

  private int id;
  private String title;
  private Boolean completed;
  private Integer order;
  private String url;

  public Todo() {
  }

  public Todo(Todo other) {
    this.id = other.id;
    this.title = other.title;
    this.completed = other.completed;
    this.order = other.order;
    this.url = other.url;
  }

  public Todo(JsonObject obj) {
    TodoConverter.fromJson(obj, this); // 還未生成Converter的時候需要先注釋掉，生成過后再取消注釋
  }

  public Todo(String jsonStr) {
    TodoConverter.fromJson(new JsonObject(jsonStr), this);
  }

  public Todo(int id, String title, Boolean completed, Integer order, String url) {
    this.id = id;
    this.title = title;
    this.completed = completed;
    this.order = order;
    this.url = url;
  }

  public JsonObject toJson() {
    JsonObject json = new JsonObject();
    TodoConverter.toJson(this, json);
    return json;
  }

  public int getId() {
    return id;
  }

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

  public void setIncId() {
    this.id = acc.incrementAndGet();
  }

  public static int getIncId() {
    return acc.get();
  }

  public static void setIncIdWith(int n) {
    acc.set(n);
  }

  public String getTitle() {
    return title;
  }

  public void setTitle(String title) {
    this.title = title;
  }

  public Boolean isCompleted() {
    return getOrElse(completed, false);
  }

  public void setCompleted(Boolean completed) {
    this.completed = completed;
  }

  public Integer getOrder() {
    return getOrElse(order, 0);
  }

  public void setOrder(Integer order) {
    this.order = order;
  }

  public String getUrl() {
    return url;
  }

  public void setUrl(String url) {
    this.url = url;
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;

    Todo todo = (Todo) o;

    if (id != todo.id) return false;
    if (!title.equals(todo.title)) return false;
    if (completed != null ? !completed.equals(todo.completed) : todo.completed != null) return false;
    return order != null ? order.equals(todo.order) : todo.order == null;

  }

  @Override
  public int hashCode() {
    int result = id;
    result = 31 * result + title.hashCode();
    result = 31 * result + (completed != null ? completed.hashCode() : 0);
    result = 31 * result + (order != null ? order.hashCode() : 0);
    return result;
  }

  @Override
  public String toString() {
    return "Todo -> {" +
      "id=" + id +
      ", title="" + title + """ +
      ", completed=" + completed +
      ", order=" + order +
      ", url="" + url + """ +
      "}";
  }

  private  T getOrElse(T value, T defaultValue) {
    return value == null ? defaultValue : value;
  }

  public Todo merge(Todo todo) {
    return new Todo(id,
      getOrElse(todo.title, title),
      getOrElse(todo.completed, completed),
      getOrElse(todo.order, order),
      url);
  }
}

我們的 Todo 實體對象由序號id、標題title、次序order、地址url以及代表待辦事項是否完成的一個標識complete組成。我們可以把它看作是一個簡單的Java Bean。它可以被編碼成JSON格式的數(shù)據(jù)，我們在后邊會大量使用JSON（事實上，在Vert.x中JSON非常普遍）。同時注意到我們給Todo類加上了一個注解：@DataObject，這是用于生成JSON轉(zhuǎn)換類的注解。

DataObject 注解
被 @DataObject 注解的實體類需要滿足以下條件：擁有一個拷貝構(gòu)造函數(shù)以及一個接受一個 JsonObject 對象的構(gòu)造函數(shù)。

我們利用Vert.x Codegen來自動生成JSON轉(zhuǎn)換類。我們需要在build.gradle中添加依賴：

compile "io.vertx:vertx-codegen:3.3.0"

同時，我們需要在io.vertx.blueprint.todolist.entity包中添加package-info.java文件來指引Vert.x Codegen生成代碼：

/**
 * Indicates that this module contains classes that need to be generated / processed.
 */
@ModuleGen(name = "vertx-blueprint-todo-entity", groupPackage = "io.vertx.blueprint.todolist.entity")
package io.vertx.blueprint.todolist.entity;

import io.vertx.codegen.annotations.ModuleGen;

Vert.x Codegen本質(zhì)上是一個注解處理器(annotation processing tool)，因此我們還需要在build.gradle中配置apt。往里面添加以下代碼：

task annotationProcessing(type: JavaCompile, group: "build") {
  source = sourceSets.main.java
  classpath = configurations.compile
  destinationDir = project.file("src/main/generated")
  options.compilerArgs = [
    "-proc:only",
    "-processor", "io.vertx.codegen.CodeGenProcessor",
    "-AoutputDirectory=${destinationDir.absolutePath}"
  ]
}

sourceSets {
  main {
    java {
      srcDirs += "src/main/generated"
    }
  }
}

compileJava {
  targetCompatibility = 1.8
  sourceCompatibility = 1.8

  dependsOn annotationProcessing
}

這樣，每次我們在編譯項目的時候，Vert.x Codegen都會自動檢測含有 @DataObject 注解的類并且根據(jù)配置生成JSON轉(zhuǎn)換類。在本例中，我們應(yīng)該會得到一個 TodoConverter 類，然后我們可以在Todo類中使用它。

下面我們來寫我們的應(yīng)用組件。在io.vertx.blueprint.todolist.verticles包中創(chuàng)建SingleApplicationVerticle類，并編寫以下代碼：

package io.vertx.blueprint.todolist.verticles;

import io.vertx.core.AbstractVerticle;
import io.vertx.core.Future;
import io.vertx.redis.RedisClient;
import io.vertx.redis.RedisOptions;

public class SingleApplicationVerticle extends AbstractVerticle {

  private static final String HTTP_HOST = "0.0.0.0";
  private static final String REDIS_HOST = "127.0.0.1";
  private static final int HTTP_PORT = 8082;
  private static final int REDIS_PORT = 6379;

  private RedisClient redis;

  @Override
  public void start(Future future) throws Exception {
      // TODO with start...
  }
}

我們的SingleApplicationVerticle類繼承了AbstractVerticle抽象類。那么什么是 Verticle 呢？在Vert.x中，一個Verticle代表應(yīng)用的某一組件。我們可以通過部署Verticle來運行這些組件。如果你了解 Actor 模型的話，你會發(fā)現(xiàn)它和Actor非常類似。

當Verticle被部署的時候，其start方法會被調(diào)用。我們注意到這里的start方法接受一個類型為Future的參數(shù)，這代表了這是一個異步的初始化方法。這里的Future代表著Verticle的初始化過程是否完成。你可以通過調(diào)用Future的complete方法來代表初始化過程完成，或者fail方法代表初始化過程失敗。

現(xiàn)在我們Verticle的輪廓已經(jīng)搞好了，那么下一步也就很明了了 - 創(chuàng)建HTTP Client并且配置路由，處理HTTP請求。

我們來給start方法加點東西：

@Override
public void start(Future future) throws Exception {
  initData();
  Router router = Router.router(vertx); // <1>
  // CORS support
  Set allowHeaders = new HashSet<>();
  allowHeaders.add("x-requested-with");
  allowHeaders.add("Access-Control-Allow-Origin");
  allowHeaders.add("origin");
  allowHeaders.add("Content-Type");
  allowHeaders.add("accept");
  Set allowMethods = new HashSet<>();
  allowMethods.add(HttpMethod.GET);
  allowMethods.add(HttpMethod.POST);
  allowMethods.add(HttpMethod.DELETE);
  allowMethods.add(HttpMethod.PATCH);

  router.route().handler(CorsHandler.create("*") // <2>
    .allowedHeaders(allowHeaders)
    .allowedMethods(allowMethods));
  router.route().handler(BodyHandler.create()); // <3>

  // TODO:routes

  vertx.createHttpServer() // <4>
    .requestHandler(router::accept)
    .listen(PORT, HOST, result -> {
        if (result.succeeded())
          future.complete();
        else
          future.fail(result.cause());
      });
}

(⊙o⊙)…一長串代碼誒。。是不是看著很暈?zāi)?？我們來詳細解釋一下?/p>

首先我們創(chuàng)建了一個 Router 實例 （1）。這里的Router代表路由器，相信做過Web開發(fā)的開發(fā)者們一定不會陌生。路由器負責將對應(yīng)的HTTP請求分發(fā)至對應(yīng)的處理邏輯（Handler）中。每個Handler負責處理請求并且寫入回應(yīng)結(jié)果。當HTTP請求到達時，對應(yīng)的Handler會被調(diào)用。

然后我們創(chuàng)建了兩個Set：allowHeaders和allowMethods，并且我們向里面添加了一些HTTP Header以及HTTP Method，然后我們給路由器綁定了一個CorsHandler （2）。route()方法（無參數(shù)）代表此路由匹配所有請求。這兩個Set的作用是支持 CORS，因為我們的API需要開啟CORS以便配合前端正常工作。有關(guān)CORS的詳細內(nèi)容我們就不在這里細說了，詳情可以參考這里。我們這里只需要知道如何開啟CORS支持即可。

接下來我們給路由器綁定了一個全局的BodyHandler （3），它的作用是處理HTTP請求正文并獲取其中的數(shù)據(jù)。比如，在實現(xiàn)添加待辦事項邏輯的時候，我們需要讀取請求正文中的JSON數(shù)據(jù)，這時候我們就可以用BodyHandler。

最后，我們通過vertx.createHttpServer()方法來創(chuàng)建一個HTTP服務(wù)端 （4）。注意這個功能是Vert.x Core提供的底層功能之一。然后我們將我們的路由處理器綁定到服務(wù)端上，這也是Vert.x Web的核心。你可能不熟悉router::accept這樣的表示，這是Java 8中的 方法引用，它相當于一個分發(fā)路由的Handler。當有請求到達時，Vert.x會調(diào)用accept方法。然后我們通過listen方法監(jiān)聽8082端口。因為創(chuàng)建服務(wù)端的過程可能失敗，因此我們還需要給listen方法傳遞一個Handler來檢查服務(wù)端是否創(chuàng)建成功。正如我們前面所提到的，我們可以使用future.complete來表示過程成功，或者用future.fail來表示過程失敗。

到現(xiàn)在為止，我們已經(jīng)創(chuàng)建好HTTP服務(wù)端了，但我們還沒有見到任何的路由呢！不要著急，是時候去聲明路由了！

下面我們來聲明路由。正如我們之前提到的，我們的路由可以設(shè)計成這樣：

添加待辦事項: POST /todos

獲取某一待辦事項: GET /todos/:todoId

獲取所有待辦事項: GET /todos

更新待辦事項: PATCH /todos/:todoId

刪除某一待辦事項: DELETE /todos/:todoId

刪除所有待辦事項: DELETE /todos

路徑參數(shù)

在URL中，我們可以通過:name的形式定義路徑參數(shù)。當處理請求的時候，Vert.x會自動獲取這些路徑參數(shù)并允許我們訪問它們。拿我們的路由舉個例子，/todos/19 將 todoId 映射為 19。

首先我們先在 io.vertx.blueprint.todolist 包下創(chuàng)建一個Constants類用于存儲各種全局常量（當然也可以放到其對應(yīng)的類中）：

package io.vertx.blueprint.todolist;

public final class Constants {

  private Constants() {}

  /** API Route */
  public static final String API_GET = "/todos/:todoId";
  public static final String API_LIST_ALL = "/todos";
  public static final String API_CREATE = "/todos";
  public static final String API_UPDATE = "/todos/:todoId";
  public static final String API_DELETE = "/todos/:todoId";
  public static final String API_DELETE_ALL = "/todos";

}

然后我們將start方法中的TODO標識處替換為以下的內(nèi)容：

// routes
router.get(Constants.API_GET).handler(this::handleGetTodo);
router.get(Constants.API_LIST_ALL).handler(this::handleGetAll);
router.post(Constants.API_CREATE).handler(this::handleCreateTodo);
router.patch(Constants.API_UPDATE).handler(this::handleUpdateTodo);
router.delete(Constants.API_DELETE).handler(this::handleDeleteOne);
router.delete(Constants.API_DELETE_ALL).handler(this::handleDeleteAll);

代碼很直觀、明了。我們用對應(yīng)的方法（如get,post,patch等等）將路由路徑與路由器綁定，并且我們調(diào)用handler方法給每個路由綁定上對應(yīng)的Handler，接受的Handler類型為Handler。這里我們分別綁定了六個方法引用，它們的形式都類似于這樣：

private void handleRequest(RoutingContext context) {
    // ...
}

我們將在稍后實現(xiàn)這六個方法，這也是我們待辦事項服務(wù)邏輯的核心。

我們之前提到過，Vert.x是 異步、非阻塞的 。每一個異步的方法總會接受一個 Handler 參數(shù)作為回調(diào)函數(shù)，當對應(yīng)的操作完成時會調(diào)用接受的Handler，這是異步方法的一種實現(xiàn)。還有一種等價的實現(xiàn)是返回Future對象：

void doAsync(A a, B b, Handler handler);
// 這兩種實現(xiàn)等價
Future doAsync(A a, B b);

其中，Future 對象代表著一個操作的結(jié)果，這個操作可能還沒有進行，可能正在進行，可能成功也可能失敗。當操作完成時，Future對象會得到對應(yīng)的結(jié)果。我們也可以通過setHandler方法給Future綁定一個Handler，當Future被賦予結(jié)果的時候，此Handler會被調(diào)用。

Future future = doAsync(A a, B b);
future.setHandler(r -> {
    if (r.failed()) {
        // 處理失敗
    } else {
        // 操作結(jié)果
    }
});

Vert.x中大多數(shù)異步方法都是基于Handler的。而在本教程中，這兩種異步模式我們都會接觸到。

現(xiàn)在是時候來實現(xiàn)我們的待辦事項業(yè)務(wù)邏輯了！這里我們使用 Redis 作為數(shù)據(jù)持久化存儲。有關(guān)Redis的詳細介紹請參照Redis 官方網(wǎng)站。Vert.x給我們提供了一個組件—— Vert.x-redis，允許我們以異步的形式操作Redis數(shù)據(jù)。

如何安裝Redis？ | 請參照Redis官方網(wǎng)站上詳細的安裝指南。

Vert.x Redis允許我們以異步的形式操作Redis數(shù)據(jù)。我們首先需要在build.gradle中添加以下依賴：

compile "io.vertx:vertx-redis-client:3.3.0"

我們通過RedisClient對象來操作Redis中的數(shù)據(jù)，因此我們定義了一個類成員redis。在使用RedisClient之前，我們首先需要與Redis建立連接，并且需要配置（以RedisOptions的形式），后邊我們再講需要配置哪些東西。

我們來實現(xiàn) initData 方法用于初始化 RedisClient 并且測試連接：

private void initData() {
  RedisOptions config = new RedisOptions()
      .setHost(config().getString("redis.host", REDIS_HOST)) // redis host
      .setPort(config().getInteger("redis.port", REDIS_PORT)); // redis port

  this.redis = RedisClient.create(vertx, config); // create redis client

  redis.hset(Constants.REDIS_TODO_KEY, "24", Json.encodePrettily( // test connection
    new Todo(24, "Something to do...", false, 1, "todo/ex")), res -> {
    if (res.failed()) {
      System.err.println("[Error] Redis service is not running!");
      res.cause().printStackTrace();
    }
  });

}

當我們在加載Verticle的時候，我們會首先調(diào)用initData方法，這樣可以保證RedisClient可以被正常創(chuàng)建。

我們知道，Redis支持各種格式的數(shù)據(jù)，并且支持多種方式存儲（如list、hash map等）。這里我們將我們的待辦事項存儲在 哈希表(map) 中。我們使用待辦事項的id作為key，JSON格式的待辦事項數(shù)據(jù)作為value。同時，我們的哈希表本身也要有個key，我們把它命名為 VERT_TODO，并且存儲到Constants類中：

public static final String REDIS_TODO_KEY = "VERT_TODO";

正如我們之前提到的，我們利用了生成的JSON數(shù)據(jù)轉(zhuǎn)換類來實現(xiàn)Todo實體與JSON數(shù)據(jù)之間的轉(zhuǎn)換（通過幾個構(gòu)造函數(shù)），在后面實現(xiàn)待辦事項服務(wù)的時候可以廣泛利用。

我們首先來實現(xiàn)獲取待辦事項的邏輯。正如我們之前所提到的，我們的處理邏輯方法需要接受一個RoutingContext類型的參數(shù)。我們看一下獲取某一待辦事項的邏輯方法(handleGetTodo)：

private void handleGetTodo(RoutingContext context) {
  String todoID = context.request().getParam("todoId"); // (1)
  if (todoID == null)
    sendError(400, context.response()); // (2)
  else {
    redis.hget(Constants.REDIS_TODO_KEY, todoID, x -> { // (3)
      if (x.succeeded()) {
        String result = x.result();
        if (result == null)
          sendError(404, context.response());
        else {
          context.response()
            .putHeader("content-type", "application/json")
            .end(result); // (4)
        }
      } else
        sendError(503, context.response());
    });
  }
}

首先我們先通過getParam方法獲取路徑參數(shù)todoId (1)。我們需要檢測路徑參數(shù)獲取是否成功，如果不成功就返回 400 Bad Request 錯誤 (2)。這里我們寫一個函數(shù)封裝返回錯誤response的邏輯：

private void sendError(int statusCode, HttpServerResponse response) {
  response.setStatusCode(statusCode).end();
}

這里面，end方法是非常重要的。只有我們調(diào)用end方法時，對應(yīng)的HTTP Response才能被發(fā)送回客戶端。

再回到handleGetTodo方法中。如果我們成功獲取到了todoId，我們可以通過hget操作從Redis中獲取對應(yīng)的待辦事項 (3)。hget代表通過key從對應(yīng)的哈希表中獲取對應(yīng)的value，我們來看一下hget函數(shù)的定義：

RedisClient hget(String key, String field, Handler> handler);

第一個參數(shù)key對應(yīng)哈希表的key，第二個參數(shù)field代表待辦事項的key，第三個參數(shù)代表當獲取操作成功時對應(yīng)的回調(diào)。在Handler中，我們首先檢查操作是否成功，如果不成功就返回503錯誤。如果成功了，我們就可以獲取操作的結(jié)果了。結(jié)果是null的話，說明Redis中沒有對應(yīng)的待辦事項，因此我們返回404 Not Found代表不存在。如果結(jié)果存在，那么我們就可以通過end方法將其寫入response中 (4)。注意到我們所有的RESTful API都返回JSON格式的數(shù)據(jù)，所以我們將content-type頭設(shè)為JSON。

獲取所有待辦事項的邏輯handleGetAll與handleGetTodo大體上類似，但實現(xiàn)上有些許不同：

private void handleGetAll(RoutingContext context) {
  redis.hvals(Constants.REDIS_TODO_KEY, res -> { // (1)
    if (res.succeeded()) {
      String encoded = Json.encodePrettily(res.result().stream() // (2)
        .map(x -> new Todo((String) x))
        .collect(Collectors.toList()));
      context.response()
        .putHeader("content-type", "application/json")
        .end(encoded); // (3)
    } else
      sendError(503, context.response());
  });
}

這里我們通過hvals操作 (1) 來獲取某個哈希表中的所有數(shù)據(jù)（以JSON數(shù)組的形式返回，即JsonArray對象）。在Handler中我們還是像之前那樣先檢查操作是否成功。如果成功的話我們就可以將結(jié)果寫入response了。注意這里我們不能直接將返回的JsonArray寫入response。想象一下返回的JsonArray包括著待辦事項的key以及對應(yīng)的JSON數(shù)據(jù)（字符串形式），因此此時每個待辦事項對應(yīng)的JSON數(shù)據(jù)都被轉(zhuǎn)義了，所以我們需要先把這些轉(zhuǎn)義過的JSON數(shù)據(jù)轉(zhuǎn)換成實體對象，再重新編碼。

我們這里采用了一種響應(yīng)式編程思想的方法。首先我們了解到JsonArray類繼承了Iterable