Eclipse Vert.x 4.3 迁移指南

WriteStream<T>.write （） 和 WriteStream<T>.end （） 方法不再是 fluent。

这是有问题的更改。如果您已将虚线用于写入流，请更新您的应用程序。

MessageProducer 接口不会扩展 WriteStream 接口。

在之前的 Eclipse Vert.x 版本中，MessageProducer 接口扩展了 WriteStream 接口。MessageProducer 界面提供对消息后端的支持。泄漏泄漏将减少消息制作者中的学分。如果这些泄漏使用了所有学分，则不会发送消息。

但是，MessageConsumer 将继续扩展 ReadStream。当 MessageConsumer 暂停并且待处理的消息队列已满时，消息将被丢弃。这会继续与 Rx 生成器集成，以构建使用管道的消息。

MessageProducer 界面中的发送方法已被删除。

使用 MessageProducer<T>.write (T) 而不是 MessageProducer<T>.send (T) 和 EventBus.request (String,Object,Handler) 的方法，而不是 MessageProducer.send (T,Handler)。

EventBus.send (…​, Handler<AsyncResult<Message<T>>) 和 Message.reply (…​, Handler<AsyncResult<Message<T>>) 方法已被删除。这些方法可能会导致 Eclipse Vert.x 4 中出现过载问题。该方法的版本返回 Future<Message<T > 将与触发和忘记版本冲突。

请求响应的消息传递模式应使用新的 请求和 replyAndRequest 方法。

以下示例显示了请求并回复 Eclipse Vert.x 3.x 版本中的消息。

eventBus.send("the-address", body, ar -> ...);

eventBus.consumer("the-address", message -> {
       message.reply(body, ar -> ...);
});

以下示例显示了请求并回复 Eclipse Vert.x 4 中的消息。

eventBus.request("the-address", body, ar -> ...);

eventBus.consumer("the-address", message -> {
  message.replyAndRequest(body, ar -> ...);
});

从 Eclipse Vert.x 4 开始，未来会支持多个处理程序。Future<T>.setHandler （） 方法用于设置单一处理程序并已被删除。使用 Future<T>.onComplete （）、Future<T> .onSuccess （） 和 Future<T>.onFailure （） 方法，而是在完成、成功和失败结果上调用处理程序。

以下示例演示了如何在 Eclipse Vert.x 3.x 版本中调用处理器。

Future<String> fut = getSomeFuture();
fut.setHandler(ar -> ...);

以下示例演示了如何在 Eclipse Vert.x 4 中调用新的 Future<T>.onComplete （） 方法。

Future<String> fut = getSomeFuture();
fut.onComplete(ar -> ...);

在较早版本的 Eclipse Vert.x 中，您可以使用 Future.completer （） 方法访问 Handler<AsyncResult<T&gt;>，这与 Future 相关联。

在 Eclipse Vert.x 4 中，Future<T>.completer （） 方法已被删除。future<T&gt; 直接扩展 Handler<AsyncResult<T>。您可以使用 Future 对象访问所有处理器方法。Future 对象也是处理程序。

HttpClientRequest.connectionHandler （） 方法已被删除。使用 HttpClient.connectionHandler （） 方法调用应用中客户端请求的连接处理程序。

以下示例演示了如何在 Eclipse Vert.x 3.x 版本中使用 HttpClientRequest.connectionHandler （） 方法。

client.request().connectionHandler(conn -> {
  // Connection related code
}).end();

以下示例演示了如何在 Eclipse Vert.x 4 中使用新的 HttpClient.connectionHandler （） 方法。

client.connectionHandler(conn -> {
  // Connection related code
});

在较早版本的 Eclipse Vert.x 中，VerleFactory.createVerticle （） 方法异步实例化verticle。从 Eclipse Vert.x 4 onward 中，该方法异步实例化verticle，并返回回调 callable<Verticle > 而不是单个验证实例。这种改进使应用调用此方法一次，并多次调用可返回调用，以创建多个实例。

以下代码演示了如何使用 Eclipse Vert.x 3.x 版本实例化。

Verticle createVerticle(String verticleName, ClassLoader classLoader) throws Exception;

以下代码演示了如何使用 Eclipse Vert.x 4 进行实例化。

void createVerticle(String verticleName, ClassLoader classLoader, Promise<Callable<Verticle>> promise);

VerticleFactory 类已被简化。类不需要对标识符进行初始解析，因为工厂可以使用嵌套部署来部署verticle。

如果您的现有应用程序使用工厂，在 Eclipse Vert.x 4 中，您可以更新代码，以便在承诺完成或失败时使用可调用的。可调用的可能是多次。

以下示例显示了 Eclipse Vert.x 3.x 应用程序中的现有因素。

return new MyVerticle();

以下示例演示了如何更新现有工厂以在 Eclipse Vert.x 4 中使用承诺。

promise.complete(() -> new MyVerticle());

如果您希望 factory 阻塞代码，请使用 Vertx.executeBlocking （） 方法。当工厂收到块代码时，它应该可以解决承诺并从承诺获取白色实例。

删除了多线程 worker verticle 部署选项。这个功能只能与 Eclipse Vert.x event-bus 一起使用。HTTP 等其他 Eclipse Vert.x 组件不支持该功能。

使用 unordered Vertx.executeBlocking （） 方法实现与多线程 worker 部署相同的功能。

Vertx.getOrCreateContext （） 方法为每个非 Eclipse Vert.x 线程创建一个上下文。非 Eclipse Vert.x 线程在首次创建上下文时与上下文关联。在早期版本中，每次从非 Eclipse Vert.x 线程调用方法时，都会创建一个新上下文。

new Thread(() -> {
  assertSame(vertx.getOrCreateContext(), vertx.getOrCreateContext());
}).start();

这个更改不会影响您的应用程序，除非应用程序隐式依赖于每个调用创建新上下文。

在以下示例中，因为每个阻塞代码在不同的上下文上调用了 n 块，所以 n 块会同时运行。

for (int i = 0;i < n;i++) {
  vertx.executeBlocking(block, handler);
}

要在 Eclipse Vert.x 4 中获得相同的结果，您必须更新代码：

for (int i = 0;i < n;i++) {
  vertx.executeBlocking(block, false, handler);
}

下面的部分论述了 Eclipse Vert.x HTTP 方法中的各种更新。

// 3.x
options.setMaxPoolSize(30); // Maximum connection is set to 30 for each endpoint

// 4.x
options.setMaxWebSockets(30); // Maximum connection is set to 30 for each endpoint

switch (method) {
  case GET:
    ...
    break;
  case OTHER:
    String s = request.getRawMethod();
    if (s.equals("PROPFIND") {
      ...
    } else ...
}

switch (method.name()) {
  case "GET":
    ...
    break;
  case "PROPFIND";
    ...
    break;
}

HttpMethod PROPFIND = HttpMethod.valueOf("PROPFIND");

if (method == HttpMethod.GET) {
  ...
} else if (method.equals(PROPFIND)) {
  ...
} else {
  ...
}

client.request(HttpMethod.OTHER, ...).setRawName("PROPFIND");

client.request(HttpMethod.valueOf("PROPFIND"), ...);

本节论述了 HTTP 客户端中的更改。

有以下类型的 Eclipse Vert.x 客户端可用：

HttpClientRequest request = client.get(80, "example.com", "/", response -> {
  int statusCode = response.statusCode();
  response.exceptionHandler(err -> {
    // Handle connection error, for example, connection closed
  });
  response.bodyHandler(body -> {
    // Handle body entirely
  });
});
request.exceptionHandler(err -> {
  // Handle connection error OR response error
});
request.end();

client.get(80, "example.com", "/some-uri")
  .send(ar -> {
    if (ar.suceeded()) {
      HttpResponse<Buffer> response = ar.result();
      // Handle response
    }  else {
      // Handle error
    }
  });

HttpClientRequest request = client.get(80, "example.com", "/", response -> {
  int statusCode = response.statusCode();
  response.exceptionHandler(err -> {
    // Handle connection error, for example, connection closed
  });
  response.bodyHandler(body -> {
    // Handle body entirely
  });
});
request.exceptionHandler(err -> {
  // Handle connection error OR response error
});
request.end();

client.request(HttpMethod.GET, 80, "example.com", "/", ar -> {
  if (ar.succeeded()) {
    HttpClientRequest = ar.result();
    request.send(ar2 -> {
      if (ar2.succeeded()) {
        HttpClientResponse = ar2.result();
        int statusCode = response.statusCode();
        response.body(ar3 -> {
          if (ar3.succeeded()) {
            Buffer body = ar3.result();
            // Handle body entirely
          } else {
            // Handle server error, for example, connection closed
          }
        });
      } else {
        // Handle server error, for example, connection closed
      }
    });
  } else {
    // Connection error, for example, invalid server or invalid SSL certificate
  }
});

Future<Buffer> fut = client.request(HttpMethod.GET, 80, "example.com", "/")
  .compose(request -> request.send().compose(response -> {
    int statusCode = response.statusCode();
    if (statusCode == 200) {
      return response.body();
    } else {
      return Future.failedFuture("Unexpectd status code");
    }
  })
});
fut.onComplete(ar -> {
  if (ar.succeeded()) {
    Buffer body = ar.result();
    // Handle body entirely
  } else {
    // Handle error
  }
});

request.end();

request.end(Buffer.buffer("hello world));

writeStream.pipeTo(request, ar -> {
  if (ar.succeeded()) {
    // Sent the stream
  }
});

// Send a request and process the response
request.onComplete(ar -> {
  if (ar.succeeded()) {
    HttpClientResponse response = ar.result();
    // Handle the response
  }
})
request.end();

// The new send method combines all the operations
request.send(ar -> {
  if (ar.succeeded()) {
    HttpClientResponse response = ar.result();
    // Handle the response
  }
}));

HttpClient client = vertx.createHttpClient(options);

    client.request(HttpMethod.GET, 8443, "localhost", "/")
      .onSuccess(request -> {
        request.onSuccess(resp -> {

        //Code to handle HTTP response
        });
      });

HttpClient client = vertx.createHttpClient(options);

    client.request(HttpMethod.GET, 8443, "localhost", "/")
      .onSuccess(request -> {
        request.response().onSuccess(resp -> {

        //Code to handle HTTP response
        });
      });

client.request(HttpMethod.GET, 8080, "example.com", "/resource", ar -> {
  if (ar.succeeded()) {
    HttpClientRequest request = ar.result();
    request.putHeader("content-type", "application/json")
    request.send(new JsonObject().put("hello", "world"))
      .onSuccess(response -> {
      //
      }).onFailure(err -> {
      //
       });
     }
})

client.request().connectionHandler(conn -> {
  // Connection related code
}).end();

client.connectionHandler(conn -> {
// Connection related code
});

client.request(HttpMethod.CONNECT, uri, ar -> {
  if (ar.succeeded()) {
    HttpClientResponse response = ar.result();
    if (response.statusCode() == 200) {
      NetSocket so = response.netSocket();
   }
  }
}).end();

client.request(HttpMethod.CONNECT, uri, ar -> {
}).netSocket(ar -> {
  if (ar.succeeded()) {
   // Got a response with a 200 status code
   NetSocket so = ar.result();
   // Go for tunneling
  }
}).end();

Future<HttpClientResponse> f1 = client.send(HttpMethod.GET, 8080, "localhost", "/uri", HttpHeaders.set("foo", "bar"));

MultiMap headers = MultiMap.caseInsensitiveMultiMap();

MultiMap headers = HttpHeaders.headers();

MultiMap headers = HttpHeaders.set("content-type", "application.data");

CaseInsensitiveHeaders headers = new CaseInsensitiveHeaders();

MultiMap multiMap = MultiMap#caseInsensitiveMultiMap();

MultiMap headers = HttpHeaders.headers();

client.request(HttpMethod.GET, 8080, "example.com", "/resource", ar -> {
  if (ar.succeeded()) {
    HttpClientRequest request = ar.result();
    request.putHeader("content-type", "application/json")
    request.send(new JsonObject().put("hello", "world"))
      .onSuccess(response -> {
      //
      }).onFailure(err -> {
      //
       });
     }
})

NetServerOptions.isClientAuthRequired （） 方法已被删除。使用 getClientAuth （）== ClientAuth.REQUIRED enumerated 类型来检查是否需要客户端身份验证。

以下示例演示了如何使用 switch 语句来检查是否需要验证客户端。

switch (options.getClientAuth()) {
case REQUIRED:
// ... behavior same as in releases prior to {VertX} {v4}
break;
default:
// fallback statement...
}

以下示例演示了如何使用检查 Eclipse Vert.x 4 中的客户端验证。

if (options.getClientAuth() == ClientAuth.REQUIRED) {
// behavior in releases prior to {VertX} {v4}

NetSocket.upgradeToSsl （） 方法已更新为使用 Handler<AsyncResult&gt; 而不是 Handler。该处理程序用于检查频道是否已成功升级到 SSL 或 TLS。

日志记录 类 logger 和 LoggerFactory 及其方法已被弃用。这些日志类和方法将在以后的版本中删除。

Log4j 1 日志记录器不再可用。但是，如果要使用 Log4j 1 日志记录器，则可通过 SLF4J 使用。

在 Eclipse Vert.x 4.1.0 中，支持 RxJava 3。

要升级到 RxJava 3，您必须进行以下更改：

WriteStreamSubscriber.onComplete （） 回调已被删除。如果 WriteStream 有待处理的数据流需要写入，则调用此回调。

在 Eclipse Vert.x 4 中，使用 callbacks WriteStreamSubscriber.onWriteStreamEnd （） 和 WriteStreamSubscriber.onWriteStreamError （）。这些回调在 WriteStream.end （） 完成后调用。

WriteStreamSubscriber<Buffer> subscriber = writeStream.toSubscriber();

以下示例演示了如何从 Eclipse Vert.x 3.x 版本的 WriteStream 中创建适配器。

subscriber.onComplete(() -> {
    // Called after writeStream.end() is invoked, even if operation has not completed
});

以下示例演示了如何使用 Eclipse Vert.x 4 中的新回调方法从 WriteStream 创建适配器：

subscriber.onWriteStreamEnd(() -> {
    // Called after writeStream.end() is invoked and completes successfully
});

subscriber.onWriteStreamError(() -> {
    // Called after writeStream.end() is invoked and fails
});

已删除方法 ConfigRetriever.getConfigAsFuture （）。使用方法 retriever.getConfig （） 替代。

以下示例演示了如何在 Eclipse Vert.x 3.x 版本中检索配置。

Future<JsonObject> fut = ConfigRetriever. getConfigAsFuture(retriever);

以下示例演示了如何在 Eclipse Vert.x 4 中检索配置。

fut = retriever.getConfig();

JSON 类中的所有实现 Jackson 类型的方法均已被删除。使用以下方法之一：

例如，使用以下代码：

在早期版本中，运行时需要 Jackson core 和 Jackson databind 依赖项。

从 Eclipse Vert.x 4 onward 中，只需要 Jackson 核心依赖项。

只有在对象映射 JSON 时，才需要 Jackson databind 依赖项。在这种情况下，您必须在 com.fasterxml.jackson.core:jackson-databind jar 中明确添加项目描述符中的依赖关系。

上述类型支持以下方法。

只支持使用 Jackson bind 的方法：

Eclipse Vert.x JSON 类型实现了 RFC-7493。在较早版本的 Eclipse Vert.x 中，实施会错误地使用 Base64 编码程序而不是 Base64URL。这个问题已在 Eclipse Vert.x 4 中修复，在 JSON 类型中使用 Base64URL encoder。

如果您要继续使用 Eclipse Vert.x 4 中的 Base64 编码器，您可以使用 旧的 配置标志。以下示例演示了如何在 Eclipse Vert.x 4 中设置配置标志。

java -Dvertx.json.base64=legacy ...

如果您部分迁移了从 Eclipse Vert.x 3.x 到 Eclipse Vert.x 4 的迁移，则应用程序将在版本 3 和 4 上进行。在这种情况下，您可以使用以下实用程序将 Base64 字符串转换为 Base64URL。

public String toBase64(String base64Url) {
  return base64Url
    .replace('+', '-')
    .replace('/', '_');
}

public String toBase64Url(String base64) {
  return base64
    .replace('-', '+')
    .replace('_', '/');
}

在以下情况下必须使用工具方法：

使用以下示例代码将 Base64URL 转换为 Base64 编码程序。

String base64url = someJsonObject.getString("base64encodedElement")
String base64 = toBase64(base64url);

Base64 和 toBase64 Url 的帮助程序功能仅启用 JSON 迁移。如果您使用对象映射将 JSON 对象自动映射到应用程序中的 Java POJO，则必须创建一个自定义对象映射程序，将 Base64 字符串转换为 Base64URL。

以下示例演示了如何使用自定义 Base64 解码器创建对象映射程序。

// simple deserializer from Base64 to byte[]
class ByteArrayDeserializer extends JsonDeserializer<byte[]> {
  ByteArrayDeserializer() {
  }

  public byte[] deserialize(JsonParser p, DeserializationContext ctxt) {
    String text = p.getText();
    return Base64.getDecoder()
      .decode(text);
  }
}

// ...

ObjectMapper mapper = new ObjectMapper();

// create a custom module to address the Base64 decoding
SimpleModule module = new SimpleModule();
module.addDeserializer(byte[].class, new ByteArrayDeserializer());
mapper.registerModule(module);

// JSON to POJO with custom deserializer
mapper.readValue(json, MyClass.class);

TrustOptions.toJSON 方法已被删除。

在较早版本的 Eclipse Vert.x 中，您必须在会话中指定 User SessionHandler 和 SessionHandler 处理程序处理程序。

为了简化这个过程，在 Eclipse Vert.x 4 中，UserSessionHandler 类已被删除，并在 SessionHandler 类中添加了其功能。在 Eclipse Vert.x 4 中，若要用于会话，您必须只指定一个处理程序。

删除了以下 Cookie 接口：

使用 io.vertx.core.http.Cookie 接口。

FaviconHandler 和 ErrorHandler 中的 create 方法已更新。您必须在创建方法中传递 Vertx 实例对象。这些方法访问文件系统。传递 Vertx 对象可确保使用"Vertx"文件系统对文件进行一致的访问。

以下示例演示了如何在 Eclipse Vert.x 3.x 版本中使用创建方法。

FaviconHandler.create();
ErrorHandler.create();

以下示例演示了如何在 Eclipse Vert.x 4 中使用创建方法。

FaviconHandler.create(vertx);
ErrorHandler.create(vertx);

使用 TemplateEngine.unwrap （） 方法访问模板引擎。然后，您可以将自定义和配置应用到模板。

用于获取和设置引擎配置的方法已弃用。改为使用 TemplateEngine.unwrap （） 方法。

io.vertx.ext.web.Locale 接口已被删除。使用 io.vertx.ext.web.LanguageHeader 接口。

已删除 RoutingContext.acceptableLocales （） 方法。使用 RoutingContext.acceptableLanguages （） 方法。

在较早版本的 Eclipse Vert.x 中，Router.mountSubRouter （） 方法错误地返回 路由器。这个问题已被解决，方法现在会返回一个 Route。

JWTAuthHandler.create (JWTAuth authProvider, String skip) 方法已被删除。使用 JWTAuthHandler.create (JWTAuth authProvider) 方法。

以下示例演示了如何在 Eclipse Vert.x 3.x 版本中创建 JWT 身份验证处理程序。

router
   // protect everything but "/excluded/path"
   .route().handler(JWTAuthHandler(jwtAuth, "/excluded/path")

以下示例演示了如何在 Eclipse Vert.x 4 中创建 JWT 身份验证处理程序。

router
   .route("/excluded/path").handler(/* public access to "/excluded/path" */)
   // protect everything
   .route().handler(JWTAuthHandler(jwtAuth)

在 Eclipse Vert.x 4 中，GGi 环境不再被支持。StaticHandler.create (String, ClassLoader) 方法已被删除，因为此方法已在 OSGi 环境中使用。

如果您在应用程序中使用了此方法，那么在 Eclipse Vert.x 4 中，您可以将资源添加到应用程序类路径或提供文件系统中的资源。

sockjs.BridgeOptions 类已被删除。改为使用新的 sockjs.SockJSBridgeOptions 类。sockjs.SockJSBridgeOptions 类包含配置事件总线网桥所需的所有选项。

新类的行为没有改变，但数据对象类的名称已改变。

在以前的版本中，当您使用 sockjs.BridgeOptions 类来添加新网桥时，会出现许多重复的配置。新类包含所有可能的通用配置，并删除重复的配置。

默认情况下，Sock JSSocket 不再注册集群事件总线使用者。如果要使用事件总线写入套接字，您必须在 SockJSHandlerOptions 中启用 writeHandler。当您启用 writeHandler 时，事件总线使用者默认设为 local。

Router router = Router.router(vertx);
SockJSHandlerOptions options = new SockJSHandlerOptions()
  .setRegisterWriteHandler(true); // enable the event bus consumer registration
SockJSHandler sockJSHandler = SockJSHandler.create(vertx, options);
router.mountSubRouter("/myapp", sockJSHandler.socketHandler(sockJSSocket -> {
  // Retrieve the writeHandlerID and store it (For example, in a local map)
  String writeHandlerID = sockJSSocket.writeHandlerID();
}));

您可以将事件总线消费者配置为集群。

SockJSHandlerOptions options = new SockJSHandlerOptions()
  .setRegisterWriteHandler(true) // enable the event bus consumer registration
  .setLocalWriteHandler(false) // register a clustered event bus consumer

SessionHandler.setAuthProvider (AuthProvider) 方法已弃用。改为使用 SessionHandler.addAuthProvider （） 方法。新的方法允许应用使用多个身份验证提供程序，并将会话对象链接到这些身份验证提供程序。

从 Eclipse Vert.x 4，OAuth2Auth.create (Vertx vertx) 方法需要 vertx 作为 constructor 参数。vertx 参数使用安全非阻塞随机数生成器来生成非保障，以确保应用程序的安全性。

现在，在 polyglot 环境中支持以下方法：* UploadScalar 现在是一个 factory，使用 UploadScalar.create （） 的方法替代。

在以前的版本中，Eclipse Vert.x Web GraphQL 处理程序可以处理自己的 POST 请求。它不需要 Eclipse Vert.x Web BodyHandler 处理请求。但是，这种实施容易受到 DDoS 攻击的影响。

从 Eclipse Vert.x 4 onward 中，需要处理 POST 请求 BodyHandler。在安装 Eclipse Vert.x Web GraphQL 处理程序前，您必须安装 BodyHandler。

在以前的版本中，以下指标被记录为套接字的发行摘要。从 Eclipse Vert.x 4 onward 中，这些指标以计数器的形式记录，后者报告交换的数据量。

对于这些计数器，在 HTTP 中引入了等效的分布摘要。这些摘要用于收集有关请求和响应大小的信息。

以下指标已被重命名。

vertx-web-openapi 模块使用 RouterBuilder 来构建 Eclipse Vert.x Web 路由器。此路由器构建器与 vertx-web-api-contract 模块中的路由器 builer OpenAPI3RouterFactory 类似。

要开始使用 vertx-web-openapi 模块，可实例化 RouterBuilder。

RouterBuilder.create(vertx, "petstore.yaml").onComplete(ar -> {
  if (ar.succeeded()) {
    // Spec loaded with success
    RouterBuilder routerBuilder = ar.result();
  } else {
    // Something went wrong during router builder initialization
    Throwable exception = ar.cause();
  }
});

您还可以使用未来实例化 RouterBuilder。

RouterBuilder.create(vertx, "petstore.yaml")
  .onSuccess(routerBuilder -> {
    // Spec loaded with success
  })
  .onFailure(exception -> {
    // Something went wrong during router builder initialization
  });

在大多数情况下，您可以使用新的 RouterBuilder 方法搜索和替换旧的 OpenAPI3RouterFactory 方法的使用。下表列出了一些旧方法和新方法示例。

使用以下语法访问解析的请求参数：

RequestParameters parameters = routingContext.get(io.vertx.ext.web.validation.ValidationHandler.REQUEST_CONTEXT_KEY);
int aParam = parameters.queryParameter("aParam").getInteger();

在 Eclipse Vert.x 4 中，方法 RouterFactory.addSecurityHandler （） 和 OpenAPI3RouterFactory.addSecuritySchemaScopeValidator （） 不再可用。

改为使用 RouterBuilder.securityHandler （） 方法。此方法接受 io.vertx.ext.web.handler.AuthenticationHandler 作为处理程序。该方法自动识别 OAuth2Handler 并设置安全架构。

新的安全处理程序也实现了 OpenAPI 规格 中定义的操作。

在 vertx-web-openapi 模块中，以下失败处理程序不可用：您必须使用 Router.errorHandler (int, Handler) 方法设置失败处理程序。

在 Eclipse Vert.x 4 中，OpenAPI 合同没有映射到普通的旧的 Java 对象(POJO)。因此，不再需要额外的 swagger-parser 依赖项。您可以使用 getters 和解析器来检索合同的特定组件。

以下示例演示了如何使用单一操作来检索特定的组件。

JsonObject model = routerBuilder.operation("getPets").getOperationModel();

以下示例演示了如何检索完整的合同。

JsonObject contract = routerBuilder.getOpenAPI().getOpenAPI();

以下示例演示了如何解决合同部分。

JsonObject petModel = routerBuilder.getOpenAPI().getCached(JsonPointer.from("/components/schemas/Pet"));

在 vertx-web-api-contract 模块中，您可以使用 HTTPRequestValidationHandler 验证 HTTP 请求。您不必使用 OpenAPI 进行验证。

在 Eclipse Vert.x 4 中，验证 HTTP 请求使用 vertx-web-validation 模块。您可以导入这个模块，并在不使用 OpenAPI 的情况下验证请求。使用 ValidationHandler 验证请求。

vertx-web-api-service 模块已更新，并可与 vertx-web-validation 模块一起使用。如果您使用 vertx-web-openapi 模块，则不会更改 web 服务功能。

但是，如果您不使用 OpenAPI，则使用带有 vertx-web-validation 模块的 web 服务模块，则必须使用 RouteToEBServiceHandler 类。

router.get("/api/transactions")
  .handler(
    ValidationHandlerBuilder.create(schemaParser)
      .queryParameter(optionalParam("from", stringSchema()))
      .queryParameter(optionalParam("to", stringSchema()))
      .build()
  ).handler(
    RouteToEBServiceHandler.build(eventBus, "transactions.myapplication", "getTransactionsList")
  );

vertx-web-api-service 模块不支持 vertx-web-api-contract。因此，当您升级到 Eclipse Vert.x 4 时，您必须将 Eclipse Vert.x OpenAPI 应用程序迁移到 vertx-web-openapi 模块。

以下方法已从 CircuitBreaker 类中删除，因为它们无法用于将来。

以下在服务发现中创建了方法，它使用 Handler<AmqpMessage > 作为参数被删除。这些方法无法用于未来的。

ServiceDiscovery.registerServiceImporter （） 和 ServiceDiscovery.registerServiceExporter （） 方法不再是 fluent。该方法返回 Future<Void>。

vertx-service-discovery-bridge-kubernetes 添加 KubernetesServiceImporter 发现网桥。网桥从 Kubernetes 或 Openshift 将服务导入到 Eclipse Vert.x 服务发现。

从 Eclipse Vert.x 4，这个网桥不再自动注册。即使您已在 Maven 项目的类路径中添加了网桥，它也不会自动注册。

在创建 ServiceDiscovery 实例后，您必须手动注册该网桥。

以下示例演示了如何手动注册网桥。

JsonObject defaultConf = new JsonObject();
serviceDiscovery.registerServiceImporter(new KubernetesServiceImporter(), defaultConf);

SecretOptions 类不再可用。使用新的 PubSecKeyOptions 类来用于加密密钥。

以下示例演示了如何在 Eclipse Vert.x 3.x 版本中使用 SecretOptions 类方法。

new SecretOptions()
    .setType("HS256")
    .setSecret("password")

以下示例演示了如何在 Eclipse Vert.x 4 中使用 PubSecKeyOptions 类的方法。

new PubSecKeyOptions()
    .setAlgorithm("HS256")
    .setSecretKey("password")

在 Eclipse Vert.x 3.x 中，公钥密钥管理中的配置对象假定为：

以下示例演示了如何在 Eclipse Vert.x 3.x 中配置密钥对。

new PubSecKeyOptions()
  .setPublicKey(
    // remove the PEM boundaries
    pubPemString
      .replaceAll("-----BEGIN PUBLIC KEY----")
      .replaceAll("-----END PUBLIC KEY----"))
  .setSecretKey(
    // remove the PEM boundaries
    secPemString
      .replaceAll("-----BEGIN PUBLIC KEY----")
      .replaceAll("-----END PUBLIC KEY----"));

在 Eclipse Vert.x 4 中，您必须指定公钥和私钥。

以下示例演示了如何在 Eclipse Vert.x 4 中配置密钥对。

PubSecKeyOptions pubKey =
  new PubSecKeyOptions()
    // the buffer is the exact contents of the PEM file and had boundaries included in it
    .setBuffer(pubPemString);

PubSecKeyOptions secKey =
  new PubSecKeyOptions()
    // the buffer is the exact contents of the PEM file and had boundaries included in it
    .setBuffer(secPemString);

现在，您可以使用 PubSecKeyOptions 处理 X509 证书。

PubSecKeyOptions x509Certificate =
  new PubSecKeyOptions()
    // the buffer is the exact contents of the PEM file and had boundaries included in it
    .setBuffer(x509PemString);

在 Eclipse Vert.x 3.x 中，KeyStoreOptions 假定密钥存储格式为 jceks，而存储的密码与密钥的密码相同。由于 jceks 是专有格式，建议使用标准的格式，如 JDK。

当在 Eclipse Vert.x 4 中使用 KeyStoreOptions 时，可以指定存储类型。例如，可以设置 PKCS11、P PKCS12 等存储类型。默认存储类型是 jceks。

在 Eclipse Vert.x 3.x 中，所有密钥存储条目都共享相同的密码，即密钥存储密码。在 Eclipse Vert.x 4 中，每个密钥存储条目都可以有专用密码。如果您不想为每个密钥存储条目设置密码，您可以将密钥存储密码配置为所有条目的默认密码。

以下示例演示了如何在 Eclipse Vert.x 3.x 中加载 jceks 密钥存储。

new KeyStoreOptions()
  .setPath("path/to/keystore.jks")
  .setPassword("keystore-password");

在 Eclipse Vert.x 4 中，假定默认格式是 JDK 配置的默认格式。格式是 Java 9 及更高版本中的 PKCS12。

以下示例演示了如何在 Eclipse Vert.x 4 中载入 jceks 密钥存储。

new KeyStoreOptions()
  .setPath("path/to/keystore.jks")
  // Modern JDKs use `jceks` keystore. But this type is not the default
  // If the type is not set to `jceks` then probably `pkcs12` will be used
  .setType("jceks")
  .setPassword("keystore-password")
  // optionally if your keys have different passwords
  // and if a key specific id is not provided it defaults to
  // the keystore password
  .putPasswordProtection("key-id", "key-specific-password");

删除了以下方法：

以下方法已弃用：

以下类已弃用：

在 Eclipse Vert.x 4 中，模块 protoc-gen-grpc-java 不再可用。这个模块是官方 gRPC 编译器的一个分叉。在较早版本的 Eclipse Vert.x 中，您必须使用这个 fork。此分叉由 Eclipse 项目维护。使用 fork 很复杂。

在以前的版本中，为了使用 gRPC，在 pom.xml 文件中添加以下详情。

  <!-- Vert.x 3.x -->
<plugin>
  <groupId>org.xolstice.maven.plugins</groupId>
  <artifactId>protobuf-maven-plugin</artifactId>
  <configuration>
    <protocArtifact>com.google.protobuf:protoc:3.2.0:exe:${os.detected.classifier}</protocArtifact>
    <pluginId>grpc-java</pluginId>
    <!-- NOTE: the gav coordinates point to the 3.x only compiler fork -->
    <pluginArtifact>io.vertx:protoc-gen-grpc-java:${vertx.grpc.version}:exe:${os.detected.classifier}</pluginArtifact>
  </configuration>
  ...
</plugin>

在 Eclipse Vert.x 4 中，提供了一个新的 gRPC 编译器插件。此插件使用官方 gRPC 编译器而不是 fork。要使用新的 gRPC 插件，请在 pom.xml 文件中添加以下详情。

    <!-- Vert.x 4.x -->
<plugin>
  <groupId>org.xolstice.maven.plugins</groupId>
  <artifactId>protobuf-maven-plugin</artifactId>
  <configuration>
    <protocArtifact>com.google.protobuf:protoc:3.2.0:exe:${os.detected.classifier}</protocArtifact>
    <pluginId>grpc-java</pluginId>
    <!-- NOTE: the gav coordinates point to the official compiler -->
    <pluginArtifact>io.grpc:protoc-gen-grpc-java:${vertx.grpc.version}:exe:${os.detected.classifier}</pluginArtifact>
    <protocPlugins>
      <!-- NEW: a plugin is added to generate the Vert.x specific code -->
      <protocPlugin>
        <id>vertx-grpc-protoc-plugin</id>
        <groupId>io.vertx</groupId>
        <artifactId>vertx-grpc-protoc-plugin</artifactId>
        <version>${vertx.version}</version>
        <mainClass>io.vertx.grpc.protoc.plugin.VertxGrpcGenerator</mainClass>
      </protocPlugin>
    </protocPlugins>
  </configuration>
  ...
</plugin>

在 Eclipse Vert.x 4 中，使用新的编译器。当使用新的 gRPC 插件时，生成的代码不会使用相同的源文件写入。这是因为编译器不允许在其基础类上生成自定义代码。插件必须生成一个具有不同名称的新类来保存代码。

在较早版本的 Eclipse Vert.x 中，旧的 gRPC 插件会在同一源文件中写入生成的代码。

例如，如果您有以下描述符：

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

在 Eclipse Vert.x 3.x 中，代码会在 GreeterGrpc 类中生成。

// 3.x
GreeterGrpc.GreeterVertxImplBase service =
  new GreeterGrpc.GreeterVertxImplBase() {
      ...
  }

在 Eclipse Vert.x 4 中，代码在 VertxGreeterGrpc 类中生成。

// 4.x
VertxGreeterGrpc.GreeterVertxImplBase service =
  new VertxGreeterGrpc.GreeterVertxImplBase() {
      ...
  }

在 Eclipse Vert.x 4 中，gRPC API 支持将来的版本。gRPC 插件会生成混杂的 API。这些 API 使用标准 Eclipse Vert.x 输入和输出参数，这有助于创建标准 Eclipse Vert.x 应用程序。

以下示例显示了在 Eclipse Vert.x 3.x 中使用 promise。

// 3.x
GreeterGrpc.GreeterVertxImplBase service =
  new GreeterGrpc.GreeterVertxImplBase() {
        @Override
        public void sayHello(HelloRequest request, Promise<HelloReply> future) {
          future.complete(
              HelloReply.newBuilder().setMessage(request.getName()).build());
        }
  }

以下示例显示了在 Eclipse Vert.x 4 中使用未来。

// 4.x
VertxGreeterGrpc.GreeterVertxImplBase service =
  new VertxGreeterGrpc.GreeterVertxImplBase() {
      @Override
      public Future<HelloReply> sayHello(HelloRequest request) {
        return Future.succeededFuture(
          HelloReply.newBuilder()
            .setMessage(request.getName())
            .build());
      }
  }

MqttClient 类中的一些流畅方法返回 Future，而不是 fluent。例如，MqttClient. connect （）、MqttClient.disconnect （）、MqttClient.disconnect （）、MqttClient.publish （） 返回 Eclipse Vert.x 4 中的未来。

以下示例显示了在 Eclipse Vert.x 3.x 版本中使用 publish （） 方法。

client
   .publish("hello", Buffer.buffer("hello"), MqttQoS.EXACTLY_ONCE, false, false)
   .publish("hello", Buffer.buffer("hello"), MqttQoS.AT_LEAST_ONCE, false, false);

以下示例显示了在 Eclipse Vert.x 4 版本中使用 publish （） 方法。

client.publish("hello", Buffer.buffer("hello"), MqttQoS.EXACTLY_ONCE, false, false);
client.publish("hello", Buffer.buffer("hello"), MqttQoS.AT_LEAST_ONCE, false, false);

Mqtt will data 对象将字符串消息包装为 Eclipse Vert.x 缓冲，而不是字节阵列。

删除了以下 MQTT 方法：

ServiceProxyProcessor 类已被删除。

要使用服务代理代码生成器，您必须将 vertx-codegen 和 classpath 中的 processor classifier 导入：

<dependencies>
  <dependency>
    <groupId>io.vertx</groupId>
    <artifactId>vertx-codegen</artifactId>
    <classifier>processor</classifier>
  </dependency>
  <dependency>
    <groupId>io.vertx</groupId>
    <artifactId>vertx-service-proxy</artifactId>
  </dependency>
</dependencies>

服务代理重用 io.vertx.codegen.CodeGenProcessor from vertx-codegen 中的 io.vertx-codeor 启动服务代理和处理程序的代码生成。

AdminUtils 类不再可用。使用新的 KafkaAdminClient 类，在 Kafka 集群上执行管理操作。

KafkaProducer 类中的 flush 方法使用 Handler<AsyncResult<Void>> 而不是 Handler<Void>。

在 Eclipse Vert.x 4 中，您可以使用 JDBC 客户端 API 创建池。在早期版本中，您只能创建客户端。您不能创建池。

以下示例演示了如何在 Eclipse Vert.x 3.x 中创建客户端。

// 3.x
SQLClient client = JDBCClient.create(vertx, jsonConfig);

以下示例演示了如何在 Eclipse Vert.x 4 中创建池。

// 4.x
JDBCPool pool = JDBCPool.pool(vertx, jsonConfig);

池允许您执行简单的查询。您不需要管理简单查询的连接。但是，对于复杂的查询或多个查询，您必须管理您的连接。

以下示例演示了如何管理 Eclipse Vert.x 3.x 中的查询的连接。

// 3.x
client.getConnection(res -> {
  if (res.succeeded()) {
    SQLConnection connection = res.result();
    // Important, do not forget to return the connection
    connection.close();
  } else {
    // Failed to get connection
  }
});

以下示例演示了如何管理 Eclipse Vert.x 4 中的查询连接。

// 4.x
pool
  .getConnection()
  .onFailure(e -> {
    // Failed to get a connection
  })
  .onSuccess(conn -> {
    // Important, do not forget to return the connection
    conn.close();
  });

您可以使用 jsonConfig 进行配置。但是，使用 jsonConfig 有时可能会导致错误。为避免这些错误，JDBC 客户端引入了 Typesafe Config。

以下示例显示了 Typesafe Config 的基本结构。

// 4.x ONLY!!!
JDBCPool pool = JDBCPool.pool(
      vertx,
      // configure the connection
      new JDBCConnectOptions()
        // H2 connection string
        .setJdbcUrl("jdbc:h2:~/test")
        // username
        .setUser("sa")
        // password
        .setPassword(""),
      // configure the pool
      new PoolOptions()
        .setMaxSize(16)
    );

本节演示了如何在 JDBC 客户端中运行查询。

// 3.x
client.query("SELECT * FROM user WHERE emp_id > ?", new JsonArray().add(1000), res -> {
  if (res.succeeded()) {
    ResultSet rs = res2.result();
    // You can use these results in your application
  }
});

// 4.x
pool
  .preparedQuery("SELECT * FROM user WHERE emp_id > ?")
  // the emp id to look up
  .execute(Tuple.of(1000))
  .onSuccess(rows -> {
    for (Row row : rows) {
      System.out.println(row.getString("FIRST_NAME"));
    }
  });

pool
  .getConnection()
  .onFailure(e -> {
    // Failed to get a connection
  })
  .onSuccess(conn -> {
    conn
      .query("SELECT * FROM user")
      .execute()
      .onFailure(e -> {
        // Handle the failure
        // Important, do not forget to return the connection
        conn.close();
      })
      .onSuccess(rows -> {
        for (Row row : rows) {
          System.out.println(row.getString("FIRST_NAME"));
        }
        // Important, do not forget to return the connection
        conn.close();
      });
  });

存储的步骤在 JDBC 客户端中受到支持。

以下示例演示了如何在 Eclipse Vert.x 3.x 中传递 IN 参数。

// 3.x
connection.callWithParams(
  "{ call new_customer(?, ?) }",
  new JsonArray().add("John").add("Doe"),
  null,
  res -> {
    if (res.succeeded()) {
      // Success!
    } else {
      // Failed!
    }
  });

以下示例演示了如何在 Eclipse Vert.x 4 中传递 IN 参数。

// 4.x
client
  .preparedQuery("{call new_customer(?, ?)}")
  .execute(Tuple.of("Paulo", "Lopes"))
  .onSuccess(rows -> {
    ...
  });

在 Eclipse Vert.x 3.x 中，由于可用类型，将 IN 和 OUT 参数结合使用的支持会非常有限。在 Eclipse Vert.x 4 中，池是安全的，可以处理 IN 和 OUT 参数的组合。您还可以在应用程序中使用 INOUT 参数。

以下示例显示了在 Eclipse Vert.x 3.x 中处理参数。

// 3.x
connection.callWithParams(
  "{ call customer_lastname(?, ?) }",
  new JsonArray().add("John"),
  new JsonArray().addNull().add("VARCHAR"),
  res -> {
    if (res.succeeded()) {
      ResultSet result = res.result();
    } else {
      // Failed!
    }
});

以下示例显示了在 Eclipse Vert.x 4 中处理参数。

// 4.x
client
  .preparedQuery("{call customer_lastname(?, ?)}")
  .execute(Tuple.of("John", SqlOutParam.OUT(JDBCType.VARCHAR)))
  .onSuccess(rows -> {
    ...
  });

在 JDBC 客户端中，数据类型已更新。

从 Eclipse Vert.x 4 开始，MailAttachment 作为一个接口可用。它可让您使用流中的邮件附加功能。在早期的 Eclipse Vert.x 版本中，邮件 附加程序作为一个类和邮件附件表示，以数据对象表示。

MailConfig 接口扩展 NetClientOptions 接口。由于此扩展，邮件配置也支持 NetClient 的代理设置。

将 Handler<AmqpMessage> 用作参数的 AMQP 客户端方法已被删除。在较早版本的中，您可以在 ReadStream<AmqpMessage > 上设置此处理程序。但是，如果您将应用程序迁移到将来使用，则无法使用此类方法。

的方法已从 MongoClient 类中删除。

在 Eclipse Vert.x 4 之前，每个 Eclipse Vert.x 发行版本都包含 JavaScript 客户端的新版本。

但是，从 Eclipse Vert.x 4 onward，只有在客户端有变化时才会在 npm 中提供一个新的 JavaScript 客户端版本。您不需要为每个 Eclipse Vert.x 版本更新客户端应用程序，除非有版本更改。

您可以将现有应用程序直接迁移到新的 Redis 客户端，或者在两个步骤中使用帮助程序类 RedisAPI 来迁移应用程序。

在迁移应用程序前，您必须创建客户端。

// Create the redis client (3.x)
RedisClient client = RedisClient
  .create(vertx, new RedisOptions().setHost(host));

// Create the redis client (4.x)
Redis client = Redis
  .createClient(
    vertx,
    "redis://server.address:port");

redis[s]://[[user]:password@]server[:port]/[database]

// Using 3.x
// omitting the error handling for brevity
client.set("key", "value", s -> {
  if (s.succeeded()) {
    System.out.println("key stored");
    client.get("key", g -> {
      if (s.succeeded()) {
        System.out.println("Retrieved value: " + s.result());
      }
    });
  }
});

// Using 4.x
// omitting the error handling for brevity

// 1. Wrap the client into a RedisAPI
api = RedisAPI.api(client);

// 2. Use the typed API
api.set(
    Arrays.asList("key", "value"), s -> {
    if (s.succeeded()) {
      System.out.println("key stored");
      client.get("key", g -> {
        if (s.succeeded()) {
          System.out.println("Retrieved value: " + s.result());
        }
      });
    }
});

// Using 3.x
// omitting the error handling for brevity
client.set("key", "value", s -> {
  if (s.succeeded()) {
    System.out.println("key stored");
    client.get("key", g -> {
      if (s.succeeded()) {
        System.out.println("Retrieved value: " + s.result());
      }
    });
  }
});

// Using 4.x
// omitting the error handling for brevity

import static io.vertx.redis.client.Request.cmd;
import static io.vertx.redis.client.Command.*;

client.send(cmd(SET).arg("key").arg("value"), s -> {
    if (s.succeeded()) {
      System.out.println("key stored");
      client.send(cmd(GET).arg("key"), g -> {
        if (s.succeeded()) {
          System.out.println("Retrieved value: " + s.result());
        }
      });
    }
});

// Using 4.x
// omitting the error handling for brevity

import static io.vertx.redis.client.Request.cmd;
import static io.vertx.redis.client.Command.*;

client.send(cmd(MGET).arg("key1").arg("key2").arg("key3"), mget -> {
  mget.result()
    .forEach(value -> {
      // Use the single value

本节论述了 Redis 客户端中的更改。

// Before (3.x)
Redis.createClient(
      rule.vertx(),
      new RedisOptions()
        .setType(RedisClientType.SENTINEL)
        .addConnectionString("redis://localhost:5000")
        .setMasterName("sentinel7000")
        .setRole(RedisRole.SLAVE));

// After (4.x)
Redis.createClient(
      rule.vertx(),
      new RedisOptions()
        .setType(RedisClientType.SENTINEL)
        .addConnectionString("redis://localhost:5000")
        .setMasterName("sentinel7000")
        .setRole(RedisRole.REPLICA));

// Before (3.9)
options.setUseSlaves(RedisSlaves);

// After (4.x)
options.setUseReplicas(RedisReplicas);

Infinispan 集群管理器基于 Infinispan 12。

在 Eclipse Vert.x 4 中，集群 SPI 已被重新设计。订阅数据模型已改变。因此，Eclipse Vert.x 3.x 节点和 Eclipse Vert.x 4 节点无法在同一个 Infinispan 集群中添加。

Eclipse Vert.x 应用程序不会受到这个变化的影响，因为 EventBus 和 SharedData API 保持不变。

如果您在 Eclipse Vert.x 3.x 应用程序中有一个自定义 Infinispan 配置文件：

 <cache-container default-cache="distributed-cache">
    <distributed-cache name="distributed-cache"/>
    <replicated-cache name="__vertx.subs"/>
    <replicated-cache name="__vertx.haInfo"/>
    <replicated-cache name="__vertx.nodeInfo"/>
    <distributed-cache-configuration name="__vertx.distributed.cache.configuration"/>
  </cache-container>

如果您在 Openshift 上运行 Eclipse Vert.x 集群，则不再需要 infinispan-cloud JAR。JAR 已从构建文件的 dependencies 部分中移除。此 JAR 中提供的配置文件现在包含在 infinispan-core JAR 中。

如果您的集群已为其应用程序部署了不同的团队，您可以考虑将 Eclipse Vert.x 3.x 集群拆分为较小的集群。请注意，在分割集群后，独立的组件将无法使用集群功能进行通信。您可以使用以下组件分离集群：

在分割集群后，每个团队在就绪或者需要时可以移至 Eclipse Vert.x 4。

如果您无法分割集群，则使用 Vert.x EventBus Link 逐步迁移您的代码库。

Vert.x EventBus Link 是一个将 Eclipse Vert.x 3.x 集群事件Bus 连接到 Eclipse Vert.x 4 集群事件Bus 的工具。

该工具创建一个实现 EventBusLink 接口的 EventBus Link 对象。在每个集群至少一个节点上创建了一个 EventBusLink 实例。该实例通过提供一组地址及其行为取决于消息模式：

Eclipse Vert.x EventBus Link 创建一个 WebSocket 服务器来接收消息，并使用 WebSocket 客户端来发送它们。

详情请查看 部分 入门和使用。

vertx-core 模块已更新，以使用服务提供商接口进行参数注入。此更改导致 JUnit5 中的以下更新：

VertxTestContext.succeeding （） 和 VertxTestContext.failing （） 方法已被弃用。使用 VertxTestContext.succeeding ThenComplete （） 和 VertxTestContext.failing ThenComplete （） 方法替代。