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

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 SM 为前缀。
```
警告：大部分浏览器不支持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框架是无主题流框架--框架处理器将会立即被调用，当自定义框架
相关阅读:
文本框测试用例
 用Apache生产csr申请证书
 apche配置后报错（Forbidden）没有权限
 Apache+Tomcat配置方法
 从程序员到项目经理：项目经理必须懂的一些章法
 linux 常见命令20200424
Linux如何通过命令查看日志文件的某几行(中间极几行或最后几行)
JPA和Hibernate的关系
 SpringBoot添加webapp目录
 @NotNull, @NotEmpty和@NotBlank之间的区别是什么？
原文地址：https://www.cnblogs.com/liyafei/p/8459155.html

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

Jetty-ALPN 支持