在Java中构建响应式微服务系统——第三章构建响应式微服务

第三章构建响应式微服务

在本章中，我们将使用Vert.x构建我们的第一个微服务。由于大多数微服务系统使用HTTP进行交互，因此我们将以HTTP微服务作为开始。但是由于系统包含多个相互通讯的微服务，因此我们会构建另一个微服务消费第一个（作为第一个的消费者）。然后，我们将说明为什么这样一个设计不是完全的拥抱响应式微服务。最后，我们将实现基于消息的微服务，以领会消息如何提升响应性。

第一个微服务

在这一章中，我们将实现同样一组微服务两次。第一个微服务公开了一个hello服务，我们称为hello微服务。另一个消费这个服务两次（并发的）。消费者被称为hello消费者微服务。这个小系统不仅说明了如何提供服务，还说明了如何消费服务。图3-1的左侧，微服务使用HTTP交互。hello消费者微服务使用一个HTTP客户端执行hello微服务。在右侧，hello消费者微服务使用消息与hello微服务交互。这种差异会影响系统的响应性。

这里写图片描述

图3-1 本章中使用HTTP和基于消息交互的微服务实现

在前一章中，我们看到使用Vert.x API的两种不同方法：回调和RxJava。为了说明它们之间差异并帮助你找到首选方法，hello微服务使用基于回调的开发模型实现，而消费者使用RxJava实现。

HTTP微服务实现

微服务总是通过HTTP公开API并且使用HTTP请求消费。让我们看一下这些HTTP交互如何使用Vert.x实现。本节中开发的代码在代码仓库的microservices/hello-microservice-http目录下。

开始

创建一个目录名为hello-microservice-http，然后生成项目结构：

mkdir hello-microservice-http
cd hello-microservice-http
mvn io.fabric8:vertx-maven-plugin:1.0.5:setup \
    -DprojectGroupId=io.vertx.microservice \
    -DprojectArtifactId=hello-microservice-http \
    -Dverticle=io.vertx.book.http.HelloMicroservice \
    -Ddependencies=web

这个命令会生成Maven项目并且配置Vert.x Maven插件。除此之外，它添加了vertx-web依赖。Vert.x Web是一个模块，提供了你在Vert.x之上构建现代Web应用所需要的任何东西。

Verticle

打开src/main/java/io/vertx/book/http/HelloMicroservice.java。生成的Verticle代码并没做任何有趣的事情，它只是一个起点：

package io.vertx.book.http;
import io.vertx.core.AbstractVerticle;
public class HelloMicroservice extends AbstractVerticle {
    @Override
    public void start() {
    }
}

现在，启动以下Maven命令：

mvn compile vertx:run

你现在可以编辑这个Verticle。你每次保存文件，应用程序都会重新编译并且自动重启。

HTTP微服务

是时候让我们的MyVerticle类做些事情了。让我们启动一个HTTP服务器。如前章看到的，使用Vert.x创建HTTP服务器，你只需要使用：

@Override
public void start() {
    vertx.createHttpServer()
        .requestHandler(req -> req.response().end("hello"))
        .listen(8080);
}

一旦添加并保存，你可以通过浏览器在http://localhost:8080看到hello。这段代码在8080端口创建了一个HTTP服务器，注册了一个requestHandler，它在每次接收到HTTP请求时调用。现在，我们只是在响应中写入hello。

使用路由和参数

许多服务是通过Web URL调用的，因此，路径检查对于知道请求是什么至关重要。然而，在requestHandler中执行路径检查以实现不同的操作可能会变得复杂。幸运的是，Vert.x Web提供了Router，我们可以在它的上面注册路由（Route）。路由是一种机制，Vert.x Web通过它检测路径并执行相关的动作。让我们重写start方法，使用两个路由：

@Override
public void start() {
    Router router = Router.router(vertx);
    router.get("/").handler(rc -> rc.response().end("hello"));
    router.get("/:name").handler(rc -> rc.response().end("hello " + rc.pathParam("name")));
    vertx.createHttpServer().requestHandler(router::accept)
        .listen(8080);
}

一旦我们创建了Router对象，我们注册两个路由。第一个处理“/”路径的请求，只是输出hello。第二个路由有一个路径参数（:name）。处理器追加参数值到祝贺消息。最后，我们变更HTTP服务器的requestHandler，使用路由器的accept方法。

如果你没有停止vertx:run的执行，你应该可以打开浏览器到：

http://localhost:8080 ——你将看到hello
http://localhost:8080/vert.x ——你将看到hello vert.x

生成JSON

在微服务中经常使用JSON。让我们修改前面的类，以生成JSON载荷：

@Override
public void start() {
    Router router = Router.router(vertx);
    router.get("/").handler(this::hello);
    router.get("/:name").handler(this::hello);
    vertx.createHttpServer()
        .requestHandler(router::accept)
        .listen(8080);
}

private void hello(RoutingContext rc) {
    String message = "hello";
    if (rc.pathParam("name") != null) {
        message += " " + rc.pathParam("name");
    }
    JsonObject json = new JsonObject().put("message", message);
    rc.response()
        .putHeader(HttpHeaders.CONTENT_TYPE, "application/json")
        .end(json.encode());
}

Vert.x提供了一个JsonObject类来创建和操作JSON结构。这段代码就绪之后，你应该可以打开浏览器指向：

http://localhost:8080 ——你将看到{“message”: “hello”}
http://localhost:8080/vert.x ——你将看到{“message”:”hello vert.x”}

打包和运行

使用Ctrl+C停止vertx:run的执行，从相同目录执行以下命令：

mvn package

这会在target目录中生成一个FatJar：hello-hellomicroservice-http-1.0-SNAPSHOT.jar。虽然FatJar往往偏胖，但这里的JAR具有合理的尺寸（~6.3MB），包含运行应用程序的所有内容：

java -jar target/hello-microservice-http-1.0-SNAPSHOT.jar

你可以通过打开：http://localhost:8080以检查确保它是运行的。保持进程运行，因为接下来的微服务将调用它。

消费HTTP微服务

一个微服务不能组成一个应用；你需要一个微服务系统。现在我们已有第一个运行的微服务，让我们编写第二个微服务来消费它。第二个微服务还提供了一个HTTP外观来执行它，每次执行会调用我们刚实现的微服务。本节中展示的代码位于代码仓库的microservices/helloconsumer-microservice-http目录。

项目创建

照旧，我们创建一个新的工程

mkdir hello-consumer-microservice-http
cd hello-consumer-microservice-http
mvn io.fabric8:vertx-maven-plugin:1.0.5:setup \
    -DprojectGroupId=io.vertx.microservice \
    -DprojectArtifactId=hello-consumer-microservice-http \
    -Dverticle=io.vertx.book.http.HelloConsumerMicroservice \
    -Ddependencies=web,web-client,rx

最后的命令行添加了另一个依赖：Vert.x Web客户端，一个异步的HTTP客户端。我们将使用这个客户端调用第一个微服务。该命令还添加了Vert.x RxJava绑定，我们随后会使用。

现在编辑src/main/java/io/vertx/book/http/HelloConsumerMicroservice.java文件并且更新它以便包含：

package io.vertx.book.http;
import io.vertx.core.AbstractVerticle;
import io.vertx.core.json.JsonObject;
import io.vertx.ext.web.*;
import io.vertx.ext.web.client.*;
import io.vertx.ext.web.codec.BodyCodec;
public class HelloConsumerMicroservice extends AbstractVerticle {

    private WebClient client;

    @Override
    public void start() {
        client = WebClient.create(vertx);
        Router router = Router.router(vertx);
        router.get("/").handler(this::invokeMyFirstMicroservice);
        vertx.createHttpServer()
            .requestHandler(router::accept)
            .listen(8081);
    }

    private void invokeMyFirstMicroservice(RoutingContext rc) {
        HttpRequest<JsonObject> request = client
            .get(8080, "localhost","/vert.x")
            .as(BodyCodec.jsonObject());
        request.send(ar -> {
            if (ar.failed()) {
                rc.fail(ar.cause());
            } else {
                rc.response().end(ar.result().body().encode());
            }
        });
    }
}

在start方法中，我们创建了一个WebClient和一个Router。在创建的Router上，我们注册了一个到“/”的路由并且启动HTTP服务器，传递Router的accept方法作为requestHandler。路由处理器是一个方法引用（hello）。这个方法使用WebClient通过一个具体的路径（/vert.x）调用第一个微服务，并且将结果写到HTTP响应。

一旦HTTP请求创建，我们调用send发送请求。当响应到达或者发生错误时，我们传递的处理器被调用。if-else块检测执行是否成功。不要忘记它是一个远程交互，有许多原因会失败。例如第一个微服务可能未运行。当它成功后，我们将收到的载荷写入响应；否则，我们回复一个500响应。

调用服务多于一次

现在我们修改当前的行为，调用hello微服务两次，使用两个不同的（路径）参数：

HttpRequest<JsonObject> request1 = client
    .get(8080, "localhost", "/Luke")
    .as(BodyCodec.jsonObject());
HttpRequest<JsonObject> request2 = client
    .get(8080, "localhost", "/Leia")
    .as(BodyCodec.jsonObject());

这两个请求是独立的并且可以并发执行。但是此处我们想要写一个组合了这两个结果的响应。调用服务两次并且装配两个结果的代码可能会变得复杂。当我们收到其中一个响应时，我们需要检查另一个请求是否已完成。虽然这部分代码对于两个请求仍然是可管理的，但是当我们需要处理更多时，它会变得极度复杂。幸运的是，如前一章所述，我们可以使用响应式编程和RxJava来简化代码。

我们通过vertx-maven-plugin导入Vert.x RxJava API。在HelloConsumerMicroservice中，我们替换import声明：

import io.vertx.core.json.JsonObject;
import io.vertx.rxjava.core.AbstractVerticle;
import io.vertx.rxjava.ext.web.*;
import io.vertx.rxjava.ext.web.client.*;
import io.vertx.rxjava.ext.web.codec.BodyCodec;
import rx.Single;

使用RX，我们编写的调用两次请求并且使用它们构建响应的复杂代码变得更简单：

private void invokeMyFirstMicroservice(RoutingContext rc) {
    HttpRequest<JsonObject> request1 = client
        .get(8080, "localhost", "/Luke")
        .as(BodyCodec.jsonObject());
    HttpRequest<JsonObject> request2 = client
        .get(8080, "localhost", "/Leia")
        .as(BodyCodec.jsonObject());
    Single<JsonObject> s1 = request1.rxSend()
        .map(HttpResponse::body);
    Single<JsonObject> s2 = request2.rxSend()
        .map(HttpResponse::body);
    Single.zip(s1, s2, (luke, leia) -> {
        // We have the results of both requests in Luke and Leia
        return new JsonObject()
            .put("Luke", luke.getString("message"))
            .put("Leia", leia.getString("message"));
    })
    .subscribe(
        result -> rc.response().end(result.encodePrettily()),
        error -> {
            error.printStackTrace();
            rc.response().setStatusCode(500).end(error.getMessage());
        }
    );
}

注意rxSend方法的调用。Vert.x的RxJava方法以rx作为前缀，很容易辨认。rxSend的结果是一个Single，即一个元素的Ovservable，表示一个操作的延期结果。single.zip方法将一组Single作为输入，一旦它们所有都接收到了值，使用这些结果调用一个函数。Single.zip产生另一个Single，包含了函数的结果。最后，我们subscribe。这个方法使用两个函数作为参数：

第一个调用使用zip函数的结果（一个JSON对象）。我们将接收到的JSON载荷写到HTTP响应。
如果一些事情失败了（超时、异常等等）将会调用第二个。这种情况，我们响应一个空的JSON对象。

代码就绪之后，如果我们打开http://localhost:8081，并且hello微服务依旧运行，我们将看到：

{
    "Luke" : "hello Luke",
    "Leia" : "hello Leia"
}

这些微服务是响应式微服务？

此刻，我们有两个微服务。它们是独立的并且可以按它们自己的步调部署和更新。它们还使用一个轻量级的协议（HTTP）交互。但是它们是响应式微服务吗？不，它们不是。记住，要称为响应式，一个微服务必须是：

自治的
异步的
可快速恢复的
有弹性的

当前设计的主要问题是两个微服务之间的紧密耦合。Web客户端被配置为明确针对第一个微服务。如果第一个微服务失败，我们不能通过调用另一个来恢复。如果我们当前欠载（under load，应该是指由于hello微服务不足导致消费该服务的其它服务无法满载工作），创建一个新的hello微服务实例不能帮助我们。感谢Vert.x Web客户端，这些交互是异步的。尽管如此，由于我们没有使用一个虚拟地址（目的地）调用微服务，而是使用它的直接URL，它不能提供我们需要的快速恢复能力和弹性。

重要的是要注意，像在第二个微服务中那样使用响应式编程不能带给你响应式系统的好处。它提供了一个简洁的模型来协调异步动作，但是它没有提供我们需要的快速恢复能力和弹性。

我们可以在响应式微服务使用HTTP吗？是的。但是这需要一些基础设施来路由虚拟URL到一组服务。我们也需要实现一个负载均衡策略来提供弹性和健康检查支持以提升快速恢复能力。

不要失望，下一节我们将向响应式微服务迈出一大步。

Vert.x事件总线——一个消息支柱

Vert.x提供了一个事件总线，允许应用程序的不同组件使用消息（messages）进行交互。消息被发送到地址（addresses）并有一组消息头（headers）和一个消息体（body）。地址是一个表示目的地的不透明字符串。消息消费者注册它们自己到地址上以接收消息。事件总线也是集群的，意味着它可以通过网络在分布式的发送者和消费者之间分发消息。通过以集群的模式启动一个Vert.x应用，节点被链接以启用共享数据结构、硬停止故障检测、负载均衡组通讯。事件总线可以在集群中所有节点之间分发消息。为了创建这样一个集群配置，你可以使用Apache Ignite、Apache Zookeeper、Infinispan或者Hazelcast。在本报告中，我们将使用Infinispan，但是我们不涉及高级配置。关于这些，参考Infinispan文档（http://infinispan.org/）。在Infinispan（或者你选择的技术）管理节点发现和存储时，事件总线通讯使用直接的P2P TCP链接。

事件总线提供了三种类型的传递语义。首先，send方法允许组件发送一条消息到一个地址。一个单独的消费者将接收这条消息。如果多于一个消费者在这个地址上注册，Vert.x应用轮询策略来选择一个消费者：

// Consumer
vertx.eventBus().consumer("address", message -> {
    System.out.println("Received: '" + message.body() + "'");
});
// Sender
vertx.eventBus().send("address", "hello");

与send相反，你可以使用publish方法传递消息到所有在这个地址注册的消费者。最后，send方法可以与一个reply处理器配合使用。request/response机制允许实现两个组件间的基于消息的异步交互：

// Consumer
vertx.eventBus().consumer("address", message -> {
    message.reply("pong");
});
// Sender
vertx.eventBus().send("address", "ping", reply -> {
    if (reply.succeeded()) {
        System.out.println("Received: " + reply.result().body());
    } else {
        // No reply or failure
        reply.cause().printStackTrace();
    }
});

如果你正使用Rx-ified API，你可以使用rxSend方法，它会返回一个Single。这个Single在收到应答时接收一个值。我们马上就要看到这个方法的运作了。

基于消息的微服务

让我们重新实现hello微服务，这次使用事件总线来替代HTTP服务器接收请求。微服务应答消息以提供响应。

项目创建

让我们创建一个新项目。这次我们将添加Infinispan依赖，一个内存数据网格，用于管理集群：

mkdir hello-microservice-message
cd hello-microservice-message
mvn io.fabric8:vertx-maven-plugin:1.0.5:setup \
    -DprojectGroupId=io.vertx.microservice \
    -DprojectArtifactId=hello-microservice-message \
    -Dverticle=io.vertx.book.message.HelloMicroservice \
    -Ddependencies=infinispan

一旦生成，我们可能需要配置Infinispan以建立集群。默认配置使用multicast发现节点。如果你的网络支持多播，它会不错。否则，检查代码库的 resource/cluster目录（包含Infinispan配置？）。

编写消息驱动Verticle

编辑src/main/java/io/vertx/book/message/HelloMicroservice.java文件，并且更新start方法：

@Override
public void start() {
    // Receive message from the address 'hello'
    vertx.eventBus().<String>consumer("hello", message -> {
        JsonObject json = new JsonObject()
            .put("served-by", this.toString());
        // Check whether we have received a payload in the
        // incoming message
        if (message.body().isEmpty()) {
            message.reply(json.put("message", "hello"));
        } else {
            message.reply(json.put("message",
            "hello " + message.body()));
        }
    });
}

代码从vertx对象获取eventBus并且注册一个consumer到hello这个地址。当接收到消息时，它会答复它。依赖于接收到的消息是否有消息体，我们计算一个不同的响应。如前一章的示例中，我们发送回一个JSON对象。你可能会奇怪，为什么我们在JSON中添加了served-by。你将很快看到为什么。现在Verticle写好了，是时候启动它了，通过：

mvn compile vertx:run \
    -Dvertx.runArgs="-cluster -Djava.net.preferIPv4Stack=true"

-cluster告诉Vert.x，以cluster模式启动：

现在，让我们写一个微服务来消费这个服务。

开始基于消息的交互

在本节中，我们将创建另一个微服务，通过发送一个消息到地址hello并获得一个回复来执行hello微服务。微服务将重新实现前一章相同的逻辑并且执行该服务两次（一次使用Luke，一次使用Leia）。

照例，我们创建一个新的项目：

mkdir hello-consumer-microservice-message
cd hello-consumer-microservice-message
mvn io.fabric8:vertx-maven-plugin:1.0.5:setup \
    -DprojectGroupId=io.vertx.microservice \
    -DprojectArtifactId=hello-consumer-microservice-message \
    -Dverticle=io.vertx.book.message.HelloConsumerMicroservice \
    -Ddependencies=infinispan,rx

此处我们还添加了Vert.x RxJava支持，以便从Vert.x提供的RXified API中获益。如果你在前面章节更新了Infinispan配置，你需要拷贝它到这个新项目：

现在，编辑io.vertx.book.message.HelloConsumerMicroservice。由于我们使用RxJava，因此需要变更import部分以匹配io.vertx.rxjava.core.AbstractVerticle。然后实现start方法：

@Override
public void start() {
    EventBus bus = vertx.eventBus();
    Single<JsonObject> obs1 = bus.<JsonObject>rxSend("hello", "Luke")
        .map(Message::body);
    Single<JsonObject> obs2 = bus.<JsonObject>rxSend("hello", "Leia")
        .map(Message::body);
    Single.zip(obs1, obs2, (luke, leia) ->
        new JsonObject()
            .put("Luke", luke.getString("message"))
            .put("Leia", leia.getString("message"))
    ).subscribe(
        x -> System.out.println(x.encode()),
        Throwable::printStackTrace);
}

这部分代码与前一章的代码非常相似。我们不再使用WebClient执行一个HTTP endpoint，而是使用事件总线发送消息到hello地址，并且提取答复体。我们使用zip操作获取这两个响应并构建最终结果。在subscribe方法中，我们打印最终结果到控制台或者打印堆栈（异常情况）。

让我们结合HTTP服务器。当收到HTTP请求时，我们执行hello服务两次并且返回构建结果作为响应：

@Override
public void start() {
    vertx.createHttpServer()
            .requestHandler(req -> {
                EventBus bus = vertx.eventBus();
                Single<JsonObject> obs1 = bus.<JsonObject> rxSend(
                                "hello", "Luke").map(Message::body);
                Single<JsonObject> obs2 = bus.<JsonObject> rxSend(
                                "hello", "Leia").map(Message::body);
                Single.zip(obs1,obs2,
                            (luke, leia) -> new JsonObject()
                                        .put("Luke",luke.getString("message") + " from " + luke.getString("served-by"))
                                        .put("Leia",leia.getString("message") + " from " + leia.getString("served-by"))
                        ).subscribe(x -> req.response().end(x.encodePrettily()),
                                    t -> {
                                        t.printStackTrace();
                                        req.response().setStatusCode(500).end(t.getMessage());
                                        });
            }).listen(8082);
}

最后的代码只是将事件总线交互封装到一个requestHandler并且处理HTTP响应。失败的情况下，我们返回一个包含错误消息的JSON对象。

如果你通过mvn compile vertx:run -Dvertx.runArgs=”-cluster -Djava.net.preferIPv4Stack=true”运行代码，并且打开浏览器到http://localhost:8082，你将看到像下面的内容：

{
"Luke" : "hello Luke from ...HelloMicroservice@39721ab",
"Leia" : "hello Leia from ...HelloMicroservice@39721ab"
}

我们现在是响应式吗？

代码非常接近我们前面编写的基于HTTP的微服务。唯一不同是我们使用事件总线替代了HTTP。这会改变我们的响应性（reactiveness）？是的！让我们看看原因。

弹性

弹性是微服务HTTP版本没有实施的特性之一。因为微服务针对一个特定的微服务实例（使用硬编码的URL），它没有提供我们需要的弹性。但是现在，我们使用发送到一个地址的消息，这改变了游戏。让我们看看这个微服务系统的行为如何。

记住前面执行的输出。返回的JSON对象显示了计算hello消息的Verticle。输出总是显示相同的Verticle。表明消息来自相同的实例。我们期望如此，因为我们只有一个单一的实例运行。让我们看一下两个实例的时候会发生什么。

停止Hello微服务的执行（vertx:run）并且运行：

mvn clean package

然后，在hello-microservice-message目录下打开两个不同的终端，执行以下命令（在每个终端）：

java -jar target/hello-microservice-message-1.0-SNAPSHOT.jar \
--cluster -Djava.net.preferIPv4Stack=true

这启动了Hello微服务的两个实例。返回你的浏览器，刷新页面，你将看到一些东西如：

{
    "Luke" : "hello Luke from ...HelloMicroservice@16d0d069",
    "Leia" : "hello Leia from ...HelloMicroservice@411fc4f"
}

这两个Hello的实例都被使用。Vert.x集群链接不同的节点，事件总线集群化。多亏事件总线轮询（round-robin），Vert.x事件总线分发消息到有效的实例，并且因此在监听相同地址的不同节点之间平衡负载。

因此，通过使用事件总线，我们拥有了我们需要的弹性属性。

快速恢复能力

快速恢复能力怎么样？在当前的代码中，如果hello微服务失败，我们将获得一个失败并执行以下代码：

t -> {
    t.printStackTrace();
    req.response().setStatusCode(500).end(t.getMessage());
}

尽管用户得到一个错误消息，但我们不会崩溃，我们没有限制我们的可伸缩性，我们仍旧可以处理请求。尽管如此，为了提升用户体验，我们应该总是及时回复用户，即便我们没有从服务收到响应。为了实现这个逻辑，我们可以通过一个超时设置来增强代码。

为了说明这个，让我们修改Hello微服务来添加失败和问题行为处理。这部分代码位于代码仓库的microservices/hello-microservice-faulty目录下。

这个新的start方法随机选择三种策略中的一种：（1）回复一个明确的失败，（2）forget回复（在消费者端导致一个超时），（3）发送正确的结果。

@Override
public void start() {
    vertx.eventBus().<String> consumer(
            "hello",
            message -> {
                double chaos = Math.random();
                JsonObject json = new JsonObject().put("served-by",this.toString());
                if (chaos < 0.6) {
                    // Normal behavior
                    if (message.body().isEmpty()) {
                        message.reply(json.put("message", "hello"));
                    } else {
                        message.reply(json.put("message", "hello " + message.body()));
                    }
                } else if (chaos < 0.9) {
                    System.out.println("Returning a failure");
                    // Reply with a failure
                    message.fail(500, "message processing failure");
                } else {
                    System.out.println("Not replying");
                    // Just do not reply, leading to a timeout on the
                    // consumer side.
                }
            });
}

重新打包并重启Hello微服务的两个实例。

随着故障注入工作的就绪，我们需要提升我们消费者的容错性。事实上，消费者可能会超时或接收显式故障。在hello消费者微服务中，将我们如何调用hello服务修改为：

EventBus bus = vertx.eventBus();
Single<JsonObject> obs1 = bus.<JsonObject>rxSend("hello", "Luke")
    .subscribeOn(RxHelper.scheduler(vertx))
    .timeout(3, TimeUnit.SECONDS)
    .retry()
    .map(Message::body);
Single<JsonObject> obs2 = bus.<JsonObject>rxSend("hello", "Leia")
    .subscribeOn(RxHelper.scheduler(vertx))
    .timeout(3, TimeUnit.SECONDS)
    .retry()
    .map(Message::body);

这部分代码位于代码仓库的microservices/hello-consumermicroservice-timeout。如果我们在给定时间内没有收到响应,timeout方法会发出一个异常。retry方法重试来获取值，如果它获得一个失败（以一个超时或者明确的失败的形式）。subscribeOn方法指示调用需要在哪个线程上完成。我们使用Vert.x的事件循环（EventLoop）调用我们的回调。如果没有指定这个，方法将由来自默认RxJava线程池的线程执行，这打破了Vert.x线程模型。RXHelper类由Vert.x提供。盲目重试服务调用不是一个非常聪明的容错策略，它甚至可能有害，下一章详细介绍了不同的方法。

现在你可以重新加载页面。你会总是得到一个结果，即便有错误或者超时。记住调用服务时，线程是非阻塞的，因此你可以总是接收新的请求并及时的响应它们。然而，这种超时重试常常弊大于利，正如我们将在下一章中看到的那样。

总结

在本章中，我们学习了如何使用Vert.x开发一个HTTP微服务并且消费它。如我们学到的，在代码中硬编码被消费方服务的URL不是个好主意，因为它破坏了响应式特性的其中之一。在第二部分，我们使用消息替换HTTP交互，展示了消息和Vert.x事件总线如何帮助构建响应式微服务。

那么，我们已经结束了吗？是也不是。是，我们知道如何构建响应式微服务，但是还有一些缺点我们需要看看。首先，要是只有HTTP服务怎么办？你如何避免硬编码地址？快速恢复能力如何？本章我们看到了超时和重试，但是断路器（circuit breakers）、故障转移和舱壁（bulkheads）怎么样？让我们继续旅程。

如果你想进一步讨论这些话题：