Vert.x 3学习笔记---01
Vert.x 3 core:
Vert.x core主要提供了一下功能：
- Writing TCP clients and servers(TCP 客户端和服务端)
- Writing HTTP clients and servers including support for WebSockets(HTTP客户端和服务端，提供WebSocket的支持)
- The Event bus(事件总线)
- Shared data - local maps and clustered distributed maps（共享数据，本地map和集群map）
- Periodic and delayed actions(定期和延迟的动作)
- Deploying and undeploying Verticles(部署和卸载Verticles)
- Datagram Sockets(数据报)
- DNS client
- File system access
- High availability(高可用)
- Clustering（可集群化）
Vert.x 3提供多种语言编程，支持java、ruby、goovy、JavaScript、Ceylon。提供了原生的ＡＰＩ支持。
Maven (in your pom.xml):
<dependency>
<groupId>io.vertx</groupId>
<artifactId>vertx-core</artifactId>
<version>3.2.1</version>
</dependency>Gradle (in your build.gradle file):
compile io.vertx:vertx-core:3.2.11. 从vertx对象开始：
Vertx vertx = Vertx.vertx();你可以直接使用以上代码获取vertx对象，以便能很便捷的使用。不过我们大多数的app只是单个的vertx对象，再一些特殊情况下可能使用多个，例如：事件总线或者多个服务端或者多个客户端之间。
创建vertx对象还可以使用一些参数来创建：
Vertx vertx = Vertx.vertx( new VertxOptions().setWorkerPoolSize(40) );VertxOptions对象就是包含这些设置参数的对象。
2. Don’t call us, we’ll call you.(一个很著名的模式)
vert.x是事件驱动的，当有你感兴趣的事件产生时，vert.x会调用你(异步)。举个例子，你可以接收一个时间(每秒的)事件:
vertx.setPeriodic(1000, id -> {
// This handler will get called every second
System.out.println("timer fired!");
});或者接收一个http的请求：
server.requestHandler(request -> {
// This handler will be called every time an HTTP request is received at the server
request.response().end("hello world!");
});不要阻塞
在Vert.x中只有很少的地方会进行阻塞操作，例如同步操作下的文件系统操作。
如果(请求的)结果能够很迅速的得到，那么就快速的返回结果就可以了。否则的话，你需要提供一个handler(回调)来监听一些事件。因为Vert.x的api不会去阻塞线程，因此你可以使用很少的线程来达到一些同步的操作。
当然也会有一些很方便的同步操作会阻塞线程，例如：从socket读取数据，向磁盘写入数据，向一个容器发送数据并等待返回，等等。
Reactor and Multi-Reactor
大多数的情况下，Vert.x通过一个叫event-loop的线程来调用咱们的handler(回调)。因为没有阻塞，event-loop线程在很短的事件里，会交付巨量的handler回调。
标准的Reactor实现，是基于单例的event-loop线程。而这会带来一定程度的困扰。因为一次只能运行一个，因此如果需要扩展的话，你就不得不启动和管理多个不同的进程。
Vert.x在这一点上的实现有所不同。一个vert.x对象包含了多个event-loop实例。默认情况下，Vert.x选择了基于机器可用内核的数量，但我们是可以改变的。这也就意味着一个Vert.x对象可以扩展(across your server)，这一点上是node.js不能比拟的。
我们称这种模式叫Multi-Reactor Pattern。
The Golden Rule - Don’t Block the Event Loop
(黄金法则：不要阻塞event-loop线程)
Running blocking code
在讨论之前，我们不应该直接的在event-loop线程中调用阻塞代码。如果这样的话，将会导致之前的代码不能工作。
我们可以通过executeBlocking 来执行同步的代码。
vertx.executeBlocking(future -> {
// Call some blocking API that takes a significant amount of time to return
String result = someAPI.blockingMethod("hello");
future.complete(result);
}, res -> {
System.out.println("The result is: " + res.result());
});当在同一个context下(如同一个vertical中)执行了非常多的executeBlocking，这些executeBlocking会排队按顺序执行。但是如果你不关心这些executeBlocking执行的顺序，那么你可以设置executeBlocking的参数ordered为false。这样的话所有的executeBlocking代码就会并行的在工作线程中执行。
还有一种替代方案：将所有的阻塞代码作为一个worker verticle(见后面章节)
Async coordination 异步协调
通过Vert.x 的futures类来实现异步返回结果的协调问题。
Future<HttpServer> httpServerFuture = Future.future();
httpServer.listen(httpServerFuture.completer());
Future<NetServer> netServerFuture = Future.future();
netServer.listen(netServerFuture.completer());
CompositeFuture.all(httpServerFuture, netServerFuture).setHandler(ar -> {
if (ar.succeeded()) {
// All server started 全部成功
} else {
// At least one server failed 至少一个失败
}
});CompositeFuture.all可以将所有的future包含起来，然后判断所有的这些future是否全部成功还是有失败的。如上面的例子。
Future<String> future1 = Future.future();
Future<String> future2 = Future.future();
CompositeFuture.any(future1, future2).setHandler(ar -> { if (ar.succeeded()) { // At least one is succeeded 至少有一个是成功的 } else { // All failed 全部失败 }
});CompositeFuture.any 跟all的意思一样，但是判断成功失败的条件不一样。
FileSystem fs = vertx.fileSystem();
Future<Void> fut1 = Future.future();
Future<Void> fut2 = Future.future();
fs.createFile("/foo", fut1.completer());
fut1.compose(v -> {
fs.writeFile("/foo", Buffer.buffer(), fut2.completer());
}, fut2);
fut2.compose(v -> {
fs.move("/foo", "/bar", startFuture.completer());
}, startFuture);以上代码表明，compose方法可以链式的调用Future。
参考文档地址：http://vertx.io/docs/vertx-core/java/