vertx 从Tcp服务端和客户端开始翻译

写TCP 服务器和客户端

vert.x能够使你很容易写出非阻塞的TCP客户端和服务器

创建一个TCP服务

最简单的创建TCP服务的方法是使用默认的配置：如下

NetServer server = vertx.createNetServer();

配置TCP服务

如果你不想使用默认配置，当创建服务时，可以通过传递NetServerOptions实例进行配置

NetServerOptions options = new NetServerOptions().setPort(4321);
NetServer server = vertx.createNetServer(options);

开启服务监听

为了告诉服务去监听输入的请求，你可以使用listen方法

可以告诉服务监听的主机和端口号通过在在options中指定

NetServer server = vertx.createNetServer();
server.listen();

或者通过指定端口号和主机在调用listen时，忽略options中的配置

NetServer server = vertx.createNetServer();
server.listen(1234, "localhost");

默认的主机是0.0.0.0，意味着监听一切可以用的地址。默认的主机是0，是一个特殊值，可以指挥服务去发现任意一个没有用的本地端口并且使用它

实际的绑定是异步的，所以服务可能不在监听状态，直到对listen方法的调用返回之后。

如果你想被通知当服务实际监听时，你可以提供一个处理器对于listen的调用。例如：

NetServer server = vertx.createNetServer();
server.listen(1234, "localhost", res -> {
  if (res.succeeded()) {
    System.out.println("Server is now listening!");
  } else {
    System.out.println("Failed to bind!");
  }
});

监听任意端口

如果0正在被用于监听端口，服务将发现一个任意的未用的端口去监听

为了弄清楚服务监听的实际端口，可以调用actualPort 方法

NetServer server = vertx.createNetServer();
server.listen(0, "localhost", res -> {
  if (res.succeeded()) {
    System.out.println("Server is now listening on actual port: " + server.actualPort());
  } else {
    System.out.println("Failed to bind!");
  }
});

得到通知对于进来的连接

为了被通知，当一个连接建立时，你需要设置一个connectHandler

NetServer server = vertx.createNetServer();
server.connectHandler(socket -> {
  // Handle the connection in here
});

当一个连接建立，handle将会被调用通过实例NetSocket

这是一个类似socket接口 对于实际的连接，允许你读和写数据，也可以做各种不同的事情，例如关闭socket

从socket中读数据

为了能够从socket中读书节，你需要设置 handler 在socket上

handler将会被Buffer实例调用，当每次socket接收数据时。

NetServer server = vertx.createNetServer();
server.connectHandler(socket -> {
  socket.handler(buffer -> {
    System.out.println("I received some bytes: " + buffer.length());
  });
});

给socket写数据

你可以给socket写数据使用write

Buffer buffer = Buffer.buffer().appendFloat(12.34f).appendInt(123);
socket.write(buffer);

// Write a string in UTF-8 encoding
socket.write("some data");

// Write a string using the specified encoding
socket.write("some data", "UTF-16");

写操作时异步的，可能不发生，直到对write的调用返回时。

关闭handler

如果你想被通知当socket关闭时，可以设置一个 closeHandler在它上面

socket.closeHandler(v -> {
  System.out.println("The socket has been closed");
});

处理异常

你可以设置一个exceptionHandler 对于接收的任意的发生在socket上面的异常，

你可以设置一个exceptionHandler 对于接收的任意的，发生在连接传递给connectHandler之前的异常，例如，在TLS 握手期间

Event bus 写处理器

每个socket 将会自动注册一个处理器在event bus上，当任何buffers被接收在这个处理器上，它将会写它们给它自己。

这能够使你写数据给一个socket,socket潜在的可能在一个完全不同的verticle中，甚至在完全不同的Vert.x实例中，通过发送buffer给这个地址去处理。

handler地址可以通过writeHandlerID 获得。

本地和远程地址

NetSocket本地地址可以通过localAddress获得。

NetSocket本地地址可以通过remoteAddress获得。

发送文件和资源从类路径。

文件和类路径下的资源可以直接写进socket，通过使用sendFile。这是很有效的发送文件的方式，因为它能直接被操作系统内核处理，操作系统支持。

请看这一章节，关于serving files from the classpath 对于类路径解决方法的限制或者使之失效

socket.sendFile("myfile.dat");

流sockets

NetSocket实例也是ReadStream和WriteStream实例，所以它们能够被用来推拉数据给/从其它的读取流和写入流

更多的信息看这个章节streams and pumps

升级SSL/TLS连接

一个非SSL/TLS连接能够升级到SSL/TLS连接使用 upgradeToSsl

服务或者客户端对于SSL/TLS必须配置使工作正确，请看这一章节chapter on SSL/TLS得到更多的信息。

关闭TCP服务

调用close 去关闭服务，关闭服务可以关闭任何打开的连接，并且释放所有的服务资源

关闭是异步的， 可能一直没有完成直到调用返回。如果你想被通知当这个实际的连接关闭时，那么你可以传递一个handler

handler将会被调用当关闭完全完成

server.close(res -> {
  if (res.succeeded()) {
    System.out.println("Server is now closed");
  } else {
    System.out.println("close failed");
  }
});

自动清理verticles

如果你创建了TCP服务和客户端从verticles内部，服务和客户端将会自动关闭当verticle发布时。

可扩展性-共享TCP服务

任何TCP服务的处理器总是执行在相同的event loop 线程上

这意味着，如果你运行了一个服务在很多核心上，你仅仅有一个实例发布，你将至少有一个核可用在服务上

为了使你的服务利用更多的核，你需要发布更多的服务实例。

你可以实例化更多的实例程序在你的代码中

for (int i = 0; i < 10; i++) {
  NetServer server = vertx.createNetServer();
  server.connectHandler(socket -> {
    socket.handler(buffer -> {
      // Just echo back the data
      socket.write(buffer);
    });
  });
  server.listen(1234, "localhost");
}

或者，如果你使用verticles,你可以简单的发布更多的服务实例，通过使用 -instances 选项在命令行中

vertx run com.mycompany.MyVerticle -instances 10

或者在程序中发布你的verticle

DeploymentOptions options = new DeploymentOptions().setInstances(10);
vertx.deployVerticle("com.mycompany.MyVerticle", options);

一旦你做了这些，你将发现服务工作的作用明显比以前，但是所有的内核都能够使用，更多的工作能够被处理

你可能会问自己，怎么有超过一个服务监听在相同的主机和端口号上，是否会有端口冲突当你发布超过一个实例时？

Vert.x 在这里做了一些魔法

当你发布另一个服务时在相同的已经存在服务的主机和端口号上，它实际上不需要创建一个新的服务监听在相同的服务和端口上。

相反，它内部仅维持一个单一的服务，当连接进来时，它分配它们给连接处理器用轮询的方式，

接下来，Vert.x TCP服务可以扩展可用的核心 ，每个实例保持单一的线程

创建一个TCP客户端

最简单的创建TCP客户端的方式是，全部使用默认选项

NetClient client = vertx.createNetClient();

配置TCP 客户端

如果你不想使用默认的配置，当创建客户端时，可以通过传递一个NetClientOptions实例进行配置。

NetClientOptions options = new NetClientOptions().setConnectTimeout(10000);
NetClient client = vertx.createNetClient(options);

建立连接

为了与服务建立一个连接，使用connect ，指定端口号和服务主机，一个handler 将会被调用，一个结果包含NetSocket 当连接成功时，或者当连接失败时。

NetClientOptions options = new NetClientOptions().setConnectTimeout(10000);
NetClient client = vertx.createNetClient(options);
client.connect(4321, "localhost", res -> {  //handler with a result
  if (res.succeeded()) {
    System.out.println("Connected!");
    NetSocket socket = res.result();
  } else {
    System.out.println("Failed to connect: " + res.cause().getMessage());
  }
});

配置连接

一个客户端可以配置自动重新获得与服务的连接，配置如下：

setReconnectInterval 和 setReconnectAttempts.

注意：目前Vert.x 将不会试图重新获得连接如果一个连接失败，重新获得的连接和时间间隔仅仅作用于初始连接

NetClientOptions options = new NetClientOptions().
  setReconnectAttempts(10).
  setReconnectInterval(500);

NetClient client = vertx.createNetClient(options);

默认情况下，多重连接尝试时无效的。

网络日志活动

调试目的，网络活动可以被打印成日志

NetServerOptions options = new NetServerOptions().setLogActivity(true);

NetServer server = vertx.createNetServer(options);

对于客户端

NetClientOptions options = new NetClientOptions().setLogActivity(true);

NetClient client = vertx.createNetClient(options);

网络活动被打印成日志通过Netty，使用DEBUG级别，用io.netty.handler.logging.LoggingHandler 的名字。当使用网络活动日志，这里有几件事情需要牢记心中

*日志不是通过Vert.x执行而是Netty

*这不是一个生产特性

你应该阅读Netty logging 部分

配置服务和客户端工作于 SSL/TLS

TCP客户端和服务器能够被配置使用 Transport Layer Security  更早的TLS版本以SSL知名

服务端和客户端APIs 通过是否使用SSL/TLS被区分，通过配置NetClientOptions 或者NetServerOptions 实例使其生效。

使SSL/TLS生效在服务上

SSL/TLS是有效的用 ssl

默认是无效的。

指定 键/验证 在服务端。

SSL/TLS服务通常提供验证给客户端去验证它们的标识在客户端。

Certificates/keys 验证能够为服务端配置通过几种方式：

第一种方法是通过指定java 键的存储位置，它包含验证和私钥。

java 密钥存储可以通过 keytool  工具管理，来自于 JDK

对于存储密钥的密码也应该被提供：

NetServerOptions options = new NetServerOptions().setSsl(true).setKeyStoreOptions(
  new JksOptions().
    setPath("/path/to/your/server-keystore.jks").
    setPassword("password-of-your-keystore")
);
NetServer server = vertx.createNetServer(options);

你可以读的自己存储的密钥作为一个流并且提供它

Buffer myKeyStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/server-keystore.jks");
JksOptions jksOptions = new JksOptions().
  setValue(myKeyStoreAsABuffer).
  setPassword("password-of-your-keystore");
NetServerOptions options = new NetServerOptions().
  setSsl(true).
  setKeyStoreOptions(jksOptions);
NetServer server = vertx.createNetServer(options);

密钥/验证 在PKCS#12格式http://en.wikipedia.org/wiki/PKCS_12 经常使用.pfx或者.p12扩展，能够被加载以更相似流行的方式比JKS密钥存储。

NetServerOptions options = new NetServerOptions().setSsl(true).setPfxKeyCertOptions(
  new PfxOptions().
    setPath("/path/to/your/server-keystore.pfx").
    setPassword("password-of-your-keystore")
);
NetServer server = vertx.createNetServer(options);

缓冲流配置也是支持的：

Buffer myKeyStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/server-keystore.pfx");
PfxOptions pfxOptions = new PfxOptions().
  setValue(myKeyStoreAsABuffer).
  setPassword("password-of-your-keystore");
NetServerOptions options = new NetServerOptions().
  setSsl(true).
  setPfxKeyCertOptions(pfxOptions);
NetServer server = vertx.createNetServer(options);

另外一个提供服务私钥和验证 可以使用 .pem文件。

NetServerOptions options = new NetServerOptions().setSsl(true).setPemKeyCertOptions(
  new PemKeyCertOptions().
    setKeyPath("/path/to/your/server-key.pem").
    setCertPath("/path/to/your/server-cert.pem")
);
NetServer server = vertx.createNetServer(options);

缓冲流配置也是支持的：

Buffer myKeyAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/server-key.pem");
Buffer myCertAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/server-cert.pem");
PemKeyCertOptions pemOptions = new PemKeyCertOptions().
  setKeyValue(myKeyAsABuffer).
  setCertValue(myCertAsABuffer);
NetServerOptions options = new NetServerOptions().
  setSsl(true).
  setPemKeyCertOptions(pemOptions);
NetServer server = vertx.createNetServer(options);

PKCS8, PKCS1 和 X.509 验证环绕在PEM块格式也是支持的。

警告:记住 pem配置，私钥不是地下墓室

指明对服务的信任

SSL/TLS服务能够使用官方验证去证明客户端标识。

官方验证能够配置在服务端用一些以下 几种方式：

java 信任存储能够用keytool  工具管理，来自于 JDK

还应该提供信任存储库的密码。

NetServerOptions options = new NetServerOptions().
  setSsl(true).
  setClientAuth(ClientAuth.REQUIRED).
  setTrustStoreOptions(
    new JksOptions().
      setPath("/path/to/your/truststore.jks").
      setPassword("password-of-your-truststore")
  );
NetServer server = vertx.createNetServer(options);

你可以选择读取信任存储库作为一个流，直接提供

Buffer myTrustStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/truststore.jks");
NetServerOptions options = new NetServerOptions().
  setSsl(true).
  setClientAuth(ClientAuth.REQUIRED).
  setTrustStoreOptions(
    new JksOptions().
      setValue(myTrustStoreAsABuffer).
      setPassword("password-of-your-truststore")
  );
NetServer server = vertx.createNetServer(options);

权威验证 用 PKCS#12格式 （http://en.wikipedia.org/wiki/PKCS_12），通常用.pfx或者.p12作为扩展名。以一种比JKS信任存储更流行的方式加载。

NetServerOptions options = new NetServerOptions().
  setSsl(true).
  setClientAuth(ClientAuth.REQUIRED).
  setPfxTrustOptions(
    new PfxOptions().
      setPath("/path/to/your/truststore.pfx").
      setPassword("password-of-your-truststore")
  );
NetServer server = vertx.createNetServer(options);

另外提供服务端权威验证可以使用.pem列表文件。

NetServerOptions options = new NetServerOptions().
  setSsl(true).
  setClientAuth(ClientAuth.REQUIRED).
  setPemTrustOptions(
    new PemTrustOptions().
      addCertPath("/path/to/your/server-ca.pem")
  );
NetServer server = vertx.createNetServer(options);

缓冲流配置也是支持的：

Buffer myCaAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/server-ca.pfx");
NetServerOptions options = new NetServerOptions().
  setSsl(true).
  setClientAuth(ClientAuth.REQUIRED).
  setPemTrustOptions(
    new PemTrustOptions().
      addCertValue(myCaAsABuffer)
  );
NetServer server = vertx.createNetServer(options);

使SSL/TLS在客户端生效

网络客户端能够容易配置去使用SSL. 它们有正确相同的API 当使用SSL作为标准的sockets时。

为了使SSL在网络客户端生效，函数setSSL(true) 被调用

客户端信任配置

如果trustALl 在客户端设置为true,那么客户端将会信任所有的服务验证。连接将会加密，但是模式是易受攻击的对于中间侵害，例如，你可能不相信连接的人。使用这些要小心，默认值是false

NetClientOptions options = new NetClientOptions().
  setSsl(true).
  setTrustAll(true);
NetClient client = vertx.createNetClient(options);

如果trustAll 没有被设置，那么客户端信任存储必须被配置并且应该包含服务端（客户端信任的服务端）的验证

默认情况下，在客户端，主机验证是无效的，为了使主机验证有效，在客户端设置算法去使用。（目前，仅HTTPS和LDAPS是支持的）

NetClientOptions options = new NetClientOptions().
  setSsl(true).
  setHostnameVerificationAlgorithm("HTTPS");
NetClient client = vertx.createNetClient(options);

除了服务配置，客户端信任应该被配置用几种方式：

第一种方法应该指定java 信任存储所在的位置，它应该包含权威验证。

它仅仅是一个标准的java 密钥存储，与服务端的密钥存储是相同的。服务端存储的位置应该被设置通过使用函数path 在jks options 上。如果一个服务含有一个验证当连接不包含客户端信任存储的时候，这个连接尝试将不会成功。

NetClientOptions options = new NetClientOptions().
  setSsl(true).
  setTrustStoreOptions(
    new JksOptions().
      setPath("/path/to/your/truststore.jks").
      setPassword("password-of-your-truststore")
  );
NetClient client = vertx.createNetClient(options);

缓冲流配置也是支持的：

Buffer myTrustStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/truststore.jks");
NetClientOptions options = new NetClientOptions().
  setSsl(true).
  setTrustStoreOptions(
    new JksOptions().
      setValue(myTrustStoreAsABuffer).
      setPassword("password-of-your-truststore")
  );
NetClient client = vertx.createNetClient(options);

权威验证用PKCS#12格式(http://en.wikipedia.org/wiki/PKCS_12)，经常使用.pfx或者.p12扩展，能够更流行的方式被加载比JKS信任存储

NetClientOptions options = new NetClientOptions().
  setSsl(true).
  setPfxTrustOptions(
    new PfxOptions().
      setPath("/path/to/your/truststore.pfx").
      setPassword("password-of-your-truststore")
  );
NetClient client = vertx.createNetClient(options);

缓冲流配置也是支持的

Buffer myTrustStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/truststore.pfx");
NetClientOptions options = new NetClientOptions().
  setSsl(true).
  setPfxTrustOptions(
    new PfxOptions().
      setValue(myTrustStoreAsABuffer).
      setPassword("password-of-your-truststore")
  );
NetClient client = vertx.createNetClient(options);

另外一个提供服务端权威验证的方法是使用.pem文件

NetClientOptions options = new NetClientOptions().
  setSsl(true).
  setPemTrustOptions(
    new PemTrustOptions().
      addCertPath("/path/to/your/ca-cert.pem")
  );
NetClient client = vertx.createNetClient(options);

缓冲流配置也是支持的：

Buffer myTrustStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/ca-cert.pem");
NetClientOptions options = new NetClientOptions().
  setSsl(true).
  setPemTrustOptions(
    new PemTrustOptions().
      addCertValue(myTrustStoreAsABuffer)
  );
NetClient client = vertx.createNetClient(options);

指定密钥/验证 为客户端

如果服务器需要客户端验证，那么客户端必须出示它自己的验证给服务器，当建立连接的时候。客户端可以通过以下几种方式配置：

第一种方式是指定java 密钥存储的位置，它应该包含密钥和验证。再一次，它仅仅是一个规则的java 键存储。客户端密钥存储位置被设置通过使用函数path在jks options 上。

NetClientOptions options = new NetClientOptions().setSsl(true).setKeyStoreOptions(
  new JksOptions().
    setPath("/path/to/your/client-keystore.jks").
    setPassword("password-of-your-keystore")
);
NetClient client = vertx.createNetClient(options);

缓冲流配置也是支持的：

Buffer myKeyStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/client-keystore.jks");
JksOptions jksOptions = new JksOptions().
  setValue(myKeyStoreAsABuffer).
  setPassword("password-of-your-keystore");
NetClientOptions options = new NetClientOptions().
  setSsl(true).
  setKeyStoreOptions(jksOptions);
NetClient client = vertx.createNetClient(options);

密钥/验证 用PKCS#12格式(http://en.wikipedia.org/wiki/PKCS_12)，通常使用.pfx或者.p12扩展，以一种比JKS密钥存储更流行的方式加载。

NetClientOptions options = new NetClientOptions().setSsl(true).setPfxKeyCertOptions(
  new PfxOptions().
    setPath("/path/to/your/client-keystore.pfx").
    setPassword("password-of-your-keystore")
);
NetClient client = vertx.createNetClient(options);

缓冲流配置也是支持的：

Buffer myKeyStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/client-keystore.pfx");
PfxOptions pfxOptions = new PfxOptions().
  setValue(myKeyStoreAsABuffer).
  setPassword("password-of-your-keystore");
NetClientOptions options = new NetClientOptions().
  setSsl(true).
  setPfxKeyCertOptions(pfxOptions);
NetClient client = vertx.createNetClient(options);

另一种提供服务端私钥和验证的方法可以分别使用.pem文件

NetClientOptions options = new NetClientOptions().setSsl(true).setPemKeyCertOptions(
  new PemKeyCertOptions().
    setKeyPath("/path/to/your/client-key.pem").
    setCertPath("/path/to/your/client-cert.pem")
);
NetClient client = vertx.createNetClient(options);

缓冲流配置也是支持的：

Buffer myKeyAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/client-key.pem");
Buffer myCertAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/client-cert.pem");
PemKeyCertOptions pemOptions = new PemKeyCertOptions().
  setKeyValue(myKeyAsABuffer).
  setCertValue(myCertAsABuffer);
NetClientOptions options = new NetClientOptions().
  setSsl(true).
  setPemKeyCertOptions(pemOptions);
NetClient client = vertx.createNetClient(options);

记住：pem配置，私钥没有被加密

用于测试和开发目的的自签名证书。

小心：不要使用生产设置，记住产生的密钥是不安全的。

经常出现需要自签名验证的情况，使它成为单元/继承测试 或者 运行开发版本为一个应用

SelfSignedCertificate 能够被用来提供自签名PEM验证帮助和给出KeyCertOptions 和TrustOptions 配置

SelfSignedCertificate certificate = SelfSignedCertificate.create();

NetServerOptions serverOptions = new NetServerOptions()
  .setSsl(true)
  .setKeyCertOptions(certificate.keyCertOptions())
  .setTrustOptions(certificate.trustOptions());

NetServer server = vertx.createNetServer(serverOptions)
  .connectHandler(socket -> socket.write("Hello!").end())
  .listen(1234, "localhost");

NetClientOptions clientOptions = new NetClientOptions()
  .setSsl(true)
  .setKeyCertOptions(certificate.keyCertOptions())
  .setTrustOptions(certificate.trustOptions());

NetClient client = vertx.createNetClient(clientOptions);
client.connect(1234, "localhost", ar -> {
  if (ar.succeeded()) {
    ar.result().handler(buffer -> System.out.println(buffer));
  } else {
    System.err.println("Woops: " + ar.cause().getMessage());
  }
});

客户端可以配置成信任所有的验证：

NetClientOptions clientOptions = new NetClientOptions()
  .setSsl(true)
  .setTrustAll(true);

注意自签名验证也可以工作于其它的TCP协议，像HTTPS：

SelfSignedCertificate certificate = SelfSignedCertificate.create();

vertx.createHttpServer(new HttpServerOptions()
  .setSsl(true)
  .setKeyCertOptions(certificate.keyCertOptions())
  .setTrustOptions(certificate.trustOptions()))
  .requestHandler(req -> req.response().end("Hello!"))
  .listen(8080);

撤销权威验证

信任可以被配置，通过使用验证撤回列表(CRL) 撤销验证，应该不再被信任。crlPath 配置列表去使用。

NetClientOptions options = new NetClientOptions().
  setSsl(true).
  setTrustStoreOptions(trustOptions).
  addCrlPath("/path/to/your/crl.pem");
NetClient client = vertx.createNetClient(options);

缓冲区配置也是支持的：

Buffer myCrlAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/crl.pem");
NetClientOptions options = new NetClientOptions().
  setSsl(true).
  setTrustStoreOptions(trustOptions).
  addCrlValue(myCrlAsABuffer);
NetClient client = vertx.createNetClient(options);

配置密码套件

默认情况下，TLS配置将会使用JVM的密码套件运行Vert.x, 密码套件能够被配置使用一套有效的密码。

NetServerOptions options = new NetServerOptions().
  setSsl(true).
  setKeyStoreOptions(keyStoreOptions).
  addEnabledCipherSuite("ECDHE-RSA-AES128-GCM-SHA256").
  addEnabledCipherSuite("ECDHE-ECDSA-AES128-GCM-SHA256").
  addEnabledCipherSuite("ECDHE-RSA-AES256-GCM-SHA384").
  addEnabledCipherSuite("CDHE-ECDSA-AES256-GCM-SHA384");
NetServer server = vertx.createNetServer(options);

密码套件能够被指定通过NetServerOptions 或 NetClientOptions 配置。

配置TLS 协议版本

默认情况下，LTS配置将使用下面的协议版本,SSLv2Hello, TLSv1, TLSv1.1 和 TLSv1.2。协议版本将会直接被配置通过添加有效的协议：

NetServerOptions options = new NetServerOptions().
  setSsl(true).
  setKeyStoreOptions(keyStoreOptions).
  removeEnabledSecureTransportProtocol("TLSv1").
  addEnabledSecureTransportProtocol("TLSv1.3");
NetServer server = vertx.createNetServer(options);

协议版本能够被指定通过 NetServerOptions 或  NetClientOptions 配置。

SSL 引擎

引擎实现能够被配置去使用 OpenSSL 代替 JDK实现，OpenSSL 提供更好的性能 和 CPU利用率 比JDK引擎，和JDK版本依赖。

引擎选项使用：

getSslEngineOptions 选项当其设置时

否者用  JdkSSLEngineOptions

NetServerOptions options = new NetServerOptions().
  setSsl(true).
  setKeyStoreOptions(keyStoreOptions);

// Use JDK SSL engine explicitly
options = new NetServerOptions().
  setSsl(true).
  setKeyStoreOptions(keyStoreOptions).
  setJdkSslEngineOptions(new JdkSSLEngineOptions());

// Use OpenSSL engine
options = new NetServerOptions().
  setSsl(true).
  setKeyStoreOptions(keyStoreOptions).
  setOpenSslEngineOptions(new OpenSSLEngineOptions());

服务器名字指示

服务器名字指示是一个TLS扩展，客户端指定试图连接的主机名：当TLS握手期间，客户端给出服务器名字和服务器能使用的和服务器通信发布的证书，不使用默认发布的证书。如果服务器需要客户端证明服务器能使用指定信任的CA证书，依赖指示服务器名字。

当SNI激活服务器使用时:

CN 或者 SAN DNS 证书 做额外的匹配，例如 www.example.com

证书 CN or SAN DNS 验证 匹配 通配符名，例如  *.example.com

另外 ，第一个证书，当客户端 不表示服务器名字时或者表示服务器名字不能被匹配。

当服务器额外需要客户端验证时：

如果 JksOptions 被使用设置信任选项(options) 那么一个正确的匹配对于信任存储别名被完成。

另外，可用的CA证书被使用用同样的方式，如果没有SNI在合适的位置。

你能够开启SNI在服务端通过设置 setSni 为true,配置服务端用多重密钥/验证对。

Java 密钥存储文件或PKCS12文件能存储多重密钥/证书对，开箱即用。

JksOptions keyCertOptions = new JksOptions().setPath("keystore.jks").setPassword("wibble");

NetServer netServer = vertx.createNetServer(new NetServerOptions()
    .setKeyStoreOptions(keyCertOptions)
    .setSsl(true)
    .setSni(true)
);

PemKeyCertOptions 能够被配置拥有多重实体：

PemKeyCertOptions keyCertOptions = new PemKeyCertOptions()
    .setKeyPaths(Arrays.asList("default-key.pem", "host1-key.pem", "etc..."))
    .setCertPaths(Arrays.asList("default-cert.pem", "host2-key.pem", "etc...")
    );

NetServer netServer = vertx.createNetServer(new NetServerOptions()
    .setPemKeyCertOptions(keyCertOptions)
    .setSsl(true)
    .setSni(true)
);

客户端隐含发送连接的主机作为SNI服务端名字对于全限定名。

你可以直接提供一个服务器名字当连接一个socket时

NetClient client = vertx.createNetClient(new NetClientOptions()
    .setTrustStoreOptions(trustOptions)
    .setSsl(true)
);

// Connect to 'localhost' and present 'server.name' server name
client.connect(1234, "localhost", "server.name", res -> {
  if (res.succeeded()) {
    System.out.println("Connected!");
    NetSocket socket = res.result();
  } else {
    System.out.println("Failed to connect: " + res.cause().getMessage());
  }
});

能用于多种目的：

表示一个不同于于服务器主机的服务器名字

表示一个服务器名字当连接IP时

强制表示一个服务器名字当使用缩减名时

应用层协议商谈

应用层协议商谈是一个应用层协议商谈的TLS扩展，用于HTTP/2:在TLS握手期间，客户端给出应用层协议列表，包含它支持的服务器响应协议。

如果你使用 Java9,这是很好的，你可以使用HTTP/2开箱即用，无需额外的步骤。

Java8 不支持ALPN开箱即用，所以ALPN应该开启通过其它方式：

OpenSSL 支持

Jetty-ALPN支持

引擎选项使用

getSslEngineOptions 选项当它设置时

JdkSSLEngineOptions 当ALPN可用时对于JDK.

OpenSSLEngineOptions 当ALPN对于OpenSSL可用时

否者，失败

OpenSSL ALPN支持

OpenSSL 提供本地ALPN支持。

OpenSSL 需要配置 setOpenSslEngineOptions 和使用 netty-tcnative jar 在类路径下。使用  tcnative 可能需要OpenSSL安装在你的操作系统中，依赖于 tcnative 实现。

Jetty-ALPN 支持

Jetty-ALPN 是一个小的jar,复写了java 8 的一些类 为了支持ALPN.

JVM必须开始以alpn-boot-${version}.jar  在 它的bootclasspath

-Xbootclasspath/p:/path/to/alpn-boot${version}.jar
${version} 依赖JVM版本，例如。 OpenJDK 1.8.0u74 的8.1.7.v20160121 全部可用的列表在  Jetty-ALPN page.
版本主要的缺陷依赖于 JVM
为了解决这个问题  Jetty ALPN agent 能够被替代。代理是一个JVM代理 将会关闭ALPN版本 用JVM运行它。

-javaagent:/path/to/alpn/agent
使用代理对于客户端连接
NetClient 支持HTTP/1.x CONNECT, SOCKS4a 或 SOCKS5 代理。
代理能够被配置在NetClientOptions 中，通过设置ProxyOptions  对象，包含代理类型，端口和可选的用户名和密码
这里有一个例子:

NetClientOptions options = new NetClientOptions()
  .setProxyOptions(new ProxyOptions().setType(ProxyType.SOCKS5)
    .setHost("localhost").setPort(1080)
    .setUsername("username").setPassword("secret"));
NetClient client = vertx.createNetClient(options);

DNS方法总是在代理服务器上完成，为了实现SOCKS4 客户端的函数，必须解决DNS 本地地址

写HTTP服务器和客户端

Vert.x允许你很容易的写出非阻塞的HTTP客户端和服务器。Vert.x支持 HTTP/1.0, HTTP/1.1 和HTTP/2协议。
HTTP基础的API和HTTP/1.x ， HTTP/2相同，具体的API特性可用于处理HTTP/2协议。
创建HTTP服务器
创建HTTP服务器最简单的方式时使用默认选项，如下：

HttpServer server = vertx.createHttpServer();

配置HTTP服务

如果你不想使用默认选项，一个服务器可以被配置通过传递一个HttpServerOptions 实例当创建它时。

HttpServerOptions options = new HttpServerOptions().setMaxWebsocketFrameSize(1000000);

HttpServer server = vertx.createHttpServer(options);

配置HTTP/2服务端。

Vert.x支持HTTP/2 TLS h2 和 TCP h2c 

h2 标识 HTTP/2协议当使用 TLS商谈 通过应用层协议商谈。

h2c标识HTTP/2协议， 当用在TCP清楚文本上时，如此的连接被建立在HTTP/1.1  更新请求。

为了处理h2请求，TLS必须随着setUseAlpn 开启：

HttpServerOptions options = new HttpServerOptions()
    .setUseAlpn(true)
    .setSsl(true)
    .setKeyStoreOptions(new JksOptions().setPath("/path/to/my/keystore"));

HttpServer server = vertx.createHttpServer(options);

ALPN是一个商谈协议的TLS扩展，在客户端和服务器开始交换数据之前。

不支持ALPN的客户端将一直能够用经典的握手。

ALPN将会同意h2协议，尽管 http/1.1 能够使用，如果服务器或客户端决定使用。

为了处理h2c请求，TLS必须失效，服务将更新到HTTP/2 ,任何HTTP/1.1请求想更新到HTTP/2.它也将接受一个直接的h2c连接，以 PRI * HTTP/2.0\r\nSM\r\n 为前缀。

警告：大部分浏览器不支持h2c,所以对于服务端网站，你应该使用h2 ，不是h2c。

当服务端接收一个HTTP/2连接，它将发送给客户端初始化设置，设置定义客户端怎么使用连接，默认的服务端初始化设置是：

getMaxConcurrentStreams：100被推荐作为HTTP/2 RFC
对于其它的服务器，默认的HTTP/2设置值

注意：工作线程和HTTP/2不兼容

日志网络服务活动

为了调试，网络日志能够被日志记录

HttpServerOptions options = new HttpServerOptions().setLogActivity(true);

HttpServer server = vertx.createHttpServer(options);

更多详细的信息看章节 logging network activity

开启服务监听

为了告诉服务器监听进入的请求，你可以使用一个可选监听

为了告诉服务器指定的监听端口，在选项中

HttpServer server = vertx.createHttpServer();
server.listen();

或者指定主机和端口号在调用listen时，忽视在选项中的配置。

HttpServer server = vertx.createHttpServer();
server.listen(8080, "myhost.com");

默认的主机是 0.0.0.0 ，意味着监听所有可用的地址，默认的端口是80.

实际的绑定是异步的，以至于服务器不能够实际监听直到调用listen返回之后。

如果你想被通知对于服务器实际监听，你可以提供一个handler对于listen调用。例如：

HttpServer server = vertx.createHttpServer();
server.listen(8080, "myhost.com", res -> {
  if (res.succeeded()) {
    System.out.println("Server is now listening!");
  } else {
    System.out.println("Failed to bind!");
  }
});

对于进入的请求得到通知

当一个请求到达，想被通知，你可以设置一个requestHandler

HttpServer server = vertx.createHttpServer();
server.requestHandler(request -> {
  // Handle the request in here
});

处理请求

当一个请求到达时，请求处理器被调用时，传递进  HttpServerRequest 实例。这个对象代表服务端的HTTP请i求。

handler 被调用，当请求头被完全读时。

如果请求包含请求体，请求体将会到达服务器，在请求处理器被调用之后。

服务端请求对象允许你得到 uri, path, params 和 headers ，所有其它的事情。

 每个服务请求对象和服务响应对象相联系。你可以使用 response 得到一个 HttpServerResponse 对象引用。

这里有一个简单的 例子，服务器处理请求并且用 “hello world ”回应。

vertx.createHttpServer().requestHandler(request -> {
  request.response().end("Hello world");
}).listen(8080);

请求版本

在请求中指定的HTTP版本可以通过 version 获得

请求方法

使用 method 获得请求的HTTP 方法（例如。 GET, POST, PUT, DELETE, HEAD, OPTIONS 等）

请求URI

使用 uri 能够获得请求的 URI

记住，这是传递给HTTP请求实际URI，它总是一个相对的URI.

URI定义在  Section 5.1.2 of the HTTP specification - Request-URI

请求路径

使用 path 获得URI的路径部分

例如，如果请求URI是：

a/b/c/page.html?param1=abc&param2=xyz

那么路径是

/a/b/c/page.html
请求查询
使用 query 返回URI的查询部分
例如：如果URI是

a/b/c/page.html?param1=abc&param2=xyz
那么查询部分是：

param1=abc&param2=xyz
请求头
使用 headers 返回HTTP请求的头。
返回一个 MultiMap 实例，它像一个普通的 Map 或者Hash ,但是对于相同的键允许多重值，这是因为 HTTP允许 多重头值对于相同的键。

它也是大小写不敏感的，意味着你能够做下面的事：

MultiMap headers = request.headers();

// Get the User-Agent:
System.out.println("User agent is " + headers.get("user-agent"));

// You can also do this and get the same result:
System.out.println("User agent is " + headers.get("User-Agent"));

请求主机

使用 host 返回HTTP请求的主机。

对于 HTTP/1.x  请求，主机头返回，对于HTTP/1  请求，这个 :authority pseudo 头返回。

请求参数

使用 params 返回HTTP请求参数

就像  headers  将返回一个 MultiMap 实例，因为这里可能有超过一个参数用相同的名字。

请求参数被送通过请求URI,在路径之后，例如，如果一个URI是：

/page.html?param1=abc&param2=xyz
那么这个请求参数将包含下面的：

param1: 'abc'
param2: 'xyz

记住，请求参数能够从请求URL中获得。如果你有表单属性，它将会作为HTML表单属性的一部分提交，在 multi-part/form-data 格式的请求体中。

远程地址

发送的请求地址能够通过 remoteAddress 获得。

绝对URI

传递给HTTP请求的URI经常是相关的。如果你想获得与请求通信的绝对的URI，你可以得到它用absoluteURI

最终处理器

请求的 endHandler 被调用当完全请求时，包括任何请求体已经被读的。

从请求体中读数据

通常HTTP请求包含请求体我们想要读取的 。   如前面所述，请求处理器将会被调用当请求头到达时，在那个时刻，请求对象不包含请求体。

这是因为body可能非常大,例如文件上传，我们一般不想缓冲全部的请求体在内存中在处理它之前，如此将会造成服务器耗尽可用的内存。

为了获得body,你可以使用handler  在请求上，每当请求体的块到达时，他将会被调用，这里有一个例子

request.handler(buffer -> {
  System.out.println("I have received a chunk of the body of length " + buffer.length());
});

传递给 handler的对象是一个 Buffer，handler会被调用多次当数据从网络中到达时，依赖于请求体的大小。

在一些情况下，（例如：请求体是小的）你将想吞噬所有的请求体在内存中，所以你可以自己做吞噬，如下：

Buffer totalBuffer = Buffer.buffer();

request.handler(buffer -> {
  System.out.println("I have received a chunk of the body of length " + buffer.length());
  totalBuffer.appendBuffer(buffer);
});

request.endHandler(v -> {
  System.out.println("Full body received, length = " + totalBuffer.length());
});

这里有一个公共的案例，Vert.x提供 bodyHandler 为你，body处理器被调用当所有的body被接收时：

request.bodyHandler(totalBuffer -> {
  System.out.println("Full body received, length = " + totalBuffer.length());
});

抽去请求

请求对象是一个读取流ReadStream，所以你能抽取请求体对于任意的 写入流WriteStream实例

更多的详情看这一章节  streams and pumps

处理HTML表单

HTML表单能够被提交以内容类型 application/x-www-form-urlencoded 和 multipart/form-data. 对于url编码的表单，表单属性能够被编码在url中，就像正常的请求参数。

对于多部分表单 ，它们能够被编码在请求体中，因为如此时不可用的，直到所有的请求体从数据报中读入。

多部分表单也能包含文件上传。

如果你想获得多部分表单，你应该告诉Vert.x你期望获得如此的表单在body的任何部分被读入之前，通过调用 setExpectMultipart 为true。然后，你应该获得实际的属性使用 formAttributes 一旦全部的body被读入：

server.requestHandler(request -> {
  request.setExpectMultipart(true);
  request.endHandler(v -> {
    // The body has now been fully read, so retrieve the form attributes
    MultiMap formAttributes = request.formAttributes();
  });
});

处理表单文件上传

Vert.x 也能处理文件上传，文件被编码为多部分请求体

为了接收文件上传，你告诉Vert.x期望多部分表单，在请求上 设置  uploadHandler

处理器将会被调用，一旦每个上传都到达服务器。

对象传递给处理器一个 HttpServerFileUpload 实例。

server.requestHandler(request -> {
  request.setExpectMultipart(true);
  request.uploadHandler(upload -> {
    System.out.println("Got a file upload " + upload.name());
  });
});

上传的文件可能非常大，我们不能够提供全部的上传在一次单一的缓冲流中，这可能导致内存耗尽，相反，上传数据被接受以块形式：

request.uploadHandler(upload -> {
  upload.handler(chunk -> {
    System.out.println("Received a chunk of the upload of length " + chunk.length());
  });
});

上传的对象是一个 读入流，所以你能提取请求体对于任意写入流实例。更多详细信息看章节streams and pumps

如果你仅仅想上传文件到硬盘，你可以使用streamToFileSystem：

request.uploadHandler(upload -> {
  upload.streamToFileSystem("myuploads_directory/" + upload.filename());
});

警告：确保你检查文件名在生产系统中，去避免有害的客户端上传文件到任意位置在你的文件系统中，看  安全笔记  security notes得到更多的 信息

处理压缩体

Vert.x 能够处理压缩体，压缩体能够被编码通过客户端，用 deflate 或 gzip 算法。

为了使解压缩有效，你可以设置 setDecompressionSupported 在选项上，当创建服务时。

默认解压缩时无效的 。

接受定制的HTTP/2框架

HTTP/2是一个框架协议用各种各样的HTTP 请求/响应 模型。协议允许其它种类的框架被接收和发送。

为了接收定制框架，你可以使用 customFrameHandler  在请求上，这将会被调用每次定制框架到达时。这里有一个例子：

request.customFrameHandler(frame -> {

  System.out.println("Received a frame type=" + frame.type() +
      " payload" + frame.payload().toString());
});

HTTP/2框架是无主题流框架--框架处理器将会立即被调用，当自定义框架