思享工具箱

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

摘要：
请看这一章节，关于servingfilesfromtheclasspath对于类路径解决方法的限制或者使之失效socket.sendFile;流socketsNetSocket实例也是ReadStream和WriteStream实例，所以它们能够被用来推拉数据给/从其它的读取流和写入流更多的信息看这个章节streamsandpumps升级SSL/TLS连接一个非SSL/TLS连接能够升级到SSL/TLS连接使用upgradeToSsl服务或者客户端对于SSL/TLS必须配置使工作正确，请看这一章节chapteronSSL/TLS得到更多的信息。关闭TCP服务调用close去关闭服务，关闭服务可以关闭任何打开的连接，并且释放所有的服务资源关闭是异步的，可能一直没有完成直到调用返回。

写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 = newNetClientOptions().
  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(
  newJksOptions().
    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 = newJksOptions().
  setValue(myKeyStoreAsABuffer).
  setPassword("password-of-your-keystore");
NetServerOptions options = newNetServerOptions().
  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(
  newPfxOptions().
    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 = newPfxOptions().
  setValue(myKeyStoreAsABuffer).
  setPassword("password-of-your-keystore");
NetServerOptions options = newNetServerOptions().
  setSsl(true).
  setPfxKeyCertOptions(pfxOptions);
NetServer server = vertx.createNetServer(options);

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

NetServerOptions options = new NetServerOptions().setSsl(true).setPemKeyCertOptions(
  newPemKeyCertOptions().
    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 = newPemKeyCertOptions().
  setKeyValue(myKeyAsABuffer).
  setCertValue(myCertAsABuffer);
NetServerOptions options = newNetServerOptions().
  setSsl(true).
  setPemKeyCertOptions(pemOptions);
NetServer server = vertx.createNetServer(options);

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

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

指明对服务的信任

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

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

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

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

NetServerOptions options = newNetServerOptions().
  setSsl(true).
  setClientAuth(ClientAuth.REQUIRED).
  setTrustStoreOptions(
    newJksOptions().
      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 = newNetServerOptions().
  setSsl(true).
  setClientAuth(ClientAuth.REQUIRED).
  setTrustStoreOptions(
    newJksOptions().
      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 = newNetServerOptions().
  setSsl(true).
  setClientAuth(ClientAuth.REQUIRED).
  setPfxTrustOptions(
    newPfxOptions().
      setPath("/path/to/your/truststore.pfx").
      setPassword("password-of-your-truststore")
  );
NetServer server = vertx.createNetServer(options);

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

NetServerOptions options = newNetServerOptions().
  setSsl(true).
  setClientAuth(ClientAuth.REQUIRED).
  setPemTrustOptions(
    newPemTrustOptions().
      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 = newNetServerOptions().
  setSsl(true).
  setClientAuth(ClientAuth.REQUIRED).
  setPemTrustOptions(
    newPemTrustOptions().
      addCertValue(myCaAsABuffer)
  );
NetServer server = vertx.createNetServer(options);

使SSL/TLS在客户端生效

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

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

客户端信任配置

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

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

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

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

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

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

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

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

NetClientOptions options = newNetClientOptions().
  setSsl(true).
  setTrustStoreOptions(
    newJksOptions().
      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 = newNetClientOptions().
  setSsl(true).
  setTrustStoreOptions(
    newJksOptions().
      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 = newNetClientOptions().
  setSsl(true).
  setPfxTrustOptions(
    newPfxOptions().
      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 = newNetClientOptions().
  setSsl(true).
  setPfxTrustOptions(
    newPfxOptions().
      setValue(myTrustStoreAsABuffer).
      setPassword("password-of-your-truststore")
  );
NetClient client = vertx.createNetClient(options);

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

NetClientOptions options = newNetClientOptions().
  setSsl(true).
  setPemTrustOptions(
    newPemTrustOptions().
      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 = newNetClientOptions().
  setSsl(true).
  setPemTrustOptions(
    newPemTrustOptions().
      addCertValue(myTrustStoreAsABuffer)
  );
NetClient client = vertx.createNetClient(options);

指定密钥/验证 为客户端

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

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

NetClientOptions options = new NetClientOptions().setSsl(true).setKeyStoreOptions(
  newJksOptions().
    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 = newJksOptions().
  setValue(myKeyStoreAsABuffer).
  setPassword("password-of-your-keystore");
NetClientOptions options = newNetClientOptions().
  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(
  newPfxOptions().
    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 = newPfxOptions().
  setValue(myKeyStoreAsABuffer).
  setPassword("password-of-your-keystore");
NetClientOptions options = newNetClientOptions().
  setSsl(true).
  setPfxKeyCertOptions(pfxOptions);
NetClient client = vertx.createNetClient(options);

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

NetClientOptions options = new NetClientOptions().setSsl(true).setPemKeyCertOptions(
  newPemKeyCertOptions().
    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 = newPemKeyCertOptions().
  setKeyValue(myKeyAsABuffer).
  setCertValue(myCertAsABuffer);
NetClientOptions options = newNetClientOptions().
  setSsl(true).
  setPemKeyCertOptions(pemOptions);
NetClient client = vertx.createNetClient(options);

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

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

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

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

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

SelfSignedCertificate certificate =SelfSignedCertificate.create();

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

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

NetClientOptions clientOptions = newNetClientOptions()
  .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 = newNetClientOptions()
  .setSsl(true)
  .setTrustAll(true);

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

SelfSignedCertificate certificate =SelfSignedCertificate.create();

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

撤销权威验证

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

NetClientOptions options = newNetClientOptions().
  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 = newNetClientOptions().
  setSsl(true).
  setTrustStoreOptions(trustOptions).
  addCrlValue(myCrlAsABuffer);
NetClient client = vertx.createNetClient(options);

配置密码套件

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

NetServerOptions options = newNetServerOptions().
  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 = newNetServerOptions().
  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 = newNetServerOptions().
  setSsl(true).
  setKeyStoreOptions(keyStoreOptions);

//Use JDK SSL engine explicitly
options = newNetServerOptions().
  setSsl(true).
  setKeyStoreOptions(keyStoreOptions).
  setJdkSslEngineOptions(newJdkSSLEngineOptions());

//Use OpenSSL engine
options = newNetServerOptions().
  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(newNetServerOptions()
    .setKeyStoreOptions(keyCertOptions)
    .setSsl(true)
    .setSni(true)
);

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

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

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

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

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

NetClient client = vertx.createNetClient(newNetClientOptions()
    .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-tcnativejar 在类路径下。使用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.xCONNECT,SOCKS4a或SOCKS5 代理。
代理能够被配置在NetClientOptions 中，通过设置ProxyOptions  对象，包含代理类型，端口和可选的用户名和密码
这里有一个例子:
NetClientOptions options = newNetClientOptions()
  .setProxyOptions(newProxyOptions().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/2TLSh2 和TCPh2c
h2 标识 HTTP/2协议当使用 TLS商谈 通过应用层协议商谈。
h2c标识HTTP/2协议， 当用在TCP清楚文本上时，如此的连接被建立在HTTP/1.1 更新请求。
为了处理h2请求，TLS必须随着setUseAlpn开启：
HttpServerOptions options = newHttpServerOptions()
    .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 请求，这个:authoritypseudo 头返回。
请求参数
使用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框架是无主题流框架--框架处理器将会立即被调用，当自定义框架
 标签：#socket通信#vertx#客户端服务器#tcp#tls#http请求 | 浏览：311 | 发布日期：
免责声明：文章转载自《vertx 从Tcp服务端和客户端开始翻译》仅用于学习参考。如对内容有疑问，请及时联系本站处理。 
上篇redis-共享对象池Linux32_配置vncserver下篇
宿迁高防，2C2G15M，22元/月；香港BGP，2C5G5M，25元/月 雨云优惠码：MjYwNzM=
 相关文章 
Java从入门到实战之（26）Java网络实例之练习
1、获取指定主机的IP地址 如何使用 InetAddress 类的 InetAddress.getByName() 方法来获取指定主机（网址）的IP地址？ package Java_Learn.File; import java.net.InetAddress; import java.net.UnknownHostException; public...
浏览器允许的并发请求资源数是什么意思？
　　我们听到的同一域名chrome最大支持6个HTTP1.1连接，针对这个问题查到的。  我是菜鸟，就是记录一下。 　　知乎的回答：　　https://www.zhihu.com/question/20474326 　　 　　浏览器的并发请求数目限制是针对同一域名的。　　意即，同一时间针对同一域名下的请求有一定数量限制。超过限制数目的请求会被阻塞，这就...
TCP协议粘包问题详解
TCP协议粘包问题详解前言 　　在本章节中，我们将探讨TCP协议基于流式传输的最大一个问题，即粘包问题。本章主要介绍TCP粘包的原理与其三种解决粘包的方案。并且还会介绍为什么UDP协议不会产生粘包。   基于TCP协议的socket实现远程命令输入 　　我们准备做一个可以在Client端远程执行Server端shell命令并拿到其执行结果的程序，而涉及...
TCP/IP详解 笔记十三
TCP协议(一) 概述 特点 1，  面向连接可靠的字节流服务 2，  只有两方通信，不能用于广播或多播 3，  应用数据被TCP分隔为最合适发送的数据段，传给IP协议栈 4，  发送端并启动定时器，超时重传 5，  接收端需要发送确认 6，  检验和错误的数据包将被丢弃，并不确认收到此数据包（希望超时重传） 7，  重新排序，因为TCP数据包是IP报文的...
python 监控主机tcp状态脚本
脚本如下： #!/usr/bin/env python # Creator: Nicolas Magliaro - Version: 0.7 # date: 16/05/2018 import sys import json from optparse import OptionParser def _parse_args(): parse...
SqlServer2000连不上
SqlServer2000连不上 在使用 SQL Server 的过程中，用户遇到的最多的问题莫过于连接失败了。一般而言，有以下两种连接 SQL Server 的方式：     一是利用 SQL Server 自带的客户端工具，如企业管理器、查询分析器、事务探查器等。     二是利用用户自己开发的客户端程序，如ASP 脚本、VB程序等，客户端程序中又是利...
最新文章
随机推荐
 思享工具箱导航