从 Vert.x 4 迁移到 5

<dependency>
  <groupId>io.vertx</groupId>
  <artifactId>vertx-launcher-legacy-cli</artifactId>
  <version>5.0.0</version>
</dependency>

<dependency>
  <groupId>io.vertx</groupId>
  <artifactId>vertx-launcher-application</artifactId>
  <version>5.0.0</version>
</dependency>

# Assuming the command is executed on a Unix-like system which has the classpath configured in the CLASSPATH environment variable.
java -cp $CLASSPATH io.vertx.launcher.application.VertxApplication my.app.MainVerticle

java -jar myapp.jar my.app.MainVerticle

// 4.x
Future<Vertx> f = Vertx.clusteredVertx(
  new VertxOptions().setClusterManager(clusterManager)
);

// 5.0
Future<Vertx> f = Vertx
  .builder()
  .withClusterManager(clusterManager)
  .buildClustered();

// 4.x
Vertx vertx = Vertx.vertx(
  new VertxOptions()
    .setMetricsOptions(new MetricsOptions().setEnabled(true).setFactory(factory))
    .setTracingOptions(new TracingOptions().setFactory(factory))
);

// 5.0
Vertx vertx = Vertx
   .builder()
  .withMetrics(factory)
  .withTracer(factory)
  .build();

// 4.x
Vertx vertx = Vertx.vertx(new VertxOptions()
    .setTracingOptions(
      new OpenTelemetryOptions(openTelemetry)
    )
  );

// 5.0
Vertx vertx = Vertx.builder()
 .withTracer(new OpenTelemetryTracingFactory(openTelemetry))
 .build();

// 4.x
Vertx vertx = Vertx.vertx(new VertxOptions()
 .setMetricsOptions(new DropwizardMetricsOptions()
   .setMetricsRegistry(myRegistry)
   .setEnabled(true)));

// 5.0
Vertx vertx = Vertx.builder()
  .with(new VertxOptions()
    .setMetricsOptions(new DropwizardMetricsOptions()
    .setEnabled(true)))
  .withMetrics(new DropwizardMetricsFactory(myRegistry))
  .build();

// 4.x
AuthProvider authProvider = ...

// 5.0
AuthenticationProvider authProvider = ...

suspend fun HttpServer.listenAwait(port: Int, host: String): HttpServer {
   return awaitResult {
     this.listen(port, host, it)
  }
}

// 4.x
server.listenAwait(port, host)

// 5.0
server.listen(host, port).coAwait()

// 4.x
stream.collecting(collector);

// 5.0
stream.collect(collector);

// 4.x
GrpcServer server = GrpcServer.create(vertx);

// 5.0
GrpcIoServer server = GrpcIoServer.create(vertx);
server.callHandler(methodDescriptor, request -> ...);

// 4.x
StaticHandler handler = StaticHandler.create().setAllowRootFileSystemAccess(true).setWebRoot(root);

// 5.0
StaticHandler handler = StaticHandler.create(FileSystemAccess.ROOT, root);

// 4.x
Handlebars handlebarsUnwrapped = handlebarsTemplateEngine.getHandlebars();
TemplateEngine thymeleafUnwrapped = thymeleafTemplateEngine.getThymeleafTemplateEngine();

// 5.0
handlebarsUnwrapped = handlebarsTemplateEngine.unwrap();
thymeleafUnwrapped = thymeleafTemplateEngine.unwrap();

// 4.x
CorsHandler.addRelativeOrigin(".*");
CorsHandler.addRelativeOrigins(List.of(".*", "https?://.*"));

// 5.0
CorsHandler.addOriginWithRegex(".*");
CorsHandler.addOriginsWithRegex(List.of(".*", "https?://.*"));

// 4.x
client
  .get(8080, "myserver.mycompany.com", "/some-uri")
  .expect(ResponsePredicate.SC_SUCCESS)
  .send()
  .onSuccess(res -> {
    // ....
  });

// 5.0
client
  .get(8080, "myserver.mycompany.com", "/some-uri")
  .send()
  .expecting(HttpResponseExpectation.SC_SUCCESS)
  .onSuccess(res -> {
    // ....
  });

// 4.x
ValidationHandlerBuilder.create(schemaParser)

// 5.0
SchemaRepository schemaRepo = SchemaRepository.create(new JsonSchemaOptions().setDraft(DRAFT7));
ValidationHandlerBuilder.create(schemaRepo);

// 4.x
PgPool client = PgPool.pool(vertx, connectOptions, poolOptions);

//5.0
Pool client = PgBuilder.pool()
  .with(poolOptions)
  .connectingTo(connectOptions)
  .using(vertx)
  .build();

// 4.x
// 5.0
PgConnectOptions options = new PgConnectOptions()
  .setPort(port)
  .setHost(host)
  .setDatabase(database)
  .setUser(user)
  .setPassword(password)
  .setSslOptions(new ClientSSLOptions()
    .setTrustOptions(new PemTrustOptions().addCertPath(pathToCert))
  );

// 5.0
Pool pool = PgBuilder.pool()
      .connectingTo(connectOptions)
      .with(tcpOptions)
      .build();

// 4.x
pool.connectHandler(connectHandler);

// 5.0
builder.connectHandler(connectHandler);

// 4.x
pool.connectionProvider(ctx -> futureOfSqlConnection(ctx));

// 5.0
builder.connectingTo(() -> futureOfSqlConnectOptions());

RedisConnection conn = ...;
conn.handler(EventBusHandler.create(vertx));
conn.send(Request.cmd(Command.SUBSCRIBE).arg("news"));

// 4.x
options.setEndpoint(location);

// 4.x
options.setConnectionString(location);

// 4.x
    RabbitMQOptions config = new RabbitMQOptions();
    // full amqp uri
    config.setUri("amqp://xvjvsrrc:VbuL1atClKt7zVNQha0bnnScbNvGiqgb@brokerhost/vhost");
    RabbitMQClient client = RabbitMQClient.create(vertx, config);

    // Connect
    client.start(asyncResult -> {
      if (asyncResult.succeeded()) {
        logger.info("RabbitMQ successfully connected!");
      } else {
        logger.warning("Failed to connect to RabbitMQ: {0}", asyncResult.cause().getMessage());
      }
    });

// 5.0
    RabbitMQOptions config = new RabbitMQOptions();
    config.setUri("amqp://brokerhost/vhost");
    config.setConnectionName(this.getClass().getSimpleName());
    config.setUser("guest");
    config.setPassword("guest");

    RabbitMQClient.connect(vertx, config)
            .compose(connection -> {
              RabbitMQChannelBuilder builder = connection.createChannelBuilder();
              return builder.openChannel();
            })
            .onSuccess(channel -> logger.info("Channel opened: {0}", channel.getChannelId()))
            .onFailure(ex -> logger.warning("Failed to connect to RabbitMQ: {0}", ex))
            ;

// 4.x
    RabbitMQClient client = RabbitMQClient.create(vertx, config);
    client.addConnectionEstablishedCallback(promise -> {
                client.exchangeDeclare(EXCHANGE_NAME, EXCHANGE_TYPE, EXCHANGE_DURABLE, EXCHANGE_AUTO_DELETE)
                    .compose(v -> {
                      return client.queueDeclare(QUEUE_NAME, QUEUE_DURABLE, QUEUE_EXCLUSIVE, QUEUE_AUTO_DELETE);
                    })
                    .compose(declareOk -> {
                      return client.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
                    })
                    .onComplete(promise);
    });

// 5.0
    RabbitMQClient.connect(vertx, config)
            .compose(connection -> {
              return connection.createChannelBuilder()
                      .withChannelOpenHandler(chann -> {
                        chann.exchangeDeclare(EXCHANGE_NAME, EXCHANGE_TYPE, EXCHANGE_DURABLE, EXCHANGE_AUTO_DELETE, null);
                        chann.queueDeclare(QUEUE_NAME, QUEUE_DURABLE, QUEUE_EXCLUSIVE, QUEUE_AUTO_DELETE, null);
                        chann.queueBind(QUEUE_NAME, EXCHANGE_NAME, "", null);
                      })
                      .openChannel();
            })
            ;

// 4.x
    client.basicConsumer(QUEUE_NAME, rabbitMQConsumerAsyncResult -> {
      if (rabbitMQConsumerAsyncResult.succeeded()) {
        RabbitMQConsumer mqConsumer = rabbitMQConsumerAsyncResult.result();
        mqConsumer.handler(message -> {
          System.out.println("Got message: " + message.body().toString());
        });
      }
    });

// 5.0
    connection.createChannelBuilder()
            .withQos(0, 10)
            .createConsumer(RabbitMQChannelBuilder.STRING_MESSAGE_CODEC
                    , QUEUE_NAME
                    , null
                    , new RabbitMQConsumerOptions()
                    , (consumer, message) -> {
                      System.out.println("Got message: " + message.body());
                      return message.basicAck();
                    });

// 4.x
    Map<String, JsonObject> messages = ...
    RabbitMQPublisher publisher = RabbitMQPublisher.create(vertx, client, options);

    publisher.getConfirmationStream().handler(conf -> {
      if (conf.isSucceeded()) {
        messages.remove(conf.getMessageId());
      }
    });

    messages.forEach((k,v) -> {
      com.rabbitmq.client.BasicProperties properties = new AMQP.BasicProperties.Builder()
              .messageId(k)
              .build();
      publisher.publish(EXCHANGE_NAME, ROUTING_KEY, properties, v.toBuffer());
    });

    // Wait for messages to be empty


// 5.0
    Map<String, JsonObject> messages = ...
    RabbitMQClient.connect(vertx, config)
            .compose(connection -> {
              return connection.createChannelBuilder()
                      .createPublisher(EXCHANGE_NAME
                              , RabbitMQChannelBuilder.JSON_OBJECT_MESSAGE_CODEC
                              , new RabbitMQPublisherOptions().setResendOnReconnect(true)
                      );
            })
            .compose(publisher -> {
              List<Future<Void>> futures = new ArrayList<>(messages.size());
              messages.forEach((k,v) -> {
                AMQP.BasicProperties properties = new AMQP.BasicProperties.Builder()
                        .messageId(k)
                        .build();
                futures.add(publisher.publish(ROUTING_KEY, properties, v));
              });

              return Future.all(futures);
            })
            .onSuccess(v -> logger.info("All message sent and confirmed"))
            .onFailure(ex -> logger.log(Level.SEVERE, "Failed: {0}", ex))
            ;

// 4.x
import io.vertx.ext.healthchecks.HealthCheckHandler;

// 5.0
import io.vertx.ext.web.healthchecks.HealthCheckHandler;

// 4.x
breaker.retryPolicy(retryCount -> 5);

// 5.0
breaker.retryPolicy((failure, retryCount) -> 5);

// 4.x
options.setWillMessage(str);

// 5.0
options.setWillMessageBytes(Buffer.buffer(str));

// 4.x
options.setKeyStore(trustStorePath);
options.setKeyStorePassword(trustStorePassword);

// 5.0
options.setTrustOptions(new JksOptions().setPath(trustStorePath).setPassword(trustStorePassword));

// 4.x
someFuture.onComplete(testContext.succeeding());

// 5.0
someFuture.onComplete(testContex.succeedingThenComplete());

// 4.x
new ServiceBinder(vertx)
   .addInterceptor(new ServiceAuthInterceptor()...)
   .register(SomeService.class, service);

// 5.0
new ServiceBinder(vertx)
   .addInterceptor(AuthorizationInterceptor.create(authorizationProvider)...)
   .register(SomeService.class, service);

// 4.x
binder.addInterceptor(msg -> vertx.timer(10, TimeUnit.MILLISECONDS).map(msg));

// 5.0
binder.addInterceptor((vertx, interceptorContext, body) -> vertx.timer(10, TimeUnit.MILLISECONDS).map(body));

// 4.x
ProxyHelper.registerService(MyService.class, vertx, service, "the-address");
MyService proxy = ProxyHelper.createProxy(MyService.class, vertx, "the-address");

// 5.0
new ServiceBinder(vertx)
  .setAddress("the-address")
  .register(MyService.class, service);
MyService proxy = new ServiceProxyBuilder(vertx)
  .setAddress("the-address")
  .build(MyService.class)

// 4.x
io.vertx.reactivex.core.buffer.Buffer buffer = rxApi.getBuffer();

// 5.0
io.vertx.core.buffer.Buffer buffer = rxApi.getBuffer();

// 4.x
stream.write(io.vertx.reactivex.core.buffer.Buffer.buffer("the-string"));

// 5.0
stream.write(io.vertx.core.buffer.Buffer.buffer("the-string"));

// 4.x
Vertx vertx = Vertx.vertx(new VertxOptions()
 .setMetricsOptions(new MicrometerMetricsOptions()
   .setMicrometerRegistry(myRegistry)
   .setEnabled(true)));

// 5.0
Vertx vertx = Vertx.builder()
  .with(new VertxOptions()
    .setMetricsOptions(new MicrometerMetricsOptions()
    .setEnabled(true)))
  .withMetrics(new MicrometerMetricsFactory(myRegistry))
  .build();

// 4.x
influxDbOptions.setNumThreads(numThreads);

// 5.0

// 4.x
options.setRequestsTagsProvider(provider);

// 5.0
options.setServerRequestsTagsProvider(provider);

options.addLabels(Label.HTTP_ROUTE);

// 4.x
Vertx vertx = Vertx.vertx(new VertxOptions()
 .setMetricsOptions(new DropwizardMetricsOptions()
   .setMetricsRegistry(myRegistry)
   .setEnabled(true)));

// 5.0
Vertx vertx = Vertx.builder()
  .with(new VertxOptions()
    .setMetricsOptions(new DropwizardMetricsOptions()
    .setEnabled(true)))
  .withMetrics(new DropwizardMetricsFactory(myRegistry))
  .build();

// 4.x
JsonObject schemaJson = new JsonObject(...);
Schema schema = new Draft7SchemaParser(SchemaRouter.create(vertx, new SchemaRouterOptions())).parse(schemaJson , scope);
JsonObject jsonToValidate = new JsonObject(...);
schema.validateSync(jsonToValidate);

// 5.0
JsonObject schemaJson = new JsonObject(...);
SchemaRepository schemaRepo = SchemaRepository.create(new JsonSchemaOptions().setDraft(DRAFT7));
JsonObject jsonToValidate = new JsonObject(...);
OutputUnit result = schemaRepo.validator(JsonSchema.of(schemaJson)).validate(jsonToValidate);

if (result.getValid()) {
  // Successful validation
}

// 4.x
OutputUnit ou = new OutputUnit("instanceLocation", "absoluteKeywordLocation", "keywordLocation", "error");

// 5.0
// Available error types are current OutputErrorType.NONE, OutputErrorType.INVALID_VALID, OutputErrorType.MISSING_VALUE
OutputUnit ou = new OutputUnit("instanceLocation", "absoluteKeywordLocation", "keywordLocation", "error", OutputErrorType.INVALID_VALUE);