使用Vert.x构建Web服务器和消息系统

若是你对Node.js感兴趣，Vert.x多是你的下一个大事件：一个创建在JVM上一个相似的架构企业制度。 这一部分介绍Vert.x是经过两个动手的例子（基于Vert.x 2.0）。

当Node.js出现，许多开发者兴奋的感到能够用不寻常的方法来构建可扩展的服务器端应用程序。 而不是开始，将服务使用多线程的请求重量级的容器。Node.js是启动多个轻便单线程的服务器和流量路由到他们。

如今，相似的框架已经出现，它的服务器部署在一个JVM中，使用JVM设施来管理流量轻量级服务器进程。 本批中的开源Java项目 ，您将了解Vert.x，事件驱动的架构相似的Node.js，是创建在JVM系列还扩展它在某些重要的新途径。

Vert.x亮点

Vert.x应用程序是事件驱动，异步和单线程的。 Vert.x过程经过事件总线，这是Vert.x的事件驱动架构的内置一块通讯。 结合异步处理，单线程组件和事件总线产生高度的可扩展性，并编写单线程应用对习惯于多线程并发Java的人来讲是一种解脱。 能够说，Vert.x的最好的部分是其模块化的基于JVM的架构。 Vert.x应用程序能够运行在几乎全部的操做系统，而且可使用任何支持的JVM兼容的编程语言来编写。 一个Vert.x应用可彻底在单一语言编写，也能够是用不一样的编程语言模块的跨界混搭。 Vert.x模块集成了Vert.x事件总线上。

在Vert.x基于事件的编程

Vert.x的基于事件的编程模型的标准和独特的功能组合。 Vert.x应用在很大程度上是经过定义事件处理程序。 不一样于传统的基于事件的应用程序，可是，Vert.x应用保证不被阻塞。 而不是打开一个socket到服务器，请求资源，而后等待（阻塞）的响应，Vert.x发送到应用程序异步地响应，经过事件处理程序，并经过事件总线传递消息写入。

Vert.x的编程框架包括一些白话，这将有助于更好的了解，经过两个演示应用程序在本文的后面：

• 一个verticle是部署在Vert.x.单位 每一个verticle包含启动它的主要手段。 一个应用程序能够是单个verticle或者能够由与彼此经由事件总线通讯的多个verticles的。

• Verticles在Vert.x实例中运行。 每一个Vert.x实例在其本身的JVM实例运行，而且能够承载多个verticles。 一个Vert.x实例确保verticles彼此经过运行每一个在其本身的类加载器分离，因此没有修改一个静态变量是另外一个实例的风险。 主机能够运行一个单一的Vert.x实例或多个的。

• 一个Vert.x实例，保证每一个verticle实例老是在同一个线程执行。 并发Vert.x 是单线程的。

• 在内部，Vert.x实例维护一组线程（一般为CPU核心数）是在执行一个事件循环 ：检查，看看是否有工做要作，作到这一点，去睡觉。

• Verticles经过使用事件总线传递消息通讯。

• 虽然你可能会认为，共享数据和可扩展性截然相反。 Vert.x提供了一个共享的MAP和跨在同一Vert.x实例中运行verticles传递不可改变的数据共享一套设施，这时候数据是可变的惟一真正的 。

• Vert.x使用相对较少的线程来建立一个事件循环和执行verticles。 但在某些状况下，须要verticle作一些要么昂贵计算，或可能阻塞，如链接到数据库。 当发生这种状况Vert.x可让你标记verticle实例做为worker verticle 。Vert.x确保worker verticles将永远不会被同时执行，因此要他们保持在最低水平，但他们在那里帮助你，当你须要他们，在这种状况下，将由后台执行的线程池执行。

图1示出Vert.x系统包括Vert.x实例，verticles，JVM中，服务器主机，以及事件总线的体系结构。

图1. Vert.x系统的体系结构

Vert.x核心服务和模块

Vert.x功能能够分为两类：核心服务和模块核心服务是可从verticle直接调用并包括用于TCP / SSL，HTTP和网络套接字的客户端和服务器上的服务。 服务来访问Vert.x事件总线; 定时器，缓冲区，流量控制，文件系统访问，共享maps 和 sets，访问配置，SockJS服务器，以及部署和取消部署verticles。 核心服务是至关静态的，预计不会改变，所以全部其余的功能由模块提供。

Vert.x应用和资源能够很容易地打包成模块，并经过Vert.x共享的公共模块库 。 与模块的交互是经过Vert.x事件总线异步：用JSON发送模块的消息，你的申请将获得答复。 模块和集成经过服务总线之间的这种脱钩意味着模块能够在任何支持的语言编写和其它任何支持的语言使用。 因此，若是有人写在Ruby中，你想在你的Java应用程序使用这个模块，是彻底能够的！

编写一个基于Java的Vert.x Web服务器

一个基本的Web服务器应用程序和消息传递系统。 首先下载vert.x 写这篇文章的是2.0.0.final。 当地解开并添加它的bin文件夹到你的PATH 。 请注意，您须要安装Java 7，若是你尚未。

若是你是一个Maven的人跟我同样，那么你能够简单如下的依赖添加到您的POM文件：

清单1. Maven的POM对Vert.x

<dependency> <groupId> io.vertx </groupId> <artifactId> vertx-core </artifactId> <version> 2.0.0-final </version> </dependency> <dependency> <groupId> io.vertx </groupId> <artifactId> vertx-platform </artifactId> <version> 2.0.0-final </version> </dependency>

清单2显示了Server.java文件内容

清单2. Server.java

package com.geekcap.vertxexamples; import org.vertx.java.core.Handler; import org.vertx.java.core.http.HttpServerRequest; import org.vertx.java.deploy.Verticle; public class Server extends Verticle { public void start() { vertx.createHttpServer().requestHandler(new Handler<HttpServerRequest>() { public void handle(HttpServerRequest req) { String file = req.path().equals("/") ? "index.html" : req.path(); req.response.sendFile("webroot/" + file); } }).listen(8080); } }

前几行清单2导入所需的Vert.x类：

• Handler是全部处理器的基类！

• HttpServerRequest表明Vert.x.服务器端的HTTP请求 这个类的一个实例将为由服务器处理的每一个请求建立，而后传递到经过您的应用程序Handler实例（你会使用已注册HttpServer ）。

• Verticle是在Vert.x应用程序部署的基本单位。 为了使用Vert.x，你须要扩展Verticle类和重写start()方法，这你的Verticle 入口点。

注意vertx清单2中的变量： 该Verticle类定义vertx做为受保护的成员变量（继承Verticle），它提供了访问Vert.x运行。 该vertx变量的类型的Vertx，这暴露了如下方法：

• createHttpClient()建立一个HTTP / HTTPS客户端

• createHttpServer()建立一个HTTP / HTTPS服务器

• createNetClient()建立了一个TCP / SSL客户端

• createNetServer()建立了一个TCP / SSL服务器

• creatSockJSServer()建立一个包装了HTTP服务器SockJS服务器

• eventBus()提供事件总线您的应用程序访问

• fileSystem()提供对文件系统的应用程序访问

• sharedData()提供应用程序访问共享数据对象，它能够被用来共享Verticles之间的数据

清单2中的代码建立一个新的HTTP服务器，检索其请求处理程序的参考，并将请求处理程序到新建立的HttpServerRequest处理程序。 该Handle接口定义了一个方法命名handler()并使用泛型定义实例传递给它的类定义的类型; 在这种状况下HttpServerRequest 。 该HttpServerRequest而后定义如下字段：

• method 是一个String包含给定请求的方法中，如GET ， POST ， PUT ， DELETE ，等等。

• path 是一个String包含所请求的路径，如/index.html 。

• query 是一个String包含查询参数，如遵循如下问号部分： ?key=value 。

• response 是一个基准HttpServerResponse表示对HTTP请求的响应。

• uri 为请求的完整URI。

清单2完成对经过映射一个空的请求- “ / ” -到index.html ，而后调用HttpServerResponse的sendFile()方法来告诉Vert.x流指定的文件返回给调用者。

综上所述， Server级访问Vert.x运行时，要求它建立一个新的HTTP服务器，并注册一个Handler （即指望一个HttpServerRequest变量）的HttpServer 。 在处理器的handle()方法时， Server类从位于文件系统提供文件服务webroot目录，这是相对的。

构建web服务器

让咱们来构建示例应用程序，那么咱们将使用Vert.x执行它。 此项目的Maven的POM文件显示清单3所示。

清单3. Maven的POM构建Web服务器

<project xmlns = "http://maven.apache.org/POM/4.0.0" xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" > <modelVersion> 4.0.0 </modelVersion> <groupId> com.geekcap </groupId> <artifactId> vertx-examples </artifactId> <version> 1.0-SNAPSHOT </version> <packaging> jar </packaging> <name> vertx-examples </name> <url> http://maven.apache.org </url> <properties> <project.build.sourceEncoding> UTF-8 </project.build.sourceEncoding> </properties> <build> <plugins> <plugin> <groupId> org.apache.maven.plugins </groupId> <artifactId> maven-compiler-plugin </artifactId> <version> 2.0.2 </version> <configuration> <source> 1.6 </source> <target> 1.6 </target> </configuration> </plugin> </plugins> </build> <dependencies> <dependency> <groupId> io.vertx </groupId> <artifactId> vertx-core </artifactId> <version> 2.0.0-final </version> </dependency> <dependency> <groupId> io.vertx </groupId> <artifactId> vertx-platform </artifactId> <version> 2.0.0-final </version> </dependency> <dependency> <groupId> junit </groupId> <artifactId> junit </artifactId> <version> 4.11 </version> <scope> test </scope> </dependency> </dependencies> </project>

两个依赖添加到POM文件是vertx-code和vertx-platform的，这是须要开发的Java应用程序Vert.x。要构建这个应用程序，请执行如下Maven命令：

mvn clean install

这将产生一个名为vertx-examples-1.0-SNAPSHOT.jar，将须要在你的CLASSPATH，以启动您的verticle。这个示例应用程序提供了在发现网络资源Web根目录相对于该应用程序的启动目录。所以，你须要建立一个webroot的目录，并创建一些资源从它服务。要启动这个verticle，执行vertx在Vert.x的应用bin目录，以下所示：

$VERTX_HOME/bin/vertx run com.geekcap.vertxexamples.Server -cp vertx-exampl

该vertx命令接受几个选项，包括咱们使用它的人，运行。这是一个扩展类的只是名字Verticle和包含的start（）方法和一个可选的参数集。在这种状况下，咱们设置CLASSPATH使用-cp参数，并传入JAR，咱们刚刚建立的文件。服务器将启动，但不输出任何内容到屏幕上，但你能够将浏览器指向的网址：HTTP：//localhost：8080。

对于个人例子中，我建立了一个简单的HTML文件，该文件说：“Hello, Vert.x”，将其命名为index.html的，并把它放在个人根目录的目录。这里是个人输出：

$ curl http://localhost:8080

<html><html> <head><title>Hello, Vert.x</title></head><head><title>Hello, Vert.x</title></head> <body><body> <p>Hello, Vert.x</p><p>Hello, Vert.x</p> </body></body> </html></html>

与Vert.x通讯

Vert.x的最重要的特色之一是它的事件总线。所述Vert.x事件总线容许verticles，可能用不一样的编程语言，在使用任意点对点通讯彼此通讯或发布/订阅消息。在本节中，你会获得怎样的功能使用这两种方法的不一样verticles整合的感受。

在咱们开始以前，你为何要使用消息在一个更传统的基于事件的编程模型？一方面，消息支持的用不一样的编程语言应用程序和组件的集成。这也使松散耦合，这意味着您能够编写代码的多个任务为中心的做品，而不是单一的，复杂的程序。最后，verticles之间的异步通讯提升了系统的可扩展性。异步通讯容许您定义系统的容量，由于它的发展。消息可能备份您的系统负荷增长，但他们最终会被处理。Vert.x对分布式事件总线的支持也给了你启动额外verticles以处理增长的负载的选项。

为了创建一个Vert.x消息系统，则须要得到该事件总线。经过执行启动eventBus（）上的方法vertx类的实例：

EventBus eb = vertx.eventBus();

一旦你链接到EventBus您能够经过如下两种方式之一发布消息：

• publish（）发布一个消息给使用地址发布/订阅消息，这意味着每subscriber到给定的地址将接收发布的消息。地址只是一个String，因此你要选择有意义的事，但在何时是这两个出版商和用户配置为使用相同的字符串。若是你熟悉Java消息系统（JMS），publish（）起一样地做用，发布消息到一个topic。

• send（）发送消息到使用地址点对点的消息，这意味着只有一个订户将接收该消息。若是有多个用户的地址，而后Vert.x将使用循环算法发送消息。使用循环算法的优势是可扩展性：若是你没有足够的资源在一个Vert.x实例来支持你的负担，那么你能够简单地启动其余Vert.x实例，并登记他们做为听众指定的地址。

发布/订阅VS点对点通讯

在发布/订阅消息模型中，发布者将消息发送到被广播到全部用户的一个话题。使用发布/事件驱动的架构订阅了点至点的消息意味着组件只对所发生事件的发布负责。发布商并不须要知道它的订阅者，以便广播到它们。图2是一个典型的Vert.x的流程图发布/订阅消息架构。

图2.发布/订阅消息

在点 - 点通讯，将消息从发布者直接经过一个队列发送给消费者。点对点的消息是一个很好的选择，当你想消息消耗正好一次时，或者当两个组件要异步地相互通讯。点 - 点消息架构显示在图3。

图3.点对点通讯

咱们将使用Vert.x在下面的章节探讨两个邮件系统。

发布/订阅消息的例子

清单4更新我原来的服务器类（清单1）在几个方面。首先，它部署了一个所谓的新verticle AuditVerticle经过调用（如清单5中定义）deployVerticle（）的方法容器实例，其被定义为母体的一部分Verticle类，提供了通向容器verticle中运行;所以，它是部署新verticles适当的位置。

清单4. Server.java 点至点消息

package com.geekcap.vertxexamples; import org.vertx.java.core.Handler;import org.vertx.java.core.Handler; import org.vertx.java.core.eventbus.EventBus;import org.vertx.java.core.eventbus.EventBus; import org.vertx.java.core.http.HttpServerRequest;import org.vertx.java.core.http.HttpServerRequest; import org.vertx.java.core.logging.Logger;import org.vertx.java.core.logging.Logger; import org.vertx.java.platform.Verticle;import org.vertx.java.platform.Verticle; public class Server extends Verticle {public class Server extends Verticle { public void start() {public void start() { // Create our dependent verticles// Create our dependent verticles container.deployVerticle("com.geekcap.vertxexamples.AuditVerticle");.deployVerticle("com.geekcap.vertxexamples.AuditVerticle"); // Create an HTTP Server that serves files// Create an HTTP Server that serves files vertx.createHttpServer().requestHandler(new Handler<HttpServerRequest>() {.createHttpServer().requestHandler(new Handler<HttpServerRequest>() { public void handle(HttpServerRequest req) {public void handle(HttpServerRequest req) { Logger logger = container.logger();Logger logger = container.logger(); if (logger.isDebugEnabled()) {if (logger.isDebugEnabled()) { logger.debug("Received a request for resource: " + req.path());.debug("Received a request for resource: " + req.path()); }} logger.fatal("Where are my logs!?!?");.fatal("Where are my logs!?!?"); logger.info("Here is an info message");.info("Here is an info message"); // Serve up our files// Serve up our files String file = req.path().equals("/") ? "index.html" : req.path();String file = req.path().equals("/") ? "index.html" : req.path(); req.response().sendFile("webroot/" + file);.response().sendFile("webroot/" + file); // Let's tell the world (via the event bus) that we received a request// Let's tell the world (via the event bus) that we received a request EventBus eb = vertx.eventBus();EventBus eb = vertx.eventBus(); eb.publish( "com.geekcap.vertxexamples.Server.announcements", "We received a request for resource: " + req.path() );.publish( "com.geekcap.vertxexamples.Server.announcements", "We received a request for resource: " + req.path() ); }} }).listen(8080);}).listen(8080); }} }}

清单4执行deployVerticle（）来部署AuditVerticle。所述deployVerticle（）方法部署一个标准Verticle到容器上，它保持它本身的事件循环。处理传入的HTTP请求（如清单1所示）以后，清单4将消息发布到事件总线。第一，它得到经过接入到事件总线vertx实例变量的话，就执行eventBus（）方法。一旦有EventBus对象将调用其发布方法，这是一个发布/订阅的时尚门户发布的消息。

消息松耦合

在过去的三年里，我以事件驱动的架构工做过，并且我发现，发布/订阅消息，有时也被称为topic，是一个伟大的方式，以松散耦合的系统。信息发布者不须要知道他们的用户，因此新用户能够在任什么时候候加入不影响发行人。

清单5显示了源代码AuditVerticle类。

清单5. AuditVerticle.java

package com.geekcap.vertxexamples; com.geekcap.vertxexamples; import org.vertx.java.core.Handler;import org.vertx.java.core.Handler; import org.vertx.java.core.eventbus.EventBus;import org.vertx.java.core.eventbus.EventBus; import org.vertx.java.core.eventbus.Message;import org.vertx.java.core.eventbus.Message; import org.vertx.java.core.logging.Logger;import org.vertx.java.core.logging.Logger; import org.vertx.java.platform.Verticle;import org.vertx.java.platform.Verticle; public class AuditVerticle extends Verticle {public class AuditVerticle extends Verticle { @Override@Override public void start() {public void start() { // Let's register ourselves as a listener to Server notifications// Let's register ourselves as a listener to Server notifications EventBus eb = vertx.eventBus();EventBus eb = vertx.eventBus(); Handler<Message> auditHandler = new Handler<Message>() {Handler<Message> auditHandler = new Handler<Message>() { @Override@Override public void handle(Message message) {public void handle(Message message) { Logger logger = container.logger();Logger logger = container.logger(); logger.info( "AuditVerticle here, someone requested resource: " + message.body() );.info( "AuditVerticle here, someone requested resource: " + message.body() ); }} };}; eb.registerHandler( "com.geekcap.vertxexamples.Server.announcements", auditHandler );.registerHandler( "com.geekcap.vertxexamples.Server.announcements", auditHandler ); }} }}

该AuditVerticle清单5的行为很像一个报告引擎：它监听来自“announcements” server类，而后写出来的那些做为信息的日志信息。若是感兴趣的东西在发生服务器类，它能够将它发布到其announcements的topic，不一样的用户能够作不一样的事情，好比记录的消息或在Hadoop集群中供之后分析插入。

清单5而后建立一个处理程序在线实例（建立一个匿名内部类，并分配给一个变量，而无需建立一个单独的文件中的类）记录消息。接着，注册一个处理程序的“com.geekcap.vertxexamples.Server.announcements经过调用”地址EventBus的registerHandler（）方法。如今，在任什么时候候服务器类将消息发布到该目的地，AuditHandler的handle（）方法将被调用。

点 - 点通讯实例

当要仅由单个消费者或做为机构组件相互异步通讯进行处理的消息的点至点的消息时使用，也能够。在这一节中，我经过建立依赖于一个worker verticle作的工做是一个新的类演示了后者，而后该worker verticle通讯的结果返回给服务器2。

清单6显示了源代码Server2类。

清单6. Server2.java

package com.geekcap.vertxexamples; com.geekcap.vertxexamples; import org.vertx.java.core.Handler;import org.vertx.java.core.Handler; import org.vertx.java.core.eventbus.EventBus;import org.vertx.java.core.eventbus.EventBus; import org.vertx.java.core.eventbus.Message;import org.vertx.java.core.eventbus.Message; import org.vertx.java.core.http.HttpServerRequest;import org.vertx.java.core.http.HttpServerRequest; import org.vertx.java.core.logging.Logger;import org.vertx.java.core.logging.Logger; import org.vertx.java.deploy.Verticle;import org.vertx.java.deploy.Verticle; import java.util.concurrent.ConcurrentMap;import java.util.concurrent.ConcurrentMap; public class Server2 extends Verticle {public class Server2 extends Verticle { public void start() {public void start() { // Create our dependent verticles// Create our dependent verticles container.deployWorkerVerticle("com.geekcap.vertxexamples.MyWorkerVerticle");.deployWorkerVerticle("com.geekcap.vertxexamples.MyWorkerVerticle"); // Start a server that handles things with point-to-point messaging// Start a server that handles things with point-to-point messaging vertx.createHttpServer().requestHandler(new Handler<HttpServerRequest>() {.createHttpServer().requestHandler(new Handler<HttpServerRequest>() { @Override@Override public void handle(final HttpServerRequest req) {public void handle(final HttpServerRequest req) { // Set a shared variable// Set a shared variable ConcurrentMap<String, String> map = vertx.sharedData().getMap("mymap");ConcurrentMap<String, String> map = vertx.sharedData().getMap("mymap"); map.put("mykey", "myvalue");.put("mykey", "myvalue"); // Let's send a message to a worker verticle and wait for it to respond// Let's send a message to a worker verticle and wait for it to respond EventBus eb = vertx.eventBus();EventBus eb = vertx.eventBus(); eb.send("request.worker", req.path, new Handler<Message<String>>() {.send("request.worker", req.path, new Handler<Message<String>>() { @Override@Override public void handle(Message<String> message) {public void handle(Message<String> message) { Logger logger = container.getLogger();Logger logger = container.getLogger(); logger.info( "Received a reply from our worker: " + message.body );.info( "Received a reply from our worker: " + message.body ); req.response.headers().put("Content-Length", Integer.toString(message.body.length()));.response.headers().put("Content-Length", Integer.toString(message.body.length())); req.response.write(message.body);.response.write(message.body); }} });}); }} }).listen(8080);}).listen(8080); }} }}

该Server2类经过部署一个工人verticle开始。worker verticles是 从在它们不包含事件外表和预期由事件总线消息来触发标准verticles不一样。worker verticles由得到访问Vert.x部署容器并调用其deployWorkerVerticle（）方法。

接着，Server2得到访问EventBus经过调用，再次eventBus（）的方法vertx实例变量。此时的Server2调用的send（）方法，它是通往在点对点方式发送消息。在这种状况下，将请求发送路径到一个命名为“request.worker ”。到的第一个参数的send（）方法是目的地，第二个参数是数据发送到目的地，和一个可选的第三个参数是一个处理程序可以由消息的接收者被回调。

该MyWorkerVerticle，这是清单7所示，旨在构建指定的请求路径的响应和发送响应返回给Server2上的处理程序。该处理程序记录的响应，而后写入该响应返回给HttpServerRequest发起的动做。咱们可以写回以前HttpServerRequest咱们须要指定HTTP 内容长度的响应，这是咱们返回的字符串只是长度。

另外两个Vert.x的功能被添加到Server2类：

• 日志记录：该容器变量命名的方法getLogger()提供了访问Vert.x的记录。此记录是很是类似的log4j的，并提供了方法，如debug（） ，info（） ，和fatal（）记录在不一样的日志记录级别的消息。默认状况下，日志信息将被回显到标准输出和将被写入一个文件名 为vertx.log位于TMPDIR -defined目录。

• 共享数据：verticles之间共享数据是经过执行sharedData（）的方法来实现vertx实例，而后调用的共享数据访问方法之一。在清单4中，咱们存储在数据MAP是经过调用检索的GetMap（） ; 你一样能够找回共享数据的设置经过调用GETSET（） 。全部在Vert.x实例verticles的访问使用相同的模式相同的共享数据，因此它是为你verticles之间共享不可变数据的一种方式。

清单7显示了源代码MyWorkerVerticle类。

清单7. MyWorkerVerticle.java

package com.geekcap.vertxexamples; import org.vertx.java.core.Handler; import org.vertx.java.core.eventbus.EventBus; import org.vertx.java.core.eventbus.Message; import org.vertx.java.core.logging.Logger; import org.vertx.java.platform.Verticle; import java.util.concurrent.ConcurrentMap; public class MyWorkerVerticle extends Verticle { @Override public void start() { // Register a listener EventBus eb = vertx.eventBus(); Handler<Message> workerHandler = new Handler<Message>() { @Override public void handle(Message message) { Logger logger = container.logger(); logger.info( "MyWorkerVerticle just received a request for: " + message.body() ); // Examine our shared map ConcurrentMap<String, String> map = vertx.sharedData().getMap("mymap"); logger.info( "Shared data: " + map.get( "mykey" ) ); message.reply( "<html><head><title>Worker Response</title></head><body>Hello, from the worker verticle</body></html>" ); } }; eb.registerHandler( "request.worker", workerHandler ); } } 

该MyWorkerVerticle类建立一个新的处理程序与实例handle（）从处理消息的方法Server2的类。从清单6中的传递给一个参数召回的send（）方法是一个处理程序，能够经过邮件收件人调用实例。清单7调用message.reply（） ，它发送一个响应返回给始发者（在该示例中是服务器2的处理程序）。

该MyWorkerVerticle类得到访问EventBus，而后注册其处理程序以侦听发送到“request.worker”目标的消息，以完成循环。

至于功能性，MyWorkerVerticle简单地构造一个HTML文档，并返回它回到Server2类。能够经过链接到一个数据库或读取数据从另外一个服务器以检索与该创建响应中的数据创建在这个例子。

并且你会发现，MyWorkerVerticle从检索共享数据vertx的sharedData（）map。

结论

随着企业系统的复杂演变，融合已经成为了软件开发人员的编程最大的挑战之一。Vert.x解决一体化的几种方法复杂：首先，它是围绕一个事件总线，松散的耦合verticles同时支持多种编程语言构建的。无论代码是用Java编写的，ruby，python，或JavaScript，能够无缝经过Vert.x事件车内集成。此外，该事件总线自己支持异步消息和事件驱动架构，它产生的高可扩展性和松耦合。

本文展现Vert.x，其独特的语言，那它结合打造高度可扩展的企业级解决方案的核心组件的概述。我展现两个web服务器和写入Vert.x一个消息传送系统中，采用后者的例子来开发一种发布/订阅消息和点至点的消息的解决方案。在后者的例子中，我还证实事件记录，共享数据，以及标准和worker verticles之间的差别。虽然这篇文章介绍中，我谈到了一些，说明Vert.x，相似的Node.js，但它主要功能是创建在JVM的一个解决方案。我但愿启发你，更多地了解Vert.x，它解决了类型的编程挑战。h