## Uses of Interface
io.vertx.core.Handler

- Packages that use Handler
  Package | Description
  --- | ---
  io.vertx.amqp |
  io.vertx.amqpbridge |
  io.vertx.camel |
  io.vertx.cassandra |
  io.vertx.circuitbreaker |
  io.vertx.config |
  io.vertx.config.consul |
  io.vertx.config.git |
  io.vertx.config.hocon |
  io.vertx.config.kubernetes |
  io.vertx.config.redis |
  io.vertx.config.spi |
  io.vertx.config.spi.utils |
  io.vertx.config.vault |
  io.vertx.config.vault.client |
  io.vertx.config.yaml |
  io.vertx.config.zookeeper |
  io.vertx.core |
  io.vertx.core.datagram |
  io.vertx.core.dns |
  io.vertx.core.eventbus |
  io.vertx.core.file |
  io.vertx.core.http |
  io.vertx.core.net |
  io.vertx.core.parsetools |
  io.vertx.core.shareddata |
  io.vertx.core.spi |
  io.vertx.core.spi.cluster |
  io.vertx.core.spi.resolver |
  io.vertx.core.streams |
  io.vertx.ext.auth |
  io.vertx.ext.auth.mongo |
  io.vertx.ext.auth.oauth2 |
  io.vertx.ext.auth.oauth2.providers |
  io.vertx.ext.bridge |
  io.vertx.ext.cluster.infinispan |
  io.vertx.ext.consul |
  io.vertx.ext.eventbus.bridge.tcp |
  io.vertx.ext.healthchecks |
  io.vertx.ext.httpservicefactory |
  io.vertx.ext.mail |
  io.vertx.ext.mongo |
  io.vertx.ext.reactivestreams |
  io.vertx.ext.shell |
  io.vertx.ext.shell.command |
  io.vertx.ext.shell.spi |
  io.vertx.ext.shell.system |
  io.vertx.ext.shell.term |
  io.vertx.ext.sql |
  io.vertx.ext.stomp |
  io.vertx.ext.sync |
  io.vertx.ext.unit |
  io.vertx.ext.unit.collect |
  io.vertx.ext.unit.report |
  io.vertx.ext.web |
  io.vertx.ext.web.api.contract |
  io.vertx.ext.web.api.contract.openapi3 |
  io.vertx.ext.web.api.validation |
  io.vertx.ext.web.client |
  io.vertx.ext.web.codec |
  io.vertx.ext.web.codec.spi |
  io.vertx.ext.web.common.template |
  io.vertx.ext.web.handler |
  io.vertx.ext.web.handler.graphql |
  io.vertx.ext.web.handler.sockjs |
  io.vertx.ext.web.sstore |
  io.vertx.ext.web.templ |
  io.vertx.grpc |
  io.vertx.junit5 |
  io.vertx.kafka.admin |
  io.vertx.kafka.client.consumer |
  io.vertx.kafka.client.producer |
  io.vertx.micrometer |
  io.vertx.mqtt |
  io.vertx.mysqlclient |
  io.vertx.pgclient |
  io.vertx.pgclient.pubsub |
  io.vertx.rabbitmq |
  io.vertx.reactivex.amqp |
  io.vertx.reactivex.amqpbridge |
  io.vertx.reactivex.cassandra |
  io.vertx.reactivex.circuitbreaker |
  io.vertx.reactivex.config |
  io.vertx.reactivex.core |
  io.vertx.reactivex.core.datagram |
  io.vertx.reactivex.core.dns |
  io.vertx.reactivex.core.eventbus |
  io.vertx.reactivex.core.file |
  io.vertx.reactivex.core.http |
  io.vertx.reactivex.core.net |
  io.vertx.reactivex.core.parsetools |
  io.vertx.reactivex.core.shareddata |
  io.vertx.reactivex.core.streams |
  io.vertx.reactivex.ext.asyncsql |
  io.vertx.reactivex.ext.auth |
  io.vertx.reactivex.ext.auth.mongo |
  io.vertx.reactivex.ext.auth.oauth2 |
  io.vertx.reactivex.ext.auth.oauth2.providers |
  io.vertx.reactivex.ext.consul |
  io.vertx.reactivex.ext.eventbus.bridge.tcp |
  io.vertx.reactivex.ext.healthchecks |
  io.vertx.reactivex.ext.jdbc |
  io.vertx.reactivex.ext.mail |
  io.vertx.reactivex.ext.mongo |
  io.vertx.reactivex.ext.shell |
  io.vertx.reactivex.ext.shell.command |
  io.vertx.reactivex.ext.shell.system |
  io.vertx.reactivex.ext.shell.term |
  io.vertx.reactivex.ext.sql |
  io.vertx.reactivex.ext.stomp |
  io.vertx.reactivex.ext.unit |
  io.vertx.reactivex.ext.unit.collect |
  io.vertx.reactivex.ext.unit.report |
  io.vertx.reactivex.ext.web |
  io.vertx.reactivex.ext.web.api.contract |
  io.vertx.reactivex.ext.web.api.contract.openapi3 |
  io.vertx.reactivex.ext.web.client |
  io.vertx.reactivex.ext.web.common.template |
  io.vertx.reactivex.ext.web.handler |
  io.vertx.reactivex.ext.web.handler.graphql |
  io.vertx.reactivex.ext.web.handler.sockjs |
  io.vertx.reactivex.ext.web.sstore |
  io.vertx.reactivex.ext.web.templ |
  io.vertx.reactivex.kafka.admin |
  io.vertx.reactivex.kafka.client.consumer |
  io.vertx.reactivex.kafka.client.producer |
  io.vertx.reactivex.micrometer |
  io.vertx.reactivex.mqtt |
  io.vertx.reactivex.mysqlclient |
  io.vertx.reactivex.pgclient |
  io.vertx.reactivex.pgclient.pubsub |
  io.vertx.reactivex.rabbitmq |
  io.vertx.reactivex.redis |
  io.vertx.reactivex.redis.client |
  io.vertx.reactivex.redis.sentinel |
  io.vertx.reactivex.servicediscovery |
  io.vertx.reactivex.servicediscovery.spi |
  io.vertx.reactivex.servicediscovery.types |
  io.vertx.reactivex.sqlclient |
  io.vertx.redis |
  io.vertx.redis.client |
  io.vertx.redis.sentinel |
  io.vertx.rxjava.amqp |
  io.vertx.rxjava.amqpbridge |
  io.vertx.rxjava.cassandra |
  io.vertx.rxjava.circuitbreaker |
  io.vertx.rxjava.config |
  io.vertx.rxjava.core |
  io.vertx.rxjava.core.datagram |
  io.vertx.rxjava.core.dns |
  io.vertx.rxjava.core.eventbus |
  io.vertx.rxjava.core.file |
  io.vertx.rxjava.core.http |
  io.vertx.rxjava.core.net |
  io.vertx.rxjava.core.parsetools |
  io.vertx.rxjava.core.shareddata |
  io.vertx.rxjava.core.streams |
  io.vertx.rxjava.ext.asyncsql |
  io.vertx.rxjava.ext.auth |
  io.vertx.rxjava.ext.auth.mongo |
  io.vertx.rxjava.ext.auth.oauth2 |
  io.vertx.rxjava.ext.auth.oauth2.providers |
  io.vertx.rxjava.ext.consul |
  io.vertx.rxjava.ext.eventbus.bridge.tcp |
  io.vertx.rxjava.ext.healthchecks |
  io.vertx.rxjava.ext.jdbc |
  io.vertx.rxjava.ext.mail |
  io.vertx.rxjava.ext.mongo |
  io.vertx.rxjava.ext.shell |
  io.vertx.rxjava.ext.shell.command |
  io.vertx.rxjava.ext.shell.system |
  io.vertx.rxjava.ext.shell.term |
  io.vertx.rxjava.ext.sql |
  io.vertx.rxjava.ext.stomp |
  io.vertx.rxjava.ext.unit |
  io.vertx.rxjava.ext.unit.collect |
  io.vertx.rxjava.ext.unit.report |
  io.vertx.rxjava.ext.web |
  io.vertx.rxjava.ext.web.api.contract |
  io.vertx.rxjava.ext.web.api.contract.openapi3 |
  io.vertx.rxjava.ext.web.api.validation |
  io.vertx.rxjava.ext.web.client |
  io.vertx.rxjava.ext.web.common.template |
  io.vertx.rxjava.ext.web.handler |
  io.vertx.rxjava.ext.web.handler.graphql |
  io.vertx.rxjava.ext.web.handler.sockjs |
  io.vertx.rxjava.ext.web.sstore |
  io.vertx.rxjava.ext.web.templ |
  io.vertx.rxjava.kafka.admin |
  io.vertx.rxjava.kafka.client.consumer |
  io.vertx.rxjava.kafka.client.producer |
  io.vertx.rxjava.micrometer |
  io.vertx.rxjava.mqtt |
  io.vertx.rxjava.mysqlclient |
  io.vertx.rxjava.pgclient |
  io.vertx.rxjava.pgclient.pubsub |
  io.vertx.rxjava.rabbitmq |
  io.vertx.rxjava.redis |
  io.vertx.rxjava.redis.client |
  io.vertx.rxjava.redis.sentinel |
  io.vertx.rxjava.servicediscovery |
  io.vertx.rxjava.servicediscovery.spi |
  io.vertx.rxjava.servicediscovery.types |
  io.vertx.rxjava.sqlclient |
  io.vertx.servicediscovery |
  io.vertx.servicediscovery.backend.redis |
  io.vertx.servicediscovery.consul |
  io.vertx.servicediscovery.docker |
  io.vertx.servicediscovery.kubernetes |
  io.vertx.servicediscovery.spi |
  io.vertx.servicediscovery.types |
  io.vertx.serviceproxy |
  io.vertx.spi.cluster.hazelcast |
  io.vertx.spi.cluster.ignite |
  io.vertx.spi.cluster.zookeeper |
  io.vertx.sqlclient |

- - ### Uses of Handler in io.vertx.amqp

    Methods in io.vertx.amqp with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `AmqpConnection` | AmqpConnection.`close(Handler<AsyncResult<Void>> done)` Closes the AMQP connection, i.e.
    `void` | AmqpSender.`close(Handler<AsyncResult<Void>> handler)` Closes the sender.
    `void` | AmqpReceiver.`close(Handler<AsyncResult<Void>> handler)` Closes the receiver.
    `void` | AmqpClient.`close(Handler<AsyncResult<Void>> closeHandler)` Closes the client.
    `AmqpClient` | AmqpClient.`connect(Handler<AsyncResult<AmqpConnection>> connectionHandler)` Connects to the AMQP broker or router.
    `AmqpConnection` | AmqpConnection.`createAnonymousSender(Handler<AsyncResult<AmqpSender>> completionHandler)` Creates an anonymous sender.
    `AmqpConnection` | AmqpConnection.`createDynamicReceiver(Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a dynamic receiver.
    `AmqpConnection` | AmqpConnection.`createReceiver(String address, AmqpReceiverOptions receiverOptions, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consumer messages from the given address.
    `AmqpClient` | AmqpClient.`createReceiver(String address, AmqpReceiverOptions receiverOptions, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consumer messages from the given address.
    `AmqpConnection` | AmqpConnection.`createReceiver(String address, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consume messages from the given address.
    `AmqpClient` | AmqpClient.`createReceiver(String address, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consume messages from the given address.
    `AmqpConnection` | AmqpConnection.`createSender(String address, AmqpSenderOptions options, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `AmqpClient` | AmqpClient.`createSender(String address, AmqpSenderOptions options, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `AmqpConnection` | AmqpConnection.`createSender(String address, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `AmqpClient` | AmqpClient.`createSender(String address, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `AmqpReceiver` | AmqpReceiver.`endHandler(Handler<Void> endHandler)`
    `AmqpConnection` | AmqpConnection.`exceptionHandler(Handler<Throwable> handler)` Registers a handler called on disconnection.
    `AmqpSender` | AmqpSender.`exceptionHandler(Handler<Throwable> handler)`
    `AmqpReceiver` | AmqpReceiver.`exceptionHandler(Handler<Throwable> handler)`
    `AmqpReceiver` | AmqpReceiver.`handler(Handler<AmqpMessage> handler)`
    `AmqpSender` | AmqpSender.`sendWithAck(AmqpMessage message, Handler<AsyncResult<Void>> acknowledgementHandler)` Sends an AMQP message and waits for an acknowledgement.
    `AmqpSender` | AmqpSender.`write(AmqpMessage data, Handler<AsyncResult<Void>> handler)`

  - ### Uses of Handler in io.vertx.amqpbridge

    Methods in io.vertx.amqpbridge with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | AmqpBridge.`close(Handler<AsyncResult<Void>> resultHandler)` Shuts the bridge down, closing the underlying connection.
    `void` | AmqpBridge.`endHandler(Handler<Void> endHandler)` Set an end handler.
    `void` | AmqpBridge.`start(String hostname, int port, Handler<AsyncResult<AmqpBridge>> resultHandler)` Starts the bridge, establishing the underlying connection.
    `void` | AmqpBridge.`start(String hostname, int port, String username, String password, Handler<AsyncResult<AmqpBridge>> resultHandler)` Starts the bridge, establishing the underlying connection.

  - ### Uses of Handler in io.vertx.camel

    Methods in io.vertx.camel with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `CamelBridge` | CamelBridge.`start(Handler<AsyncResult<Void>> completed)` Starts the bridge.
    `CamelBridge` | CamelBridge.`stop(Handler<AsyncResult<Void>> completed)` Stops the bridge.

  - ### Uses of Handler in io.vertx.cassandra

    Methods in io.vertx.cassandra with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `ResultSet` | ResultSet.`all(Handler<AsyncResult<List<com.datastax.driver.core.Row>>> handler)` The method should not be used concurrently with others like `ResultSet.several(int, Handler)` or `ResultSet.one(Handler)`.
    `CassandraClient` | CassandraClient.`close(Handler<AsyncResult<Void>> closeHandler)` Closes this client.
    `void` | Mapper.`delete(List<Object> primaryKey, Handler<AsyncResult<Void>> handler)` Asynchronous delete method based on the column values of the primary key.
    `CassandraRowStream` | CassandraRowStream.`endHandler(Handler<Void> handler)`
    `CassandraRowStream` | CassandraRowStream.`exceptionHandler(Handler<Throwable> handler)`
    `<R> CassandraClient` | CassandraClient.`execute(com.datastax.driver.core.Statement statement, java.util.stream.Collector<com.datastax.driver.core.Row,?,R> collector, Handler<AsyncResult<R>> resultHandler)` Execute a statement and produce a result by applying a collector to result set rows.
    `CassandraClient` | CassandraClient.`execute(com.datastax.driver.core.Statement statement, Handler<AsyncResult<ResultSet>> resultHandler)` Execute the statement and provide a handler for consuming results.
    `<R> CassandraClient` | CassandraClient.`execute(String query, java.util.stream.Collector<com.datastax.driver.core.Row,?,R> collector, Handler<AsyncResult<R>> resultHandler)` Execute a query and produce a result by applying a collector to result set rows.
    `CassandraClient` | CassandraClient.`execute(String query, Handler<AsyncResult<ResultSet>> resultHandler)` Execute the query and provide a handler for consuming results.
    `CassandraClient` | CassandraClient.`executeWithFullFetch(com.datastax.driver.core.Statement statement, Handler<AsyncResult<List<com.datastax.driver.core.Row>>> resultHandler)` Execute the query and provide a handler for consuming results.
    `CassandraClient` | CassandraClient.`executeWithFullFetch(String query, Handler<AsyncResult<List<com.datastax.driver.core.Row>>> resultHandler)` Execute the query and provide a handler for consuming results.
    `ResultSet` | ResultSet.`fetchMoreResults(Handler<AsyncResult<Void>> handler)`
    `void` | Mapper.`get(List<Object> primaryKey, Handler<AsyncResult<T>> handler)` Asynchronous get method based on the column values of the primary key.
    `CassandraRowStream` | CassandraRowStream.`handler(Handler<com.datastax.driver.core.Row> handler)`
    `ResultSet` | ResultSet.`one(Handler<AsyncResult<com.datastax.driver.core.Row>> handler)` The method should not be used concurrently with others like `ResultSet.several(int, Handler)` or `ResultSet.all(Handler)`.
    `CassandraClient` | CassandraClient.`prepare(String query, Handler<AsyncResult<com.datastax.driver.core.PreparedStatement>> resultHandler)` Prepares the provided query string.
    `CassandraClient` | CassandraClient.`queryStream(com.datastax.driver.core.Statement statement, Handler<AsyncResult<CassandraRowStream>> rowStreamHandler)` Executes the given SQL statement which returns the results of the query as a read stream.
    `CassandraClient` | CassandraClient.`queryStream(String sql, Handler<AsyncResult<CassandraRowStream>> rowStreamHandler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `void` | Mapper.`save(T entity, Handler<AsyncResult<Void>> handler)` Asynchronous save method.
    `ResultSet` | ResultSet.`several(int amount, Handler<AsyncResult<List<com.datastax.driver.core.Row>>> handler)` Fetch a specific amount of rows and notify via a handler.

  - ### Uses of Handler in io.vertx.circuitbreaker

    Subinterfaces of Handler in io.vertx.circuitbreaker
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `HystrixMetricHandler` A Vert.x web handler to expose the circuit breaker to the Hystrix dasbboard.

    Methods in io.vertx.circuitbreaker with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `CircuitBreaker` | CircuitBreaker.`closeHandler(Handler<Void> handler)` Sets a `Handler` invoked when the circuit breaker state switches to close.
    `<T> Future<T>` | CircuitBreaker.`execute(Handler<Promise<T>> command)` Same as `CircuitBreaker.executeWithFallback(Handler, Function)` but using the circuit breaker default fallback.
    `default <T> void` | CircuitBreaker.`execute(Handler<Promise<T>> command, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(Handler, Function)` but using the circuit breaker default fallback.
    `default <T> void` | CircuitBreaker.`execute(Handler<Promise<T>> command, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(Handler, Function)` but using the circuit breaker default fallback.
    `default <T> CircuitBreaker` | CircuitBreaker.`executeAndReport(Future<T> resultFuture, Handler<Promise<T>> command)` Deprecated. use `CircuitBreaker.executeAndReport(Promise, Handler)` instead
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReport(Promise<T> resultPromise, Handler<Promise<T>> command)` Same as `CircuitBreaker.executeAndReportWithFallback(Promise, Handler, Function)` but using the circuit breaker default fallback.
    `default <T> CircuitBreaker` | CircuitBreaker.`executeAndReportWithFallback(Future<T> resultFuture, Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback)` Deprecated. use `CircuitBreaker.executeAndReportWithFallback(Promise, Handler, Function)` instead
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReportWithFallback(Promise<T> resultPromise, Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback)` Executes the given operation with the circuit breaker control.
    `default <T> void` | CircuitBreaker.`executeCommand(Handler<Promise<T>> command, Handler<AsyncResult<T>> handler)` Deprecated. instead use `CircuitBreaker.execute(Handler, Handler)`
    `default <T> void` | CircuitBreaker.`executeCommand(Handler<Promise<T>> command, Handler<AsyncResult<T>> handler)` Deprecated. instead use `CircuitBreaker.execute(Handler, Handler)`
    `default <T> void` | CircuitBreaker.`executeCommandWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback, Handler<AsyncResult<T>> handler)` Deprecated. instead use `CircuitBreaker.executeWithFallback(Handler, Function, Handler)`
    `default <T> void` | CircuitBreaker.`executeCommandWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback, Handler<AsyncResult<T>> handler)` Deprecated. instead use `CircuitBreaker.executeWithFallback(Handler, Function, Handler)`
    `<T> Future<T>` | CircuitBreaker.`executeWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback)` Executes the given operation with the circuit breaker control.
    `default <T> void` | CircuitBreaker.`executeWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(Handler, Function)` but using a callback.
    `default <T> void` | CircuitBreaker.`executeWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(Handler, Function)` but using a callback.
    `CircuitBreaker` | CircuitBreaker.`halfOpenHandler(Handler<Void> handler)` Sets a `Handler` invoked when the circuit breaker state switches to half-open.
    `CircuitBreaker` | CircuitBreaker.`openHandler(Handler<Void> handler)` Sets a `Handler` invoked when the circuit breaker state switches to open.

  - ### Uses of Handler in io.vertx.config

    Methods in io.vertx.config with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ConfigRetriever.`getConfig(Handler<AsyncResult<JsonObject>> completionHandler)` Reads the configuration from the different `ConfigStore` and computes the final configuration.
    `void` | ConfigRetriever.`listen(Handler<ConfigChange> listener)` Registers a listener receiving configuration changes.
    `ConfigRetriever` | ConfigRetriever.`setBeforeScanHandler(Handler<Void> function)` Registers a handler called before every scan.

  - ### Uses of Handler in io.vertx.config.consul

    Methods in io.vertx.config.consul with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ConsulConfigStore.`close(Handler<Void> completionHandler)`
    `void` | ConsulConfigStore.`get(Handler<AsyncResult<Buffer>> completionHandler)`

  - ### Uses of Handler in io.vertx.config.git

    Methods in io.vertx.config.git with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | GitConfigStore.`close(Handler<Void> completionHandler)`
    `void` | GitConfigStore.`get(Handler<AsyncResult<Buffer>> completionHandler)`

  - ### Uses of Handler in io.vertx.config.hocon

    Methods in io.vertx.config.hocon with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | HoconProcessor.`process(Vertx vertx, JsonObject configuration, Buffer input, Handler<AsyncResult<JsonObject>> handler)`

  - ### Uses of Handler in io.vertx.config.kubernetes

    Methods in io.vertx.config.kubernetes with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ConfigMapStore.`close(Handler<Void> completionHandler)`
    `void` | ConfigMapStore.`get(Handler<AsyncResult<Buffer>> completionHandler)`

  - ### Uses of Handler in io.vertx.config.redis

    Methods in io.vertx.config.redis with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | RedisConfigStore.`close(Handler<Void> completionHandler)`
    `void` | RedisConfigStore.`get(Handler<AsyncResult<Buffer>> completionHandler)`

  - ### Uses of Handler in io.vertx.config.spi

    Methods in io.vertx.config.spi with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `default void` | ConfigStore.`close(Handler<Void> completionHandler)` Closes the configuration store.
    `void` | ConfigStore.`get(Handler<AsyncResult<Buffer>> completionHandler)` Retrieves the configuration store in this store.
    `void` | ConfigProcessor.`process(Vertx vertx, JsonObject configuration, Buffer input, Handler<AsyncResult<JsonObject>> handler)` Transforms the given `input` into a `JsonObject`.

  - ### Uses of Handler in io.vertx.config.spi.utils

    Methods in io.vertx.config.spi.utils with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | FileSet.`buildConfiguration(List<File> files, Handler<AsyncResult<JsonObject>> handler)` Iterates over the given set of files, and for each matching file, computes the resulting configuration.

  - ### Uses of Handler in io.vertx.config.vault

    Methods in io.vertx.config.vault with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | VaultConfigStore.`close(Handler<Void> completionHandler)`
    `void` | VaultConfigStore.`get(Handler<AsyncResult<Buffer>> completionHandler)`

  - ### Uses of Handler in io.vertx.config.vault.client

    Methods in io.vertx.config.vault.client with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | SlimVaultClient.`createToken(TokenRequest tokenRequest, Handler<AsyncResult<Auth>> resultHandler)` Creates a new token.
    `void` | SlimVaultClient.`delete(String path, Handler<AsyncResult<Void>> resultHandler)` Deletes a secret from `path`.
    `void` | SlimVaultClient.`list(String path, Handler<AsyncResult<List<String>>> resultHandler)` Lists secrets from path (children).
    `void` | SlimVaultClient.`loginWithAppRole(String roleId, String secretId, Handler<AsyncResult<Auth>> resultHandler)` Logs in against the `AppRole` backend.
    `void` | SlimVaultClient.`loginWithCert(Handler<AsyncResult<Auth>> resultHandler)` Logs in against the `Cert` backend.
    `void` | SlimVaultClient.`loginWithUserCredentials(String username, String password, Handler<AsyncResult<Auth>> resultHandler)` Logs in against the `userpass` backend.
    `void` | SlimVaultClient.`lookupSelf(Handler<AsyncResult<Lookup>> resultHandler)` Looks up for the current token metadata.
    `void` | SlimVaultClient.`read(String path, Handler<AsyncResult<Secret>> responseHandler)` Reads a secret from `path`.
    `void` | SlimVaultClient.`renewSelf(long leaseDurationInSecond, Handler<AsyncResult<Auth>> resultHandler)` Renews the current token.
    `void` | SlimVaultClient.`write(String path, JsonObject secrets, Handler<AsyncResult<Secret>> resultHandler)` Write a secret to `path`.

  - ### Uses of Handler in io.vertx.config.yaml

    Methods in io.vertx.config.yaml with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | YamlProcessor.`process(Vertx vertx, JsonObject configuration, Buffer input, Handler<AsyncResult<JsonObject>> handler)`

  - ### Uses of Handler in io.vertx.config.zookeeper

    Methods in io.vertx.config.zookeeper with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ZookeeperConfigStore.`close(Handler<Void> completionHandler)`
    `void` | ZookeeperConfigStore.`get(Handler<AsyncResult<Buffer>> completionHandler)`

  - ### Uses of Handler in io.vertx.core

    Subinterfaces of Handler in io.vertx.core
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `CompositeFuture` The composite future wraps a list of `futures`, it is useful when several futures needs to be coordinated.
    `interface` | `Future<T>` Represents the result of an action that may, or may not, have occurred yet.
    `interface` | `Promise<T>` Represents the writable side of an action that may, or may not, have occurred yet.

    Methods in io.vertx.core that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `default Handler<AsyncResult<T>>` | Future.`completer()` Deprecated. use this object instead since it extends `Handler<AsyncResult<T>>`
    `Handler<Throwable>` | Context.`exceptionHandler()`
    `Handler<Throwable>` | Vertx.`exceptionHandler()`

    Methods in io.vertx.core with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | Closeable.`close(Handler<AsyncResult<Void>> completionHandler)` Close this resource, the `completionHandler` must be notified when the operation has completed.
    `void` | Vertx.`close(Handler<AsyncResult<Void>> completionHandler)` Like `Vertx.close()` but the completionHandler will be called when the close is complete
    `static void` | Vertx.`clusteredVertx(VertxOptions options, Handler<AsyncResult<Vertx>> resultHandler)` Creates a clustered instance using the specified options.
    `default <U> Future<U>` | Future.`compose(Handler<T> handler, Future<U> next)` Deprecated. use `Future.compose(Function)`)} instead
    `void` | Vertx.`deployVerticle(Class<? extends Verticle> verticleClass, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(Verticle, DeploymentOptions, Handler)` but `Verticle` instance is created by invoking the default constructor of `verticleClass`.
    `void` | Vertx.`deployVerticle(String name, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(String, Handler)` but `DeploymentOptions` are provided to configure the deployment.
    `void` | Vertx.`deployVerticle(String name, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(String)` but the completionHandler will be notified when the deployment is complete.
    `void` | Vertx.`deployVerticle(java.util.function.Supplier<Verticle> verticleSupplier, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(Verticle, DeploymentOptions, Handler)` but `Verticle` instance is created by invoking the `verticleSupplier`.
    `void` | Vertx.`deployVerticle(Verticle verticle, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(Verticle, Handler)` but `DeploymentOptions` are provided to configure the deployment.
    `void` | Vertx.`deployVerticle(Verticle verticle, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(Verticle)` but the completionHandler will be notified when the deployment is complete.
    `TimeoutStream` | TimeoutStream.`endHandler(Handler<Void> endHandler)`
    `Context` | Context.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler called when the context runs an action throwing an uncaught throwable. When this handler is called, `Vertx.currentContext()` will return this context.
    `TimeoutStream` | TimeoutStream.`exceptionHandler(Handler<Throwable> handler)`
    `Vertx` | Vertx.`exceptionHandler(Handler<Throwable> handler)` Set a default exception handler for `Context`, set on `Context.exceptionHandler(Handler)` at creation.
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Invoke `Context.executeBlocking(Handler, boolean, Handler)` with order = true.
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Invoke `Context.executeBlocking(Handler, boolean, Handler)` with order = true.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `Vertx.executeBlocking(Handler, boolean, Handler)` called with ordered = true.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `Vertx.executeBlocking(Handler, boolean, Handler)` called with ordered = true.
    `default <T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `WorkerExecutor.executeBlocking(Handler, boolean, Handler)` called with ordered = true.
    `default <T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `WorkerExecutor.executeBlocking(Handler, boolean, Handler)` called with ordered = true.
    `static <T> Future<T>` | Future.`future(Handler<Promise<T>> handler)` Create a future that hasn't completed yet and that is passed to the `handler` before it is returned.
    `TimeoutStream` | TimeoutStream.`handler(Handler<Long> handler)`
    `CompositeFuture` | CompositeFuture.`onComplete(Handler<AsyncResult<CompositeFuture>> handler)`
    `Future<T>` | Future.`onComplete(Handler<AsyncResult<T>> handler)` Add a handler to be notified of the result.
    `default Future<T>` | Future.`onFailure(Handler<Throwable> handler)` Add a handler to be notified of the failed result.
    `default CompositeFuture` | CompositeFuture.`onFailure(Handler<Throwable> handler)`
    `default CompositeFuture` | CompositeFuture.`onSuccess(Handler<CompositeFuture> handler)`
    `default Future<T>` | Future.`onSuccess(Handler<T> handler)` Add a handler to be notified of the succeeded result.
    `void` | Context.`runOnContext(Handler<Void> action)` Run the specified action asynchronously on the same context, some time after the current execution has completed.
    `void` | Vertx.`runOnContext(Handler<Void> action)` Puts the handler on the event queue for the current context so it will be run asynchronously ASAP after all preceeding events have been handled.
    `default CompositeFuture` | CompositeFuture.`setHandler(Handler<AsyncResult<CompositeFuture>> handler)` Deprecated.
    `default Future<T>` | Future.`setHandler(Handler<AsyncResult<T>> handler)` Deprecated. use `Future.onComplete(io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` instead
    `long` | Vertx.`setPeriodic(long delay, Handler<Long> handler)` Set a periodic timer to fire every `delay` milliseconds, at which point `handler` will be called with the id of the timer.
    `long` | Vertx.`setTimer(long delay, Handler<Long> handler)` Set a one-shot timer to fire after `delay` milliseconds, at which point `handler` will be called with the id of the timer.
    `void` | Vertx.`undeploy(String deploymentID, Handler<AsyncResult<Void>> completionHandler)` Like `Vertx.undeploy(String)` but the completionHandler will be notified when the undeployment is complete.

  - ### Uses of Handler in io.vertx.core.datagram

    Methods in io.vertx.core.datagram with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `DatagramSocket` | DatagramSocket.`blockMulticastGroup(String multicastAddress, String sourceToBlock, Handler<AsyncResult<DatagramSocket>> handler)` Block the given address for the given multicast address and notifies the `Handler` once the operation completes.
    `DatagramSocket` | DatagramSocket.`blockMulticastGroup(String multicastAddress, String networkInterface, String sourceToBlock, Handler<AsyncResult<DatagramSocket>> handler)` Block the given address for the given multicast address on the given network interface and notifies the `Handler` once the operation completes.
    `void` | DatagramSocket.`close(Handler<AsyncResult<Void>> handler)` Closes the `DatagramSocket` implementation asynchronous and notifies the handler once done.
    `DatagramSocket` | DatagramSocket.`endHandler(Handler<Void> endHandler)`
    `DatagramSocket` | DatagramSocket.`exceptionHandler(Handler<Throwable> handler)`
    `DatagramSocket` | DatagramSocket.`handler(Handler<DatagramPacket> handler)`
    `DatagramSocket` | DatagramSocket.`listen(int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Start listening on the given port and host.
    `DatagramSocket` | DatagramSocket.`listenMulticastGroup(String multicastAddress, Handler<AsyncResult<DatagramSocket>> handler)` Joins a multicast group and listens for packets send to it.
    `DatagramSocket` | DatagramSocket.`listenMulticastGroup(String multicastAddress, String networkInterface, String source, Handler<AsyncResult<DatagramSocket>> handler)` Joins a multicast group and listens for packets send to it on the given network interface.
    `DatagramSocket` | DatagramSocket.`send(Buffer packet, int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Write the given `Buffer` to the `SocketAddress`.
    `DatagramSocket` | DatagramSocket.`send(String str, int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Write the given `String` to the `SocketAddress` using UTF8 encoding.
    `DatagramSocket` | DatagramSocket.`send(String str, String enc, int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Write the given `String` to the `SocketAddress` using the given encoding.
    `DatagramSocket` | DatagramSocket.`unlistenMulticastGroup(String multicastAddress, Handler<AsyncResult<DatagramSocket>> handler)` Leaves a multicast group and stops listening for packets send to it.
    `DatagramSocket` | DatagramSocket.`unlistenMulticastGroup(String multicastAddress, String networkInterface, String source, Handler<AsyncResult<DatagramSocket>> handler)` Leaves a multicast group and stops listening for packets send to it on the given network interface.

  - ### Uses of Handler in io.vertx.core.dns

    Methods in io.vertx.core.dns with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `DnsClient` | DnsClient.`lookup(String name, Handler<AsyncResult<String>> handler)` Try to lookup the A (ipv4) or AAAA (ipv6) record for the given name.
    `DnsClient` | DnsClient.`lookup4(String name, Handler<AsyncResult<String>> handler)` Try to lookup the A (ipv4) record for the given name.
    `DnsClient` | DnsClient.`lookup6(String name, Handler<AsyncResult<String>> handler)` Try to lookup the AAAA (ipv6) record for the given name.
    `DnsClient` | DnsClient.`resolveA(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve all A (ipv4) records for the given name.
    `DnsClient` | DnsClient.`resolveAAAA(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve all AAAA (ipv6) records for the given name.
    `DnsClient` | DnsClient.`resolveCNAME(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve the CNAME record for the given name.
    `DnsClient` | DnsClient.`resolveMX(String name, Handler<AsyncResult<List<MxRecord>>> handler)` Try to resolve the MX records for the given name.
    `DnsClient` | DnsClient.`resolveNS(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve the NS records for the given name.
    `DnsClient` | DnsClient.`resolvePTR(String name, Handler<AsyncResult<String>> handler)` Try to resolve the PTR record for the given name.
    `DnsClient` | DnsClient.`resolveSRV(String name, Handler<AsyncResult<List<SrvRecord>>> handler)` Try to resolve the SRV records for the given name.
    `DnsClient` | DnsClient.`resolveTXT(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve the TXT records for the given name.
    `DnsClient` | DnsClient.`reverseLookup(String ipaddress, Handler<AsyncResult<String>> handler)` Try to do a reverse lookup of an IP address.

  - ### Uses of Handler in io.vertx.core.eventbus

    Methods in io.vertx.core.eventbus with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `<T> EventBus` | EventBus.`addInboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Add an interceptor that will be called whenever a message is received by Vert.x
    `<T> EventBus` | EventBus.`addOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Add an interceptor that will be called whenever a message is sent from Vert.x
    `void` | EventBus.`close(Handler<AsyncResult<Void>> completionHandler)` Close the event bus and release any resources held.
    `void` | MessageProducer.`close(Handler<AsyncResult<Void>> handler)` Same as `MessageProducer.close()` but with an `handler` called when the operation completes
    `void` | MessageConsumer.`completionHandler(Handler<AsyncResult<Void>> completionHandler)` Optional method which can be called to indicate when the registration has been propagated across the cluster.
    `<T> MessageConsumer<T>` | EventBus.`consumer(String address, Handler<Message<T>> handler)` Create a consumer and register it against the specified address.
    `MessageProducer<T>` | MessageProducer.`drainHandler(Handler<Void> handler)`
    `void` | MessageProducer.`end(Handler<AsyncResult<Void>> handler)` Closes the producer, calls `MessageProducer.close(Handler)`
    `MessageConsumer<T>` | MessageConsumer.`endHandler(Handler<Void> endHandler)`
    `MessageConsumer<T>` | MessageConsumer.`exceptionHandler(Handler<Throwable> handler)`
    `MessageProducer<T>` | MessageProducer.`exceptionHandler(Handler<Throwable> handler)`
    `MessageConsumer<T>` | MessageConsumer.`handler(Handler<Message<T>> handler)`
    `<T> MessageConsumer<T>` | EventBus.`localConsumer(String address, Handler<Message<T>> handler)` Like `EventBus.consumer(String, Handler)` but the address won't be propagated across the cluster.
    `<T> EventBus` | EventBus.`removeInboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Remove an interceptor that was added by `EventBus.addInboundInterceptor(Handler)`
    `<T> EventBus` | EventBus.`removeOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Remove an interceptor that was added by `EventBus.addOutboundInterceptor(Handler)`
    `<R> void` | Message.`reply(Object message, DeliveryOptions options, Handler<AsyncResult<Message<R>>> replyHandler)` Deprecated. use `Message.replyAndRequest(Object, DeliveryOptions, Handler)`
    `<R> void` | Message.`reply(Object message, Handler<AsyncResult<Message<R>>> replyHandler)` Deprecated. use `Message.replyAndRequest(Object, Handler)`
    `default <R> void` | Message.`replyAndRequest(Object message, DeliveryOptions options, Handler<AsyncResult<Message<R>>> replyHandler)` Like `Message.replyAndRequest(Object, Handler)` but specifying `options` that can be used to configure the delivery.
    `default <R> void` | Message.`replyAndRequest(Object message, Handler<AsyncResult<Message<R>>> replyHandler)` Reply to this message, specifying a `replyHandler` for the reply - i.e.
    `default <T> EventBus` | EventBus.`request(String address, Object message, DeliveryOptions options, Handler<AsyncResult<Message<T>>> replyHandler)` Like `EventBus.request(String, Object, Handler)` but specifying `options` that can be used to configure the delivery.
    `default <T> EventBus` | EventBus.`request(String address, Object message, Handler<AsyncResult<Message<T>>> replyHandler)` Sends a message and and specify a `replyHandler` that will be called if the recipient subsequently replies to the message.
    `<T> EventBus` | EventBus.`send(String address, Object message, DeliveryOptions options, Handler<AsyncResult<Message<T>>> replyHandler)` Deprecated. use `EventBus.request(String, Object, DeliveryOptions, Handler)` instead
    `<T> EventBus` | EventBus.`send(String address, Object message, Handler<AsyncResult<Message<T>>> replyHandler)` Deprecated. use `EventBus.request(String, Object, Handler)` instead
    `<R> MessageProducer<T>` | MessageProducer.`send(T message, Handler<AsyncResult<Message<R>>> replyHandler)` Deprecated. instead use `EventBus.request(String, Object, Handler)`
    `void` | EventBus.`start(Handler<AsyncResult<Void>> completionHandler)` Start the event bus.
    `void` | MessageConsumer.`unregister(Handler<AsyncResult<Void>> completionHandler)` Unregisters the handler which created this registration
    `MessageProducer<T>` | MessageProducer.`write(T data, Handler<AsyncResult<Void>> handler)`

  - ### Uses of Handler in io.vertx.core.file

    Methods in io.vertx.core.file with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `FileSystem` | FileSystem.`chmod(String path, String perms, Handler<AsyncResult<Void>> handler)` Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `FileSystem` | FileSystem.`chmodRecursive(String path, String perms, String dirPerms, Handler<AsyncResult<Void>> handler)` Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `FileSystem` | FileSystem.`chown(String path, String user, String group, Handler<AsyncResult<Void>> handler)` Change the ownership on the file represented by `path` to `user` and {code group}, asynchronously.
    `void` | AsyncFile.`close(Handler<AsyncResult<Void>> handler)` Close the file.
    `FileSystem` | FileSystem.`copy(String from, String to, CopyOptions options, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`copy(String from, String to, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`copyRecursive(String from, String to, boolean recursive, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`createFile(String path, Handler<AsyncResult<Void>> handler)` Creates an empty file with the specified `path`, asynchronously.
    `FileSystem` | FileSystem.`createFile(String path, String perms, Handler<AsyncResult<Void>> handler)` Creates an empty file with the specified `path` and permissions `perms`, asynchronously.
    `FileSystem` | FileSystem.`createTempDirectory(String prefix, Handler<AsyncResult<String>> handler)` Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempDirectory(String prefix, String perms, Handler<AsyncResult<String>> handler)` Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempDirectory(String dir, String prefix, String perms, Handler<AsyncResult<String>> handler)` Creates a new directory in the directory provided by the path `path`, using the given prefix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempFile(String prefix, String suffix, Handler<AsyncResult<String>> handler)` Creates a new file in the default temporary-file directory, using the given prefix and suffix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempFile(String prefix, String suffix, String perms, Handler<AsyncResult<String>> handler)` Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempFile(String dir, String prefix, String suffix, String perms, Handler<AsyncResult<String>> handler)` Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`delete(String path, Handler<AsyncResult<Void>> handler)` Deletes the file represented by the specified `path`, asynchronously.
    `FileSystem` | FileSystem.`deleteRecursive(String path, boolean recursive, Handler<AsyncResult<Void>> handler)` Deletes the file represented by the specified `path`, asynchronously.
    `AsyncFile` | AsyncFile.`drainHandler(Handler<Void> handler)`
    `void` | AsyncFile.`end(Handler<AsyncResult<Void>> handler)` Close the file, see `AsyncFile.close(Handler)`.
    `AsyncFile` | AsyncFile.`endHandler(Handler<Void> endHandler)`
    `AsyncFile` | AsyncFile.`exceptionHandler(Handler<Throwable> handler)`
    `FileSystem` | FileSystem.`exists(String path, Handler<AsyncResult<Boolean>> handler)` Determines whether the file as specified by the path `path` exists, asynchronously.
    `AsyncFile` | AsyncFile.`flush(Handler<AsyncResult<Void>> handler)` Same as `AsyncFile.flush()` but the handler will be called when the flush is complete or if an error occurs
    `FileSystem` | FileSystem.`fsProps(String path, Handler<AsyncResult<FileSystemProps>> handler)` Returns properties of the file-system being used by the specified `path`, asynchronously.
    `AsyncFile` | AsyncFile.`handler(Handler<Buffer> handler)`
    `FileSystem` | FileSystem.`link(String link, String existing, Handler<AsyncResult<Void>> handler)` Create a hard link on the file system from `link` to `existing`, asynchronously.
    `FileSystem` | FileSystem.`lprops(String path, Handler<AsyncResult<FileProps>> handler)` Obtain properties for the link represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`mkdir(String path, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`mkdir(String path, String perms, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`mkdirs(String path, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path` and any non existent parents, asynchronously.
    `FileSystem` | FileSystem.`mkdirs(String path, String perms, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path` and any non existent parents, asynchronously.
    `FileSystem` | FileSystem.`move(String from, String to, CopyOptions options, Handler<AsyncResult<Void>> handler)` Move a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`move(String from, String to, Handler<AsyncResult<Void>> handler)` Move a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`open(String path, OpenOptions options, Handler<AsyncResult<AsyncFile>> handler)` Open the file represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`props(String path, Handler<AsyncResult<FileProps>> handler)` Obtain properties for the file represented by `path`, asynchronously.
    `AsyncFile` | AsyncFile.`read(Buffer buffer, int offset, long position, int length, Handler<AsyncResult<Buffer>> handler)` Reads `length` bytes of data from the file at position `position` in the file, asynchronously.
    `FileSystem` | FileSystem.`readDir(String path, Handler<AsyncResult<List<String>>> handler)` Read the contents of the directory specified by `path`, asynchronously.
    `FileSystem` | FileSystem.`readDir(String path, String filter, Handler<AsyncResult<List<String>>> handler)` Read the contents of the directory specified by `path`, asynchronously.
    `FileSystem` | FileSystem.`readFile(String path, Handler<AsyncResult<Buffer>> handler)` Reads the entire file as represented by the path `path` as a `Buffer`, asynchronously.
    `FileSystem` | FileSystem.`readSymlink(String link, Handler<AsyncResult<String>> handler)` Returns the path representing the file that the symbolic link specified by `link` points to, asynchronously.
    `FileSystem` | FileSystem.`symlink(String link, String existing, Handler<AsyncResult<Void>> handler)` Create a symbolic link on the file system from `link` to `existing`, asynchronously.
    `FileSystem` | FileSystem.`truncate(String path, long len, Handler<AsyncResult<Void>> handler)` Truncate the file represented by `path` to length `len` in bytes, asynchronously.
    `FileSystem` | FileSystem.`unlink(String link, Handler<AsyncResult<Void>> handler)` Unlinks the link on the file system represented by the path `link`, asynchronously.
    `AsyncFile` | AsyncFile.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as `AsyncFile.write(Buffer)` but with an `handler` called when the operation completes
    `AsyncFile` | AsyncFile.`write(Buffer buffer, long position, Handler<AsyncResult<Void>> handler)` Write a `Buffer` to the file at position `position` in the file, asynchronously.
    `FileSystem` | FileSystem.`writeFile(String path, Buffer data, Handler<AsyncResult<Void>> handler)` Creates the file, and writes the specified `Buffer data` to the file represented by the path `path`, asynchronously.

  - ### Uses of Handler in io.vertx.core.http

    Methods in io.vertx.core.http that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<HttpServerRequest>` | HttpServer.`requestHandler()`
    `Handler<ServerWebSocket>` | HttpServer.`websocketHandler()` Deprecated. use instead `HttpServer.webSocketHandler()`
    `Handler<ServerWebSocket>` | HttpServer.`webSocketHandler()`

    Methods in io.vertx.core.http with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `WebSocketBase` | WebSocketBase.`binaryMessageHandler(Handler<Buffer> handler)` Set a binary message handler on the connection.
    `HttpServerResponse` | HttpServerResponse.`bodyEndHandler(Handler<Void> handler)` Provides a handler that will be called after the last part of the body is written to the wire.
    `HttpClientResponse` | HttpClientResponse.`bodyHandler(Handler<Buffer> bodyHandler)` Convenience method for receiving the entire request body in one piece.
    `default HttpServerRequest` | HttpServerRequest.`bodyHandler(Handler<Buffer> bodyHandler)` Convenience method for receiving the entire request body in one piece.
    `void` | HttpServer.`close(Handler<AsyncResult<Void>> completionHandler)` Like `HttpServer.close()` but supplying a handler that will be called when the server is actually closed (or has failed).
    `void` | WebSocketBase.`close(Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close()` but with an `handler` called when the operation completes
    `void` | WebSocketBase.`close(short statusCode, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(short)` but with an `handler` called when the operation completes
    `void` | WebSocketBase.`close(short statusCode, String reason, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close(short, String)` but with an `handler` called when the operation completes
    `HttpServerResponse` | HttpServerResponse.`closeHandler(Handler<Void> handler)` Set a close handler for the response, this is called when the underlying connection is closed and the response was still using the connection.
    `ServerWebSocket` | ServerWebSocket.`closeHandler(Handler<Void> handler)`
    `WebSocket` | WebSocket.`closeHandler(Handler<Void> handler)`
    `HttpConnection` | HttpConnection.`closeHandler(Handler<Void> handler)` Set a close handler.
    `WebSocketBase` | WebSocketBase.`closeHandler(Handler<Void> handler)` Set a close handler.
    `HttpServer` | HttpServer.`connectionHandler(Handler<HttpConnection> handler)` Set a connection handler for the server.
    `HttpClientRequest` | HttpClientRequest.`connectionHandler(Handler<HttpConnection> handler)` Deprecated. instead use `HttpClient.connectionHandler(Handler)`
    `HttpClient` | HttpClient.`connectionHandler(Handler<HttpConnection> handler)` Set a connection handler for the client.
    `HttpClientRequest` | HttpClientRequest.`continueHandler(Handler<Void> handler)` If you send an HTTP request with the header `Expect` set to the value `100-continue` and the server responds with an interim HTTP response with a status code of `100` and a continue handler has been set using this method, then the `handler` will be called.
    `HttpClientResponse` | HttpClientResponse.`customFrameHandler(Handler<HttpFrame> handler)` Set an custom frame handler.
    `HttpServerRequest` | HttpServerRequest.`customFrameHandler(Handler<HttpFrame> handler)` Set a custom frame handler.
    `HttpClientRequest` | HttpClient.`delete(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`delete(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`delete(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`delete(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`deleteAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpServerResponse` | HttpServerResponse.`drainHandler(Handler<Void> handler)`
    `ServerWebSocket` | ServerWebSocket.`drainHandler(Handler<Void> handler)`
    `HttpClientRequest` | HttpClientRequest.`drainHandler(Handler<Void> handler)`
    `WebSocket` | WebSocket.`drainHandler(Handler<Void> handler)`
    `WebSocketBase` | WebSocketBase.`drainHandler(Handler<Void> handler)`
    `void` | HttpServerResponse.`end(Buffer chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.end(Buffer)` but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`end(Buffer chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end(String)` but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`end(Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end()` but with an `handler` called when the operation completes
    `void` | WebSocketBase.`end(Handler<AsyncResult<Void>> handler)` Calls `WebSocketBase.close(Handler)`
    `void` | HttpServerResponse.`end(String chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.end(String)` but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`end(String chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end(String)` but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`end(String chunk, String enc, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.end(String, String)` but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`end(String chunk, String enc, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end(String,String)` but with an `handler` called when the operation completes
    `HttpClientResponse` | HttpClientResponse.`endHandler(Handler<Void> endHandler)`
    `HttpServerResponse` | HttpServerResponse.`endHandler(Handler<Void> handler)` Set an end handler for the response.
    `ServerWebSocket` | ServerWebSocket.`endHandler(Handler<Void> endHandler)`
    `HttpClientRequest` | HttpClientRequest.`endHandler(Handler<Void> endHandler)` Deprecated. this method will be removed in Vert.x 4
    `WebSocket` | WebSocket.`endHandler(Handler<Void> endHandler)`
    `HttpServerFileUpload` | HttpServerFileUpload.`endHandler(Handler<Void> endHandler)`
    `HttpServerRequest` | HttpServerRequest.`endHandler(Handler<Void> endHandler)`
    `WebSocketBase` | WebSocketBase.`endHandler(Handler<Void> endHandler)`
    `HttpClientResponse` | HttpClientResponse.`exceptionHandler(Handler<Throwable> handler)`
    `HttpServerResponse` | HttpServerResponse.`exceptionHandler(Handler<Throwable> handler)`
    `ServerWebSocket` | ServerWebSocket.`exceptionHandler(Handler<Throwable> handler)`
    `HttpServer` | HttpServer.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler called for socket errors happening before the HTTP connection is established, e.g during the TLS handshake.
    `HttpClientRequest` | HttpClientRequest.`exceptionHandler(Handler<Throwable> handler)`
    `WebSocket` | WebSocket.`exceptionHandler(Handler<Throwable> handler)`
    `HttpConnection` | HttpConnection.`exceptionHandler(Handler<Throwable> handler)` Set an handler called when a connection error happens
    `HttpServerFileUpload` | HttpServerFileUpload.`exceptionHandler(Handler<Throwable> handler)`
    `HttpServerRequest` | HttpServerRequest.`exceptionHandler(Handler<Throwable> handler)`
    `WebSocketBase` | WebSocketBase.`exceptionHandler(Handler<Throwable> handler)`
    `ServerWebSocket` | ServerWebSocket.`frameHandler(Handler<WebSocketFrame> handler)`
    `WebSocket` | WebSocket.`frameHandler(Handler<WebSocketFrame> handler)`
    `WebSocketBase` | WebSocketBase.`frameHandler(Handler<WebSocketFrame> handler)` Set a frame handler on the connection.
    `HttpClientRequest` | HttpClient.`get(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`get(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`get(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`get(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`getAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClient` | HttpClient.`getNow(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClient` | HttpClient.`getNow(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClient` | HttpClient.`getNow(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClient` | HttpClient.`getNow(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpConnection` | HttpConnection.`goAwayHandler(Handler<GoAway> handler)` Set an handler called when a GOAWAY frame is received.
    `HttpClientResponse` | HttpClientResponse.`handler(Handler<Buffer> handler)`
    `ServerWebSocket` | ServerWebSocket.`handler(Handler<Buffer> handler)`
    `WebSocket` | WebSocket.`handler(Handler<Buffer> handler)`
    `HttpServerFileUpload` | HttpServerFileUpload.`handler(Handler<Buffer> handler)`
    `HttpServerRequest` | HttpServerRequest.`handler(Handler<Buffer> handler)`
    `WebSocketBase` | WebSocketBase.`handler(Handler<Buffer> handler)`
    `HttpClientRequest` | HttpClientRequest.`handler(Handler<HttpClientResponse> handler)` Deprecated. this method will break in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`
    `HttpClientRequest` | HttpClient.`head(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`head(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`head(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`head(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`headAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpServerResponse` | HttpServerResponse.`headersEndHandler(Handler<Void> handler)` Provide a handler that will be called just before the headers are written to the wire.
    `HttpClient` | HttpClient.`headNow(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClient` | HttpClient.`headNow(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClient` | HttpClient.`headNow(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClient` | HttpClient.`headNow(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpServer` | HttpServer.`listen(Handler<AsyncResult<HttpServer>> listenHandler)` Like `HttpServer.listen()` but supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpServer` | HttpServer.`listen(int port, Handler<AsyncResult<HttpServer>> listenHandler)` Like `HttpServer.listen(int)` but supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpServer` | HttpServer.`listen(int port, String host, Handler<AsyncResult<HttpServer>> listenHandler)` Like `HttpServer.listen(int, String)` but supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpServer` | HttpServer.`listen(SocketAddress address, Handler<AsyncResult<HttpServer>> listenHandler)` Tell the server to start listening on the given address supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpClientRequest` | HttpClient.`options(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`options(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`options(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`options(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`optionsAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClient` | HttpClient.`optionsNow(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClient` | HttpClient.`optionsNow(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClient` | HttpClient.`optionsNow(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClient` | HttpClient.`optionsNow(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpConnection` | HttpConnection.`ping(Buffer data, Handler<AsyncResult<Buffer>> pongHandler)` Send a PING frame to the remote endpoint.
    `HttpConnection` | HttpConnection.`pingHandler(Handler<Buffer> handler)` Set an handler notified when a PING frame is received from the remote endpoint.
    `WebSocketBase` | WebSocketBase.`pongHandler(Handler<Buffer> handler)` Set a pong frame handler on the connection.
    `HttpClientRequest` | HttpClient.`post(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`post(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`post(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`post(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`postAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler)` Like `HttpServerResponse.push(HttpMethod, String, String, MultiMap, Handler)` with the host copied from the current request.
    `HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler)` Like `HttpServerResponse.push(HttpMethod, String, String, MultiMap, Handler)` with the host copied from the current request.
    `HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, String host, String path, Handler<AsyncResult<HttpServerResponse>> handler)` Like `HttpServerResponse.push(HttpMethod, String, String, MultiMap, Handler)` with no headers.
    `HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, String host, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler)` Push a response to the client. The `handler` will be notified with a success when the push can be sent and with a failure when the client has disabled push or reset the push before it has been sent. The `handler` may be queued if the client has reduced the maximum number of streams the server can push concurrently. Push can be sent only for peer initiated streams and if the response is not ended.
    `HttpClientRequest` | HttpClientRequest.`pushHandler(Handler<HttpClientRequest> handler)` Set a push handler for this request. The handler is called when the client receives a push promise from the server.
    `HttpClientRequest` | HttpClient.`put(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`put(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`put(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`put(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`putAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpConnection` | HttpConnection.`remoteSettingsHandler(Handler<Http2Settings> handler)` Set an handler that is called when remote endpoint `Http2Settings` are updated.
    `HttpClientRequest` | HttpClient.`request(HttpMethod method, int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`request(HttpMethod method, RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated. this method will break in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`
    `HttpClientRequest` | HttpClient.`request(HttpMethod method, SocketAddress serverAddress, int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Like `HttpClient.request(HttpMethod, int, String, String, Handler)` using the `serverAddress` parameter to connect to the server instead of the `absoluteURI` parameter.
    `HttpClientRequest` | HttpClient.`request(HttpMethod method, SocketAddress serverAddress, RequestOptions options, Handler<HttpClientResponse> responseHandler)` Like `HttpClient.request(HttpMethod, RequestOptions, Handler)` using the `serverAddress` parameter to connect to the server instead of the `absoluteURI` parameter.
    `HttpClientRequest` | HttpClient.`request(HttpMethod method, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`request(HttpMethod method, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | HttpClient.`requestAbs(HttpMethod method, SocketAddress serverAddress, String absoluteURI, Handler<HttpClientResponse> responseHandler)` Like `HttpClient.requestAbs(HttpMethod, String, Handler)` using the `serverAddress` parameter to connect to the server instead of the `absoluteURI` parameter.
    `HttpClientRequest` | HttpClient.`requestAbs(HttpMethod method, String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpServer` | HttpServer.`requestHandler(Handler<HttpServerRequest> handler)` Set the request handler for the server to `requestHandler`.
    `default HttpServerResponse` | HttpServerResponse.`sendFile(String filename, Handler<AsyncResult<Void>> resultHandler)` Like `HttpServerResponse.sendFile(String)` but providing a handler which will be notified once the file has been completely written to the wire.
    `default HttpServerResponse` | HttpServerResponse.`sendFile(String filename, long offset, Handler<AsyncResult<Void>> resultHandler)` Like `HttpServerResponse.sendFile(String, long)` but providing a handler which will be notified once the file has been completely written to the wire.
    `HttpServerResponse` | HttpServerResponse.`sendFile(String filename, long offset, long length, Handler<AsyncResult<Void>> resultHandler)` Like `HttpServerResponse.sendFile(String, long, long)` but providing a handler which will be notified once the file has been completely written to the wire.
    `HttpClientRequest` | HttpClientRequest.`sendHead(Handler<HttpVersion> completionHandler)` Like `HttpClientRequest.sendHead()` but with an handler after headers have been sent.
    `void` | ServerWebSocket.`setHandshake(Future<Integer> future, Handler<AsyncResult<Integer>> handler)` Set an asynchronous result for the handshake, upon completion of the specified `future`, the WebSocket will either be accepted when the `future` succeeds with the HTTP 101 status code rejected when the `future` is succeeds with an HTTP status code different than 101 rejected when the `future` fails with the HTTP status code `500` The provided future might be completed by the WebSocket itself, e.g calling the `ServerWebSocket.close()` method will try to accept the handshake and close the WebSocket afterward.
    `HttpConnection` | HttpConnection.`shutdownHandler(Handler<Void> handler)` Set an handler called when a GOAWAY frame has been sent or received and all connections are closed.
    `HttpClientResponse` | HttpClientResponse.`streamPriorityHandler(Handler<StreamPriority> handler)` Set an handler for stream priority changes.
    `HttpServerRequest` | HttpServerRequest.`streamPriorityHandler(Handler<StreamPriority> handler)` Set an handler for stream priority changes
    `WebSocketBase` | WebSocketBase.`textMessageHandler(Handler<String> handler)` Set a text message handler on the connection.
    `HttpConnection` | HttpConnection.`updateSettings(Http2Settings settings, Handler<AsyncResult<Void>> completionHandler)` Send to the remote endpoint an update of this endpoint settings The `completionHandler` will be notified when the remote endpoint has acknowledged the settings.
    `HttpServerRequest` | HttpServerRequest.`uploadHandler(Handler<HttpServerFileUpload> uploadHandler)` Set an upload handler.
    `void` | HttpClient.`webSocket(int port, String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket to the specified port, host and relative request URI
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, Handler<WebSocket> wsConnect)` Deprecated. use `HttpClient.webSocket(int, String, String, Handler)` instead
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(int, String, String, Handler)` instead
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(int, String, String, Handler)` instead
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(RequestOptions options, Handler<WebSocket> wsConnect)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(RequestOptions options, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(RequestOptions options, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, Handler<WebSocket> wsConnect)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `void` | HttpClient.`webSocket(String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket at the relative request URI using the default host and port
    `HttpClient` | HttpClient.`websocket(String requestURI, Handler<WebSocket> wsConnect)` Deprecated. use `HttpClient.webSocket(String, Handler)` instead
    `HttpClient` | HttpClient.`websocket(String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(String, Handler)` instead
    `HttpClient` | HttpClient.`websocket(String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(String, Handler)` instead
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, Handler<WebSocket> wsConnect)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `void` | HttpClient.`webSocket(String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket to the host and relative request URI and default port
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, Handler<WebSocket> wsConnect)` Deprecated. use `HttpClient.webSocket(String, String, Handler)` instead
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(String, String, Handler)` instead
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(String, String, Handler)` instead
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `void` | HttpClient.`webSocket(WebSocketConnectOptions options, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket with the specified options.
    `void` | HttpClient.`webSocketAbs(String url, MultiMap headers, WebsocketVersion version, List<String> subProtocols, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket with the specified absolute url, with the specified headers, using the specified version of WebSockets, and the specified WebSocket sub protocols.
    `HttpClient` | HttpClient.`websocketAbs(String url, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | HttpClient.`websocketAbs(String url, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `HttpClient.webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpServer` | HttpServer.`websocketHandler(Handler<ServerWebSocket> handler)` Deprecated. use instead `HttpServer.webSocketHandler()`
    `HttpServer` | HttpServer.`webSocketHandler(Handler<ServerWebSocket> handler)` Set the WebSocket handler for the server to `wsHandler`.
    `HttpServerResponse` | HttpServerResponse.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.write(Buffer)` but with an `handler` called when the operation completes
    `ServerWebSocket` | ServerWebSocket.`write(Buffer data, Handler<AsyncResult<Void>> handler)`
    `HttpClientRequest` | HttpClientRequest.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.write(Buffer)` but with an `handler` called when the operation completes
    `WebSocket` | WebSocket.`write(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`write(Buffer data, Handler<AsyncResult<Void>> handler)`
    `HttpServerResponse` | HttpServerResponse.`write(String chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.write(String)` but with an `handler` called when the operation completes
    `HttpClientRequest` | HttpClientRequest.`write(String chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.write(String)` but with an `handler` called when the operation completes
    `HttpServerResponse` | HttpServerResponse.`write(String chunk, String enc, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.write(String, String)` but with an `handler` called when the operation completes
    `HttpClientRequest` | HttpClientRequest.`write(String chunk, String enc, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.write(String,String)` but with an `handler` called when the operation completes
    `ServerWebSocket` | ServerWebSocket.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeBinaryMessage(Buffer)` but with an `handler` called when the operation completes
    `ServerWebSocket` | ServerWebSocket.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeFinalBinaryFrame(Buffer, Handler)` but with an `handler` called when the operation completes
    `ServerWebSocket` | ServerWebSocket.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeFinalTextFrame(String, Handler)` but with an `handler` called when the operation completes
    `ServerWebSocket` | ServerWebSocket.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeFrame(WebSocketFrame)` but with an `handler` called when the operation completes
    `ServerWebSocket` | ServerWebSocket.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeTextMessage(String)` but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.core.net

    Methods in io.vertx.core.net that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<NetSocket>` | NetServer.`connectHandler()`

    Methods in io.vertx.core.net with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | NetSocket.`close(Handler<AsyncResult<Void>> handler)` Close the NetSocket and notify the `handler` when the operation completes.
    `void` | NetServer.`close(Handler<AsyncResult<Void>> completionHandler)` Like `NetServer.close()` but supplying a handler that will be notified when close is complete.
    `NetSocket` | NetSocket.`closeHandler(Handler<Void> handler)` Set a handler that will be called when the NetSocket is closed
    `NetClient` | NetClient.`connect(int port, String host, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `port` and `host`.
    `NetClient` | NetClient.`connect(int port, String host, String serverName, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `port` and `host`.
    `NetClient` | NetClient.`connect(SocketAddress remoteAddress, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `remoteAddress`.
    `NetClient` | NetClient.`connect(SocketAddress remoteAddress, String serverName, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `remoteAddress`.
    `NetServer` | NetServer.`connectHandler(Handler<NetSocket> handler)` Supply a connect handler for this server.
    `NetSocket` | NetSocket.`drainHandler(Handler<Void> handler)`
    `void` | NetSocket.`end(Handler<AsyncResult<Void>> handler)` Calls `NetSocket.end(Handler)`
    `NetSocket` | NetSocket.`endHandler(Handler<Void> endHandler)` Set an end handler.
    `NetSocket` | NetSocket.`exceptionHandler(Handler<Throwable> handler)`
    `NetServer` | NetServer.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler called for socket errors happening before the connection is passed to the `NetServer.connectHandler(io.vertx.core.Handler<io.vertx.core.net.NetSocket>)`, e.g during the TLS handshake.
    `NetSocket` | NetSocket.`handler(Handler<Buffer> handler)`
    `NetServer` | NetServer.`listen(Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen()` but providing a handler that will be notified when the server is listening, or fails.
    `NetServer` | NetServer.`listen(int port, Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen(int)` but providing a handler that will be notified when the server is listening, or fails.
    `NetServer` | NetServer.`listen(int port, String host, Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen(int, String)` but providing a handler that will be notified when the server is listening, or fails.
    `NetServer` | NetServer.`listen(SocketAddress localAddress, Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen(SocketAddress)` but providing a handler that will be notified when the server is listening, or fails.
    `default NetSocket` | NetSocket.`sendFile(String filename, Handler<AsyncResult<Void>> resultHandler)` Same as `NetSocket.sendFile(String)` but also takes a handler that will be called when the send has completed or a failure has occurred
    `default NetSocket` | NetSocket.`sendFile(String filename, long offset, Handler<AsyncResult<Void>> resultHandler)` Same as `NetSocket.sendFile(String, long)` but also takes a handler that will be called when the send has completed or a failure has occurred
    `NetSocket` | NetSocket.`sendFile(String filename, long offset, long length, Handler<AsyncResult<Void>> resultHandler)` Same as `NetSocket.sendFile(String, long, long)` but also takes a handler that will be called when the send has completed or a failure has occurred
    `NetSocket` | NetSocket.`upgradeToSsl(Handler<Void> handler)` Upgrade channel to use SSL/TLS.
    `NetSocket` | NetSocket.`upgradeToSsl(String serverName, Handler<Void> handler)` Upgrade channel to use SSL/TLS.
    `NetSocket` | NetSocket.`write(Buffer message, Handler<AsyncResult<Void>> handler)` Like `WriteStream.write(Object)` but with an `handler` called when the message has been written or failed to be written.
    `NetSocket` | NetSocket.`write(String str, Handler<AsyncResult<Void>> handler)` Same as `NetSocket.write(String)` but with an `handler` called when the operation completes
    `NetSocket` | NetSocket.`write(String str, String enc, Handler<AsyncResult<Void>> handler)` Same as `NetSocket.write(String, String)` but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.core.parsetools

    Subinterfaces of Handler in io.vertx.core.parsetools
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `JsonParser` A parser class which allows to incrementally parse json elements and emit json parse events instead of parsing a json element fully.
    `interface` | `RecordParser` A helper class which allows you to easily parse protocols which are delimited by a sequence of bytes, or fixed size records.

    Methods in io.vertx.core.parsetools with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `RecordParser` | RecordParser.`endHandler(Handler<Void> endHandler)`
    `JsonParser` | JsonParser.`endHandler(Handler<Void> endHandler)`
    `RecordParser` | RecordParser.`exceptionHandler(Handler<Throwable> handler)`
    `JsonParser` | JsonParser.`exceptionHandler(Handler<Throwable> handler)`
    `RecordParser` | RecordParser.`handler(Handler<Buffer> handler)`
    `JsonParser` | JsonParser.`handler(Handler<JsonEvent> handler)`
    `static RecordParser` | RecordParser.`newDelimited(Buffer delim, Handler<Buffer> output)` Like `RecordParser.newDelimited(Buffer)` but set the `output` that will receive whole records which have been parsed.
    `static RecordParser` | RecordParser.`newDelimited(String delim, Handler<Buffer> output)` Like `RecordParser.newDelimited(String)` but set the `output` that will receive whole records which have been parsed.
    `static RecordParser` | RecordParser.`newFixed(int size, Handler<Buffer> output)` Like `RecordParser.newFixed(int)` but set the `output` that will receive whole records which have been parsed.
    `void` | RecordParser.`setOutput(Handler<Buffer> output)`

  - ### Uses of Handler in io.vertx.core.shareddata

    Methods in io.vertx.core.shareddata with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | Counter.`addAndGet(long value, Handler<AsyncResult<Long>> resultHandler)` Add the value to the counter atomically and return the new count
    `void` | AsyncMap.`clear(Handler<AsyncResult<Void>> resultHandler)` Clear all entries in the map
    `void` | Counter.`compareAndSet(long expected, long value, Handler<AsyncResult<Boolean>> resultHandler)` Set the counter to the specified value only if the current value is the expectec value.
    `void` | Counter.`decrementAndGet(Handler<AsyncResult<Long>> resultHandler)` Decrement the counter atomically and return the new count
    `void` | AsyncMap.`entries(Handler<AsyncResult<Map<K,V>>> resultHandler)` Get the entries of the map, asynchronously.
    `void` | Counter.`get(Handler<AsyncResult<Long>> resultHandler)` Get the current value of the counter
    `void` | AsyncMap.`get(K k, Handler<AsyncResult<V>> resultHandler)` Get a value from the map, asynchronously.
    `void` | Counter.`getAndAdd(long value, Handler<AsyncResult<Long>> resultHandler)` Add the value to the counter atomically and return the value before the add
    `void` | Counter.`getAndIncrement(Handler<AsyncResult<Long>> resultHandler)` Increment the counter atomically and return the value before the increment.
    `<K,V> void` | SharedData.`getAsyncMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)` Get the `AsyncMap` with the specified name.
    `<K,V> void` | SharedData.`getClusterWideMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)` Get the cluster wide map with the specified name.
    `void` | SharedData.`getCounter(String name, Handler<AsyncResult<Counter>> resultHandler)` Get an asynchronous counter.
    `<K,V> void` | SharedData.`getLocalAsyncMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)` Get the `AsyncMap` with the specified name.
    `void` | SharedData.`getLocalCounter(String name, Handler<AsyncResult<Counter>> resultHandler)` Get an asynchronous local counter.
    `void` | SharedData.`getLocalLock(String name, Handler<AsyncResult<Lock>> resultHandler)` Get an asynchronous local lock with the specified name.
    `void` | SharedData.`getLocalLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler)` Like `SharedData.getLocalLock(String, Handler)` but specifying a timeout.
    `void` | SharedData.`getLock(String name, Handler<AsyncResult<Lock>> resultHandler)` Get an asynchronous lock with the specified name.
    `void` | SharedData.`getLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler)` Like `SharedData.getLock(String, Handler)` but specifying a timeout.
    `void` | Counter.`incrementAndGet(Handler<AsyncResult<Long>> resultHandler)` Increment the counter atomically and return the new count
    `void` | AsyncMap.`keys(Handler<AsyncResult<Set<K>>> resultHandler)` Get the keys of the map, asynchronously.
    `void` | AsyncMap.`put(K k, V v, Handler<AsyncResult<Void>> completionHandler)` Put a value in the map, asynchronously.
    `void` | AsyncMap.`put(K k, V v, long ttl, Handler<AsyncResult<Void>> completionHandler)` Like `AsyncMap.put(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but specifying a time to live for the entry.
    `void` | AsyncMap.`putIfAbsent(K k, V v, Handler<AsyncResult<V>> completionHandler)` Put the entry only if there is no entry with the key already present.
    `void` | AsyncMap.`putIfAbsent(K k, V v, long ttl, Handler<AsyncResult<V>> completionHandler)` Link `AsyncMap.putIfAbsent(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<V>>)` but specifying a time to live for the entry.
    `void` | AsyncMap.`remove(K k, Handler<AsyncResult<V>> resultHandler)` Remove a value from the map, asynchronously.
    `void` | AsyncMap.`removeIfPresent(K k, V v, Handler<AsyncResult<Boolean>> resultHandler)` Remove a value from the map, only if entry already exists with same value.
    `void` | AsyncMap.`replace(K k, V v, Handler<AsyncResult<V>> resultHandler)` Replace the entry only if it is currently mapped to some value
    `void` | AsyncMap.`replaceIfPresent(K k, V oldValue, V newValue, Handler<AsyncResult<Boolean>> resultHandler)` Replace the entry only if it is currently mapped to a specific value
    `void` | AsyncMap.`size(Handler<AsyncResult<Integer>> resultHandler)` Provide the number of entries in the map
    `void` | AsyncMap.`values(Handler<AsyncResult<List<V>>> resultHandler)` Get the values of the map, asynchronously.

  - ### Uses of Handler in io.vertx.core.spi

    Methods in io.vertx.core.spi with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | VertxFactory.`clusteredVertx(VertxOptions options, Handler<AsyncResult<Vertx>> resultHandler)`
    `void` | VertxFactory.`clusteredVertx(VertxOptions options, io.vertx.core.net.impl.transport.Transport transport, Handler<AsyncResult<Vertx>> resultHandler)`

  - ### Uses of Handler in io.vertx.core.spi.cluster

    Methods in io.vertx.core.spi.cluster with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | AsyncMultiMap.`add(K k, V v, Handler<AsyncResult<Void>> completionHandler)` Add a value to the values for that key in the map.
    `void` | AsyncMultiMap.`get(K k, Handler<AsyncResult<ChoosableIterable<V>>> resultHandler)` Get the values from the map for the key.
    `<K,V> void` | ClusterManager.`getAsyncMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)` Return an async map for the given name
    `<K,V> void` | ClusterManager.`getAsyncMultiMap(String name, Handler<AsyncResult<AsyncMultiMap<K,V>>> resultHandler)` Return an async multi-map for the given name
    `void` | ClusterManager.`getCounter(String name, Handler<AsyncResult<Counter>> resultHandler)`
    `void` | ClusterManager.`getLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler)`
    `void` | ClusterManager.`join(Handler<AsyncResult<Void>> resultHandler)` Join the cluster
    `void` | ClusterManager.`leave(Handler<AsyncResult<Void>> resultHandler)` Leave the cluster
    `void` | AsyncMultiMap.`remove(K k, V v, Handler<AsyncResult<Boolean>> completionHandler)` Remove a value from the values of that key in the map.
    `void` | AsyncMultiMap.`removeAllForValue(V v, Handler<AsyncResult<Void>> completionHandler)` Remove the specified value from all values found `equals` associated to all keys in the map.
    `void` | AsyncMultiMap.`removeAllMatching(java.util.function.Predicate<V> p, Handler<AsyncResult<Void>> completionHandler)` Remove values which satisfies the given predicate in all keys.

  - ### Uses of Handler in io.vertx.core.spi.resolver

    Methods in io.vertx.core.spi.resolver with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ResolverProvider.`close(Handler<Void> doneHandler)`

  - ### Uses of Handler in io.vertx.core.streams

    Methods in io.vertx.core.streams with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `WriteStream<T>` | WriteStream.`drainHandler(Handler<Void> handler)` Set a drain handler on the stream.
    `void` | WriteStream.`end(Handler<AsyncResult<Void>> handler)` Same as `WriteStream.end()` but with an `handler` called when the operation completes
    `default void` | WriteStream.`end(T data, Handler<AsyncResult<Void>> handler)` Same as `#end(T)` but with an `handler` called when the operation completes
    `ReadStream<T>` | ReadStream.`endHandler(Handler<Void> endHandler)` Set an end handler.
    `ReadStream<T>` | ReadStream.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the read stream.
    `StreamBase` | StreamBase.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler.
    `WriteStream<T>` | WriteStream.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the write stream.
    `ReadStream<T>` | ReadStream.`handler(Handler<T> handler)` Set a data handler.
    `default void` | ReadStream.`pipeTo(WriteStream<T> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | Pipe.`to(WriteStream<T> dst, Handler<AsyncResult<Void>> completionHandler)` Start to pipe the elements to the destination `WriteStream`.
    `WriteStream<T>` | WriteStream.`write(T data, Handler<AsyncResult<Void>> handler)` Same as `#write(T)` but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.ext.auth

    Methods in io.vertx.ext.auth with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | AuthProvider.`authenticate(JsonObject authInfo, Handler<AsyncResult<User>> resultHandler)` Authenticate a user.
    `protected abstract void` | AbstractUser.`doIsPermitted(String permission, Handler<AsyncResult<Boolean>> resultHandler)` Deprecated.
    `default User` | User.`isAuthorised(String authority, Handler<AsyncResult<Boolean>> resultHandler)` Deprecated. See `User.isAuthorized(String, Handler)`
    `User` | AbstractUser.`isAuthorized(String authority, Handler<AsyncResult<Boolean>> resultHandler)` Deprecated.
    `User` | User.`isAuthorized(String authority, Handler<AsyncResult<Boolean>> resultHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.ext.auth.mongo

    Methods in io.vertx.ext.auth.mongo with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | MongoAuth.`insertUser(String username, String password, List<String> roles, List<String> permissions, Handler<AsyncResult<String>> resultHandler)` Insert a new user into mongo in the convenient way

  - ### Uses of Handler in io.vertx.ext.auth.oauth2

    Methods in io.vertx.ext.auth.oauth2 with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `OAuth2Auth` | OAuth2Auth.`decodeToken(String token, Handler<AsyncResult<AccessToken>> handler)` Deprecated. use `AuthProvider.authenticate(JsonObject, Handler)` instead.
    `AccessToken` | AccessToken.`fetch(HttpMethod method, String resource, JsonObject headers, Buffer payload, Handler<AsyncResult<OAuth2Response>> callback)` Deprecated. Fetches a JSON resource using this Access Token.
    `default AccessToken` | AccessToken.`fetch(String resource, Handler<AsyncResult<OAuth2Response>> callback)` Deprecated. Fetches a JSON resource using this Access Token.
    `void` | OAuth2Auth.`getToken(JsonObject params, Handler<AsyncResult<AccessToken>> handler)` Deprecated. use `AuthProvider.authenticate(JsonObject, Handler)` instead.
    `AccessToken` | AccessToken.`introspect(Handler<AsyncResult<Void>> callback)` Deprecated. Introspect access token.
    `AccessToken` | AccessToken.`introspect(String tokenType, Handler<AsyncResult<Void>> callback)` Deprecated. Introspect access token.
    `default OAuth2Auth` | OAuth2Auth.`introspectToken(String token, Handler<AsyncResult<AccessToken>> handler)` Deprecated.
    `OAuth2Auth` | OAuth2Auth.`introspectToken(String token, String tokenType, Handler<AsyncResult<AccessToken>> handler)` Deprecated.
    `void` | OAuth2RBAC.`isAuthorized(AccessToken user, String authority, Handler<AsyncResult<Boolean>> handler)` This method should verify if the user has the given authority and return either a boolean value or an error.
    `OAuth2Auth` | OAuth2Auth.`loadJWK(Handler<AsyncResult<Void>> handler)` Deprecated.
    `AccessToken` | AccessToken.`logout(Handler<AsyncResult<Void>> callback)` Deprecated. Revoke refresh token and calls the logout endpoint.
    `AccessToken` | AccessToken.`refresh(Handler<AsyncResult<Void>> callback)` Deprecated. Refresh the access token
    `AccessToken` | AccessToken.`revoke(String token_type, Handler<AsyncResult<Void>> callback)` Deprecated. Revoke access or refresh token
    `AccessToken` | AccessToken.`userInfo(Handler<AsyncResult<JsonObject>> callback)` Deprecated. Load the user info as per OIDC spec.

  - ### Uses of Handler in io.vertx.ext.auth.oauth2.providers

    Methods in io.vertx.ext.auth.oauth2.providers with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static void` | SalesforceAuth.`discover(Vertx vertx, OAuth2ClientOptions config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | GoogleAuth.`discover(Vertx vertx, OAuth2ClientOptions config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | AzureADAuth.`discover(Vertx vertx, OAuth2ClientOptions config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | OpenIDConnectAuth.`discover(Vertx vertx, OAuth2ClientOptions config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | KeycloakAuth.`discover(Vertx vertx, OAuth2ClientOptions config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.

  - ### Uses of Handler in io.vertx.ext.bridge

    Subinterfaces of Handler in io.vertx.ext.bridge
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `BaseBridgeEvent` Represents an event that occurs on the event bus bridge.

  - ### Uses of Handler in io.vertx.ext.cluster.infinispan

    Methods in io.vertx.ext.cluster.infinispan that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `static Handler<Promise<Status>>` | ClusterHealthCheck.`createProcedure(Vertx vertx)` Like `ClusterHealthCheck.createProcedure(Vertx, boolean)` with `details` set to `true`.
    `static Handler<Promise<Status>>` | ClusterHealthCheck.`createProcedure(Vertx vertx, boolean detailed)` Creates a ready-to-use Vert.x cluster `HealthChecks` procedure.

    Methods in io.vertx.ext.cluster.infinispan with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `<K,V> void` | InfinispanClusterManager.`getAsyncMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)`
    `<K,V> void` | InfinispanClusterManager.`getAsyncMultiMap(String name, Handler<AsyncResult<AsyncMultiMap<K,V>>> resultHandler)`
    `void` | InfinispanClusterManager.`getCounter(String name, Handler<AsyncResult<Counter>> resultHandler)`
    `void` | InfinispanClusterManager.`getLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler)`
    `void` | InfinispanClusterManager.`join(Handler<AsyncResult<Void>> resultHandler)`
    `void` | InfinispanClusterManager.`leave(Handler<AsyncResult<Void>> resultHandler)`

  - ### Uses of Handler in io.vertx.ext.consul

    Methods in io.vertx.ext.consul with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `ConsulClient` | ConsulClient.`agentInfo(Handler<AsyncResult<JsonObject>> resultHandler)` Returns the configuration and member information of the local agent
    `ConsulService` | ConsulService.`agentInfo(Handler<AsyncResult<JsonObject>> resultHandler)`
    `ConsulClient` | ConsulClient.`catalogDatacenters(Handler<AsyncResult<List<String>>> resultHandler)` Return all the datacenters that are known by the Consul server
    `ConsulService` | ConsulService.`catalogDatacenters(Handler<AsyncResult<List<String>>> resultHandler)`
    `ConsulClient` | ConsulClient.`catalogNodes(Handler<AsyncResult<NodeList>> resultHandler)` Returns the nodes registered in a datacenter
    `ConsulService` | ConsulService.`catalogNodes(Handler<AsyncResult<NodeList>> resultHandler)`
    `ConsulClient` | ConsulClient.`catalogNodeServices(String node, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the node's registered services
    `ConsulService` | ConsulService.`catalogNodeServices(String node, Handler<AsyncResult<ServiceList>> resultHandler)`
    `ConsulClient` | ConsulClient.`catalogNodeServicesWithOptions(String node, BlockingQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the node's registered services This is blocking query unlike `ConsulClient.catalogNodeServices(String, Handler)`
    `ConsulService` | ConsulService.`catalogNodeServicesWithOptions(String node, BlockingQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)`
    `ConsulClient` | ConsulClient.`catalogNodesWithOptions(NodeQueryOptions options, Handler<AsyncResult<NodeList>> resultHandler)` Returns the nodes registered in a datacenter
    `ConsulService` | ConsulService.`catalogNodesWithOptions(NodeQueryOptions options, Handler<AsyncResult<NodeList>> resultHandler)`
    `ConsulClient` | ConsulClient.`catalogServiceNodes(String service, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the nodes providing a service
    `ConsulService` | ConsulService.`catalogServiceNodes(String service, Handler<AsyncResult<ServiceList>> resultHandler)`
    `ConsulClient` | ConsulClient.`catalogServiceNodesWithOptions(String service, ServiceQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the nodes providing a service
    `ConsulService` | ConsulService.`catalogServiceNodesWithOptions(String service, ServiceQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)`
    `ConsulClient` | ConsulClient.`catalogServices(Handler<AsyncResult<ServiceList>> resultHandler)` Returns the services registered in a datacenter
    `ConsulService` | ConsulService.`catalogServices(Handler<AsyncResult<ServiceList>> resultHandler)`
    `ConsulClient` | ConsulClient.`catalogServicesWithOptions(BlockingQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the services registered in a datacenter This is blocking query unlike `ConsulClient.catalogServices(Handler)`
    `ConsulService` | ConsulService.`catalogServicesWithOptions(BlockingQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)`
    `ConsulClient` | ConsulClient.`cloneAclToken(String id, Handler<AsyncResult<String>> idHandler)` Clone Acl token
    `ConsulService` | ConsulService.`cloneAclToken(String id, Handler<AsyncResult<String>> idHandler)`
    `ConsulClient` | ConsulClient.`coordinateDatacenters(Handler<AsyncResult<List<DcCoordinates>>> resultHandler)` Returns the WAN network coordinates for all Consul servers, organized by DCs
    `ConsulService` | ConsulService.`coordinateDatacenters(Handler<AsyncResult<List<DcCoordinates>>> resultHandler)`
    `ConsulClient` | ConsulClient.`coordinateNodes(Handler<AsyncResult<CoordinateList>> resultHandler)` Returns the LAN network coordinates for all nodes in a given DC
    `ConsulService` | ConsulService.`coordinateNodes(Handler<AsyncResult<CoordinateList>> resultHandler)`
    `ConsulClient` | ConsulClient.`coordinateNodesWithOptions(BlockingQueryOptions options, Handler<AsyncResult<CoordinateList>> resultHandler)` Returns the LAN network coordinates for all nodes in a given DC This is blocking query unlike `ConsulClient.coordinateNodes(Handler)`
    `ConsulService` | ConsulService.`coordinateNodesWithOptions(BlockingQueryOptions options, Handler<AsyncResult<CoordinateList>> resultHandler)`
    `ConsulClient` | ConsulClient.`createAclToken(AclToken token, Handler<AsyncResult<String>> idHandler)` Create new Acl token
    `ConsulService` | ConsulService.`createAclToken(AclToken token, Handler<AsyncResult<String>> idHandler)`
    `ConsulClient` | ConsulClient.`createPreparedQuery(PreparedQueryDefinition definition, Handler<AsyncResult<String>> resultHandler)`
    `ConsulService` | ConsulService.`createPreparedQuery(PreparedQueryDefinition definition, Handler<AsyncResult<String>> resultHandler)`
    `ConsulClient` | ConsulClient.`createSession(Handler<AsyncResult<String>> idHandler)` Initialize a new session
    `ConsulService` | ConsulService.`createSession(Handler<AsyncResult<String>> idHandler)`
    `ConsulClient` | ConsulClient.`createSessionWithOptions(SessionOptions options, Handler<AsyncResult<String>> idHandler)` Initialize a new session
    `ConsulService` | ConsulService.`createSessionWithOptions(SessionOptions options, Handler<AsyncResult<String>> idHandler)`
    `ConsulClient` | ConsulClient.`deletePreparedQuery(String id, Handler<AsyncResult<Void>> resultHandler)` Deletes an existing prepared query
    `ConsulService` | ConsulService.`deletePreparedQuery(String id, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`deleteValue(String key, Handler<AsyncResult<Void>> resultHandler)` Remove the key/value pair that corresponding to the specified key
    `ConsulService` | ConsulService.`deleteValue(String key, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`deleteValues(String keyPrefix, Handler<AsyncResult<Void>> resultHandler)` Removes all the key/value pair that corresponding to the specified key prefix
    `ConsulService` | ConsulService.`deleteValues(String keyPrefix, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`deregisterCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Remove a check from the local agent.
    `ConsulService` | ConsulService.`deregisterCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`deregisterService(String id, Handler<AsyncResult<Void>> resultHandler)` Remove a service from the local agent.
    `ConsulService` | ConsulService.`deregisterService(String id, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`destroyAclToken(String id, Handler<AsyncResult<Void>> resultHandler)` Destroy Acl token
    `ConsulService` | ConsulService.`destroyAclToken(String id, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`destroySession(String id, Handler<AsyncResult<Void>> resultHandler)` Destroys the given session
    `ConsulService` | ConsulService.`destroySession(String id, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`executePreparedQuery(String query, Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)` Executes an existing prepared query.
    `ConsulService` | ConsulService.`executePreparedQuery(String query, Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)`
    `ConsulClient` | ConsulClient.`executePreparedQueryWithOptions(String query, PreparedQueryExecuteOptions options, Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)` Executes an existing prepared query.
    `ConsulService` | ConsulService.`executePreparedQueryWithOptions(String query, PreparedQueryExecuteOptions options, Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)`
    `ConsulClient` | ConsulClient.`failCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "critical".
    `ConsulService` | ConsulService.`failCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`failCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "critical".
    `ConsulService` | ConsulService.`failCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`fireEvent(String name, Handler<AsyncResult<Event>> resultHandler)` Fires a new user event
    `ConsulService` | ConsulService.`fireEvent(String name, Handler<AsyncResult<Event>> resultHandler)`
    `ConsulClient` | ConsulClient.`fireEventWithOptions(String name, EventOptions options, Handler<AsyncResult<Event>> resultHandler)` Fires a new user event
    `ConsulService` | ConsulService.`fireEventWithOptions(String name, EventOptions options, Handler<AsyncResult<Event>> resultHandler)`
    `ConsulClient` | ConsulClient.`getAllPreparedQueries(Handler<AsyncResult<List<PreparedQueryDefinition>>> resultHandler)` Returns a list of all prepared queries.
    `ConsulService` | ConsulService.`getAllPreparedQueries(Handler<AsyncResult<List<PreparedQueryDefinition>>> resultHandler)`
    `ConsulClient` | ConsulClient.`getKeys(String keyPrefix, Handler<AsyncResult<List<String>>> resultHandler)` Returns the list of keys that corresponding to the specified key prefix.
    `ConsulService` | ConsulService.`getKeys(String keyPrefix, Handler<AsyncResult<List<String>>> resultHandler)`
    `ConsulClient` | ConsulClient.`getKeysWithOptions(String keyPrefix, BlockingQueryOptions options, Handler<AsyncResult<List<String>>> resultHandler)` Returns the list of keys that corresponding to the specified key prefix.
    `ConsulService` | ConsulService.`getKeysWithOptions(String keyPrefix, BlockingQueryOptions options, Handler<AsyncResult<List<String>>> resultHandler)`
    `ConsulClient` | ConsulClient.`getPreparedQuery(String id, Handler<AsyncResult<PreparedQueryDefinition>> resultHandler)` Returns an existing prepared query
    `ConsulService` | ConsulService.`getPreparedQuery(String id, Handler<AsyncResult<PreparedQueryDefinition>> resultHandler)`
    `ConsulClient` | ConsulClient.`getValue(String key, Handler<AsyncResult<KeyValue>> resultHandler)` Returns key/value pair that corresponding to the specified key.
    `ConsulService` | ConsulService.`getValue(String key, Handler<AsyncResult<KeyValue>> resultHandler)`
    `ConsulClient` | ConsulClient.`getValues(String keyPrefix, Handler<AsyncResult<KeyValueList>> resultHandler)` Returns the list of key/value pairs that corresponding to the specified key prefix.
    `ConsulService` | ConsulService.`getValues(String keyPrefix, Handler<AsyncResult<KeyValueList>> resultHandler)`
    `ConsulClient` | ConsulClient.`getValuesWithOptions(String keyPrefix, BlockingQueryOptions options, Handler<AsyncResult<KeyValueList>> resultHandler)` Returns the list of key/value pairs that corresponding to the specified key prefix.
    `ConsulService` | ConsulService.`getValuesWithOptions(String keyPrefix, BlockingQueryOptions options, Handler<AsyncResult<KeyValueList>> resultHandler)`
    `ConsulClient` | ConsulClient.`getValueWithOptions(String key, BlockingQueryOptions options, Handler<AsyncResult<KeyValue>> resultHandler)` Returns key/value pair that corresponding to the specified key.
    `ConsulService` | ConsulService.`getValueWithOptions(String key, BlockingQueryOptions options, Handler<AsyncResult<KeyValue>> resultHandler)`
    `ConsulClient` | ConsulClient.`healthChecks(String service, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks associated with the service
    `ConsulService` | ConsulService.`healthChecks(String service, Handler<AsyncResult<CheckList>> resultHandler)`
    `ConsulClient` | ConsulClient.`healthChecksWithOptions(String service, CheckQueryOptions options, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks associated with the service
    `ConsulService` | ConsulService.`healthChecksWithOptions(String service, CheckQueryOptions options, Handler<AsyncResult<CheckList>> resultHandler)`
    `ConsulClient` | ConsulClient.`healthServiceNodes(String service, boolean passing, Handler<AsyncResult<ServiceEntryList>> resultHandler)` Returns the nodes providing the service.
    `ConsulService` | ConsulService.`healthServiceNodes(String service, boolean passing, Handler<AsyncResult<ServiceEntryList>> resultHandler)`
    `ConsulClient` | ConsulClient.`healthServiceNodesWithOptions(String service, boolean passing, ServiceQueryOptions options, Handler<AsyncResult<ServiceEntryList>> resultHandler)` Returns the nodes providing the service.
    `ConsulService` | ConsulService.`healthServiceNodesWithOptions(String service, boolean passing, ServiceQueryOptions options, Handler<AsyncResult<ServiceEntryList>> resultHandler)`
    `ConsulClient` | ConsulClient.`healthState(HealthState healthState, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks in the specified status
    `ConsulService` | ConsulService.`healthState(HealthState healthState, Handler<AsyncResult<CheckList>> handler)`
    `ConsulClient` | ConsulClient.`healthStateWithOptions(HealthState healthState, CheckQueryOptions options, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks in the specified status
    `ConsulService` | ConsulService.`healthStateWithOptions(HealthState healthState, CheckQueryOptions checkQueryOptions, Handler<AsyncResult<CheckList>> handler)`
    `ConsulClient` | ConsulClient.`infoAclToken(String id, Handler<AsyncResult<AclToken>> tokenHandler)` Get info of Acl token
    `ConsulService` | ConsulService.`infoAclToken(String id, Handler<AsyncResult<AclToken>> tokenHandler)`
    `ConsulClient` | ConsulClient.`infoSession(String id, Handler<AsyncResult<Session>> resultHandler)` Returns the requested session information
    `ConsulService` | ConsulService.`infoSession(String id, Handler<AsyncResult<Session>> resultHandler)`
    `ConsulClient` | ConsulClient.`infoSessionWithOptions(String id, BlockingQueryOptions options, Handler<AsyncResult<Session>> resultHandler)` Returns the requested session information This is blocking query unlike `ConsulClient.infoSession(String, Handler)`
    `ConsulService` | ConsulService.`infoSessionWithOptions(String id, BlockingQueryOptions options, Handler<AsyncResult<Session>> resultHandler)`
    `ConsulClient` | ConsulClient.`leaderStatus(Handler<AsyncResult<String>> resultHandler)` Get the Raft leader for the datacenter in which the agent is running.
    `ConsulService` | ConsulService.`leaderStatus(Handler<AsyncResult<String>> resultHandler)`
    `ConsulClient` | ConsulClient.`listAclTokens(Handler<AsyncResult<List<AclToken>>> resultHandler)` Get list of Acl token
    `ConsulService` | ConsulService.`listAclTokens(Handler<AsyncResult<List<AclToken>>> resultHandler)`
    `ConsulClient` | ConsulClient.`listEvents(Handler<AsyncResult<EventList>> resultHandler)` Returns the most recent events known by the agent
    `ConsulService` | ConsulService.`listEvents(Handler<AsyncResult<EventList>> resultHandler)`
    `ConsulClient` | ConsulClient.`listEventsWithOptions(EventListOptions options, Handler<AsyncResult<EventList>> resultHandler)` Returns the most recent events known by the agent.
    `ConsulService` | ConsulService.`listEventsWithOptions(EventListOptions options, Handler<AsyncResult<EventList>> resultHandler)`
    `ConsulClient` | ConsulClient.`listNodeSessions(String nodeId, Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions for a given node
    `ConsulService` | ConsulService.`listNodeSessions(String nodeId, Handler<AsyncResult<SessionList>> resultHandler)`
    `ConsulClient` | ConsulClient.`listNodeSessionsWithOptions(String nodeId, BlockingQueryOptions options, Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions for a given node This is blocking query unlike `ConsulClient.listNodeSessions(String, Handler)`
    `ConsulService` | ConsulService.`listNodeSessionsWithOptions(String nodeId, BlockingQueryOptions options, Handler<AsyncResult<SessionList>> resultHandler)`
    `ConsulClient` | ConsulClient.`listSessions(Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions
    `ConsulService` | ConsulService.`listSessions(Handler<AsyncResult<SessionList>> resultHandler)`
    `ConsulClient` | ConsulClient.`listSessionsWithOptions(BlockingQueryOptions options, Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions This is blocking query unlike `ConsulClient.listSessions(Handler)`
    `ConsulService` | ConsulService.`listSessionsWithOptions(BlockingQueryOptions options, Handler<AsyncResult<SessionList>> resultHandler)`
    `ConsulClient` | ConsulClient.`localChecks(Handler<AsyncResult<List<Check>>> resultHandler)` Return all the checks that are registered with the local agent.
    `ConsulService` | ConsulService.`localChecks(Handler<AsyncResult<List<Check>>> resultHandler)`
    `ConsulClient` | ConsulClient.`localServices(Handler<AsyncResult<List<Service>>> resultHandler)` Returns list of services registered with the local agent.
    `ConsulService` | ConsulService.`localServices(Handler<AsyncResult<List<Service>>> resultHandler)`
    `ConsulClient` | ConsulClient.`maintenanceService(MaintenanceOptions maintenanceOptions, Handler<AsyncResult<Void>> resultHandler)` Places a given service into "maintenance mode"
    `ConsulService` | ConsulService.`maintenanceService(MaintenanceOptions maintenanceOptions, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`passCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "passing".
    `ConsulService` | ConsulService.`passCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`passCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "passing".
    `ConsulService` | ConsulService.`passCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`peersStatus(Handler<AsyncResult<List<String>>> resultHandler)` Retrieves the Raft peers for the datacenter in which the the agent is running.
    `ConsulService` | ConsulService.`peersStatus(Handler<AsyncResult<List<String>>> resultHandler)`
    `ConsulClient` | ConsulClient.`putValue(String key, String value, Handler<AsyncResult<Boolean>> resultHandler)` Adds specified key/value pair
    `ConsulService` | ConsulService.`putValue(String key, String value, Handler<AsyncResult<Boolean>> resultHandler)`
    `ConsulClient` | ConsulClient.`putValueWithOptions(String key, String value, KeyValueOptions options, Handler<AsyncResult<Boolean>> resultHandler)`
    `ConsulService` | ConsulService.`putValueWithOptions(String key, String value, KeyValueOptions options, Handler<AsyncResult<Boolean>> resultHandler)`
    `ConsulClient` | ConsulClient.`registerCheck(CheckOptions checkOptions, Handler<AsyncResult<Void>> resultHandler)` Add a new check to the local agent.
    `ConsulService` | ConsulService.`registerCheck(CheckOptions checkOptions, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`registerService(ServiceOptions serviceOptions, Handler<AsyncResult<Void>> resultHandler)` Adds a new service, with an optional health check, to the local agent.
    `ConsulService` | ConsulService.`registerService(ServiceOptions serviceOptions, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`renewSession(String id, Handler<AsyncResult<Session>> resultHandler)` Renews the given session.
    `ConsulService` | ConsulService.`renewSession(String id, Handler<AsyncResult<Session>> resultHandler)`
    `Watch<T>` | Watch.`setHandler(Handler<WatchResult<T>> handler)` Set the result handler.
    `ConsulClient` | ConsulClient.`transaction(TxnRequest request, Handler<AsyncResult<TxnResponse>> resultHandler)` Manages multiple operations inside a single, atomic transaction.
    `ConsulService` | ConsulService.`transaction(TxnRequest request, Handler<AsyncResult<TxnResponse>> resultHandler)`
    `ConsulClient` | ConsulClient.`updateAclToken(AclToken token, Handler<AsyncResult<String>> idHandler)` Update Acl token
    `ConsulService` | ConsulService.`updateAclToken(AclToken token, Handler<AsyncResult<String>> idHandler)`
    `ConsulClient` | ConsulClient.`updateCheck(String checkId, CheckStatus status, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to given status.
    `ConsulService` | ConsulService.`updateCheck(String checkId, CheckStatus status, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`updateCheckWithNote(String checkId, CheckStatus status, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to given status.
    `ConsulService` | ConsulService.`updateCheckWithNote(String checkId, CheckStatus status, String note, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`updatePreparedQuery(PreparedQueryDefinition definition, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulService` | ConsulService.`updatePreparedQuery(PreparedQueryDefinition definition, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`warnCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "warning".
    `ConsulService` | ConsulService.`warnCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`warnCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "warning".
    `ConsulService` | ConsulService.`warnCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)`

  - ### Uses of Handler in io.vertx.ext.eventbus.bridge.tcp

    Subinterfaces of Handler in io.vertx.ext.eventbus.bridge.tcp
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `BridgeEvent` Represents an event that occurs on the event bus bridge.

    Methods in io.vertx.ext.eventbus.bridge.tcp with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | TcpEventBusBridge.`close(Handler<AsyncResult<Void>> handler)` Close the current socket.
    `static TcpEventBusBridge` | TcpEventBusBridge.`create(Vertx vertx, BridgeOptions options, NetServerOptions netServerOptions, Handler<BridgeEvent> eventHandler)`
    `TcpEventBusBridge` | TcpEventBusBridge.`listen(Handler<AsyncResult<TcpEventBusBridge>> handler)` Listen on default port 7000 with a handler to report the state of the socket listen operation.
    `TcpEventBusBridge` | TcpEventBusBridge.`listen(int port, Handler<AsyncResult<TcpEventBusBridge>> handler)` Listen on specific port
    `TcpEventBusBridge` | TcpEventBusBridge.`listen(int port, String address, Handler<AsyncResult<TcpEventBusBridge>> handler)` Listen on specific port and bind to specific address

  - ### Uses of Handler in io.vertx.ext.healthchecks

    Subinterfaces of Handler in io.vertx.ext.healthchecks
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `HealthCheckHandler` A Vert.x Web handler on which you register health check procedure.

    Methods in io.vertx.ext.healthchecks with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `HealthChecks` | HealthChecks.`invoke(Handler<JsonObject> resultHandler)` Invokes the registered procedures and computes the outcome.
    `HealthChecks` | HealthChecks.`invoke(String name, Handler<AsyncResult<JsonObject>> resultHandler)` Invokes the registered procedure with the given name and sub-procedures.
    `HealthChecks` | HealthChecks.`register(String name, Handler<Promise<Status>> procedure)` Registers a health check procedure.
    `HealthCheckHandler` | HealthCheckHandler.`register(String name, Handler<Promise<Status>> procedure)` Registers a health check procedure.
    `HealthChecks` | HealthChecks.`register(String name, long timeout, Handler<Promise<Status>> procedure)` Registers a health check procedure.
    `HealthCheckHandler` | HealthCheckHandler.`register(String name, long timeout, Handler<Promise<Status>> procedure)` Registers a health check procedure.

  - ### Uses of Handler in io.vertx.ext.httpservicefactory

    Methods in io.vertx.ext.httpservicefactory with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | HttpServiceFactory.`doRequest(HttpClient client, File file, URI url, File signatureFile, URI signatureURL, Handler<AsyncResult<io.vertx.ext.httpservicefactory.HttpServiceFactory.Result>> handler)`

  - ### Uses of Handler in io.vertx.ext.mail

    Methods in io.vertx.ext.mail with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MailService` | MailService.`sendMail(MailMessage email, Handler<AsyncResult<MailResult>> resultHandler)`
    `MailClient` | MailClient.`sendMail(MailMessage email, Handler<AsyncResult<MailResult>> resultHandler)` send a single mail via MailClient

  - ### Uses of Handler in io.vertx.ext.mongo

    Methods in io.vertx.ext.mongo with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MongoClient` | MongoClient.`bulkWrite(String collection, List<BulkOperation> operations, Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)` Execute a bulk operation.
    `MongoService` | MongoService.`bulkWrite(String collection, List<BulkOperation> operations, Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)`
    `MongoClient` | MongoClient.`bulkWriteWithOptions(String collection, List<BulkOperation> operations, BulkWriteOptions bulkWriteOptions, Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)` Execute a bulk operation with the specified write options.
    `MongoService` | MongoService.`bulkWriteWithOptions(String collection, List<BulkOperation> operations, BulkWriteOptions bulkWriteOptions, Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)`
    `MongoClient` | MongoClient.`count(String collection, JsonObject query, Handler<AsyncResult<Long>> resultHandler)` Count matching documents in a collection.
    `MongoService` | MongoService.`count(String collection, JsonObject query, Handler<AsyncResult<Long>> resultHandler)`
    `MongoClient` | MongoClient.`createCollection(String collectionName, Handler<AsyncResult<Void>> resultHandler)` Create a new collection
    `MongoService` | MongoService.`createCollection(String collectionName, Handler<AsyncResult<Void>> resultHandler)`
    `MongoClient` | MongoClient.`createIndex(String collection, JsonObject key, Handler<AsyncResult<Void>> resultHandler)` Creates an index.
    `MongoService` | MongoService.`createIndex(String collection, JsonObject key, Handler<AsyncResult<Void>> resultHandler)`
    `MongoClient` | MongoClient.`createIndexWithOptions(String collection, JsonObject key, IndexOptions options, Handler<AsyncResult<Void>> resultHandler)` Creates an index.
    `MongoService` | MongoService.`createIndexWithOptions(String collection, JsonObject key, IndexOptions options, Handler<AsyncResult<Void>> resultHandler)`
    `MongoClient` | MongoClient.`distinct(String collection, String fieldName, String resultClassname, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name.
    `MongoService` | MongoService.`distinct(String collection, String fieldName, String resultClassname, Handler<AsyncResult<JsonArray>> resultHandler)`
    `MongoClient` | MongoClient.`distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name filtered by specified query.
    `MongoService` | MongoService.`distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, Handler<AsyncResult<JsonArray>> resultHandler)`
    `MongoClient` | MongoClient.`dropCollection(String collection, Handler<AsyncResult<Void>> resultHandler)` Drop a collection
    `MongoService` | MongoService.`dropCollection(String collection, Handler<AsyncResult<Void>> resultHandler)`
    `MongoClient` | MongoClient.`dropIndex(String collection, String indexName, Handler<AsyncResult<Void>> resultHandler)` Drops the index given its name.
    `MongoService` | MongoService.`dropIndex(String collection, String indexName, Handler<AsyncResult<Void>> resultHandler)`
    `MongoClient` | MongoClient.`find(String collection, JsonObject query, Handler<AsyncResult<List<JsonObject>>> resultHandler)` Find matching documents in the specified collection
    `MongoService` | MongoService.`find(String collection, JsonObject query, Handler<AsyncResult<List<JsonObject>>> resultHandler)`
    `MongoClient` | MongoClient.`findOne(String collection, JsonObject query, JsonObject fields, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection
    `MongoService` | MongoService.`findOne(String collection, JsonObject query, JsonObject fields, Handler<AsyncResult<JsonObject>> resultHandler)`
    `MongoClient` | MongoClient.`findOneAndDelete(String collection, JsonObject query, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and delete it.
    `MongoService` | MongoService.`findOneAndDelete(String collection, JsonObject query, Handler<AsyncResult<JsonObject>> resultHandler)`
    `MongoClient` | MongoClient.`findOneAndDeleteWithOptions(String collection, JsonObject query, FindOptions findOptions, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and delete it.
    `MongoService` | MongoService.`findOneAndDeleteWithOptions(String collection, JsonObject query, FindOptions findOptions, Handler<AsyncResult<JsonObject>> resultHandler)`
    `MongoClient` | MongoClient.`findOneAndReplace(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and replace it.
    `MongoService` | MongoService.`findOneAndReplace(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<JsonObject>> resultHandler)`
    `MongoClient` | MongoClient.`findOneAndReplaceWithOptions(String collection, JsonObject query, JsonObject replace, FindOptions findOptions, UpdateOptions updateOptions, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and replace it.
    `MongoService` | MongoService.`findOneAndReplaceWithOptions(String collection, JsonObject query, JsonObject update, FindOptions findOptions, UpdateOptions updateOptions, Handler<AsyncResult<JsonObject>> resultHandler)`
    `MongoClient` | MongoClient.`findOneAndUpdate(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and update it.
    `MongoService` | MongoService.`findOneAndUpdate(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<JsonObject>> resultHandler)`
    `MongoClient` | MongoClient.`findOneAndUpdateWithOptions(String collection, JsonObject query, JsonObject update, FindOptions findOptions, UpdateOptions updateOptions, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and update it.
    `MongoService` | MongoService.`findOneAndUpdateWithOptions(String collection, JsonObject query, JsonObject update, FindOptions findOptions, UpdateOptions updateOptions, Handler<AsyncResult<JsonObject>> resultHandler)`
    `MongoClient` | MongoClient.`findWithOptions(String collection, JsonObject query, FindOptions options, Handler<AsyncResult<List<JsonObject>>> resultHandler)` Find matching documents in the specified collection, specifying options
    `MongoService` | MongoService.`findWithOptions(String collection, JsonObject query, FindOptions options, Handler<AsyncResult<List<JsonObject>>> resultHandler)`
    `MongoClient` | MongoClient.`getCollections(Handler<AsyncResult<List<String>>> resultHandler)` Get a list of all collections in the database.
    `MongoService` | MongoService.`getCollections(Handler<AsyncResult<List<String>>> resultHandler)`
    `MongoClient` | MongoClient.`insert(String collection, JsonObject document, Handler<AsyncResult<String>> resultHandler)` Insert a document in the specified collection
    `MongoService` | MongoService.`insert(String collection, JsonObject document, Handler<AsyncResult<String>> resultHandler)`
    `MongoClient` | MongoClient.`insertWithOptions(String collection, JsonObject document, WriteOption writeOption, Handler<AsyncResult<String>> resultHandler)` Insert a document in the specified collection with the specified write option
    `MongoService` | MongoService.`insertWithOptions(String collection, JsonObject document, WriteOption writeOption, Handler<AsyncResult<String>> resultHandler)`
    `MongoClient` | MongoClient.`listIndexes(String collection, Handler<AsyncResult<JsonArray>> resultHandler)` Get all the indexes in this collection.
    `MongoService` | MongoService.`listIndexes(String collection, Handler<AsyncResult<JsonArray>> resultHandler)`
    `MongoClient` | MongoClient.`remove(String collection, JsonObject query, Handler<AsyncResult<Void>> resultHandler)` Deprecated. use instead `MongoClient.removeDocuments(String, JsonObject, Handler)`
    `MongoService` | MongoService.`remove(String collection, JsonObject query, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoClient` | MongoClient.`removeDocument(String collection, JsonObject query, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove a single matching document from a collection and return the handler with MongoClientDeleteResult result
    `MongoService` | MongoService.`removeDocument(String collection, JsonObject query, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)`
    `MongoClient` | MongoClient.`removeDocuments(String collection, JsonObject query, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove matching documents from a collection and return the handler with MongoClientDeleteResult result
    `MongoService` | MongoService.`removeDocuments(String collection, JsonObject query, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)`
    `MongoClient` | MongoClient.`removeDocumentsWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove matching documents from a collection with the specified write option and return the handler with MongoClientDeleteResult result
    `MongoService` | MongoService.`removeDocumentsWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)`
    `MongoClient` | MongoClient.`removeDocumentWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove a single matching document from a collection with the specified write option and return the handler with MongoClientDeleteResult result
    `MongoService` | MongoService.`removeDocumentWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)`
    `MongoClient` | MongoClient.`removeOne(String collection, JsonObject query, Handler<AsyncResult<Void>> resultHandler)` Deprecated. instead use `MongoClient.removeDocument(String, JsonObject, Handler)`
    `MongoService` | MongoService.`removeOne(String collection, JsonObject query, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoClient` | MongoClient.`removeOneWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<Void>> resultHandler)` Deprecated. instead use `MongoClient.removeDocumentsWithOptions(String, JsonObject, WriteOption, Handler)`
    `MongoService` | MongoService.`removeOneWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoClient` | MongoClient.`removeWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<Void>> resultHandler)` Deprecated. instead use `MongoClient.removeDocumentsWithOptions(String, JsonObject, WriteOption, Handler)`
    `MongoService` | MongoService.`removeWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoClient` | MongoClient.`replace(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<Void>> resultHandler)` Deprecated. instead use `MongoClient.replaceDocuments(String, JsonObject, JsonObject, Handler)`
    `MongoService` | MongoService.`replace(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoClient` | MongoClient.`replaceDocuments(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Replace matching documents in the specified collection and return the handler with MongoClientUpdateResult result
    `MongoService` | MongoService.`replaceDocuments(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)`
    `MongoClient` | MongoClient.`replaceDocumentsWithOptions(String collection, JsonObject query, JsonObject replace, UpdateOptions options, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Replace matching documents in the specified collection, specifying options and return the handler with MongoClientUpdateResult result
    `MongoService` | MongoService.`replaceDocumentsWithOptions(String collection, JsonObject query, JsonObject replace, UpdateOptions options, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)`
    `MongoClient` | MongoClient.`replaceWithOptions(String collection, JsonObject query, JsonObject replace, UpdateOptions options, Handler<AsyncResult<Void>> resultHandler)` Deprecated. instead use `MongoClient.replaceDocumentsWithOptions(String, JsonObject, JsonObject, UpdateOptions, Handler)`
    `MongoService` | MongoService.`replaceWithOptions(String collection, JsonObject query, JsonObject replace, UpdateOptions options, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoClient` | MongoClient.`runCommand(String commandName, JsonObject command, Handler<AsyncResult<JsonObject>> resultHandler)` Run an arbitrary MongoDB command.
    `MongoService` | MongoService.`runCommand(String commandName, JsonObject command, Handler<AsyncResult<JsonObject>> resultHandler)`
    `MongoClient` | MongoClient.`save(String collection, JsonObject document, Handler<AsyncResult<String>> resultHandler)` Save a document in the specified collection
    `MongoService` | MongoService.`save(String collection, JsonObject document, Handler<AsyncResult<String>> resultHandler)`
    `MongoClient` | MongoClient.`saveWithOptions(String collection, JsonObject document, WriteOption writeOption, Handler<AsyncResult<String>> resultHandler)` Save a document in the specified collection with the specified write option
    `MongoService` | MongoService.`saveWithOptions(String collection, JsonObject document, WriteOption writeOption, Handler<AsyncResult<String>> resultHandler)`
    `MongoClient` | MongoClient.`update(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<Void>> resultHandler)` Deprecated. instead use `MongoClient.updateCollection(String, JsonObject, JsonObject, Handler)`
    `MongoService` | MongoService.`update(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoClient` | MongoClient.`updateCollection(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Update matching documents in the specified collection and return the handler with MongoClientUpdateResult result
    `MongoService` | MongoService.`updateCollection(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)`
    `MongoClient` | MongoClient.`updateCollectionWithOptions(String collection, JsonObject query, JsonObject update, UpdateOptions options, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Update matching documents in the specified collection, specifying options and return the handler with MongoClientUpdateResult result
    `MongoService` | MongoService.`updateCollectionWithOptions(String collection, JsonObject query, JsonObject update, UpdateOptions options, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)`
    `MongoClient` | MongoClient.`updateWithOptions(String collection, JsonObject query, JsonObject update, UpdateOptions options, Handler<AsyncResult<Void>> resultHandler)` Deprecated. use instead `MongoClient.updateCollectionWithOptions(String, JsonObject, JsonObject, UpdateOptions, Handler)`
    `MongoService` | MongoService.`updateWithOptions(String collection, JsonObject query, JsonObject update, UpdateOptions options, Handler<AsyncResult<Void>> resultHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.ext.reactivestreams

    Methods in io.vertx.ext.reactivestreams with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `ReactiveWriteStream<T>` | ReactiveWriteStream.`drainHandler(Handler<Void> handler)`
    `ReactiveReadStream<T>` | ReactiveReadStream.`endHandler(Handler<Void> endHandler)`
    `ReactiveReadStream<T>` | ReactiveReadStream.`exceptionHandler(Handler<Throwable> handler)`
    `ReactiveWriteStream<T>` | ReactiveWriteStream.`exceptionHandler(Handler<Throwable> handler)`
    `ReactiveReadStream<T>` | ReactiveReadStream.`handler(Handler<T> handler)`
    `ReactiveWriteStream<T>` | ReactiveWriteStream.`write(T data, Handler<AsyncResult<Void>> handler)`

  - ### Uses of Handler in io.vertx.ext.shell

    Methods in io.vertx.ext.shell with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ShellServer.`close(Handler<AsyncResult<Void>> completionHandler)` Close the shell server, this is an asynchronous close.
    `ShellServer` | ShellServer.`listen(Handler<AsyncResult<Void>> listenHandler)` Start the shell service, this is an asynchronous start.
    `void` | ShellServer.`shellHandler(Handler<Shell> shellHandler)` Called when a new shell is created.
    `void` | ShellService.`start(Handler<AsyncResult<Void>> startHandler)` Start the shell service, this is an asynchronous start.
    `void` | ShellService.`stop(Handler<AsyncResult<Void>> stopHandler)` Stop the shell service, this is an asynchronous start.

  - ### Uses of Handler in io.vertx.ext.shell.command

    Methods in io.vertx.ext.shell.command with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `CommandProcess` | CommandProcess.`backgroundHandler(Handler<Void> handler)` Set a background handler, this handler is called when the command is running and put to background.
    `CommandBuilder` | CommandBuilder.`completionHandler(Handler<Completion> handler)` Set the command completion handler, the completion handler when the user asks for contextual command line completion, usually hitting the tab key.
    `CommandProcess` | CommandProcess.`endHandler(Handler<Void> handler)` Set an end handler, this handler is called when the command is ended, for instance the command is running and the shell closes.
    `CommandProcess` | CommandProcess.`foregroundHandler(Handler<Void> handler)` Set a foreground handler, this handler is called when the command is running and put to foreground.
    `CommandProcess` | CommandProcess.`interruptHandler(Handler<Void> handler)` Set an interrupt handler, this handler is called when the command is interrupted, for instance user press `Ctrl-C`.
    `CommandBuilder` | CommandBuilder.`processHandler(Handler<CommandProcess> handler)` Set the command process handler, the process handler is called when the command is executed.
    `CommandRegistry` | CommandRegistry.`registerCommand(Class<? extends AnnotatedCommand> command, Handler<AsyncResult<Command>> completionHandler)` Register a single command.
    `CommandRegistry` | CommandRegistry.`registerCommand(Command command, Handler<AsyncResult<Command>> completionHandler)` Register a command
    `CommandRegistry` | CommandRegistry.`registerCommands(List<Command> commands, Handler<AsyncResult<List<Command>>> completionHandler)` Register a list of commands.
    `CommandProcess` | CommandProcess.`resizehandler(Handler<Void> handler)`
    `CommandProcess` | CommandProcess.`resumeHandler(Handler<Void> handler)` Set a resume handler, this handler is called when the command is resumed, for instance user types `bg` or `fg` to resume the command.
    `CommandProcess` | CommandProcess.`stdinHandler(Handler<String> handler)`
    `CommandProcess` | CommandProcess.`suspendHandler(Handler<Void> handler)` Set a suspend handler, this handler is called when the command is suspended, for instance user press `Ctrl-Z`.
    `CommandRegistry` | CommandRegistry.`unregisterCommand(String commandName, Handler<AsyncResult<Void>> completionHandler)` Unregister a command.

  - ### Uses of Handler in io.vertx.ext.shell.spi

    Methods in io.vertx.ext.shell.spi with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | CommandResolverFactory.`resolver(Vertx vertx, Handler<AsyncResult<CommandResolver>> resolveHandler)` Obtain a command resolver for a Vert.x instance.

  - ### Uses of Handler in io.vertx.ext.shell.system

    Methods in io.vertx.ext.shell.system with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | JobController.`close(Handler<Void> completionHandler)` Close the controller and terminate all the underlying jobs, a closed controller does not accept anymore jobs.
    `boolean` | Process.`interrupt(Handler<Void> completionHandler)` Attempt to interrupt the process.
    `void` | Process.`resume(boolean foreground, Handler<Void> completionHandler)` Suspend the process.
    `default void` | Process.`resume(Handler<Void> completionHandler)` Suspend the process.
    `Job` | Job.`statusUpdateHandler(Handler<ExecStatus> handler)` Set an handler called when the job terminates.
    `void` | Process.`suspend(Handler<Void> completionHandler)` Resume the process.
    `void` | Process.`terminate(Handler<Void> completionHandler)` Terminate the process.
    `Process` | Process.`terminatedHandler(Handler<Integer> handler)` Set an handler for being notified when the process terminates.
    `void` | Process.`toBackground(Handler<Void> completionHandler)` Set the process in background.
    `void` | Process.`toForeground(Handler<Void> completionHandler)` Set the process in foreground.

  - ### Uses of Handler in io.vertx.ext.shell.term

    Subinterfaces of Handler in io.vertx.ext.shell.term
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `SockJSTermHandler`

    Methods in io.vertx.ext.shell.term with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | TermServer.`close(Handler<AsyncResult<Void>> completionHandler)` Like `TermServer.close()` but supplying a handler that will be notified when close is complete.
    `Term` | Term.`closeHandler(Handler<Void> handler)` Set a handler that will be called when the terminal is closed.
    `TermServer` | TermServer.`listen(Handler<AsyncResult<TermServer>> listenHandler)` Bind the term server, the `TermServer.termHandler(Handler)` must be set before.
    `void` | Term.`readline(String prompt, Handler<String> lineHandler)` Prompt the user a line of text.
    `void` | Term.`readline(String prompt, Handler<String> lineHandler, Handler<Completion> completionHandler)` Prompt the user a line of text, providing a completion handler to handle user's completion.
    `void` | Term.`readline(String prompt, Handler<String> lineHandler, Handler<Completion> completionHandler)` Prompt the user a line of text, providing a completion handler to handle user's completion.
    `Tty` | Tty.`resizehandler(Handler<Void> handler)` Set a resize handler, the handler is called when the tty size changes.
    `Term` | Term.`resizehandler(Handler<Void> handler)`
    `Tty` | Tty.`stdinHandler(Handler<String> handler)` Set a stream handler on the standard input to read the data.
    `Term` | Term.`stdinHandler(Handler<String> handler)`
    `Pty` | Pty.`stdoutHandler(Handler<String> handler)` Set the standard out handler of the pseudo terminal.
    `SockJSTermHandler` | SockJSTermHandler.`termHandler(Handler<Term> handler)`
    `TermServer` | TermServer.`termHandler(Handler<Term> handler)` Set the term handler that will receive incoming client connections.

  - ### Uses of Handler in io.vertx.ext.sql

    Methods in io.vertx.ext.sql with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `SQLConnection` | SQLConnection.`batch(List<String> sqlStatements, Handler<AsyncResult<List<Integer>>> handler)` Batch simple SQL strings and execute the batch where the async result contains a array of Integers.
    `SQLConnection` | SQLConnection.`batchCallableWithParams(String sqlStatement, List<JsonArray> inArgs, List<JsonArray> outArgs, Handler<AsyncResult<List<Integer>>> handler)` Batch a callable statement with all entries from the args list.
    `SQLConnection` | SQLConnection.`batchWithParams(String sqlStatement, List<JsonArray> args, Handler<AsyncResult<List<Integer>>> handler)` Batch a prepared statement with all entries from the args list.
    `SQLConnection` | SQLConnection.`call(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `default SQLClient` | SQLClient.`call(String sql, Handler<AsyncResult<ResultSet>> handler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLOperations` | SQLOperations.`call(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLConnection` | SQLConnection.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `default SQLClient` | SQLClient.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> handler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLOperations` | SQLOperations.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `void` | SQLRowStream.`close(Handler<AsyncResult<Void>> handler)` Closes the stream/underlying cursor(s).
    `void` | SQLConnection.`close(Handler<AsyncResult<Void>> handler)` Closes the connection.
    `void` | SQLClient.`close(Handler<AsyncResult<Void>> handler)` Close the client and release all resources.
    `SQLConnection` | SQLConnection.`commit(Handler<AsyncResult<Void>> handler)` Commits all changes made since the previous commit/rollback.
    `SQLRowStream` | SQLRowStream.`endHandler(Handler<Void> endHandler)`
    `SQLRowStream` | SQLRowStream.`exceptionHandler(Handler<Throwable> handler)`
    `SQLConnection` | SQLConnection.`execute(String sql, Handler<AsyncResult<Void>> resultHandler)` Executes the given SQL statement
    `SQLClient` | SQLClient.`getConnection(Handler<AsyncResult<SQLConnection>> handler)` Returns a connection that can be used to perform SQL operations on.
    `SQLConnection` | SQLConnection.`getTransactionIsolation(Handler<AsyncResult<TransactionIsolation>> handler)` Attempts to return the transaction isolation level for this Connection object to the one given.
    `SQLRowStream` | SQLRowStream.`handler(Handler<JsonArray> handler)`
    `SQLConnection` | SQLConnection.`query(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` statement which returns the results of the query.
    `default SQLClient` | SQLClient.`query(String sql, Handler<AsyncResult<ResultSet>> handler)` Execute a single SQL statement, this method acquires a connection from the the pool and executes the SQL statement and returns it back after the execution.
    `SQLOperations` | SQLOperations.`query(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` statement which returns the results of the query.
    `default SQLOperations` | SQLOperations.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `default SQLOperations` | SQLOperations.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLConnection` | SQLConnection.`queryStream(String sql, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `default SQLClient` | SQLClient.`queryStream(String sql, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLOperations` | SQLOperations.`queryStream(String sql, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLConnection` | SQLConnection.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `default SQLClient` | SQLClient.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLOperations` | SQLOperations.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLConnection` | SQLConnection.`queryWithParams(String sql, JsonArray params, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` prepared statement which returns the results of the query.
    `default SQLClient` | SQLClient.`queryWithParams(String sql, JsonArray arguments, Handler<AsyncResult<ResultSet>> handler)` Execute a single SQL prepared statement, this method acquires a connection from the the pool and executes the SQL prepared statement and returns it back after the execution.
    `SQLOperations` | SQLOperations.`queryWithParams(String sql, JsonArray params, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` prepared statement which returns the results of the query.
    `SQLRowStream` | SQLRowStream.`resultSetClosedHandler(Handler<Void> handler)` Event handler when a resultset is closed.
    `SQLConnection` | SQLConnection.`rollback(Handler<AsyncResult<Void>> handler)` Rolls back all changes made since the previous commit/rollback.
    `SQLConnection` | SQLConnection.`setAutoCommit(boolean autoCommit, Handler<AsyncResult<Void>> resultHandler)` Sets the auto commit flag for this connection.
    `SQLConnection` | SQLConnection.`setTransactionIsolation(TransactionIsolation isolation, Handler<AsyncResult<Void>> handler)` Attempts to change the transaction isolation level for this Connection object to the one given.
    `SQLConnection` | SQLConnection.`update(String sql, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
    `default SQLClient` | SQLClient.`update(String sql, Handler<AsyncResult<UpdateResult>> handler)` Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
    `SQLOperations` | SQLOperations.`update(String sql, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
    `SQLConnection` | SQLConnection.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
    `default SQLClient` | SQLClient.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> handler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
    `SQLOperations` | SQLOperations.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters

  - ### Uses of Handler in io.vertx.ext.stomp

    Subinterfaces of Handler in io.vertx.ext.stomp
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `StompServerHandler` STOMP server handler implements the behavior of the STOMP server when a specific event occurs.

    Classes in io.vertx.ext.stomp that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `DefaultAbortHandler` STOMP compliant actions executed when receiving a `ABORT` frame.
    `class` | `DefaultAckHandler` STOMP compliant actions executed when receiving a `ACK` frame.
    `class` | `DefaultBeginHandler` STOMP compliant actions executed when receiving a `BEGIN` frame.
    `class` | `DefaultCommitHandler` STOMP compliant actions executed when receiving a `COMMIT` frame.
    `class` | `DefaultConnectHandler` STOMP compliant actions executed when receiving a `CONNECT` frame.
    `class` | `DefaultNackHandler` STOMP compliant actions executed when receiving a `NACK` sf.frame().
    `class` | `DefaultSendHandler` STOMP compliant actions executed when receiving a `SEND` sf.frame().
    `class` | `DefaultSubscribeHandler` STOMP compliant actions executed when receiving a `SUBSCRIBE` frame.
    `class` | `DefaultUnsubscribeHandler` STOMP compliant actions executed when receiving a `UNSUBSCRIBE` frame.

    Methods in io.vertx.ext.stomp that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<ServerWebSocket>` | StompServer.`webSocketHandler()` Gets the `Handler` able to manage web socket connections.

    Methods in io.vertx.ext.stomp with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `StompClientConnection` | StompClientConnection.`abort(String id, Handler<Frame> receiptHandler)` Aborts a transaction.
    `StompClientConnection` | StompClientConnection.`abort(String id, Map<String,String> headers, Handler<Frame> receiptHandler)` Aborts a transaction.
    `StompServerHandler` | StompServerHandler.`abortHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `ABORT` frame is received.
    `StompClientConnection` | StompClientConnection.`ack(String id, Handler<Frame> receiptHandler)` Sends an acknowledgement for a specific message.
    `StompClientConnection` | StompClientConnection.`ack(String id, String txId, Handler<Frame> receiptHandler)` Sends an acknowledgement for the given frame.
    `StompServerHandler` | StompServerHandler.`ackHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `ACK` frame is received.
    `StompServerHandler` | StompServerHandler.`beginHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `BEGIN` frame is received.
    `StompClientConnection` | StompClientConnection.`beginTX(String id, Handler<Frame> receiptHandler)` Begins a transaction.
    `StompClientConnection` | StompClientConnection.`beginTX(String id, Map<String,String> headers, Handler<Frame> receiptHandler)` Begins a transaction.
    `void` | StompServer.`close(Handler<AsyncResult<Void>> completionHandler)` Closes the server.
    `StompClientConnection` | StompClientConnection.`closeHandler(Handler<StompClientConnection> handler)` Sets a handler notified when the STOMP connection is closed.
    `StompServerHandler` | StompServerHandler.`closeHandler(Handler<StompServerConnection> handler)` Configures the action to execute when a connection with the client is closed.
    `StompClientConnection` | StompClientConnection.`commit(String id, Handler<Frame> receiptHandler)` Commits a transaction.
    `StompClientConnection` | StompClientConnection.`commit(String id, Map<String,String> headers, Handler<Frame> receiptHandler)` Commits a transaction.
    `StompServerHandler` | StompServerHandler.`commitHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `COMMIT` frame is received.
    `void` | StompServerConnection.`configureHeartbeat(long ping, long pong, Handler<StompServerConnection> pingHandler)` Configures the heartbeat.
    `StompClient` | StompClient.`connect(Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server using the host and port configured in the client's options.
    `StompClient` | StompClient.`connect(int port, String host, Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server.
    `StompClient` | StompClient.`connect(int port, String host, NetClient net, Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server.
    `StompClient` | StompClient.`connect(NetClient net, Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server.
    `StompServerHandler` | StompServerHandler.`connectHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `CONNECT` frame is received.
    `StompClientConnection` | StompClientConnection.`connectionDroppedHandler(Handler<StompClientConnection> handler)` Sets a handler notified when the server does not respond to a `ping` request in time.
    `StompClientConnection` | StompClientConnection.`disconnect(Frame frame, Handler<Frame> receiptHandler)` Disconnects the client.
    `StompClientConnection` | StompClientConnection.`disconnect(Handler<Frame> receiptHandler)` Disconnects the client.
    `StompServerHandler` | StompServerHandler.`disconnectHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `DISCONNECT` frame is received.
    `StompClient` | StompClient.`errorFrameHandler(Handler<Frame> handler)` A general error frame handler.
    `StompClientConnection` | StompClientConnection.`errorHandler(Handler<Frame> handler)` Sets a handler notified when an `ERROR` frame is received by the client.
    `StompClientConnection` | StompClientConnection.`exceptionHandler(Handler<Throwable> exceptionHandler)` Configures the exception handler notified upon TCP-level errors.
    `StompClient` | StompClient.`exceptionHandler(Handler<Throwable> handler)` Sets an exception handler notified for TCP-level errors.
    `StompServer` | StompServer.`listen(Handler<AsyncResult<StompServer>> handler)` Connects the STOMP server default port (61613) and network interface (`0.0.0.0`).
    `StompServer` | StompServer.`listen(int port, Handler<AsyncResult<StompServer>> handler)` Connects the STOMP server to the given port.
    `StompServer` | StompServer.`listen(int port, String host, Handler<AsyncResult<StompServer>> handler)` Connects the STOMP server to the given port / interface.
    `StompClientConnection` | StompClientConnection.`nack(String id, Handler<Frame> receiptHandler)` Sends a non-acknowledgement for the given message.
    `StompClientConnection` | StompClientConnection.`nack(String id, String txId, Handler<Frame> receiptHandler)` Sends a non-acknowledgement for the given frame.
    `StompServerHandler` | StompServerHandler.`nackHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `NACK` frame is received.
    `StompServerHandler` | StompServerHandler.`onAckHandler(Handler<Acknowledgement> handler)` Configures the action to execute when messages are acknowledged.
    `StompServerHandler` | StompServerHandler.`onAuthenticationRequest(StompServerConnection connection, String login, String passcode, Handler<AsyncResult<Boolean>> handler)` Called when the client connects to a server requiring authentication.
    `StompServerHandler` | StompServerHandler.`onNackHandler(Handler<Acknowledgement> handler)` Configures the action to execute when messages are not acknowledged.
    `StompClientConnection` | StompClientConnection.`pingHandler(Handler<StompClientConnection> handler)` Sets a handler that let customize the behavior when a ping needs to be sent to the server.
    `StompServerHandler` | StompServerHandler.`pingHandler(Handler<StompServerConnection> handler)` Allows customizing the action to do when the server needs to send a `PING` to the client.
    `StompClientConnection` | StompClientConnection.`receivedFrameHandler(Handler<Frame> handler)` Configures a received handler that get notified when a STOMP frame is received by the client.
    `StompClient` | StompClient.`receivedFrameHandler(Handler<Frame> handler)` Configures a received handler that gets notified when a STOMP frame is received by the client.
    `StompServerHandler` | StompServerHandler.`receivedFrameHandler(Handler<ServerFrame> handler)` Configures a handler that get notified when a STOMP frame is received by the server.
    `StompClientConnection` | StompClientConnection.`send(Frame frame, Handler<Frame> receiptHandler)` Sends the given frame to the server.
    `StompClientConnection` | StompClientConnection.`send(Map<String,String> headers, Buffer body, Handler<Frame> receiptHandler)` Sends a `SEND` frame to the server.
    `StompClientConnection` | StompClientConnection.`send(String destination, Buffer body, Handler<Frame> receiptHandler)` Sends a `SEND` frame to the server to the given destination.
    `StompClientConnection` | StompClientConnection.`send(String destination, Map<String,String> headers, Buffer body, Handler<Frame> receiptHandler)` Sends a `SEND` frame to the server to the given destination.
    `StompServerHandler` | StompServerHandler.`sendHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `SEND` frame is received.
    `StompServerHandler` | StompServerHandler.`stompHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `STOMP` frame is received.
    `String` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler)` Subscribes to the given destination.
    `String` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler, Handler<Frame> receiptHandler)` Subscribes to the given destination.
    `String` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler, Handler<Frame> receiptHandler)` Subscribes to the given destination.
    `String` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler)` Subscribes to the given destination.
    `String` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler, Handler<Frame> receiptHandler)` Subscribes to the given destination.
    `String` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler, Handler<Frame> receiptHandler)` Subscribes to the given destination.
    `StompServerHandler` | StompServerHandler.`subscribeHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `SUBSCRIBE` frame is received.
    `StompClientConnection` | StompClientConnection.`unsubscribe(String destination, Handler<Frame> receiptHandler)` Un-subscribes from the given destination.
    `StompClientConnection` | StompClientConnection.`unsubscribe(String destination, Map<String,String> headers, Handler<Frame> receiptHandler)` Un-subscribes from the given destination.
    `StompServerHandler` | StompServerHandler.`unsubscribeHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `UNSUBSCRIBE` frame is received.
    `StompClientConnection` | StompClientConnection.`writingFrameHandler(Handler<Frame> handler)` Configures a handler notified when a frame is going to be written on the wire.
    `StompClient` | StompClient.`writingFrameHandler(Handler<Frame> handler)` Configures a writing handler that gets notified when a STOMP frame is written on the wire.
    `StompServer` | StompServer.`writingFrameHandler(Handler<ServerFrame> handler)` Configures the handler that is invoked every time a frame is going to be written to the "wire".

  - ### Uses of Handler in io.vertx.ext.sync

    Subinterfaces of Handler in io.vertx.ext.sync
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `HandlerReceiverAdaptor<T>` Represents an object that is both a handler of a particular event and also a receiver of that event.

    Methods in io.vertx.ext.sync that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `static <T> Handler<T>` | Sync.`fiberHandler(Handler<T> handler)` Convert a standard handler to a handler which runs on a fiber.

    Methods in io.vertx.ext.sync with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static <T> Handler<T>` | Sync.`fiberHandler(Handler<T> handler)` Convert a standard handler to a handler which runs on a fiber.

    Method parameters in io.vertx.ext.sync with type arguments of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static <T> T` | Sync.`awaitEvent(java.util.function.Consumer<Handler<T>> consumer)` Receive a single event from a handler synchronously.
    `static <T> T` | Sync.`awaitEvent(java.util.function.Consumer<Handler<T>> consumer, long timeout)` Receive a single event from a handler synchronously.
    `static <T> T` | Sync.`awaitResult(java.util.function.Consumer<Handler<AsyncResult<T>>> consumer)` Invoke an asynchronous operation and obtain the result synchronous.
    `static <T> T` | Sync.`awaitResult(java.util.function.Consumer<Handler<AsyncResult<T>>> consumer, long timeout)` Invoke an asynchronous operation and obtain the result synchronous.

  - ### Uses of Handler in io.vertx.ext.unit

    Methods in io.vertx.ext.unit that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure()` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure(Handler<Throwable> causeHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess()` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it completes the async operation. When the returned handler is called back with a failed result it fails the test with the cause of the failure.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess(Handler<T> resultHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it invokes the `resultHandler` argument with the async result.
    `Handler<Throwable>` | TestContext.`exceptionHandler()`

    Methods in io.vertx.ext.unit with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `TestSuite` | TestSuite.`after(Handler<TestContext> callback)` Set a callback executed after the tests.
    `TestSuite` | TestSuite.`afterEach(Handler<TestContext> callback)` Set a callback executed after each test and before the suite `after` callback.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure(Handler<Throwable> causeHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess(Handler<T> resultHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it invokes the `resultHandler` argument with the async result.
    `TestSuite` | TestSuite.`before(Handler<TestContext> callback)` Set a callback executed before the tests.
    `TestSuite` | TestSuite.`beforeEach(Handler<TestContext> callback)` Set a callback executed before each test and after the suite `before` callback.
    `static TestCase` | TestCase.`create(String name, Handler<TestContext> testCase)` Create a test case.
    `void` | Completion.`handler(Handler<AsyncResult<T>> completionHandler)` Completion handler to receive a completion signal when this completions completes.
    `TestSuite` | TestSuite.`test(String name, Handler<TestContext> testCase)` Add a new test case to the suite.
    `TestSuite` | TestSuite.`test(String name, int repeat, Handler<TestContext> testCase)` Add a new test case to the suite.
    `TestContext` | TestContext.`verify(Handler<Void> block)` Execute the provided handler, which may contain assertions, possibly from any third-party assertion framework.

  - ### Uses of Handler in io.vertx.ext.unit.collect

    Methods in io.vertx.ext.unit.collect that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<Message<JsonObject>>` | EventBusCollector.`asMessageHandler()`

    Methods in io.vertx.ext.unit.collect with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static EventBusCollector` | EventBusCollector.`create(Vertx vertx, Handler<TestSuiteReport> reporter)`

  - ### Uses of Handler in io.vertx.ext.unit.report

    Methods in io.vertx.ext.unit.report with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `TestCaseReport` | TestCaseReport.`endHandler(Handler<TestResult> handler)` Set a callback for completion, the specified `handler` is invoked when the test exec has completed.
    `TestSuiteReport` | TestSuiteReport.`endHandler(Handler<Void> endHandler)`
    `TestSuiteReport` | TestSuiteReport.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler, the exception handler reports the test suite errors, it can be called mulitple times before the test ends.
    `TestSuiteReport` | TestSuiteReport.`handler(Handler<TestCaseReport> handler)`

  - ### Uses of Handler in io.vertx.ext.web

    Subinterfaces of Handler in io.vertx.ext.web
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `Router` A router receives request from an `HttpServer` and routes it to the first matching `Route` that it contains.

    Methods in io.vertx.ext.web with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `int` | RoutingContext.`addBodyEndHandler(Handler<Void> handler)` Provides a handler that will be called after the last part of the body is written to the wire.
    `int` | RoutingContext.`addHeadersEndHandler(Handler<Void> handler)` Add a handler that will be called just before headers are written to the response.
    `Route` | Route.`blockingHandler(Handler<RoutingContext> requestHandler)` Like `Route.blockingHandler(Handler, boolean)` called with ordered = true
    `Route` | Route.`blockingHandler(Handler<RoutingContext> requestHandler, boolean ordered)` Specify a blocking request handler for the route.
    `Router` | Router.`errorHandler(int statusCode, Handler<RoutingContext> errorHandler)` Specify an handler to handle an error for a particular status code.
    `Router` | Router.`exceptionHandler(Handler<Throwable> exceptionHandler)` Deprecated. you should use `Router.errorHandler(int, Handler)` with 500 status code
    `Route` | Route.`failureHandler(Handler<RoutingContext> failureHandler)` Append a failure handler to the route failure handlers list.
    `Route` | Route.`handler(Handler<RoutingContext> requestHandler)` Append a request handler to the route handlers list.
    `Router` | Router.`modifiedHandler(Handler<Router> handler)` When a Router routes are changed this handler is notified.

  - ### Uses of Handler in io.vertx.ext.web.api.contract

    Methods in io.vertx.ext.web.api.contract that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<RoutingContext>` | RouterFactory.`getValidationFailureHandler()` Deprecated. Router Factory won't manage the validation errors anymore. You must use `Router.errorHandler(int, Handler)` with 400 error

    Methods in io.vertx.ext.web.api.contract with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `RouterFactory` | RouterFactory.`addGlobalHandler(Handler<RoutingContext> globalHandler)` Add global handler to be applied prior to `Router` being generated.
    `RouterFactory` | RouterFactory.`addSecurityHandler(String securitySchemaName, Handler<RoutingContext> handler)` Mount to paths that have to follow a security schema a security handler
    `RouterFactory` | RouterFactory.`setNotImplementedFailureHandler(Handler<RoutingContext> notImplementedFailureHandler)` Deprecated. You must use `Router.errorHandler(int, Handler)` with 501 error
    `RouterFactory` | RouterFactory.`setValidationFailureHandler(Handler<RoutingContext> validationFailureHandler)` Deprecated. Router Factory won't manage the validation errors anymore. You must use `Router.errorHandler(int, Handler)` with 400 error

  - ### Uses of Handler in io.vertx.ext.web.api.contract.openapi3

    Subinterfaces of Handler in io.vertx.ext.web.api.contract.openapi3
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `OpenAPI3RequestValidationHandler`

    Methods in io.vertx.ext.web.api.contract.openapi3 with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `OpenAPI3RouterFactory` | OpenAPI3RouterFactory.`addFailureHandlerByOperationId(String operationId, Handler<RoutingContext> failureHandler)` Add a failure handler by operation_id field in Operation object
    `OpenAPI3RouterFactory` | OpenAPI3RouterFactory.`addHandlerByOperationId(String operationId, Handler<RoutingContext> handler)` Add an handler by operation_id field in Operation object
    `OpenAPI3RouterFactory` | OpenAPI3RouterFactory.`addSecuritySchemaScopeValidator(String securitySchemaName, String scopeName, Handler<RoutingContext> handler)` Add a particular scope validator.
    `static void` | OpenAPI3RouterFactory.`create(Vertx vertx, String url, Handler<AsyncResult<OpenAPI3RouterFactory>> handler)` Create a new OpenAPI3RouterFactory
    `static void` | OpenAPI3RouterFactory.`create(Vertx vertx, String url, List<JsonObject> auth, Handler<AsyncResult<OpenAPI3RouterFactory>> handler)` Create a new OpenAPI3RouterFactory

  - ### Uses of Handler in io.vertx.ext.web.api.validation

    Subinterfaces of Handler in io.vertx.ext.web.api.validation
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `HTTPRequestValidationHandler` An interface for add HTTP Request validation.
    `interface` | `ValidationHandler` Base interface for validation.

  - ### Uses of Handler in io.vertx.ext.web.client

    Methods in io.vertx.ext.web.client with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | HttpRequest.`send(Handler<AsyncResult<HttpResponse<T>>> handler)` Send a request, the `handler` will receive the response as an `HttpResponse`.
    `void` | HttpRequest.`sendBuffer(Buffer body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(Handler)` but with an HTTP request `body` buffer.
    `void` | HttpRequest.`sendForm(MultiMap body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(Handler)` but with an HTTP request `body` multimap encoded as form and the content type set to `application/x-www-form-urlencoded`.
    `void` | HttpRequest.`sendJson(Object body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(Handler)` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
    `void` | HttpRequest.`sendJsonObject(JsonObject body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(Handler)` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
    `void` | HttpRequest.`sendMultipartForm(MultipartForm body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(Handler)` but with an HTTP request `body` multimap encoded as form and the content type set to `multipart/form-data`.
    `void` | HttpRequest.`sendStream(ReadStream<Buffer> body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(Handler)` but with an HTTP request `body` stream.

  - ### Uses of Handler in io.vertx.ext.web.codec

    Methods in io.vertx.ext.web.codec with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | BodyCodec.`create(Handler<AsyncResult<BodyStream<T>>> handler)` Create the `BodyStream`.

  - ### Uses of Handler in io.vertx.ext.web.codec.spi

    Subinterfaces of Handler in io.vertx.ext.web.codec.spi
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `BodyStream<T>` The body stream decodes a `WriteStream` into the a `T` instance.

  - ### Uses of Handler in io.vertx.ext.web.common.template

    Methods in io.vertx.ext.web.common.template with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `default void` | TemplateEngine.`render(JsonObject context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Render the template.
    `void` | TemplateEngine.`render(Map<String,Object> context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Render the template.

  - ### Uses of Handler in io.vertx.ext.web.handler

    Subinterfaces of Handler in io.vertx.ext.web.handler
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `AuthHandler` Base interface for auth handlers.
    `interface` | `BasicAuthHandler` An auth handler that provides HTTP Basic Authentication support.
    `interface` | `BodyHandler` A handler which gathers the entire request body and sets it on the `RoutingContext`.
    `interface` | `ChainAuthHandler` An auth handler that chains to a sequence of handlers.
    `interface` | `CookieHandler` Deprecated. cookies are enabled by default and this handler is not required anymore
    `interface` | `CorsHandler` A handler which implements server side http://www.w3.org/TR/cors/[CORS] support for Vert.x-Web.
    `interface` | `CSRFHandler` This handler adds a CSRF token to requests which mutate state.
    `interface` | `DigestAuthHandler` An auth handler that provides HTTP Basic Authentication support.
    `interface` | `ErrorHandler` A pretty error handler for rendering error pages.
    `interface` | `FaviconHandler` A handler that serves favicons.
    `interface` | `FormLoginHandler` Handler that handles login from a form on a custom login page.
    `interface` | `JWTAuthHandler` An auth handler that provides JWT Authentication support.
    `interface` | `LoggerHandler` A handler which logs request information to the Vert.x logger.
    `interface` | `MultiTenantHandler` A handler which selectively executes another handler if a precondition is met.
    `interface` | `OAuth2AuthHandler` An auth handler that provides OAuth2 Authentication support.
    `interface` | `RedirectAuthHandler` An auth handler that's used to handle auth by redirecting user to a custom login page.
    `interface` | `ResponseContentTypeHandler` A handler which sets the response content type automatically according to the best `Accept` header match.
    `interface` | `ResponseTimeHandler` Handler which adds a header `x-response-time` in the response of matching requests containing the time taken in ms to process the request.
    `interface` | `SessionHandler` A handler that maintains a `Session` for each browser session.
    `interface` | `StaticHandler` A handler for serving static resources from the file system or classpath.
    `interface` | `TemplateHandler` A handler which renders responses using a template engine and where the template name is selected from the URI path.
    `interface` | `TimeoutHandler` Handler that will timeout requests if the response has not been written after a certain time.
    `interface` | `UserSessionHandler` Deprecated. the Session Handler also manages the user session.
    `interface` | `VirtualHostHandler` Handler that will filter requests based on the request Host name.

    Methods in io.vertx.ext.web.handler with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MultiTenantHandler` | MultiTenantHandler.`addDefaultHandler(Handler<RoutingContext> handler)` Add a default handler for the case when no tenant was matched.
    `MultiTenantHandler` | MultiTenantHandler.`addTenantHandler(String tenant, Handler<RoutingContext> handler)` Add a handler for a given tenant to this handler.
    `void` | AuthHandler.`authorize(User user, Handler<AsyncResult<Void>> handler)` Authorizes the given user against all added authorities.
    `static VirtualHostHandler` | VirtualHostHandler.`create(String hostname, Handler<RoutingContext> handler)` Create a handler
    `void` | AuthHandler.`parseCredentials(RoutingContext context, Handler<AsyncResult<JsonObject>> handler)` Parses the credentials from the request into a JsonObject.

  - ### Uses of Handler in io.vertx.ext.web.handler.graphql

    Subinterfaces of Handler in io.vertx.ext.web.handler.graphql
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `ApolloWSHandler` A handler for GraphQL requests sent over Apollo's `subscriptions-transport-ws` transport.
    `interface` | `GraphiQLHandler` A `Route` handler for GraphiQL resources.
    `interface` | `GraphQLHandler` A `Route` handler for GraphQL requests.

    Methods in io.vertx.ext.web.handler.graphql with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `ApolloWSHandler` | ApolloWSHandler.`connectionHandler(Handler<ServerWebSocket> connectionHandler)` Customize the connection `Handler`.
    `ApolloWSHandler` | ApolloWSHandler.`endHandler(Handler<ServerWebSocket> endHandler)` Customize the end `Handler`.
    `ApolloWSHandler` | ApolloWSHandler.`messageHandler(Handler<ApolloWSMessage> messageHandler)` Customize the message `Handler`.

  - ### Uses of Handler in io.vertx.ext.web.handler.sockjs

    Subinterfaces of Handler in io.vertx.ext.web.handler.sockjs
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `SockJSHandler` A handler that allows you to handle SockJS connections from clients.

    Methods in io.vertx.ext.web.handler.sockjs with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `Router` | SockJSHandler.`bridge(BridgeOptions bridgeOptions, Handler<BridgeEvent> bridgeEventHandler)` Like `SockJSHandler.bridge(BridgeOptions)` but specifying a handler that will receive bridge events.
    `SockJSSocket` | SockJSSocket.`drainHandler(Handler<Void> handler)`
    `SockJSSocket` | SockJSSocket.`endHandler(Handler<Void> endHandler)`
    `SockJSSocket` | SockJSSocket.`exceptionHandler(Handler<Throwable> handler)`
    `SockJSSocket` | SockJSSocket.`handler(Handler<Buffer> handler)`
    `Router` | SockJSHandler.`socketHandler(Handler<SockJSSocket> handler)` Set a SockJS socket handler.
    `SockJSSocket` | SockJSSocket.`write(Buffer data, Handler<AsyncResult<Void>> handler)`
    `default SockJSSocket` | SockJSSocket.`write(String data, Handler<AsyncResult<Void>> handler)`

  - ### Uses of Handler in io.vertx.ext.web.sstore

    Methods in io.vertx.ext.web.sstore with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | SessionStore.`clear(Handler<AsyncResult<Void>> resultHandler)` Remove all sessions from the store.
    `void` | SessionStore.`delete(String id, Handler<AsyncResult<Void>> resultHandler)` Delete the session with the specified ID.
    `void` | SessionStore.`get(String cookieValue, Handler<AsyncResult<Session>> resultHandler)` Get the session with the specified ID.
    `void` | SessionStore.`put(Session session, Handler<AsyncResult<Void>> resultHandler)` Add a session with the specified ID.
    `void` | SessionStore.`size(Handler<AsyncResult<Integer>> resultHandler)` Get the number of sessions in the store.

  - ### Uses of Handler in io.vertx.ext.web.templ

    Methods in io.vertx.ext.web.templ with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `default void` | TemplateEngine.`render(RoutingContext context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Deprecated. use `TemplateEngine.render(RoutingContext, String, String, Handler)`
    `default void` | FreeMarkerTemplateEngine.`render(RoutingContext context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Deprecated.
    `default void` | PebbleTemplateEngine.`render(RoutingContext context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Deprecated.
    `default void` | JadeTemplateEngine.`render(RoutingContext context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Deprecated.
    `default void` | ThymeleafTemplateEngine.`render(RoutingContext context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Deprecated.
    `default void` | HandlebarsTemplateEngine.`render(RoutingContext context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Deprecated.
    `default void` | RockerTemplateEngine.`render(RoutingContext context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Deprecated.
    `default void` | MVELTemplateEngine.`render(RoutingContext context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Deprecated.
    `default void` | TemplateEngine.`render(RoutingContext context, String templateDirectory, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Deprecated.

  - ### Uses of Handler in io.vertx.grpc

    Methods in io.vertx.grpc with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `GrpcWriteStream<T>` | GrpcWriteStream.`drainHandler(Handler<Void> handler)` Set a drain handler on the stream.
    `GrpcBidiExchange<I,O>` | GrpcBidiExchange.`drainHandler(Handler<Void> handler)`
    `GrpcUniExchange<O,I>` | GrpcUniExchange.`drainHandler(Handler<Void> handler)`
    `GrpcReadStream<T>` | GrpcReadStream.`endHandler(Handler<Void> endHandler)` Set an end handler.
    `GrpcBidiExchange<I,O>` | GrpcBidiExchange.`endHandler(Handler<Void> handler)`
    `GrpcReadStream<T>` | GrpcReadStream.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the read stream.
    `GrpcWriteStream<T>` | GrpcWriteStream.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the write stream.
    `GrpcBidiExchange<I,O>` | GrpcBidiExchange.`exceptionHandler(Handler<Throwable> handler)`
    `GrpcUniExchange<O,I>` | GrpcUniExchange.`handler(Handler<AsyncResult<I>> handler)`
    `GrpcBidiExchange<I,O>` | GrpcBidiExchange.`handler(Handler<I> handler)`
    `GrpcReadStream<T>` | GrpcReadStream.`handler(Handler<T> handler)` Set a data handler.
    `VertxServer` | VertxServer.`shutdown(Handler<AsyncResult<Void>> completionHandler)`
    `VertxServer` | VertxServer.`start(Handler<AsyncResult<Void>> completionHandler)`
    `VertxChannelBuilder` | VertxChannelBuilder.`useSsl(Handler<ClientOptionsBase> handler)`
    `VertxServerBuilder` | VertxServerBuilder.`useSsl(Handler<HttpServerOptions> handler)`

  - ### Uses of Handler in io.vertx.junit5

    Methods in io.vertx.junit5 that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `<T> Handler<AsyncResult<T>>` | VertxTestContext.`completing()` Create an asynchronous result handler that expects a success to then complete the test context.
    `<T> Handler<AsyncResult<T>>` | VertxTestContext.`failing()` Create an asynchronous result handler that expects a failure.
    `<T> Handler<AsyncResult<T>>` | VertxTestContext.`failing(Handler<Throwable> nextHandler)` Create an asynchronous result handler that expects a failure, and passes the exception to another handler.
    `<T> Handler<AsyncResult<T>>` | VertxTestContext.`succeeding()` Create an asynchronous result handler that expects a success.
    `<T> Handler<AsyncResult<T>>` | VertxTestContext.`succeeding(Handler<T> nextHandler)` Create an asynchronous result handler that expects a success, and passes the value to another handler.

    Methods in io.vertx.junit5 with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `<T> Handler<AsyncResult<T>>` | VertxTestContext.`failing(Handler<Throwable> nextHandler)` Create an asynchronous result handler that expects a failure, and passes the exception to another handler.
    `<T> Handler<AsyncResult<T>>` | VertxTestContext.`succeeding(Handler<T> nextHandler)` Create an asynchronous result handler that expects a success, and passes the value to another handler.

  - ### Uses of Handler in io.vertx.kafka.admin

    Methods in io.vertx.kafka.admin with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | KafkaAdminClient.`alterConfigs(Map<ConfigResource,Config> configs, Handler<AsyncResult<Void>> completionHandler)` Update the configuration for the specified resources with the default options
    `void` | KafkaAdminClient.`close(Handler<AsyncResult<Void>> completionHandler)` Close the admin client
    `void` | KafkaAdminClient.`close(long timeout, Handler<AsyncResult<Void>> completionHandler)` Close the admin client
    `void` | KafkaAdminClient.`createTopics(List<NewTopic> topics, Handler<AsyncResult<Void>> completionHandler)` Creates a batch of new Kafka topics
    `void` | KafkaAdminClient.`deleteTopics(List<String> topicNames, Handler<AsyncResult<Void>> completionHandler)` Deletes a batch of Kafka topics
    `void` | KafkaAdminClient.`describeConfigs(List<ConfigResource> configResources, Handler<AsyncResult<Map<ConfigResource,Config>>> completionHandler)` Get the configuration for the specified resources with the default options
    `void` | KafkaAdminClient.`describeConsumerGroups(List<String> groupIds, Handler<AsyncResult<Map<String,ConsumerGroupDescription>>> completionHandler)` Describe some group ids in the cluster, with the default options
    `void` | KafkaAdminClient.`describeTopics(List<String> topicNames, Handler<AsyncResult<Map<String,TopicDescription>>> completionHandler)` Describe some topics in the cluster, with the default options.
    `void` | KafkaAdminClient.`listConsumerGroups(Handler<AsyncResult<List<ConsumerGroupListing>>> completionHandler)` Get the the consumer groups available in the cluster with the default options
    `void` | KafkaAdminClient.`listTopics(Handler<AsyncResult<Set<String>>> completionHandler)` List the topics available in the cluster with the default options.

  - ### Uses of Handler in io.vertx.kafka.client.consumer

    Methods in io.vertx.kafka.client.consumer with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `KafkaReadStream<K,V>` | KafkaReadStream.`assign(Set<org.apache.kafka.common.TopicPartition> partitions, Handler<AsyncResult<Void>> completionHandler)` Manually assign a set of partitions to this consumer.
    `KafkaConsumer<K,V>` | KafkaConsumer.`assign(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Manually assign a list of partition to this consumer.
    `KafkaConsumer<K,V>` | KafkaConsumer.`assign(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Manually assign a partition to this consumer.
    `KafkaReadStream<K,V>` | KafkaReadStream.`assignment(Handler<AsyncResult<Set<org.apache.kafka.common.TopicPartition>>> handler)` Get the set of partitions currently assigned to this consumer.
    `KafkaConsumer<K,V>` | KafkaConsumer.`assignment(Handler<AsyncResult<Set<TopicPartition>>> handler)` Get the set of partitions currently assigned to this consumer.
    `KafkaReadStream<K,V>` | KafkaReadStream.`batchHandler(Handler<org.apache.kafka.clients.consumer.ConsumerRecords<K,V>> handler)` Set the handler that will be called when a new batch of records is returned from Kafka.
    `KafkaConsumer<K,V>` | KafkaConsumer.`batchHandler(Handler<KafkaConsumerRecords<K,V>> handler)` Set the handler to be used when batches of messages are fetched from the Kafka server.
    `void` | KafkaReadStream.`beginningOffsets(Set<org.apache.kafka.common.TopicPartition> topicPartitions, Handler<AsyncResult<Map<org.apache.kafka.common.TopicPartition,Long>>> handler)` Get the first offset for the given partitions.
    `void` | KafkaConsumer.`beginningOffsets(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Map<TopicPartition,Long>>> handler)` Get the first offset for the given partitions.
    `void` | KafkaReadStream.`beginningOffsets(org.apache.kafka.common.TopicPartition topicPartition, Handler<AsyncResult<Long>> handler)` Get the first offset for the given partition.
    `void` | KafkaConsumer.`beginningOffsets(TopicPartition topicPartition, Handler<AsyncResult<Long>> handler)` Get the first offset for the given partitions.
    `void` | KafkaReadStream.`close(Handler<AsyncResult<Void>> completionHandler)` Close the stream
    `void` | KafkaConsumer.`close(Handler<AsyncResult<Void>> completionHandler)` Close the consumer
    `void` | KafkaReadStream.`commit(Handler<AsyncResult<Map<org.apache.kafka.common.TopicPartition,org.apache.kafka.clients.consumer.OffsetAndMetadata>>> completionHandler)` Commit current offsets for all the subscribed list of topics and partition.
    `void` | KafkaConsumer.`commit(Handler<AsyncResult<Void>> completionHandler)` Commit current offsets for all the subscribed list of topics and partition.
    `void` | KafkaReadStream.`commit(Map<org.apache.kafka.common.TopicPartition,org.apache.kafka.clients.consumer.OffsetAndMetadata> offsets, Handler<AsyncResult<Map<org.apache.kafka.common.TopicPartition,org.apache.kafka.clients.consumer.OffsetAndMetadata>>> completionHandler)` Commit the specified offsets for the specified list of topics and partitions to Kafka.
    `void` | KafkaConsumer.`commit(Map<TopicPartition,OffsetAndMetadata> offsets, Handler<AsyncResult<Map<TopicPartition,OffsetAndMetadata>>> completionHandler)` Commit the specified offsets for the specified list of topics and partitions to Kafka.
    `void` | KafkaReadStream.`committed(org.apache.kafka.common.TopicPartition topicPartition, Handler<AsyncResult<org.apache.kafka.clients.consumer.OffsetAndMetadata>> handler)` Get the last committed offset for the given partition (whether the commit happened by this process or another).
    `void` | KafkaConsumer.`committed(TopicPartition topicPartition, Handler<AsyncResult<OffsetAndMetadata>> handler)` Get the last committed offset for the given partition (whether the commit happened by this process or another).
    `KafkaReadStream<K,V>` | KafkaReadStream.`endHandler(Handler<Void> endHandler)`
    `KafkaConsumer<K,V>` | KafkaConsumer.`endHandler(Handler<Void> endHandler)`
    `void` | KafkaReadStream.`endOffsets(Set<org.apache.kafka.common.TopicPartition> topicPartitions, Handler<AsyncResult<Map<org.apache.kafka.common.TopicPartition,Long>>> handler)` Get the last offset for the given partitions.
    `void` | KafkaConsumer.`endOffsets(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Map<TopicPartition,Long>>> handler)` Get the last offset for the given partitions.
    `void` | KafkaReadStream.`endOffsets(org.apache.kafka.common.TopicPartition topicPartition, Handler<AsyncResult<Long>> handler)` Get the last offset for the given partition.
    `void` | KafkaConsumer.`endOffsets(TopicPartition topicPartition, Handler<AsyncResult<Long>> handler)` Get the last offset for the given partition.
    `KafkaReadStream<K,V>` | KafkaReadStream.`exceptionHandler(Handler<Throwable> handler)`
    `KafkaConsumer<K,V>` | KafkaConsumer.`exceptionHandler(Handler<Throwable> handler)`
    `KafkaReadStream<K,V>` | KafkaReadStream.`handler(Handler<org.apache.kafka.clients.consumer.ConsumerRecord<K,V>> handler)`
    `KafkaConsumer<K,V>` | KafkaConsumer.`handler(Handler<KafkaConsumerRecord<K,V>> handler)`
    `KafkaReadStream<K,V>` | KafkaReadStream.`listTopics(Handler<AsyncResult<Map<String,List<org.apache.kafka.common.PartitionInfo>>>> handler)` Get metadata about partitions for all topics that the user is authorized to view.
    `KafkaConsumer<K,V>` | KafkaConsumer.`listTopics(Handler<AsyncResult<Map<String,List<PartitionInfo>>>> handler)` Get metadata about partitions for all topics that the user is authorized to view.
    `void` | KafkaReadStream.`offsetsForTimes(Map<org.apache.kafka.common.TopicPartition,Long> topicPartitionTimestamps, Handler<AsyncResult<Map<org.apache.kafka.common.TopicPartition,org.apache.kafka.clients.consumer.OffsetAndTimestamp>>> handler)` Look up the offsets for the given partitions by timestamp.
    `void` | KafkaConsumer.`offsetsForTimes(Map<TopicPartition,Long> topicPartitionTimestamps, Handler<AsyncResult<Map<TopicPartition,OffsetAndTimestamp>>> handler)` Look up the offsets for the given partitions by timestamp.
    `void` | KafkaReadStream.`offsetsForTimes(org.apache.kafka.common.TopicPartition topicPartition, long timestamp, Handler<AsyncResult<org.apache.kafka.clients.consumer.OffsetAndTimestamp>> handler)` * Look up the offset for the given partition by timestamp.
    `void` | KafkaConsumer.`offsetsForTimes(TopicPartition topicPartition, Long timestamp, Handler<AsyncResult<OffsetAndTimestamp>> handler)` Look up the offset for the given partition by timestamp.
    `KafkaReadStream<K,V>` | KafkaReadStream.`partitionsAssignedHandler(Handler<Set<org.apache.kafka.common.TopicPartition>> handler)` Set the handler called when topic partitions are assigned to the consumer
    `KafkaConsumer<K,V>` | KafkaConsumer.`partitionsAssignedHandler(Handler<Set<TopicPartition>> handler)` Set the handler called when topic partitions are assigned to the consumer
    `KafkaReadStream<K,V>` | KafkaReadStream.`partitionsFor(String topic, Handler<AsyncResult<List<org.apache.kafka.common.PartitionInfo>>> handler)` Get metadata about the partitions for a given topic.
    `KafkaConsumer<K,V>` | KafkaConsumer.`partitionsFor(String topic, Handler<AsyncResult<List<PartitionInfo>>> handler)` Get metadata about the partitions for a given topic.
    `KafkaReadStream<K,V>` | KafkaReadStream.`partitionsRevokedHandler(Handler<Set<org.apache.kafka.common.TopicPartition>> handler)` Set the handler called when topic partitions are revoked to the consumer
    `KafkaConsumer<K,V>` | KafkaConsumer.`partitionsRevokedHandler(Handler<Set<TopicPartition>> handler)` Set the handler called when topic partitions are revoked to the consumer
    `KafkaReadStream<K,V>` | KafkaReadStream.`pause(Set<org.apache.kafka.common.TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Suspend fetching from the requested partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`pause(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Suspend fetching from the requested partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`pause(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Suspend fetching from the requested partition.
    `void` | KafkaReadStream.`paused(Handler<AsyncResult<Set<org.apache.kafka.common.TopicPartition>>> handler)` Get the set of partitions that were previously paused by a call to `KafkaReadStream.pause(Set)`.
    `void` | KafkaConsumer.`paused(Handler<AsyncResult<Set<TopicPartition>>> handler)` Get the set of partitions that were previously paused by a call to pause(Set).
    `void` | KafkaReadStream.`poll(long timeout, Handler<AsyncResult<org.apache.kafka.clients.consumer.ConsumerRecords<K,V>>> handler)` Executes a poll for getting messages from Kafka
    `void` | KafkaConsumer.`poll(long timeout, Handler<AsyncResult<KafkaConsumerRecords<K,V>>> handler)` Executes a poll for getting messages from Kafka
    `void` | KafkaReadStream.`position(org.apache.kafka.common.TopicPartition partition, Handler<AsyncResult<Long>> handler)` Get the offset of the next record that will be fetched (if a record with that offset exists).
    `void` | KafkaConsumer.`position(TopicPartition partition, Handler<AsyncResult<Long>> handler)` Get the offset of the next record that will be fetched (if a record with that offset exists).
    `KafkaReadStream<K,V>` | KafkaReadStream.`resume(Set<org.apache.kafka.common.TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Resume specified partitions which have been paused with pause.
    `KafkaConsumer<K,V>` | KafkaConsumer.`resume(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Resume specified partitions which have been paused with pause.
    `KafkaConsumer<K,V>` | KafkaConsumer.`resume(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Resume specified partition which have been paused with pause.
    `KafkaReadStream<K,V>` | KafkaReadStream.`seek(org.apache.kafka.common.TopicPartition topicPartition, long offset, Handler<AsyncResult<Void>> completionHandler)` Overrides the fetch offsets that the consumer will use on the next poll.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seek(TopicPartition topicPartition, long offset, Handler<AsyncResult<Void>> completionHandler)` Overrides the fetch offsets that the consumer will use on the next poll.
    `KafkaReadStream<K,V>` | KafkaReadStream.`seekToBeginning(Set<org.apache.kafka.common.TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Seek to the first offset for each of the given partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seekToBeginning(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Seek to the first offset for each of the given partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seekToBeginning(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Seek to the first offset for each of the given partition.
    `KafkaReadStream<K,V>` | KafkaReadStream.`seekToEnd(Set<org.apache.kafka.common.TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Seek to the last offset for each of the given partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seekToEnd(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Seek to the last offset for each of the given partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seekToEnd(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Seek to the last offset for each of the given partition.
    `KafkaReadStream<K,V>` | KafkaReadStream.`subscribe(Pattern pattern, Handler<AsyncResult<Void>> completionHandler)` Subscribe to all topics matching specified pattern to get dynamically assigned partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`subscribe(Pattern pattern, Handler<AsyncResult<Void>> completionHandler)` Subscribe to all topics matching specified pattern to get dynamically assigned partitions.
    `KafkaReadStream<K,V>` | KafkaReadStream.`subscribe(Set<String> topics, Handler<AsyncResult<Void>> completionHandler)` Subscribe to the given list of topics to get dynamically assigned partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`subscribe(Set<String> topics, Handler<AsyncResult<Void>> completionHandler)` Subscribe to the given list of topics to get dynamically assigned partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`subscribe(String topic, Handler<AsyncResult<Void>> completionHandler)` Subscribe to the given topic to get dynamically assigned partitions.
    `KafkaReadStream<K,V>` | KafkaReadStream.`subscription(Handler<AsyncResult<Set<String>>> handler)` Get the current subscription.
    `KafkaConsumer<K,V>` | KafkaConsumer.`subscription(Handler<AsyncResult<Set<String>>> handler)` Get the current subscription.
    `KafkaReadStream<K,V>` | KafkaReadStream.`unsubscribe(Handler<AsyncResult<Void>> completionHandler)` Unsubscribe from topics currently subscribed with subscribe.
    `KafkaConsumer<K,V>` | KafkaConsumer.`unsubscribe(Handler<AsyncResult<Void>> completionHandler)` Unsubscribe from topics currently subscribed with subscribe.

  - ### Uses of Handler in io.vertx.kafka.client.producer

    Methods in io.vertx.kafka.client.producer with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | KafkaProducer.`close(Handler<AsyncResult<Void>> completionHandler)` Close the producer
    `void` | KafkaWriteStream.`close(Handler<AsyncResult<Void>> completionHandler)` Close the stream
    `void` | KafkaProducer.`close(long timeout, Handler<AsyncResult<Void>> completionHandler)` Close the producer
    `void` | KafkaWriteStream.`close(long timeout, Handler<AsyncResult<Void>> completionHandler)` Close the stream
    `KafkaProducer<K,V>` | KafkaProducer.`drainHandler(Handler<Void> handler)`
    `KafkaProducer<K,V>` | KafkaProducer.`exceptionHandler(Handler<Throwable> handler)`
    `KafkaProducer<K,V>` | KafkaProducer.`flush(Handler<Void> completionHandler)` Invoking this method makes all buffered records immediately available to write
    `KafkaWriteStream<K,V>` | KafkaWriteStream.`flush(Handler<Void> completionHandler)` Invoking this method makes all buffered records immediately available to write
    `KafkaProducer<K,V>` | KafkaProducer.`partitionsFor(String topic, Handler<AsyncResult<List<PartitionInfo>>> handler)` Get the partition metadata for the give topic.
    `KafkaWriteStream<K,V>` | KafkaWriteStream.`partitionsFor(String topic, Handler<AsyncResult<List<org.apache.kafka.common.PartitionInfo>>> handler)` Get the partition metadata for the give topic.
    `KafkaProducer<K,V>` | KafkaProducer.`send(KafkaProducerRecord<K,V> record, Handler<AsyncResult<RecordMetadata>> handler)` Asynchronously write a record to a topic
    `KafkaWriteStream<K,V>` | KafkaWriteStream.`send(org.apache.kafka.clients.producer.ProducerRecord<K,V> record, Handler<AsyncResult<org.apache.kafka.clients.producer.RecordMetadata>> handler)` Asynchronously write a record to a topic
    `KafkaProducer<K,V>` | KafkaProducer.`write(KafkaProducerRecord<K,V> data, Handler<AsyncResult<Void>> handler)`

  - ### Uses of Handler in io.vertx.micrometer

    Methods in io.vertx.micrometer that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `static Handler<RoutingContext>` | PrometheusScrapingHandler.`create()` Creates a Vert.x Web `Route` handler for Prometheus metrics scraping.
    `static Handler<RoutingContext>` | PrometheusScrapingHandler.`create(String registryName)` Creates a Vert.x Web `Route` handler for Prometheus metrics scraping.

  - ### Uses of Handler in io.vertx.mqtt

    Methods in io.vertx.mqtt with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | MqttServer.`close(Handler<AsyncResult<Void>> completionHandler)` Close the server supplying an handler that will be called when the server is actually closed (or has failed).
    `MqttClient` | MqttClient.`closeHandler(Handler<Void> closeHandler)` Set a handler that will be called when the connection with server is closed
    `MqttEndpoint` | MqttEndpoint.`closeHandler(Handler<Void> handler)` Set a close handler.
    `MqttClient` | MqttClient.`connect(int port, String host, Handler<AsyncResult<MqttConnAckMessage>> connectHandler)` Connects to an MQTT server calling connectHandler after connection
    `MqttClient` | MqttClient.`connect(int port, String host, String serverName, Handler<AsyncResult<MqttConnAckMessage>> connectHandler)` Connects to an MQTT server calling connectHandler after connection
    `MqttClient` | MqttClient.`disconnect(Handler<AsyncResult<Void>> disconnectHandler)` Disconnects from the MQTT server calling disconnectHandler after disconnection
    `MqttEndpoint` | MqttEndpoint.`disconnectHandler(Handler<Void> handler)` Set a disconnect handler on the MQTT endpoint.
    `MqttServer` | MqttServer.`endpointHandler(Handler<MqttEndpoint> handler)` Set the endpoint handler for the server.
    `MqttClient` | MqttClient.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler for the client, that will be called when an error happens in internal netty structures.
    `MqttEndpoint` | MqttEndpoint.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler.
    `MqttServer` | MqttServer.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler for the server, that will be called when an error happens independantly of an accepted `MqttEndpoint`, like a rejected connection
    `MqttServer` | MqttServer.`listen(Handler<AsyncResult<MqttServer>> listenHandler)` Start the server listening for incoming connections using the specified options through the constructor
    `MqttServer` | MqttServer.`listen(int port, Handler<AsyncResult<MqttServer>> listenHandler)` Start the server listening for incoming connections on the port specified but on "0.0.0.0" as host.
    `MqttServer` | MqttServer.`listen(int port, String host, Handler<AsyncResult<MqttServer>> listenHandler)` Start the server listening for incoming connections on the port and host specified It ignores any options specified through the constructor
    `MqttEndpoint` | MqttEndpoint.`pingHandler(Handler<Void> handler)` Set the pingreq handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`pingResponseHandler(Handler<Void> pingResponseHandler)` Sets handler which will be called after PINGRESP packet receiving
    `MqttClient` | MqttClient.`publish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server
    `MqttEndpoint` | MqttEndpoint.`publish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server
    `MqttEndpoint` | MqttEndpoint.`publish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
    `MqttEndpoint` | MqttEndpoint.`publishAcknowledgeHandler(Handler<Integer> handler)` Set the puback handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`publishCompletionHandler(Handler<Integer> publishCompletionHandler)` Sets handler which will be called each time publish is completed
    `MqttEndpoint` | MqttEndpoint.`publishCompletionHandler(Handler<Integer> handler)` Set the pubcomp handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`publishHandler(Handler<MqttPublishMessage> publishHandler)` Sets handler which will be called each time server publish something to client
    `MqttEndpoint` | MqttEndpoint.`publishHandler(Handler<MqttPublishMessage> handler)` Set the publish handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishReceivedHandler(Handler<Integer> handler)` Set the pubrec handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishReleaseHandler(Handler<Integer> handler)` Set the pubrel handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`subscribe(Map<String,Integer> topics, Handler<AsyncResult<Integer>> subscribeSentHandler)` Subscribes to the topic and adds a handler which will be called after the request is sent
    `MqttClient` | MqttClient.`subscribe(String topic, int qos, Handler<AsyncResult<Integer>> subscribeSentHandler)` Subscribes to the topic with a specified QoS level
    `MqttClient` | MqttClient.`subscribeCompletionHandler(Handler<MqttSubAckMessage> subscribeCompletionHandler)` Sets handler which will be called after SUBACK packet receiving
    `MqttEndpoint` | MqttEndpoint.`subscribeHandler(Handler<MqttSubscribeMessage> handler)` Set a subscribe handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`unsubscribe(String topic, Handler<AsyncResult<Integer>> unsubscribeSentHandler)` Unsubscribe from receiving messages on given topic
    `MqttClient` | MqttClient.`unsubscribeCompletionHandler(Handler<Integer> unsubscribeCompletionHandler)` Sets handler which will be called after UNSUBACK packet receiving
    `MqttEndpoint` | MqttEndpoint.`unsubscribeHandler(Handler<MqttUnsubscribeMessage> handler)` Set a unsubscribe handler on the MQTT endpoint.

  - ### Uses of Handler in io.vertx.mysqlclient

    Methods in io.vertx.mysqlclient with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MySQLConnection` | MySQLConnection.`changeUser(MySQLAuthOptions options, Handler<AsyncResult<Void>> handler)` Send a CHANGE_USER command to change the user of the current connection, this operation will also reset connection state.
    `MySQLConnection` | MySQLConnection.`closeHandler(Handler<Void> handler)`
    `static void` | MySQLConnection.`connect(Vertx vertx, MySQLConnectOptions connectOptions, Handler<AsyncResult<MySQLConnection>> handler)` Create a connection to MySQL server with the given `connectOptions`.
    `static void` | MySQLConnection.`connect(Vertx vertx, String connectionUri, Handler<AsyncResult<MySQLConnection>> handler)` Like `MySQLConnection.connect(Vertx, MySQLConnectOptions, Handler)` with options build from `connectionUri`.
    `MySQLConnection` | MySQLConnection.`debug(Handler<AsyncResult<Void>> handler)` Send a DEBUG command to dump debug information to the server's stdout.
    `MySQLConnection` | MySQLConnection.`exceptionHandler(Handler<Throwable> handler)`
    `MySQLConnection` | MySQLConnection.`getInternalStatistics(Handler<AsyncResult<String>> handler)` Send a STATISTICS command to get a human readable string of the server internal status.
    `MySQLConnection` | MySQLConnection.`ping(Handler<AsyncResult<Void>> handler)` Send a PING command to check if the server is alive.
    `MySQLConnection` | MySQLConnection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)`
    `MySQLConnection` | MySQLConnection.`resetConnection(Handler<AsyncResult<Void>> handler)` Send a RESET_CONNECTION command to reset the session state.
    `MySQLConnection` | MySQLConnection.`setOption(MySQLSetOption option, Handler<AsyncResult<Void>> handler)` Send a SET_OPTION command to set options for the current connection.
    `MySQLConnection` | MySQLConnection.`specifySchema(String schemaName, Handler<AsyncResult<Void>> handler)` Send a INIT_DB command to change the default schema of the connection.

  - ### Uses of Handler in io.vertx.pgclient

    Methods in io.vertx.pgclient with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `PgConnection` | PgConnection.`cancelRequest(Handler<AsyncResult<Void>> handler)` Send a request cancellation message to tell the server to cancel processing request in this connection.
    `PgConnection` | PgConnection.`closeHandler(Handler<Void> handler)`
    `static void` | PgConnection.`connect(Vertx vertx, Handler<AsyncResult<PgConnection>> handler)` Like `PgConnection.connect(Vertx, PgConnectOptions, Handler)` with options build from the environment variables.
    `static void` | PgConnection.`connect(Vertx vertx, PgConnectOptions options, Handler<AsyncResult<PgConnection>> handler)` Connects to the database and returns the connection if that succeeds.
    `static void` | PgConnection.`connect(Vertx vertx, String connectionUri, Handler<AsyncResult<PgConnection>> handler)` Like `PgConnection.connect(Vertx, PgConnectOptions, Handler)` with options build from `connectionUri`.
    `PgConnection` | PgConnection.`exceptionHandler(Handler<Throwable> handler)` Set an handler called with connection errors.
    `PgConnection` | PgConnection.`notificationHandler(Handler<PgNotification> handler)` Set an handler called when the connection receives notification on a channel.
    `PgConnection` | PgConnection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)` Create a prepared query.

  - ### Uses of Handler in io.vertx.pgclient.pubsub

    Methods in io.vertx.pgclient.pubsub with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `PgSubscriber` | PgSubscriber.`closeHandler(Handler<Void> handler)` Set an handler called when the subscriber is closed.
    `PgSubscriber` | PgSubscriber.`connect(Handler<AsyncResult<Void>> handler)` Connect the subscriber to Postgres.
    `PgChannel` | PgChannel.`endHandler(Handler<Void> endHandler)` Set an handler to be called when no more notifications will be received.
    `PgChannel` | PgChannel.`exceptionHandler(Handler<Throwable> handler)`
    `PgChannel` | PgChannel.`handler(Handler<String> handler)` Set or unset an handler to be called when a the channel is notified by Postgres.
    `PgChannel` | PgChannel.`subscribeHandler(Handler<Void> handler)` Set an handler called when the the channel get subscribed.

  - ### Uses of Handler in io.vertx.rabbitmq

    Methods in io.vertx.rabbitmq with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | RabbitMQClient.`basicAck(long deliveryTag, boolean multiple, Handler<AsyncResult<JsonObject>> resultHandler)` Acknowledge one or several received messages.
    `void` | RabbitMQClient.`basicCancel(String consumerTag, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `void` | RabbitMQClient.`basicConsume(String queue, String address, boolean autoAck, Handler<AsyncResult<String>> resultHandler)` Deprecated.
    `void` | RabbitMQClient.`basicConsume(String queue, String address, boolean autoAck, Handler<AsyncResult<String>> resultHandler, Handler<Throwable> errorHandler)` Deprecated.
    `void` | RabbitMQClient.`basicConsume(String queue, String address, boolean autoAck, Handler<AsyncResult<String>> resultHandler, Handler<Throwable> errorHandler)` Deprecated.
    `void` | RabbitMQClient.`basicConsume(String queue, String address, Handler<AsyncResult<String>> resultHandler)` Deprecated.
    `default void` | RabbitMQClient.`basicConsumer(String queue, Handler<AsyncResult<RabbitMQConsumer>> resultHandler)`
    `void` | RabbitMQClient.`basicConsumer(String queue, QueueOptions options, Handler<AsyncResult<RabbitMQConsumer>> resultHandler)` Create a consumer with the given `options`.
    `void` | RabbitMQClient.`basicGet(String queue, boolean autoAck, Handler<AsyncResult<JsonObject>> resultHandler)` Retrieve a message from a queue using AMQP.Basic.Get
    `void` | RabbitMQClient.`basicNack(long deliveryTag, boolean multiple, boolean requeue, Handler<AsyncResult<JsonObject>> resultHandler)` Reject one or several received messages.
    `void` | RabbitMQClient.`basicPublish(String exchange, String routingKey, JsonObject message, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `default void` | RabbitMQClient.`basicQos(int prefetchCount, boolean global, Handler<AsyncResult<Void>> resultHandler)` Request a specific prefetchCount "quality of service" settings for this channel.
    `default void` | RabbitMQClient.`basicQos(int prefetchCount, Handler<AsyncResult<Void>> resultHandler)` Request a specific prefetchCount "quality of service" settings for this channel.
    `void` | RabbitMQClient.`basicQos(int prefetchSize, int prefetchCount, boolean global, Handler<AsyncResult<Void>> resultHandler)` Request specific "quality of service" settings.
    `void` | RabbitMQConsumer.`cancel(Handler<AsyncResult<Void>> cancelResult)` Stop message consumption from a queue.
    `void` | RabbitMQClient.`confirmSelect(Handler<AsyncResult<Void>> resultHandler)` Enables publisher acknowledgements on this channel.
    `RabbitMQConsumer` | RabbitMQConsumer.`endHandler(Handler<Void> endHandler)` Set an end handler.
    `RabbitMQConsumer` | RabbitMQConsumer.`exceptionHandler(Handler<Throwable> exceptionHandler)` Set an exception handler on the read stream.
    `void` | RabbitMQClient.`exchangeBind(String destination, String source, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Bind an exchange to an exchange.
    `void` | RabbitMQClient.`exchangeBind(String destination, String source, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Bind an exchange to an exchange.
    `void` | RabbitMQClient.`exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, Handler<AsyncResult<Void>> resultHandler)` Declare an exchange.
    `void` | RabbitMQClient.`exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, JsonObject config, Handler<AsyncResult<Void>> resultHandler)` Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
    `void` | RabbitMQClient.`exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, Map<String,String> config, Handler<AsyncResult<Void>> resultHandler)` Deprecated. Use `RabbitMQClient.exchangeDeclare(String, String, boolean, boolean, JsonObject, Handler)` instead for support for more than just String config values
    `void` | RabbitMQClient.`exchangeDelete(String exchange, Handler<AsyncResult<Void>> resultHandler)` Delete an exchange, without regard for whether it is in use or not.
    `void` | RabbitMQClient.`exchangeUnbind(String destination, String source, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Unbind an exchange from an exchange.
    `void` | RabbitMQClient.`exchangeUnbind(String destination, String source, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Unbind an exchange from an exchange.
    `RabbitMQConsumer` | RabbitMQConsumer.`handler(Handler<RabbitMQMessage> messageArrived)` Set a message handler.
    `void` | RabbitMQClient.`messageCount(String queue, Handler<AsyncResult<Long>> resultHandler)` Returns the number of messages in a queue ready to be delivered.
    `void` | RabbitMQClient.`queueBind(String queue, String exchange, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Bind a queue to an exchange
    `void` | RabbitMQClient.`queueBind(String queue, String exchange, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Bind a queue to an exchange
    `void` | RabbitMQClient.`queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Handler<AsyncResult<JsonObject>> resultHandler)` Declare a queue
    `void` | RabbitMQClient.`queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, JsonObject config, Handler<AsyncResult<JsonObject>> resultHandler)` Declare a queue with config options
    `void` | RabbitMQClient.`queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String,String> config, Handler<AsyncResult<JsonObject>> resultHandler)` Deprecated. See `RabbitMQClient.queueDeclare(String, boolean, boolean, boolean, JsonObject, Handler)` instead for support for more than just String config values
    `void` | RabbitMQClient.`queueDeclareAuto(Handler<AsyncResult<JsonObject>> resultHandler)` Actively declare a server-named exclusive, autodelete, non-durable queue.
    `void` | RabbitMQClient.`queueDelete(String queue, Handler<AsyncResult<JsonObject>> resultHandler)` Delete a queue, without regard for whether it is in use or has messages on it
    `void` | RabbitMQClient.`queueDeleteIf(String queue, boolean ifUnused, boolean ifEmpty, Handler<AsyncResult<JsonObject>> resultHandler)` Delete a queue
    `void` | RabbitMQClient.`queueUnbind(String queue, String exchange, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Unbind a queue from an exchange
    `void` | RabbitMQClient.`queueUnbind(String queue, String exchange, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Unbind a queue from an exchange
    `void` | RabbitMQClient.`start(Handler<AsyncResult<Void>> resultHandler)` Start the rabbitMQ client.
    `void` | RabbitMQClient.`stop(Handler<AsyncResult<Void>> resultHandler)` Stop the rabbitMQ client.
    `void` | RabbitMQClient.`waitForConfirms(Handler<AsyncResult<Void>> resultHandler)` Wait until all messages published since the last call have been either ack'd or nack'd by the broker.
    `void` | RabbitMQClient.`waitForConfirms(long timeout, Handler<AsyncResult<Void>> resultHandler)` Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses.

  - ### Uses of Handler in io.vertx.reactivex.amqp

    Methods in io.vertx.reactivex.amqp with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `AmqpConnection` | AmqpConnection.`close(Handler<AsyncResult<Void>> done)` Closes the AMQP connection, i.e.
    `void` | AmqpSender.`close(Handler<AsyncResult<Void>> handler)` Closes the sender.
    `void` | AmqpReceiver.`close(Handler<AsyncResult<Void>> handler)` Closes the receiver.
    `void` | AmqpClient.`close(Handler<AsyncResult<Void>> closeHandler)` Closes the client.
    `AmqpClient` | AmqpClient.`connect(Handler<AsyncResult<AmqpConnection>> connectionHandler)` Connects to the AMQP broker or router.
    `AmqpConnection` | AmqpConnection.`createAnonymousSender(Handler<AsyncResult<AmqpSender>> completionHandler)` Creates an anonymous sender.
    `AmqpConnection` | AmqpConnection.`createDynamicReceiver(Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a dynamic receiver.
    `AmqpConnection` | AmqpConnection.`createReceiver(String address, AmqpReceiverOptions receiverOptions, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consumer messages from the given address.
    `AmqpClient` | AmqpClient.`createReceiver(String address, AmqpReceiverOptions receiverOptions, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consumer messages from the given address.
    `AmqpConnection` | AmqpConnection.`createReceiver(String address, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consume messages from the given address.
    `AmqpClient` | AmqpClient.`createReceiver(String address, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consume messages from the given address.
    `AmqpConnection` | AmqpConnection.`createSender(String address, AmqpSenderOptions options, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `AmqpClient` | AmqpClient.`createSender(String address, AmqpSenderOptions options, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `AmqpConnection` | AmqpConnection.`createSender(String address, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `AmqpClient` | AmqpClient.`createSender(String address, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `WriteStream<AmqpMessage>` | AmqpSender.`drainHandler(Handler<Void> handler)` Set a drain handler on the stream.
    `void` | AmqpSender.`end(AmqpMessage data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | AmqpSender.`end(Handler<AsyncResult<Void>> handler)` Same as `WriteStream.end()` but with an `handler` called when the operation completes
    `AmqpReceiver` | AmqpReceiver.`endHandler(Handler<Void> endHandler)`
    `AmqpConnection` | AmqpConnection.`exceptionHandler(Handler<Throwable> handler)` Registers a handler called on disconnection.
    `AmqpSender` | AmqpSender.`exceptionHandler(Handler<Throwable> handler)`
    `AmqpReceiver` | AmqpReceiver.`exceptionHandler(Handler<Throwable> handler)`
    `AmqpReceiver` | AmqpReceiver.`handler(Handler<AmqpMessage> handler)`
    `void` | AmqpReceiver.`pipeTo(WriteStream<AmqpMessage> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `AmqpSender` | AmqpSender.`sendWithAck(AmqpMessage message, Handler<AsyncResult<Void>> acknowledgementHandler)` Sends an AMQP message and waits for an acknowledgement.
    `AmqpSender` | AmqpSender.`write(AmqpMessage data, Handler<AsyncResult<Void>> handler)`

  - ### Uses of Handler in io.vertx.reactivex.amqpbridge

    Methods in io.vertx.reactivex.amqpbridge with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | AmqpBridge.`close(Handler<AsyncResult<Void>> resultHandler)` Shuts the bridge down, closing the underlying connection.
    `void` | AmqpBridge.`endHandler(Handler<Void> endHandler)` Set an end handler.
    `void` | AmqpBridge.`start(String hostname, int port, Handler<AsyncResult<AmqpBridge>> resultHandler)` Starts the bridge, establishing the underlying connection.
    `void` | AmqpBridge.`start(String hostname, int port, String username, String password, Handler<AsyncResult<AmqpBridge>> resultHandler)` Starts the bridge, establishing the underlying connection.

  - ### Uses of Handler in io.vertx.reactivex.cassandra

    Methods in io.vertx.reactivex.cassandra with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `ResultSet` | ResultSet.`all(Handler<AsyncResult<List<com.datastax.driver.core.Row>>> handler)` The method should not be used concurrently with others like `ResultSet.several(int, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.util.List<com.datastax.driver.core.Row>>>)` or `ResultSet.one(io.vertx.core.Handler<io.vertx.core.AsyncResult<com.datastax.driver.core.Row>>)`.
    `CassandraClient` | CassandraClient.`close(Handler<AsyncResult<Void>> closeHandler)` Closes this client.
    `void` | Mapper.`delete(List<Object> primaryKey, Handler<AsyncResult<Void>> handler)` Asynchronous delete method based on the column values of the primary key.
    `CassandraRowStream` | CassandraRowStream.`endHandler(Handler<Void> handler)`
    `CassandraRowStream` | CassandraRowStream.`exceptionHandler(Handler<Throwable> handler)`
    `CassandraClient` | CassandraClient.`execute(com.datastax.driver.core.Statement statement, Handler<AsyncResult<ResultSet>> resultHandler)` Execute the statement and provide a handler for consuming results.
    `CassandraClient` | CassandraClient.`execute(String query, Handler<AsyncResult<ResultSet>> resultHandler)` Execute the query and provide a handler for consuming results.
    `CassandraClient` | CassandraClient.`executeWithFullFetch(com.datastax.driver.core.Statement statement, Handler<AsyncResult<List<com.datastax.driver.core.Row>>> resultHandler)` Execute the query and provide a handler for consuming results.
    `CassandraClient` | CassandraClient.`executeWithFullFetch(String query, Handler<AsyncResult<List<com.datastax.driver.core.Row>>> resultHandler)` Execute the query and provide a handler for consuming results.
    `ResultSet` | ResultSet.`fetchMoreResults(Handler<AsyncResult<Void>> handler)`
    `void` | Mapper.`get(List<Object> primaryKey, Handler<AsyncResult<T>> handler)` Asynchronous get method based on the column values of the primary key.
    `CassandraRowStream` | CassandraRowStream.`handler(Handler<com.datastax.driver.core.Row> handler)`
    `ResultSet` | ResultSet.`one(Handler<AsyncResult<com.datastax.driver.core.Row>> handler)` The method should not be used concurrently with others like `ResultSet.several(int, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.util.List<com.datastax.driver.core.Row>>>)` or `ResultSet.all(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.util.List<com.datastax.driver.core.Row>>>)`.
    `void` | CassandraRowStream.`pipeTo(WriteStream<com.datastax.driver.core.Row> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `CassandraClient` | CassandraClient.`prepare(String query, Handler<AsyncResult<com.datastax.driver.core.PreparedStatement>> resultHandler)` Prepares the provided query string.
    `CassandraClient` | CassandraClient.`queryStream(com.datastax.driver.core.Statement statement, Handler<AsyncResult<CassandraRowStream>> rowStreamHandler)` Executes the given SQL statement which returns the results of the query as a read stream.
    `CassandraClient` | CassandraClient.`queryStream(String sql, Handler<AsyncResult<CassandraRowStream>> rowStreamHandler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `void` | Mapper.`save(T entity, Handler<AsyncResult<Void>> handler)` Asynchronous save method.
    `ResultSet` | ResultSet.`several(int amount, Handler<AsyncResult<List<com.datastax.driver.core.Row>>> handler)` Fetch a specific amount of rows and notify via a handler.

  - ### Uses of Handler in io.vertx.reactivex.circuitbreaker

    Methods in io.vertx.reactivex.circuitbreaker with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `CircuitBreaker` | CircuitBreaker.`closeHandler(Handler<Void> handler)` Sets a invoked when the circuit breaker state switches to close.
    `<T> void` | CircuitBreaker.`execute(Handler<Promise<T>> command, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using the circuit breaker default fallback.
    `<T> void` | CircuitBreaker.`execute(Handler<Promise<T>> command, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using the circuit breaker default fallback.
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReport(Promise<T> resultPromise, Handler<Promise<T>> command)` Same as `CircuitBreaker.executeAndReportWithFallback(io.vertx.reactivex.core.Promise<T>, io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker default fallback.
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReportWithFallback(Promise<T> resultPromise, Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback)` Executes the given operation with the circuit breaker control.
    `<T> void` | CircuitBreaker.`executeCommand(Handler<Promise<T>> command, Handler<AsyncResult<T>> handler)` Deprecated.
    `<T> void` | CircuitBreaker.`executeCommand(Handler<Promise<T>> command, Handler<AsyncResult<T>> handler)` Deprecated.
    `<T> void` | CircuitBreaker.`executeCommandWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback, Handler<AsyncResult<T>> handler)` Deprecated.
    `<T> void` | CircuitBreaker.`executeCommandWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback, Handler<AsyncResult<T>> handler)` Deprecated.
    `<T> void` | CircuitBreaker.`executeWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
    `<T> void` | CircuitBreaker.`executeWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
    `CircuitBreaker` | CircuitBreaker.`halfOpenHandler(Handler<Void> handler)` Sets a invoked when the circuit breaker state switches to half-open.
    `CircuitBreaker` | CircuitBreaker.`openHandler(Handler<Void> handler)` Sets a invoked when the circuit breaker state switches to open.
    `<T> Single<T>` | CircuitBreaker.`rxExecute(Handler<Promise<T>> command)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using the circuit breaker default fallback.
    `<T> Single<T>` | CircuitBreaker.`rxExecuteCommand(Handler<Promise<T>> command)` Deprecated.
    `<T> Single<T>` | CircuitBreaker.`rxExecuteCommandWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback)` Deprecated.
    `<T> Single<T>` | CircuitBreaker.`rxExecuteWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.

  - ### Uses of Handler in io.vertx.reactivex.config

    Methods in io.vertx.reactivex.config with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ConfigRetriever.`getConfig(Handler<AsyncResult<JsonObject>> completionHandler)` Reads the configuration from the different and computes the final configuration.
    `void` | ConfigRetriever.`listen(Handler<ConfigChange> listener)` Registers a listener receiving configuration changes.
    `ConfigRetriever` | ConfigRetriever.`setBeforeScanHandler(Handler<Void> function)` Registers a handler called before every scan.

  - ### Uses of Handler in io.vertx.reactivex.core

    Methods in io.vertx.reactivex.core that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<AsyncResult<T>>` | Future.`completer()` Deprecated.
    `Handler<AsyncResult<CompositeFuture>>` | CompositeFuture.`completer()` Deprecated.

    Methods in io.vertx.reactivex.core with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | Vertx.`close(Handler<AsyncResult<Void>> completionHandler)` Like `Vertx.close()` but the completionHandler will be called when the close is complete
    `static void` | Vertx.`clusteredVertx(VertxOptions options, Handler<AsyncResult<Vertx>> resultHandler)` Creates a clustered instance using the specified options.
    `void` | Vertx.`deployVerticle(String name, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(java.lang.String)` but `DeploymentOptions` are provided to configure the deployment.
    `void` | Vertx.`deployVerticle(String name, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(java.lang.String)` but the completionHandler will be notified when the deployment is complete.
    `void` | Vertx.`deployVerticle(java.util.function.Supplier<Verticle> verticleSupplier, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(java.lang.String)` but `Verticle` instance is created by invoking the `verticleSupplier`.
    `void` | Vertx.`deployVerticle(Verticle verticle, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(java.lang.String)` but `DeploymentOptions` are provided to configure the deployment.
    `void` | Vertx.`deployVerticle(Verticle verticle, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(java.lang.String)` but the completionHandler will be notified when the deployment is complete.
    `TimeoutStream` | TimeoutStream.`endHandler(Handler<Void> endHandler)`
    `Context` | Context.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler called when the context runs an action throwing an uncaught throwable. When this handler is called, `Vertx.currentContext()` will return this context.
    `TimeoutStream` | TimeoutStream.`exceptionHandler(Handler<Throwable> handler)`
    `Vertx` | Vertx.`exceptionHandler(Handler<Throwable> handler)` Set a default exception handler for `Context`, set on at creation.
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Invoke `Context.executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` with order = true.
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Invoke `Context.executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` with order = true.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `Vertx.executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` called with ordered = true.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `Vertx.executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` called with ordered = true.
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `WorkerExecutor.executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` called with ordered = true.
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `WorkerExecutor.executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` called with ordered = true.
    `static <T> Future<T>` | Future.`future(Handler<Promise<T>> handler)` Create a future that hasn't completed yet and that is passed to the `handler` before it is returned.
    `TimeoutStream` | TimeoutStream.`handler(Handler<Long> handler)`
    `CompositeFuture` | CompositeFuture.`onComplete(Handler<AsyncResult<CompositeFuture>> handler)`
    `Future<T>` | Future.`onComplete(Handler<AsyncResult<T>> handler)` Add a handler to be notified of the result.
    `Future<T>` | Future.`onFailure(Handler<Throwable> handler)` Add a handler to be notified of the failed result.
    `CompositeFuture` | CompositeFuture.`onFailure(Handler<Throwable> handler)`
    `CompositeFuture` | CompositeFuture.`onSuccess(Handler<CompositeFuture> handler)`
    `Future<T>` | Future.`onSuccess(Handler<T> handler)` Add a handler to be notified of the succeeded result.
    `void` | TimeoutStream.`pipeTo(WriteStream<Long> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | Context.`runOnContext(Handler<Void> action)` Run the specified action asynchronously on the same context, some time after the current execution has completed.
    `void` | Vertx.`runOnContext(Handler<Void> action)` Puts the handler on the event queue for the current context so it will be run asynchronously ASAP after all preceeding events have been handled.
    `<T> Maybe<T>` | Context.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)` Invoke `Context.executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` with order = true.
    `<T> Maybe<T>` | Vertx.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)` Like `Vertx.executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` called with ordered = true.
    `<T> Maybe<T>` | WorkerExecutor.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)` Like `WorkerExecutor.executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` called with ordered = true.
    `<T> Maybe<T>` | Context.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Safely execute some blocking code.
    `<T> Maybe<T>` | Vertx.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Safely execute some blocking code.
    `<T> Maybe<T>` | WorkerExecutor.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Safely execute some blocking code.
    `CompositeFuture` | CompositeFuture.`setHandler(Handler<AsyncResult<CompositeFuture>> handler)` Deprecated.
    `Future<T>` | Future.`setHandler(Handler<AsyncResult<T>> handler)` Deprecated.
    `long` | Vertx.`setPeriodic(long delay, Handler<Long> handler)` Set a periodic timer to fire every `delay` milliseconds, at which point `handler` will be called with the id of the timer.
    `long` | Vertx.`setTimer(long delay, Handler<Long> handler)` Set a one-shot timer to fire after `delay` milliseconds, at which point `handler` will be called with the id of the timer.
    `void` | Vertx.`undeploy(String deploymentID, Handler<AsyncResult<Void>> completionHandler)` Like `#undeploy(String)` but the completionHandler will be notified when the undeployment is complete.

  - ### Uses of Handler in io.vertx.reactivex.core.datagram

    Methods in io.vertx.reactivex.core.datagram with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `DatagramSocket` | DatagramSocket.`blockMulticastGroup(String multicastAddress, String sourceToBlock, Handler<AsyncResult<DatagramSocket>> handler)` Block the given address for the given multicast address and notifies the once the operation completes.
    `DatagramSocket` | DatagramSocket.`blockMulticastGroup(String multicastAddress, String networkInterface, String sourceToBlock, Handler<AsyncResult<DatagramSocket>> handler)` Block the given address for the given multicast address on the given network interface and notifies the once the operation completes.
    `void` | DatagramSocket.`close(Handler<AsyncResult<Void>> handler)` Closes the `DatagramSocket` implementation asynchronous and notifies the handler once done.
    `DatagramSocket` | DatagramSocket.`endHandler(Handler<Void> endHandler)`
    `DatagramSocket` | DatagramSocket.`exceptionHandler(Handler<Throwable> handler)`
    `DatagramSocket` | DatagramSocket.`handler(Handler<DatagramPacket> handler)`
    `DatagramSocket` | DatagramSocket.`listen(int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Start listening on the given port and host.
    `DatagramSocket` | DatagramSocket.`listenMulticastGroup(String multicastAddress, Handler<AsyncResult<DatagramSocket>> handler)` Joins a multicast group and listens for packets send to it.
    `DatagramSocket` | DatagramSocket.`listenMulticastGroup(String multicastAddress, String networkInterface, String source, Handler<AsyncResult<DatagramSocket>> handler)` Joins a multicast group and listens for packets send to it on the given network interface.
    `void` | DatagramSocket.`pipeTo(WriteStream<DatagramPacket> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `DatagramSocket` | DatagramSocket.`send(Buffer packet, int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Write the given `Buffer` to the `SocketAddress`.
    `DatagramSocket` | DatagramSocket.`send(String str, int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Write the given `String` to the `SocketAddress` using UTF8 encoding.
    `DatagramSocket` | DatagramSocket.`send(String str, String enc, int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Write the given `String` to the `SocketAddress` using the given encoding.
    `DatagramSocket` | DatagramSocket.`unlistenMulticastGroup(String multicastAddress, Handler<AsyncResult<DatagramSocket>> handler)` Leaves a multicast group and stops listening for packets send to it.
    `DatagramSocket` | DatagramSocket.`unlistenMulticastGroup(String multicastAddress, String networkInterface, String source, Handler<AsyncResult<DatagramSocket>> handler)` Leaves a multicast group and stops listening for packets send to it on the given network interface.

  - ### Uses of Handler in io.vertx.reactivex.core.dns

    Methods in io.vertx.reactivex.core.dns with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `DnsClient` | DnsClient.`lookup(String name, Handler<AsyncResult<String>> handler)` Try to lookup the A (ipv4) or AAAA (ipv6) record for the given name.
    `DnsClient` | DnsClient.`lookup4(String name, Handler<AsyncResult<String>> handler)` Try to lookup the A (ipv4) record for the given name.
    `DnsClient` | DnsClient.`lookup6(String name, Handler<AsyncResult<String>> handler)` Try to lookup the AAAA (ipv6) record for the given name.
    `DnsClient` | DnsClient.`resolveA(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve all A (ipv4) records for the given name.
    `DnsClient` | DnsClient.`resolveAAAA(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve all AAAA (ipv6) records for the given name.
    `DnsClient` | DnsClient.`resolveCNAME(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve the CNAME record for the given name.
    `DnsClient` | DnsClient.`resolveMX(String name, Handler<AsyncResult<List<MxRecord>>> handler)` Try to resolve the MX records for the given name.
    `DnsClient` | DnsClient.`resolveNS(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve the NS records for the given name.
    `DnsClient` | DnsClient.`resolvePTR(String name, Handler<AsyncResult<String>> handler)` Try to resolve the PTR record for the given name.
    `DnsClient` | DnsClient.`resolveSRV(String name, Handler<AsyncResult<List<SrvRecord>>> handler)` Try to resolve the SRV records for the given name.
    `DnsClient` | DnsClient.`resolveTXT(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve the TXT records for the given name.
    `DnsClient` | DnsClient.`reverseLookup(String ipaddress, Handler<AsyncResult<String>> handler)` Try to do a reverse lookup of an IP address.

  - ### Uses of Handler in io.vertx.reactivex.core.eventbus

    Methods in io.vertx.reactivex.core.eventbus with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `<T> EventBus` | EventBus.`addInboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Add an interceptor that will be called whenever a message is received by Vert.x
    `<T> EventBus` | EventBus.`addOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Add an interceptor that will be called whenever a message is sent from Vert.x
    `void` | MessageProducer.`close(Handler<AsyncResult<Void>> handler)` Same as `MessageProducer.close()` but with an `handler` called when the operation completes
    `void` | MessageConsumer.`completionHandler(Handler<AsyncResult<Void>> completionHandler)` Optional method which can be called to indicate when the registration has been propagated across the cluster.
    `<T> MessageConsumer<T>` | EventBus.`consumer(String address, Handler<Message<T>> handler)` Create a consumer and register it against the specified address.
    `MessageProducer<T>` | MessageProducer.`drainHandler(Handler<Void> handler)`
    `void` | MessageProducer.`end(Handler<AsyncResult<Void>> handler)` Closes the producer, calls `MessageProducer.close()`
    `void` | MessageProducer.`end(T data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `MessageConsumer<T>` | MessageConsumer.`endHandler(Handler<Void> endHandler)`
    `MessageConsumer<T>` | MessageConsumer.`exceptionHandler(Handler<Throwable> handler)`
    `MessageProducer<T>` | MessageProducer.`exceptionHandler(Handler<Throwable> handler)`
    `MessageConsumer<T>` | MessageConsumer.`handler(Handler<Message<T>> handler)`
    `<T> MessageConsumer<T>` | EventBus.`localConsumer(String address, Handler<Message<T>> handler)` Like `EventBus.consumer(java.lang.String)` but the address won't be propagated across the cluster.
    `void` | MessageConsumer.`pipeTo(WriteStream<Message<T>> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `<T> EventBus` | EventBus.`removeInboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Remove an interceptor that was added by `EventBus.addInboundInterceptor(io.vertx.core.Handler<io.vertx.reactivex.core.eventbus.DeliveryContext<T>>)`
    `<T> EventBus` | EventBus.`removeOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Remove an interceptor that was added by `EventBus.addOutboundInterceptor(io.vertx.core.Handler<io.vertx.reactivex.core.eventbus.DeliveryContext<T>>)`
    `<R> void` | Message.`reply(Object message, DeliveryOptions options, Handler<AsyncResult<Message<R>>> replyHandler)` Deprecated.
    `<R> void` | Message.`reply(Object message, Handler<AsyncResult<Message<R>>> replyHandler)` Deprecated.
    `<R> void` | Message.`replyAndRequest(Object message, DeliveryOptions options, Handler<AsyncResult<Message<R>>> replyHandler)` Like but specifying `options` that can be used to configure the delivery.
    `<R> void` | Message.`replyAndRequest(Object message, Handler<AsyncResult<Message<R>>> replyHandler)` Reply to this message, specifying a `replyHandler` for the reply - i.e.
    `<T> EventBus` | EventBus.`request(String address, Object message, DeliveryOptions options, Handler<AsyncResult<Message<T>>> replyHandler)` Like but specifying `options` that can be used to configure the delivery.
    `<T> EventBus` | EventBus.`request(String address, Object message, Handler<AsyncResult<Message<T>>> replyHandler)` Sends a message and and specify a `replyHandler` that will be called if the recipient subsequently replies to the message.
    `<T> EventBus` | EventBus.`send(String address, Object message, DeliveryOptions options, Handler<AsyncResult<Message<T>>> replyHandler)` Deprecated.
    `<T> EventBus` | EventBus.`send(String address, Object message, Handler<AsyncResult<Message<T>>> replyHandler)` Deprecated.
    `<R> MessageProducer<T>` | MessageProducer.`send(T message, Handler<AsyncResult<Message<R>>> replyHandler)` Deprecated.
    `void` | MessageConsumer.`unregister(Handler<AsyncResult<Void>> completionHandler)` Unregisters the handler which created this registration
    `MessageProducer<T>` | MessageProducer.`write(T data, Handler<AsyncResult<Void>> handler)`

  - ### Uses of Handler in io.vertx.reactivex.core.file

    Methods in io.vertx.reactivex.core.file with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `FileSystem` | FileSystem.`chmod(String path, String perms, Handler<AsyncResult<Void>> handler)` Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `FileSystem` | FileSystem.`chmodRecursive(String path, String perms, String dirPerms, Handler<AsyncResult<Void>> handler)` Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `FileSystem` | FileSystem.`chown(String path, String user, String group, Handler<AsyncResult<Void>> handler)` Change the ownership on the file represented by `path` to `user` and {code group}, asynchronously.
    `void` | AsyncFile.`close(Handler<AsyncResult<Void>> handler)` Close the file.
    `FileSystem` | FileSystem.`copy(String from, String to, CopyOptions options, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`copy(String from, String to, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`copyRecursive(String from, String to, boolean recursive, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`createFile(String path, Handler<AsyncResult<Void>> handler)` Creates an empty file with the specified `path`, asynchronously.
    `FileSystem` | FileSystem.`createFile(String path, String perms, Handler<AsyncResult<Void>> handler)` Creates an empty file with the specified `path` and permissions `perms`, asynchronously.
    `FileSystem` | FileSystem.`createTempDirectory(String prefix, Handler<AsyncResult<String>> handler)` Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempDirectory(String prefix, String perms, Handler<AsyncResult<String>> handler)` Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempDirectory(String dir, String prefix, String perms, Handler<AsyncResult<String>> handler)` Creates a new directory in the directory provided by the path `path`, using the given prefix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempFile(String prefix, String suffix, Handler<AsyncResult<String>> handler)` Creates a new file in the default temporary-file directory, using the given prefix and suffix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempFile(String prefix, String suffix, String perms, Handler<AsyncResult<String>> handler)` Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempFile(String dir, String prefix, String suffix, String perms, Handler<AsyncResult<String>> handler)` Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`delete(String path, Handler<AsyncResult<Void>> handler)` Deletes the file represented by the specified `path`, asynchronously.
    `FileSystem` | FileSystem.`deleteRecursive(String path, boolean recursive, Handler<AsyncResult<Void>> handler)` Deletes the file represented by the specified `path`, asynchronously.
    `AsyncFile` | AsyncFile.`drainHandler(Handler<Void> handler)`
    `void` | AsyncFile.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | AsyncFile.`end(Handler<AsyncResult<Void>> handler)` Close the file, see `AsyncFile.close()`.
    `AsyncFile` | AsyncFile.`endHandler(Handler<Void> endHandler)`
    `AsyncFile` | AsyncFile.`exceptionHandler(Handler<Throwable> handler)`
    `FileSystem` | FileSystem.`exists(String path, Handler<AsyncResult<Boolean>> handler)` Determines whether the file as specified by the path `path` exists, asynchronously.
    `AsyncFile` | AsyncFile.`flush(Handler<AsyncResult<Void>> handler)` Same as `AsyncFile.flush()` but the handler will be called when the flush is complete or if an error occurs
    `FileSystem` | FileSystem.`fsProps(String path, Handler<AsyncResult<FileSystemProps>> handler)` Returns properties of the file-system being used by the specified `path`, asynchronously.
    `AsyncFile` | AsyncFile.`handler(Handler<Buffer> handler)`
    `FileSystem` | FileSystem.`link(String link, String existing, Handler<AsyncResult<Void>> handler)` Create a hard link on the file system from `link` to `existing`, asynchronously.
    `FileSystem` | FileSystem.`lprops(String path, Handler<AsyncResult<FileProps>> handler)` Obtain properties for the link represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`mkdir(String path, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`mkdir(String path, String perms, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`mkdirs(String path, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path` and any non existent parents, asynchronously.
    `FileSystem` | FileSystem.`mkdirs(String path, String perms, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path` and any non existent parents, asynchronously.
    `FileSystem` | FileSystem.`move(String from, String to, CopyOptions options, Handler<AsyncResult<Void>> handler)` Move a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`move(String from, String to, Handler<AsyncResult<Void>> handler)` Move a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`open(String path, OpenOptions options, Handler<AsyncResult<AsyncFile>> handler)` Open the file represented by `path`, asynchronously.
    `void` | AsyncFile.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `FileSystem` | FileSystem.`props(String path, Handler<AsyncResult<FileProps>> handler)` Obtain properties for the file represented by `path`, asynchronously.
    `AsyncFile` | AsyncFile.`read(Buffer buffer, int offset, long position, int length, Handler<AsyncResult<Buffer>> handler)` Reads `length` bytes of data from the file at position `position` in the file, asynchronously.
    `FileSystem` | FileSystem.`readDir(String path, Handler<AsyncResult<List<String>>> handler)` Read the contents of the directory specified by `path`, asynchronously.
    `FileSystem` | FileSystem.`readDir(String path, String filter, Handler<AsyncResult<List<String>>> handler)` Read the contents of the directory specified by `path`, asynchronously.
    `FileSystem` | FileSystem.`readFile(String path, Handler<AsyncResult<Buffer>> handler)` Reads the entire file as represented by the path `path` as a , asynchronously.
    `FileSystem` | FileSystem.`readSymlink(String link, Handler<AsyncResult<String>> handler)` Returns the path representing the file that the symbolic link specified by `link` points to, asynchronously.
    `FileSystem` | FileSystem.`symlink(String link, String existing, Handler<AsyncResult<Void>> handler)` Create a symbolic link on the file system from `link` to `existing`, asynchronously.
    `FileSystem` | FileSystem.`truncate(String path, long len, Handler<AsyncResult<Void>> handler)` Truncate the file represented by `path` to length `len` in bytes, asynchronously.
    `FileSystem` | FileSystem.`unlink(String link, Handler<AsyncResult<Void>> handler)` Unlinks the link on the file system represented by the path `link`, asynchronously.
    `AsyncFile` | AsyncFile.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as `AsyncFile.write(io.vertx.reactivex.core.buffer.Buffer)` but with an `handler` called when the operation completes
    `AsyncFile` | AsyncFile.`write(Buffer buffer, long position, Handler<AsyncResult<Void>> handler)` Write a `Buffer` to the file at position `position` in the file, asynchronously.
    `FileSystem` | FileSystem.`writeFile(String path, Buffer data, Handler<AsyncResult<Void>> handler)` Creates the file, and writes the specified `Buffer data` to the file represented by the path `path`, asynchronously.

  - ### Uses of Handler in io.vertx.reactivex.core.http

    Methods in io.vertx.reactivex.core.http with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `WebSocketBase` | ServerWebSocket.`binaryMessageHandler(Handler<Buffer> handler)` Set a binary message handler on the connection.
    `WebSocketBase` | WebSocket.`binaryMessageHandler(Handler<Buffer> handler)` Set a binary message handler on the connection.
    `WebSocketBase` | WebSocketBase.`binaryMessageHandler(Handler<Buffer> handler)` Set a binary message handler on the connection.
    `HttpServerResponse` | HttpServerResponse.`bodyEndHandler(Handler<Void> handler)` Provides a handler that will be called after the last part of the body is written to the wire.
    `HttpClientResponse` | HttpClientResponse.`bodyHandler(Handler<Buffer> bodyHandler)` Convenience method for receiving the entire request body in one piece.
    `HttpServerRequest` | HttpServerRequest.`bodyHandler(Handler<Buffer> bodyHandler)` Convenience method for receiving the entire request body in one piece.
    `void` | ServerWebSocket.`close(Handler<AsyncResult<Void>> handler)` Same as `ServerWebSocket.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpServer.`close(Handler<AsyncResult<Void>> completionHandler)` Like `HttpServer.close()` but supplying a handler that will be called when the server is actually closed (or has failed).
    `void` | WebSocket.`close(Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close()` but with an `handler` called when the operation completes
    `void` | WebSocketBase.`close(Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close()` but with an `handler` called when the operation completes
    `void` | ServerWebSocket.`close(short statusCode, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close()` but with an `handler` called when the operation completes
    `void` | WebSocket.`close(short statusCode, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close()` but with an `handler` called when the operation completes
    `void` | WebSocketBase.`close(short statusCode, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close()` but with an `handler` called when the operation completes
    `void` | ServerWebSocket.`close(short statusCode, String reason, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | WebSocket.`close(short statusCode, String reason, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | WebSocketBase.`close(short statusCode, String reason, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `HttpServerResponse` | HttpServerResponse.`closeHandler(Handler<Void> handler)` Set a close handler for the response, this is called when the underlying connection is closed and the response was still using the connection.
    `ServerWebSocket` | ServerWebSocket.`closeHandler(Handler<Void> handler)`
    `WebSocket` | WebSocket.`closeHandler(Handler<Void> handler)`
    `HttpConnection` | HttpConnection.`closeHandler(Handler<Void> handler)` Set a close handler.
    `WebSocketBase` | WebSocketBase.`closeHandler(Handler<Void> handler)` Set a close handler.
    `HttpServer` | HttpServer.`connectionHandler(Handler<HttpConnection> handler)` Set a connection handler for the server.
    `HttpClientRequest` | HttpClientRequest.`connectionHandler(Handler<HttpConnection> handler)` Deprecated.
    `HttpClient` | HttpClient.`connectionHandler(Handler<HttpConnection> handler)` Set a connection handler for the client.
    `HttpClientRequest` | HttpClientRequest.`continueHandler(Handler<Void> handler)` If you send an HTTP request with the header `Expect` set to the value `100-continue` and the server responds with an interim HTTP response with a status code of `100` and a continue handler has been set using this method, then the `handler` will be called.
    `HttpClientResponse` | HttpClientResponse.`customFrameHandler(Handler<HttpFrame> handler)` Set an custom frame handler.
    `HttpServerRequest` | HttpServerRequest.`customFrameHandler(Handler<HttpFrame> handler)` Set a custom frame handler.
    `HttpClientRequest` | HttpClient.`delete(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`delete(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`delete(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`delete(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`deleteAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpServerResponse` | HttpServerResponse.`drainHandler(Handler<Void> handler)`
    `ServerWebSocket` | ServerWebSocket.`drainHandler(Handler<Void> handler)`
    `HttpClientRequest` | HttpClientRequest.`drainHandler(Handler<Void> handler)`
    `WebSocket` | WebSocket.`drainHandler(Handler<Void> handler)`
    `WebSocketBase` | WebSocketBase.`drainHandler(Handler<Void> handler)`
    `void` | HttpServerResponse.`end(Buffer chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | ServerWebSocket.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`end(Buffer chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end(java.lang.String)` but with an `handler` called when the operation completes
    `void` | WebSocket.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | WebSocketBase.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`end(Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | ServerWebSocket.`end(Handler<AsyncResult<Void>> handler)` Calls `WebSocketBase.close()`
    `void` | HttpClientRequest.`end(Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end(java.lang.String)` but with an `handler` called when the operation completes
    `void` | WebSocket.`end(Handler<AsyncResult<Void>> handler)` Calls `WebSocketBase.close()`
    `void` | WebSocketBase.`end(Handler<AsyncResult<Void>> handler)` Calls `WebSocketBase.close()`
    `void` | HttpServerResponse.`end(String chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`end(String chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end(java.lang.String)` but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`end(String chunk, String enc, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`end(String chunk, String enc, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end(java.lang.String)` but with an `handler` called when the operation completes
    `HttpClientResponse` | HttpClientResponse.`endHandler(Handler<Void> endHandler)`
    `HttpServerResponse` | HttpServerResponse.`endHandler(Handler<Void> handler)` Set an end handler for the response.
    `ServerWebSocket` | ServerWebSocket.`endHandler(Handler<Void> endHandler)`
    `HttpClientRequest` | HttpClientRequest.`endHandler(Handler<Void> endHandler)` Deprecated.
    `WebSocket` | WebSocket.`endHandler(Handler<Void> endHandler)`
    `HttpServerFileUpload` | HttpServerFileUpload.`endHandler(Handler<Void> endHandler)`
    `HttpServerRequest` | HttpServerRequest.`endHandler(Handler<Void> endHandler)`
    `WebSocketBase` | WebSocketBase.`endHandler(Handler<Void> endHandler)`
    `HttpClientResponse` | HttpClientResponse.`exceptionHandler(Handler<Throwable> handler)`
    `HttpServerResponse` | HttpServerResponse.`exceptionHandler(Handler<Throwable> handler)`
    `ServerWebSocket` | ServerWebSocket.`exceptionHandler(Handler<Throwable> handler)`
    `HttpServer` | HttpServer.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler called for socket errors happening before the HTTP connection is established, e.g during the TLS handshake.
    `HttpClientRequest` | HttpClientRequest.`exceptionHandler(Handler<Throwable> handler)`
    `WebSocket` | WebSocket.`exceptionHandler(Handler<Throwable> handler)`
    `HttpConnection` | HttpConnection.`exceptionHandler(Handler<Throwable> handler)` Set an handler called when a connection error happens
    `HttpServerFileUpload` | HttpServerFileUpload.`exceptionHandler(Handler<Throwable> handler)`
    `HttpServerRequest` | HttpServerRequest.`exceptionHandler(Handler<Throwable> handler)`
    `WebSocketBase` | WebSocketBase.`exceptionHandler(Handler<Throwable> handler)`
    `ServerWebSocket` | ServerWebSocket.`frameHandler(Handler<WebSocketFrame> handler)`
    `WebSocket` | WebSocket.`frameHandler(Handler<WebSocketFrame> handler)`
    `WebSocketBase` | WebSocketBase.`frameHandler(Handler<WebSocketFrame> handler)` Set a frame handler on the connection.
    `HttpClientRequest` | HttpClient.`get(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`get(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`get(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`get(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`getAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClient` | HttpClient.`getNow(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClient` | HttpClient.`getNow(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClient` | HttpClient.`getNow(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClient` | HttpClient.`getNow(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpConnection` | HttpConnection.`goAwayHandler(Handler<GoAway> handler)` Set an handler called when a frame is received.
    `HttpClientResponse` | HttpClientResponse.`handler(Handler<Buffer> handler)`
    `ServerWebSocket` | ServerWebSocket.`handler(Handler<Buffer> handler)`
    `WebSocket` | WebSocket.`handler(Handler<Buffer> handler)`
    `HttpServerFileUpload` | HttpServerFileUpload.`handler(Handler<Buffer> handler)`
    `HttpServerRequest` | HttpServerRequest.`handler(Handler<Buffer> handler)`
    `WebSocketBase` | WebSocketBase.`handler(Handler<Buffer> handler)`
    `HttpClientRequest` | HttpClientRequest.`handler(Handler<HttpClientResponse> handler)` Deprecated.
    `HttpClientRequest` | HttpClient.`head(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`head(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`head(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`head(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`headAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpServerResponse` | HttpServerResponse.`headersEndHandler(Handler<Void> handler)` Provide a handler that will be called just before the headers are written to the wire.
    `HttpClient` | HttpClient.`headNow(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClient` | HttpClient.`headNow(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClient` | HttpClient.`headNow(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClient` | HttpClient.`headNow(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpServer` | HttpServer.`listen(Handler<AsyncResult<HttpServer>> listenHandler)` Like `HttpServer.listen()` but supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpServer` | HttpServer.`listen(int port, Handler<AsyncResult<HttpServer>> listenHandler)` Like `HttpServer.listen()` but supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpServer` | HttpServer.`listen(int port, String host, Handler<AsyncResult<HttpServer>> listenHandler)` Like `HttpServer.listen()` but supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpServer` | HttpServer.`listen(SocketAddress address, Handler<AsyncResult<HttpServer>> listenHandler)` Tell the server to start listening on the given address supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpClientRequest` | HttpClient.`options(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`options(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`options(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`options(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`optionsAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClient` | HttpClient.`optionsNow(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClient` | HttpClient.`optionsNow(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClient` | HttpClient.`optionsNow(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClient` | HttpClient.`optionsNow(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpConnection` | HttpConnection.`ping(Buffer data, Handler<AsyncResult<Buffer>> pongHandler)` Send a frame to the remote endpoint.
    `HttpConnection` | HttpConnection.`pingHandler(Handler<Buffer> handler)` Set an handler notified when a frame is received from the remote endpoint.
    `void` | HttpClientResponse.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | ServerWebSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | WebSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | HttpServerFileUpload.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | HttpServerRequest.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | WebSocketBase.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | HttpClientRequest.`pipeTo(WriteStream<HttpClientResponse> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `WebSocketBase` | ServerWebSocket.`pongHandler(Handler<Buffer> handler)` Set a pong frame handler on the connection.
    `WebSocketBase` | WebSocket.`pongHandler(Handler<Buffer> handler)` Set a pong frame handler on the connection.
    `WebSocketBase` | WebSocketBase.`pongHandler(Handler<Buffer> handler)` Set a pong frame handler on the connection.
    `HttpClientRequest` | HttpClient.`post(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`post(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`post(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`post(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`postAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler)` Like `HttpServerResponse.push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServerResponse>>)` with the host copied from the current request.
    `HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler)` Like `HttpServerResponse.push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServerResponse>>)` with the host copied from the current request.
    `HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, String host, String path, Handler<AsyncResult<HttpServerResponse>> handler)` Like `HttpServerResponse.push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServerResponse>>)` with no headers.
    `HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, String host, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler)` Push a response to the client. The `handler` will be notified with a success when the push can be sent and with a failure when the client has disabled push or reset the push before it has been sent. The `handler` may be queued if the client has reduced the maximum number of streams the server can push concurrently. Push can be sent only for peer initiated streams and if the response is not ended.
    `HttpClientRequest` | HttpClientRequest.`pushHandler(Handler<HttpClientRequest> handler)` Set a push handler for this request. The handler is called when the client receives a push promise from the server.
    `HttpClientRequest` | HttpClient.`put(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`put(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`put(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`put(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`putAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpConnection` | HttpConnection.`remoteSettingsHandler(Handler<Http2Settings> handler)` Set an handler that is called when remote endpoint `Http2Settings` are updated.
    `HttpClientRequest` | HttpClient.`request(HttpMethod method, int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`request(HttpMethod method, RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`request(HttpMethod method, SocketAddress serverAddress, int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Like `HttpClient.request(io.vertx.core.http.HttpMethod, io.vertx.reactivex.core.net.SocketAddress, io.vertx.core.http.RequestOptions)` using the `serverAddress` parameter to connect to the server instead of the `absoluteURI` parameter.
    `HttpClientRequest` | HttpClient.`request(HttpMethod method, SocketAddress serverAddress, RequestOptions options, Handler<HttpClientResponse> responseHandler)` Like `HttpClient.request(io.vertx.core.http.HttpMethod, io.vertx.reactivex.core.net.SocketAddress, io.vertx.core.http.RequestOptions)` using the `serverAddress` parameter to connect to the server instead of the `absoluteURI` parameter.
    `HttpClientRequest` | HttpClient.`request(HttpMethod method, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`request(HttpMethod method, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`requestAbs(HttpMethod method, SocketAddress serverAddress, String absoluteURI, Handler<HttpClientResponse> responseHandler)` Like `HttpClient.requestAbs(io.vertx.core.http.HttpMethod, java.lang.String)` using the `serverAddress` parameter to connect to the server instead of the `absoluteURI` parameter.
    `HttpClientRequest` | HttpClient.`requestAbs(HttpMethod method, String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpServer` | HttpServer.`requestHandler(Handler<HttpServerRequest> handler)` Set the request handler for the server to `requestHandler`.
    `HttpServerResponse` | HttpServerResponse.`sendFile(String filename, Handler<AsyncResult<Void>> resultHandler)` Like `HttpServerResponse.sendFile(java.lang.String)` but providing a handler which will be notified once the file has been completely written to the wire.
    `HttpServerResponse` | HttpServerResponse.`sendFile(String filename, long offset, Handler<AsyncResult<Void>> resultHandler)` Like `HttpServerResponse.sendFile(java.lang.String)` but providing a handler which will be notified once the file has been completely written to the wire.
    `HttpServerResponse` | HttpServerResponse.`sendFile(String filename, long offset, long length, Handler<AsyncResult<Void>> resultHandler)` Like `HttpServerResponse.sendFile(java.lang.String)` but providing a handler which will be notified once the file has been completely written to the wire.
    `HttpClientRequest` | HttpClientRequest.`sendHead(Handler<HttpVersion> completionHandler)` Like `HttpClientRequest.sendHead()` but with an handler after headers have been sent.
    `void` | ServerWebSocket.`setHandshake(Future<Integer> future, Handler<AsyncResult<Integer>> handler)` Set an asynchronous result for the handshake, upon completion of the specified `future`, the WebSocket will either be accepted when the `future` succeeds with the HTTP status code rejected when the `future` is succeeds with an HTTP status code different than rejected when the `future` fails with the HTTP status code `500` The provided future might be completed by the WebSocket itself, e.g calling the `ServerWebSocket.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` method will try to accept the handshake and close the WebSocket afterward.
    `HttpConnection` | HttpConnection.`shutdownHandler(Handler<Void> handler)` Set an handler called when a frame has been sent or received and all connections are closed.
    `HttpClientResponse` | HttpClientResponse.`streamPriorityHandler(Handler<StreamPriority> handler)` Set an handler for stream priority changes.
    `HttpServerRequest` | HttpServerRequest.`streamPriorityHandler(Handler<StreamPriority> handler)` Set an handler for stream priority changes
    `WebSocketBase` | ServerWebSocket.`textMessageHandler(Handler<String> handler)` Set a text message handler on the connection.
    `WebSocketBase` | WebSocket.`textMessageHandler(Handler<String> handler)` Set a text message handler on the connection.
    `WebSocketBase` | WebSocketBase.`textMessageHandler(Handler<String> handler)` Set a text message handler on the connection.
    `HttpConnection` | HttpConnection.`updateSettings(Http2Settings settings, Handler<AsyncResult<Void>> completionHandler)` Send to the remote endpoint an update of this endpoint settings The `completionHandler` will be notified when the remote endpoint has acknowledged the settings.
    `HttpServerRequest` | HttpServerRequest.`uploadHandler(Handler<HttpServerFileUpload> uploadHandler)` Set an upload handler.
    `void` | HttpClient.`webSocket(int port, String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket to the specified port, host and relative request URI
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(RequestOptions options, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(RequestOptions options, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(RequestOptions options, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `void` | HttpClient.`webSocket(String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket at the relative request URI using the default host and port
    `HttpClient` | HttpClient.`websocket(String requestURI, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `void` | HttpClient.`webSocket(String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket to the host and relative request URI and default port
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `void` | HttpClient.`webSocket(WebSocketConnectOptions options, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket with the specified options.
    `void` | HttpClient.`webSocketAbs(String url, MultiMap headers, WebsocketVersion version, List<String> subProtocols, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket with the specified absolute url, with the specified headers, using the specified version of WebSockets, and the specified WebSocket sub protocols.
    `HttpClient` | HttpClient.`websocketAbs(String url, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocketAbs(String url, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpServer` | HttpServer.`websocketHandler(Handler<ServerWebSocket> handler)` Deprecated.
    `HttpServer` | HttpServer.`webSocketHandler(Handler<ServerWebSocket> handler)` Set the WebSocket handler for the server to `wsHandler`.
    `HttpServerResponse` | HttpServerResponse.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.write(io.vertx.reactivex.core.buffer.Buffer)` but with an `handler` called when the operation completes
    `ServerWebSocket` | ServerWebSocket.`write(Buffer data, Handler<AsyncResult<Void>> handler)`
    `HttpClientRequest` | HttpClientRequest.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.write(io.vertx.reactivex.core.buffer.Buffer)` but with an `handler` called when the operation completes
    `WebSocket` | WebSocket.`write(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`write(Buffer data, Handler<AsyncResult<Void>> handler)`
    `HttpServerResponse` | HttpServerResponse.`write(String chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.write(io.vertx.reactivex.core.buffer.Buffer)` but with an `handler` called when the operation completes
    `HttpClientRequest` | HttpClientRequest.`write(String chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.write(io.vertx.reactivex.core.buffer.Buffer)` but with an `handler` called when the operation completes
    `HttpServerResponse` | HttpServerResponse.`write(String chunk, String enc, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.write(io.vertx.reactivex.core.buffer.Buffer)` but with an `handler` called when the operation completes
    `HttpClientRequest` | HttpClientRequest.`write(String chunk, String enc, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.write(io.vertx.reactivex.core.buffer.Buffer)` but with an `handler` called when the operation completes
    `ServerWebSocket` | ServerWebSocket.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeBinaryMessage(io.vertx.reactivex.core.buffer.Buffer)` but with an `handler` called when the operation completes
    `ServerWebSocket` | ServerWebSocket.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeFinalBinaryFrame(io.vertx.reactivex.core.buffer.Buffer)` but with an `handler` called when the operation completes
    `ServerWebSocket` | ServerWebSocket.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeFinalTextFrame(java.lang.String)` but with an `handler` called when the operation completes
    `ServerWebSocket` | ServerWebSocket.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeFrame(io.vertx.reactivex.core.http.WebSocketFrame)` but with an `handler` called when the operation completes
    `ServerWebSocket` | ServerWebSocket.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeTextMessage(java.lang.String)` but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.reactivex.core.net

    Methods in io.vertx.reactivex.core.net with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | NetSocket.`close(Handler<AsyncResult<Void>> handler)` Close the NetSocket and notify the `handler` when the operation completes.
    `void` | NetServer.`close(Handler<AsyncResult<Void>> completionHandler)` Like `NetServer.close()` but supplying a handler that will be notified when close is complete.
    `NetSocket` | NetSocket.`closeHandler(Handler<Void> handler)` Set a handler that will be called when the NetSocket is closed
    `NetClient` | NetClient.`connect(int port, String host, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `port` and `host`.
    `NetClient` | NetClient.`connect(int port, String host, String serverName, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `port` and `host`.
    `NetClient` | NetClient.`connect(SocketAddress remoteAddress, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `remoteAddress`.
    `NetClient` | NetClient.`connect(SocketAddress remoteAddress, String serverName, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `remoteAddress`.
    `NetServer` | NetServer.`connectHandler(Handler<NetSocket> handler)` Supply a connect handler for this server.
    `NetSocket` | NetSocket.`drainHandler(Handler<Void> handler)`
    `void` | NetSocket.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | NetSocket.`end(Handler<AsyncResult<Void>> handler)` Calls `NetSocket.end(io.vertx.reactivex.core.buffer.Buffer)`
    `NetSocket` | NetSocket.`endHandler(Handler<Void> endHandler)` This handler might be called after the close handler when the socket is paused and there are still buffers to deliver.
    `NetSocket` | NetSocket.`exceptionHandler(Handler<Throwable> handler)`
    `NetSocket` | NetSocket.`handler(Handler<Buffer> handler)`
    `NetServer` | NetServer.`listen(Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen()` but providing a handler that will be notified when the server is listening, or fails.
    `NetServer` | NetServer.`listen(int port, Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen()` but providing a handler that will be notified when the server is listening, or fails.
    `NetServer` | NetServer.`listen(int port, String host, Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen()` but providing a handler that will be notified when the server is listening, or fails.
    `NetServer` | NetServer.`listen(SocketAddress localAddress, Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen()` but providing a handler that will be notified when the server is listening, or fails.
    `void` | NetSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `NetSocket` | NetSocket.`sendFile(String filename, Handler<AsyncResult<Void>> resultHandler)` Same as `NetSocket.sendFile(java.lang.String)` but also takes a handler that will be called when the send has completed or a failure has occurred
    `NetSocket` | NetSocket.`sendFile(String filename, long offset, Handler<AsyncResult<Void>> resultHandler)` Same as `NetSocket.sendFile(java.lang.String)` but also takes a handler that will be called when the send has completed or a failure has occurred
    `NetSocket` | NetSocket.`sendFile(String filename, long offset, long length, Handler<AsyncResult<Void>> resultHandler)` Same as `NetSocket.sendFile(java.lang.String)` but also takes a handler that will be called when the send has completed or a failure has occurred
    `NetSocket` | NetSocket.`upgradeToSsl(Handler<Void> handler)` Upgrade channel to use SSL/TLS.
    `NetSocket` | NetSocket.`upgradeToSsl(String serverName, Handler<Void> handler)` Upgrade channel to use SSL/TLS.
    `NetSocket` | NetSocket.`write(Buffer message, Handler<AsyncResult<Void>> handler)` Like but with an `handler` called when the message has been written or failed to be written.
    `NetSocket` | NetSocket.`write(String str, Handler<AsyncResult<Void>> handler)` Same as `NetSocket.write(io.vertx.reactivex.core.buffer.Buffer)` but with an `handler` called when the operation completes
    `NetSocket` | NetSocket.`write(String str, String enc, Handler<AsyncResult<Void>> handler)` Same as `NetSocket.write(io.vertx.reactivex.core.buffer.Buffer)` but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.reactivex.core.parsetools

    Methods in io.vertx.reactivex.core.parsetools with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `RecordParser` | RecordParser.`endHandler(Handler<Void> endHandler)`
    `JsonParser` | JsonParser.`endHandler(Handler<Void> endHandler)`
    `RecordParser` | RecordParser.`exceptionHandler(Handler<Throwable> handler)`
    `JsonParser` | JsonParser.`exceptionHandler(Handler<Throwable> handler)`
    `RecordParser` | RecordParser.`handler(Handler<Buffer> handler)`
    `JsonParser` | JsonParser.`handler(Handler<JsonEvent> handler)`
    `static RecordParser` | RecordParser.`newDelimited(Buffer delim, Handler<Buffer> output)` Like `RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.reactivex.core.buffer.Buffer>)` but set the `output` that will receive whole records which have been parsed.
    `static RecordParser` | RecordParser.`newDelimited(String delim, Handler<Buffer> output)` Like `RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.reactivex.core.buffer.Buffer>)` but set the `output` that will receive whole records which have been parsed.
    `static RecordParser` | RecordParser.`newFixed(int size, Handler<Buffer> output)` Like `RecordParser.newFixed(int)` but set the `output` that will receive whole records which have been parsed.
    `void` | RecordParser.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | JsonParser.`pipeTo(WriteStream<JsonEvent> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | RecordParser.`setOutput(Handler<Buffer> output)`

  - ### Uses of Handler in io.vertx.reactivex.core.shareddata

    Methods in io.vertx.reactivex.core.shareddata with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | Counter.`addAndGet(long value, Handler<AsyncResult<Long>> resultHandler)` Add the value to the counter atomically and return the new count
    `void` | AsyncMap.`clear(Handler<AsyncResult<Void>> resultHandler)` Clear all entries in the map
    `void` | Counter.`compareAndSet(long expected, long value, Handler<AsyncResult<Boolean>> resultHandler)` Set the counter to the specified value only if the current value is the expectec value.
    `void` | Counter.`decrementAndGet(Handler<AsyncResult<Long>> resultHandler)` Decrement the counter atomically and return the new count
    `void` | Counter.`get(Handler<AsyncResult<Long>> resultHandler)` Get the current value of the counter
    `void` | AsyncMap.`get(K k, Handler<AsyncResult<V>> resultHandler)` Get a value from the map, asynchronously.
    `void` | Counter.`getAndAdd(long value, Handler<AsyncResult<Long>> resultHandler)` Add the value to the counter atomically and return the value before the add
    `void` | Counter.`getAndIncrement(Handler<AsyncResult<Long>> resultHandler)` Increment the counter atomically and return the value before the increment.
    `<K,V> void` | SharedData.`getAsyncMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)` Get the `AsyncMap` with the specified name.
    `<K,V> void` | SharedData.`getClusterWideMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)` Get the cluster wide map with the specified name.
    `void` | SharedData.`getCounter(String name, Handler<AsyncResult<Counter>> resultHandler)` Get an asynchronous counter.
    `<K,V> void` | SharedData.`getLocalAsyncMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)` Get the `AsyncMap` with the specified name.
    `void` | SharedData.`getLocalCounter(String name, Handler<AsyncResult<Counter>> resultHandler)` Get an asynchronous local counter.
    `void` | SharedData.`getLocalLock(String name, Handler<AsyncResult<Lock>> resultHandler)` Get an asynchronous local lock with the specified name.
    `void` | SharedData.`getLocalLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler)` Like `SharedData.getLocalLock(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.shareddata.Lock>>)` but specifying a timeout.
    `void` | SharedData.`getLock(String name, Handler<AsyncResult<Lock>> resultHandler)` Get an asynchronous lock with the specified name.
    `void` | SharedData.`getLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler)` Like `SharedData.getLock(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.shareddata.Lock>>)` but specifying a timeout.
    `void` | Counter.`incrementAndGet(Handler<AsyncResult<Long>> resultHandler)` Increment the counter atomically and return the new count
    `void` | AsyncMap.`put(K k, V v, Handler<AsyncResult<Void>> completionHandler)` Put a value in the map, asynchronously.
    `void` | AsyncMap.`put(K k, V v, long ttl, Handler<AsyncResult<Void>> completionHandler)` Like `AsyncMap.put(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but specifying a time to live for the entry.
    `void` | AsyncMap.`putIfAbsent(K k, V v, Handler<AsyncResult<V>> completionHandler)` Put the entry only if there is no entry with the key already present.
    `void` | AsyncMap.`putIfAbsent(K k, V v, long ttl, Handler<AsyncResult<V>> completionHandler)` Link `AsyncMap.putIfAbsent(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<V>>)` but specifying a time to live for the entry.
    `void` | AsyncMap.`remove(K k, Handler<AsyncResult<V>> resultHandler)` Remove a value from the map, asynchronously.
    `void` | AsyncMap.`removeIfPresent(K k, V v, Handler<AsyncResult<Boolean>> resultHandler)` Remove a value from the map, only if entry already exists with same value.
    `void` | AsyncMap.`replace(K k, V v, Handler<AsyncResult<V>> resultHandler)` Replace the entry only if it is currently mapped to some value
    `void` | AsyncMap.`replaceIfPresent(K k, V oldValue, V newValue, Handler<AsyncResult<Boolean>> resultHandler)` Replace the entry only if it is currently mapped to a specific value
    `void` | AsyncMap.`size(Handler<AsyncResult<Integer>> resultHandler)` Provide the number of entries in the map

  - ### Uses of Handler in io.vertx.reactivex.core.streams

    Methods in io.vertx.reactivex.core.streams with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `WriteStream<T>` | WriteStream.`drainHandler(Handler<Void> handler)` Set a drain handler on the stream.
    `void` | WriteStream.`end(Handler<AsyncResult<Void>> handler)` Same as `WriteStream.end()` but with an `handler` called when the operation completes
    `void` | WriteStream.`end(T data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `ReadStream<T>` | ReadStream.`endHandler(Handler<Void> endHandler)` Set an end handler.
    `ReadStream<T>` | ReadStream.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the read stream.
    `StreamBase` | StreamBase.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler.
    `WriteStream<T>` | WriteStream.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the write stream.
    `ReadStream<T>` | ReadStream.`handler(Handler<T> handler)` Set a data handler.
    `void` | ReadStream.`pipeTo(WriteStream<T> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | Pipe.`to(WriteStream<T> dst, Handler<AsyncResult<Void>> completionHandler)` Start to pipe the elements to the destination `WriteStream`.
    `WriteStream<T>` | WriteStream.`write(T data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.reactivex.ext.asyncsql

    Methods in io.vertx.reactivex.ext.asyncsql with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `SQLOperations` | PostgreSQLClient.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | AsyncSQLClient.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | MySQLClient.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | PostgreSQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | AsyncSQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | MySQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.

  - ### Uses of Handler in io.vertx.reactivex.ext.auth

    Methods in io.vertx.reactivex.ext.auth with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | AuthProvider.`authenticate(JsonObject authInfo, Handler<AsyncResult<User>> resultHandler)` Authenticate a user.
    `User` | User.`isAuthorised(String authority, Handler<AsyncResult<Boolean>> resultHandler)` Deprecated.
    `User` | User.`isAuthorized(String authority, Handler<AsyncResult<Boolean>> resultHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.reactivex.ext.auth.mongo

    Methods in io.vertx.reactivex.ext.auth.mongo with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | MongoAuth.`insertUser(String username, String password, List<String> roles, List<String> permissions, Handler<AsyncResult<String>> resultHandler)` Insert a new user into mongo in the convenient way

  - ### Uses of Handler in io.vertx.reactivex.ext.auth.oauth2

    Methods in io.vertx.reactivex.ext.auth.oauth2 with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `OAuth2Auth` | OAuth2Auth.`decodeToken(String token, Handler<AsyncResult<AccessToken>> handler)` Deprecated.
    `AccessToken` | AccessToken.`fetch(HttpMethod method, String resource, JsonObject headers, Buffer payload, Handler<AsyncResult<OAuth2Response>> callback)` Fetches a JSON resource using this Access Token.
    `AccessToken` | AccessToken.`fetch(String resource, Handler<AsyncResult<OAuth2Response>> callback)` Fetches a JSON resource using this Access Token.
    `void` | OAuth2Auth.`getToken(JsonObject params, Handler<AsyncResult<AccessToken>> handler)` Deprecated.
    `AccessToken` | AccessToken.`introspect(Handler<AsyncResult<Void>> callback)` Introspect access token.
    `AccessToken` | AccessToken.`introspect(String tokenType, Handler<AsyncResult<Void>> callback)` Introspect access token.
    `OAuth2Auth` | OAuth2Auth.`introspectToken(String token, Handler<AsyncResult<AccessToken>> handler)` Deprecated.
    `OAuth2Auth` | OAuth2Auth.`introspectToken(String token, String tokenType, Handler<AsyncResult<AccessToken>> handler)` Deprecated.
    `void` | OAuth2RBAC.`isAuthorized(AccessToken user, String authority, Handler<AsyncResult<Boolean>> handler)` This method should verify if the user has the given authority and return either a boolean value or an error.
    `OAuth2Auth` | OAuth2Auth.`loadJWK(Handler<AsyncResult<Void>> handler)` Deprecated.
    `AccessToken` | AccessToken.`logout(Handler<AsyncResult<Void>> callback)` Revoke refresh token and calls the logout endpoint.
    `AccessToken` | AccessToken.`refresh(Handler<AsyncResult<Void>> callback)` Refresh the access token
    `AccessToken` | AccessToken.`revoke(String token_type, Handler<AsyncResult<Void>> callback)` Revoke access or refresh token
    `AccessToken` | AccessToken.`userInfo(Handler<AsyncResult<JsonObject>> callback)` Load the user info as per OIDC spec.

  - ### Uses of Handler in io.vertx.reactivex.ext.auth.oauth2.providers

    Methods in io.vertx.reactivex.ext.auth.oauth2.providers with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static void` | SalesforceAuth.`discover(Vertx vertx, OAuth2ClientOptions config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | GoogleAuth.`discover(Vertx vertx, OAuth2ClientOptions config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | AzureADAuth.`discover(Vertx vertx, OAuth2ClientOptions config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | OpenIDConnectAuth.`discover(Vertx vertx, OAuth2ClientOptions config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | KeycloakAuth.`discover(Vertx vertx, OAuth2ClientOptions config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.

  - ### Uses of Handler in io.vertx.reactivex.ext.consul

    Methods in io.vertx.reactivex.ext.consul with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `ConsulClient` | ConsulClient.`agentInfo(Handler<AsyncResult<JsonObject>> resultHandler)` Returns the configuration and member information of the local agent
    `ConsulService` | ConsulService.`agentInfo(Handler<AsyncResult<JsonObject>> resultHandler)`
    `ConsulClient` | ConsulClient.`catalogDatacenters(Handler<AsyncResult<List<String>>> resultHandler)` Return all the datacenters that are known by the Consul server
    `ConsulService` | ConsulService.`catalogDatacenters(Handler<AsyncResult<List<String>>> resultHandler)`
    `ConsulClient` | ConsulClient.`catalogNodes(Handler<AsyncResult<NodeList>> resultHandler)` Returns the nodes registered in a datacenter
    `ConsulService` | ConsulService.`catalogNodes(Handler<AsyncResult<NodeList>> resultHandler)`
    `ConsulClient` | ConsulClient.`catalogNodeServices(String node, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the node's registered services
    `ConsulService` | ConsulService.`catalogNodeServices(String node, Handler<AsyncResult<ServiceList>> resultHandler)`
    `ConsulClient` | ConsulClient.`catalogNodeServicesWithOptions(String node, BlockingQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the node's registered services This is blocking query unlike `ConsulClient.catalogNodeServices(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.ServiceList>>)`
    `ConsulService` | ConsulService.`catalogNodeServicesWithOptions(String node, BlockingQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)`
    `ConsulClient` | ConsulClient.`catalogNodesWithOptions(NodeQueryOptions options, Handler<AsyncResult<NodeList>> resultHandler)` Returns the nodes registered in a datacenter
    `ConsulService` | ConsulService.`catalogNodesWithOptions(NodeQueryOptions options, Handler<AsyncResult<NodeList>> resultHandler)`
    `ConsulClient` | ConsulClient.`catalogServiceNodes(String service, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the nodes providing a service
    `ConsulService` | ConsulService.`catalogServiceNodes(String service, Handler<AsyncResult<ServiceList>> resultHandler)`
    `ConsulClient` | ConsulClient.`catalogServiceNodesWithOptions(String service, ServiceQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the nodes providing a service
    `ConsulService` | ConsulService.`catalogServiceNodesWithOptions(String service, ServiceQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)`
    `ConsulClient` | ConsulClient.`catalogServices(Handler<AsyncResult<ServiceList>> resultHandler)` Returns the services registered in a datacenter
    `ConsulService` | ConsulService.`catalogServices(Handler<AsyncResult<ServiceList>> resultHandler)`
    `ConsulClient` | ConsulClient.`catalogServicesWithOptions(BlockingQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the services registered in a datacenter This is blocking query unlike `ConsulClient.catalogServices(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.ServiceList>>)`
    `ConsulService` | ConsulService.`catalogServicesWithOptions(BlockingQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)`
    `ConsulClient` | ConsulClient.`cloneAclToken(String id, Handler<AsyncResult<String>> idHandler)` Clone Acl token
    `ConsulService` | ConsulService.`cloneAclToken(String id, Handler<AsyncResult<String>> idHandler)`
    `ConsulClient` | ConsulClient.`coordinateDatacenters(Handler<AsyncResult<List<DcCoordinates>>> resultHandler)` Returns the WAN network coordinates for all Consul servers, organized by DCs
    `ConsulService` | ConsulService.`coordinateDatacenters(Handler<AsyncResult<List<DcCoordinates>>> resultHandler)`
    `ConsulClient` | ConsulClient.`coordinateNodes(Handler<AsyncResult<CoordinateList>> resultHandler)` Returns the LAN network coordinates for all nodes in a given DC
    `ConsulService` | ConsulService.`coordinateNodes(Handler<AsyncResult<CoordinateList>> resultHandler)`
    `ConsulClient` | ConsulClient.`coordinateNodesWithOptions(BlockingQueryOptions options, Handler<AsyncResult<CoordinateList>> resultHandler)` Returns the LAN network coordinates for all nodes in a given DC This is blocking query unlike `ConsulClient.coordinateNodes(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.CoordinateList>>)`
    `ConsulService` | ConsulService.`coordinateNodesWithOptions(BlockingQueryOptions options, Handler<AsyncResult<CoordinateList>> resultHandler)`
    `ConsulClient` | ConsulClient.`createAclToken(AclToken token, Handler<AsyncResult<String>> idHandler)` Create new Acl token
    `ConsulService` | ConsulService.`createAclToken(AclToken token, Handler<AsyncResult<String>> idHandler)`
    `ConsulClient` | ConsulClient.`createPreparedQuery(PreparedQueryDefinition definition, Handler<AsyncResult<String>> resultHandler)`
    `ConsulService` | ConsulService.`createPreparedQuery(PreparedQueryDefinition definition, Handler<AsyncResult<String>> resultHandler)`
    `ConsulClient` | ConsulClient.`createSession(Handler<AsyncResult<String>> idHandler)` Initialize a new session
    `ConsulService` | ConsulService.`createSession(Handler<AsyncResult<String>> idHandler)`
    `ConsulClient` | ConsulClient.`createSessionWithOptions(SessionOptions options, Handler<AsyncResult<String>> idHandler)` Initialize a new session
    `ConsulService` | ConsulService.`createSessionWithOptions(SessionOptions options, Handler<AsyncResult<String>> idHandler)`
    `ConsulClient` | ConsulClient.`deletePreparedQuery(String id, Handler<AsyncResult<Void>> resultHandler)` Deletes an existing prepared query
    `ConsulService` | ConsulService.`deletePreparedQuery(String id, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`deleteValue(String key, Handler<AsyncResult<Void>> resultHandler)` Remove the key/value pair that corresponding to the specified key
    `ConsulService` | ConsulService.`deleteValue(String key, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`deleteValues(String keyPrefix, Handler<AsyncResult<Void>> resultHandler)` Removes all the key/value pair that corresponding to the specified key prefix
    `ConsulService` | ConsulService.`deleteValues(String keyPrefix, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`deregisterCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Remove a check from the local agent.
    `ConsulService` | ConsulService.`deregisterCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`deregisterService(String id, Handler<AsyncResult<Void>> resultHandler)` Remove a service from the local agent.
    `ConsulService` | ConsulService.`deregisterService(String id, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`destroyAclToken(String id, Handler<AsyncResult<Void>> resultHandler)` Destroy Acl token
    `ConsulService` | ConsulService.`destroyAclToken(String id, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`destroySession(String id, Handler<AsyncResult<Void>> resultHandler)` Destroys the given session
    `ConsulService` | ConsulService.`destroySession(String id, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`executePreparedQuery(String query, Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)` Executes an existing prepared query.
    `ConsulService` | ConsulService.`executePreparedQuery(String query, Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)`
    `ConsulClient` | ConsulClient.`executePreparedQueryWithOptions(String query, PreparedQueryExecuteOptions options, Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)` Executes an existing prepared query.
    `ConsulService` | ConsulService.`executePreparedQueryWithOptions(String query, PreparedQueryExecuteOptions options, Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)`
    `ConsulClient` | ConsulClient.`failCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "critical".
    `ConsulService` | ConsulService.`failCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`failCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "critical".
    `ConsulService` | ConsulService.`failCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`fireEvent(String name, Handler<AsyncResult<Event>> resultHandler)` Fires a new user event
    `ConsulService` | ConsulService.`fireEvent(String name, Handler<AsyncResult<Event>> resultHandler)`
    `ConsulClient` | ConsulClient.`fireEventWithOptions(String name, EventOptions options, Handler<AsyncResult<Event>> resultHandler)` Fires a new user event
    `ConsulService` | ConsulService.`fireEventWithOptions(String name, EventOptions options, Handler<AsyncResult<Event>> resultHandler)`
    `ConsulClient` | ConsulClient.`getAllPreparedQueries(Handler<AsyncResult<List<PreparedQueryDefinition>>> resultHandler)` Returns a list of all prepared queries.
    `ConsulService` | ConsulService.`getAllPreparedQueries(Handler<AsyncResult<List<PreparedQueryDefinition>>> resultHandler)`
    `ConsulClient` | ConsulClient.`getKeys(String keyPrefix, Handler<AsyncResult<List<String>>> resultHandler)` Returns the list of keys that corresponding to the specified key prefix.
    `ConsulService` | ConsulService.`getKeys(String keyPrefix, Handler<AsyncResult<List<String>>> resultHandler)`
    `ConsulClient` | ConsulClient.`getKeysWithOptions(String keyPrefix, BlockingQueryOptions options, Handler<AsyncResult<List<String>>> resultHandler)` Returns the list of keys that corresponding to the specified key prefix.
    `ConsulService` | ConsulService.`getKeysWithOptions(String keyPrefix, BlockingQueryOptions options, Handler<AsyncResult<List<String>>> resultHandler)`
    `ConsulClient` | ConsulClient.`getPreparedQuery(String id, Handler<AsyncResult<PreparedQueryDefinition>> resultHandler)` Returns an existing prepared query
    `ConsulService` | ConsulService.`getPreparedQuery(String id, Handler<AsyncResult<PreparedQueryDefinition>> resultHandler)`
    `ConsulClient` | ConsulClient.`getValue(String key, Handler<AsyncResult<KeyValue>> resultHandler)` Returns key/value pair that corresponding to the specified key.
    `ConsulService` | ConsulService.`getValue(String key, Handler<AsyncResult<KeyValue>> resultHandler)`
    `ConsulClient` | ConsulClient.`getValues(String keyPrefix, Handler<AsyncResult<KeyValueList>> resultHandler)` Returns the list of key/value pairs that corresponding to the specified key prefix.
    `ConsulService` | ConsulService.`getValues(String keyPrefix, Handler<AsyncResult<KeyValueList>> resultHandler)`
    `ConsulClient` | ConsulClient.`getValuesWithOptions(String keyPrefix, BlockingQueryOptions options, Handler<AsyncResult<KeyValueList>> resultHandler)` Returns the list of key/value pairs that corresponding to the specified key prefix.
    `ConsulService` | ConsulService.`getValuesWithOptions(String keyPrefix, BlockingQueryOptions options, Handler<AsyncResult<KeyValueList>> resultHandler)`
    `ConsulClient` | ConsulClient.`getValueWithOptions(String key, BlockingQueryOptions options, Handler<AsyncResult<KeyValue>> resultHandler)` Returns key/value pair that corresponding to the specified key.
    `ConsulService` | ConsulService.`getValueWithOptions(String key, BlockingQueryOptions options, Handler<AsyncResult<KeyValue>> resultHandler)`
    `ConsulClient` | ConsulClient.`healthChecks(String service, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks associated with the service
    `ConsulService` | ConsulService.`healthChecks(String service, Handler<AsyncResult<CheckList>> resultHandler)`
    `ConsulClient` | ConsulClient.`healthChecksWithOptions(String service, CheckQueryOptions options, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks associated with the service
    `ConsulService` | ConsulService.`healthChecksWithOptions(String service, CheckQueryOptions options, Handler<AsyncResult<CheckList>> resultHandler)`
    `ConsulClient` | ConsulClient.`healthServiceNodes(String service, boolean passing, Handler<AsyncResult<ServiceEntryList>> resultHandler)` Returns the nodes providing the service.
    `ConsulService` | ConsulService.`healthServiceNodes(String service, boolean passing, Handler<AsyncResult<ServiceEntryList>> resultHandler)`
    `ConsulClient` | ConsulClient.`healthServiceNodesWithOptions(String service, boolean passing, ServiceQueryOptions options, Handler<AsyncResult<ServiceEntryList>> resultHandler)` Returns the nodes providing the service.
    `ConsulService` | ConsulService.`healthServiceNodesWithOptions(String service, boolean passing, ServiceQueryOptions options, Handler<AsyncResult<ServiceEntryList>> resultHandler)`
    `ConsulClient` | ConsulClient.`healthState(HealthState healthState, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks in the specified status
    `ConsulService` | ConsulService.`healthState(HealthState healthState, Handler<AsyncResult<CheckList>> handler)`
    `ConsulClient` | ConsulClient.`healthStateWithOptions(HealthState healthState, CheckQueryOptions options, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks in the specified status
    `ConsulService` | ConsulService.`healthStateWithOptions(HealthState healthState, CheckQueryOptions checkQueryOptions, Handler<AsyncResult<CheckList>> handler)`
    `ConsulClient` | ConsulClient.`infoAclToken(String id, Handler<AsyncResult<AclToken>> tokenHandler)` Get info of Acl token
    `ConsulService` | ConsulService.`infoAclToken(String id, Handler<AsyncResult<AclToken>> tokenHandler)`
    `ConsulClient` | ConsulClient.`infoSession(String id, Handler<AsyncResult<Session>> resultHandler)` Returns the requested session information
    `ConsulService` | ConsulService.`infoSession(String id, Handler<AsyncResult<Session>> resultHandler)`
    `ConsulClient` | ConsulClient.`infoSessionWithOptions(String id, BlockingQueryOptions options, Handler<AsyncResult<Session>> resultHandler)` Returns the requested session information This is blocking query unlike `ConsulClient.infoSession(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.Session>>)`
    `ConsulService` | ConsulService.`infoSessionWithOptions(String id, BlockingQueryOptions options, Handler<AsyncResult<Session>> resultHandler)`
    `ConsulClient` | ConsulClient.`leaderStatus(Handler<AsyncResult<String>> resultHandler)` Get the Raft leader for the datacenter in which the agent is running.
    `ConsulService` | ConsulService.`leaderStatus(Handler<AsyncResult<String>> resultHandler)`
    `ConsulClient` | ConsulClient.`listAclTokens(Handler<AsyncResult<List<AclToken>>> resultHandler)` Get list of Acl token
    `ConsulService` | ConsulService.`listAclTokens(Handler<AsyncResult<List<AclToken>>> resultHandler)`
    `ConsulClient` | ConsulClient.`listEvents(Handler<AsyncResult<EventList>> resultHandler)` Returns the most recent events known by the agent
    `ConsulService` | ConsulService.`listEvents(Handler<AsyncResult<EventList>> resultHandler)`
    `ConsulClient` | ConsulClient.`listEventsWithOptions(EventListOptions options, Handler<AsyncResult<EventList>> resultHandler)` Returns the most recent events known by the agent.
    `ConsulService` | ConsulService.`listEventsWithOptions(EventListOptions options, Handler<AsyncResult<EventList>> resultHandler)`
    `ConsulClient` | ConsulClient.`listNodeSessions(String nodeId, Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions for a given node
    `ConsulService` | ConsulService.`listNodeSessions(String nodeId, Handler<AsyncResult<SessionList>> resultHandler)`
    `ConsulClient` | ConsulClient.`listNodeSessionsWithOptions(String nodeId, BlockingQueryOptions options, Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions for a given node This is blocking query unlike `ConsulClient.listNodeSessions(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.SessionList>>)`
    `ConsulService` | ConsulService.`listNodeSessionsWithOptions(String nodeId, BlockingQueryOptions options, Handler<AsyncResult<SessionList>> resultHandler)`
    `ConsulClient` | ConsulClient.`listSessions(Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions
    `ConsulService` | ConsulService.`listSessions(Handler<AsyncResult<SessionList>> resultHandler)`
    `ConsulClient` | ConsulClient.`listSessionsWithOptions(BlockingQueryOptions options, Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions This is blocking query unlike `ConsulClient.listSessions(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.SessionList>>)`
    `ConsulService` | ConsulService.`listSessionsWithOptions(BlockingQueryOptions options, Handler<AsyncResult<SessionList>> resultHandler)`
    `ConsulClient` | ConsulClient.`localChecks(Handler<AsyncResult<List<Check>>> resultHandler)` Return all the checks that are registered with the local agent.
    `ConsulService` | ConsulService.`localChecks(Handler<AsyncResult<List<Check>>> resultHandler)`
    `ConsulClient` | ConsulClient.`localServices(Handler<AsyncResult<List<Service>>> resultHandler)` Returns list of services registered with the local agent.
    `ConsulService` | ConsulService.`localServices(Handler<AsyncResult<List<Service>>> resultHandler)`
    `ConsulClient` | ConsulClient.`maintenanceService(MaintenanceOptions maintenanceOptions, Handler<AsyncResult<Void>> resultHandler)` Places a given service into "maintenance mode"
    `ConsulService` | ConsulService.`maintenanceService(MaintenanceOptions maintenanceOptions, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`passCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "passing".
    `ConsulService` | ConsulService.`passCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`passCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "passing".
    `ConsulService` | ConsulService.`passCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`peersStatus(Handler<AsyncResult<List<String>>> resultHandler)` Retrieves the Raft peers for the datacenter in which the the agent is running.
    `ConsulService` | ConsulService.`peersStatus(Handler<AsyncResult<List<String>>> resultHandler)`
    `ConsulClient` | ConsulClient.`putValue(String key, String value, Handler<AsyncResult<Boolean>> resultHandler)` Adds specified key/value pair
    `ConsulService` | ConsulService.`putValue(String key, String value, Handler<AsyncResult<Boolean>> resultHandler)`
    `ConsulClient` | ConsulClient.`putValueWithOptions(String key, String value, KeyValueOptions options, Handler<AsyncResult<Boolean>> resultHandler)`
    `ConsulService` | ConsulService.`putValueWithOptions(String key, String value, KeyValueOptions options, Handler<AsyncResult<Boolean>> resultHandler)`
    `ConsulClient` | ConsulClient.`registerCheck(CheckOptions checkOptions, Handler<AsyncResult<Void>> resultHandler)` Add a new check to the local agent.
    `ConsulService` | ConsulService.`registerCheck(CheckOptions checkOptions, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`registerService(ServiceOptions serviceOptions, Handler<AsyncResult<Void>> resultHandler)` Adds a new service, with an optional health check, to the local agent.
    `ConsulService` | ConsulService.`registerService(ServiceOptions serviceOptions, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`renewSession(String id, Handler<AsyncResult<Session>> resultHandler)` Renews the given session.
    `ConsulService` | ConsulService.`renewSession(String id, Handler<AsyncResult<Session>> resultHandler)`
    `Watch<T>` | Watch.`setHandler(Handler<WatchResult<T>> handler)` Set the result handler.
    `ConsulClient` | ConsulClient.`transaction(TxnRequest request, Handler<AsyncResult<TxnResponse>> resultHandler)` Manages multiple operations inside a single, atomic transaction.
    `ConsulService` | ConsulService.`transaction(TxnRequest request, Handler<AsyncResult<TxnResponse>> resultHandler)`
    `ConsulClient` | ConsulClient.`updateAclToken(AclToken token, Handler<AsyncResult<String>> idHandler)` Update Acl token
    `ConsulService` | ConsulService.`updateAclToken(AclToken token, Handler<AsyncResult<String>> idHandler)`
    `ConsulClient` | ConsulClient.`updateCheck(String checkId, CheckStatus status, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to given status.
    `ConsulService` | ConsulService.`updateCheck(String checkId, CheckStatus status, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`updateCheckWithNote(String checkId, CheckStatus status, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to given status.
    `ConsulService` | ConsulService.`updateCheckWithNote(String checkId, CheckStatus status, String note, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`updatePreparedQuery(PreparedQueryDefinition definition, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulService` | ConsulService.`updatePreparedQuery(PreparedQueryDefinition definition, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`warnCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "warning".
    `ConsulService` | ConsulService.`warnCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`warnCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "warning".
    `ConsulService` | ConsulService.`warnCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)`

  - ### Uses of Handler in io.vertx.reactivex.ext.eventbus.bridge.tcp

    Methods in io.vertx.reactivex.ext.eventbus.bridge.tcp with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | TcpEventBusBridge.`close(Handler<AsyncResult<Void>> handler)` Close the current socket.
    `static TcpEventBusBridge` | TcpEventBusBridge.`create(Vertx vertx, BridgeOptions options, NetServerOptions netServerOptions, Handler<BridgeEvent> eventHandler)`
    `TcpEventBusBridge` | TcpEventBusBridge.`listen(Handler<AsyncResult<TcpEventBusBridge>> handler)` Listen on default port 7000 with a handler to report the state of the socket listen operation.
    `TcpEventBusBridge` | TcpEventBusBridge.`listen(int port, Handler<AsyncResult<TcpEventBusBridge>> handler)` Listen on specific port
    `TcpEventBusBridge` | TcpEventBusBridge.`listen(int port, String address, Handler<AsyncResult<TcpEventBusBridge>> handler)` Listen on specific port and bind to specific address

  - ### Uses of Handler in io.vertx.reactivex.ext.healthchecks

    Methods in io.vertx.reactivex.ext.healthchecks with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `HealthChecks` | HealthChecks.`invoke(Handler<JsonObject> resultHandler)` Invokes the registered procedures and computes the outcome.
    `HealthChecks` | HealthChecks.`invoke(String name, Handler<AsyncResult<JsonObject>> resultHandler)` Invokes the registered procedure with the given name and sub-procedures.
    `HealthChecks` | HealthChecks.`register(String name, Handler<Promise<Status>> procedure)` Registers a health check procedure.
    `HealthCheckHandler` | HealthCheckHandler.`register(String name, Handler<Promise<Status>> procedure)` Registers a health check procedure.
    `HealthChecks` | HealthChecks.`register(String name, long timeout, Handler<Promise<Status>> procedure)` Registers a health check procedure.
    `HealthCheckHandler` | HealthCheckHandler.`register(String name, long timeout, Handler<Promise<Status>> procedure)` Registers a health check procedure.

  - ### Uses of Handler in io.vertx.reactivex.ext.jdbc

    Methods in io.vertx.reactivex.ext.jdbc with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `SQLOperations` | JDBCClient.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | JDBCClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.

  - ### Uses of Handler in io.vertx.reactivex.ext.mail

    Methods in io.vertx.reactivex.ext.mail with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MailService` | MailService.`sendMail(MailMessage email, Handler<AsyncResult<MailResult>> resultHandler)`
    `MailClient` | MailClient.`sendMail(MailMessage email, Handler<AsyncResult<MailResult>> resultHandler)` send a single mail via MailClient

  - ### Uses of Handler in io.vertx.reactivex.ext.mongo

    Methods in io.vertx.reactivex.ext.mongo with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MongoClient` | MongoClient.`bulkWrite(String collection, List<BulkOperation> operations, Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)` Execute a bulk operation.
    `MongoService` | MongoService.`bulkWrite(String collection, List<BulkOperation> operations, Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)`
    `MongoClient` | MongoClient.`bulkWriteWithOptions(String collection, List<BulkOperation> operations, BulkWriteOptions bulkWriteOptions, Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)` Execute a bulk operation with the specified write options.
    `MongoService` | MongoService.`bulkWriteWithOptions(String collection, List<BulkOperation> operations, BulkWriteOptions bulkWriteOptions, Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)`
    `MongoClient` | MongoClient.`count(String collection, JsonObject query, Handler<AsyncResult<Long>> resultHandler)` Count matching documents in a collection.
    `MongoService` | MongoService.`count(String collection, JsonObject query, Handler<AsyncResult<Long>> resultHandler)`
    `MongoClient` | MongoClient.`createCollection(String collectionName, Handler<AsyncResult<Void>> resultHandler)` Create a new collection
    `MongoService` | MongoService.`createCollection(String collectionName, Handler<AsyncResult<Void>> resultHandler)`
    `MongoClient` | MongoClient.`createIndex(String collection, JsonObject key, Handler<AsyncResult<Void>> resultHandler)` Creates an index.
    `MongoService` | MongoService.`createIndex(String collection, JsonObject key, Handler<AsyncResult<Void>> resultHandler)`
    `MongoClient` | MongoClient.`createIndexWithOptions(String collection, JsonObject key, IndexOptions options, Handler<AsyncResult<Void>> resultHandler)` Creates an index.
    `MongoService` | MongoService.`createIndexWithOptions(String collection, JsonObject key, IndexOptions options, Handler<AsyncResult<Void>> resultHandler)`
    `MongoClient` | MongoClient.`distinct(String collection, String fieldName, String resultClassname, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name.
    `MongoService` | MongoService.`distinct(String collection, String fieldName, String resultClassname, Handler<AsyncResult<JsonArray>> resultHandler)`
    `MongoClient` | MongoClient.`distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name filtered by specified query.
    `MongoService` | MongoService.`distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, Handler<AsyncResult<JsonArray>> resultHandler)`
    `MongoClient` | MongoClient.`dropCollection(String collection, Handler<AsyncResult<Void>> resultHandler)` Drop a collection
    `MongoService` | MongoService.`dropCollection(String collection, Handler<AsyncResult<Void>> resultHandler)`
    `MongoClient` | MongoClient.`dropIndex(String collection, String indexName, Handler<AsyncResult<Void>> resultHandler)` Drops the index given its name.
    `MongoService` | MongoService.`dropIndex(String collection, String indexName, Handler<AsyncResult<Void>> resultHandler)`
    `MongoClient` | MongoClient.`find(String collection, JsonObject query, Handler<AsyncResult<List<JsonObject>>> resultHandler)` Find matching documents in the specified collection
    `MongoService` | MongoService.`find(String collection, JsonObject query, Handler<AsyncResult<List<JsonObject>>> resultHandler)`
    `MongoClient` | MongoClient.`findOne(String collection, JsonObject query, JsonObject fields, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection
    `MongoService` | MongoService.`findOne(String collection, JsonObject query, JsonObject fields, Handler<AsyncResult<JsonObject>> resultHandler)`
    `MongoClient` | MongoClient.`findOneAndDelete(String collection, JsonObject query, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and delete it.
    `MongoService` | MongoService.`findOneAndDelete(String collection, JsonObject query, Handler<AsyncResult<JsonObject>> resultHandler)`
    `MongoClient` | MongoClient.`findOneAndDeleteWithOptions(String collection, JsonObject query, FindOptions findOptions, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and delete it.
    `MongoService` | MongoService.`findOneAndDeleteWithOptions(String collection, JsonObject query, FindOptions findOptions, Handler<AsyncResult<JsonObject>> resultHandler)`
    `MongoClient` | MongoClient.`findOneAndReplace(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and replace it.
    `MongoService` | MongoService.`findOneAndReplace(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<JsonObject>> resultHandler)`
    `MongoClient` | MongoClient.`findOneAndReplaceWithOptions(String collection, JsonObject query, JsonObject replace, FindOptions findOptions, UpdateOptions updateOptions, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and replace it.
    `MongoService` | MongoService.`findOneAndReplaceWithOptions(String collection, JsonObject query, JsonObject update, FindOptions findOptions, UpdateOptions updateOptions, Handler<AsyncResult<JsonObject>> resultHandler)`
    `MongoClient` | MongoClient.`findOneAndUpdate(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and update it.
    `MongoService` | MongoService.`findOneAndUpdate(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<JsonObject>> resultHandler)`
    `MongoClient` | MongoClient.`findOneAndUpdateWithOptions(String collection, JsonObject query, JsonObject update, FindOptions findOptions, UpdateOptions updateOptions, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and update it.
    `MongoService` | MongoService.`findOneAndUpdateWithOptions(String collection, JsonObject query, JsonObject update, FindOptions findOptions, UpdateOptions updateOptions, Handler<AsyncResult<JsonObject>> resultHandler)`
    `MongoClient` | MongoClient.`findWithOptions(String collection, JsonObject query, FindOptions options, Handler<AsyncResult<List<JsonObject>>> resultHandler)` Find matching documents in the specified collection, specifying options
    `MongoService` | MongoService.`findWithOptions(String collection, JsonObject query, FindOptions options, Handler<AsyncResult<List<JsonObject>>> resultHandler)`
    `MongoClient` | MongoClient.`getCollections(Handler<AsyncResult<List<String>>> resultHandler)` Get a list of all collections in the database.
    `MongoService` | MongoService.`getCollections(Handler<AsyncResult<List<String>>> resultHandler)`
    `MongoClient` | MongoClient.`insert(String collection, JsonObject document, Handler<AsyncResult<String>> resultHandler)` Insert a document in the specified collection
    `MongoService` | MongoService.`insert(String collection, JsonObject document, Handler<AsyncResult<String>> resultHandler)`
    `MongoClient` | MongoClient.`insertWithOptions(String collection, JsonObject document, WriteOption writeOption, Handler<AsyncResult<String>> resultHandler)` Insert a document in the specified collection with the specified write option
    `MongoService` | MongoService.`insertWithOptions(String collection, JsonObject document, WriteOption writeOption, Handler<AsyncResult<String>> resultHandler)`
    `MongoClient` | MongoClient.`listIndexes(String collection, Handler<AsyncResult<JsonArray>> resultHandler)` Get all the indexes in this collection.
    `MongoService` | MongoService.`listIndexes(String collection, Handler<AsyncResult<JsonArray>> resultHandler)`
    `MongoClient` | MongoClient.`remove(String collection, JsonObject query, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoService` | MongoService.`remove(String collection, JsonObject query, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoClient` | MongoClient.`removeDocument(String collection, JsonObject query, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove a single matching document from a collection and return the handler with MongoClientDeleteResult result
    `MongoService` | MongoService.`removeDocument(String collection, JsonObject query, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)`
    `MongoClient` | MongoClient.`removeDocuments(String collection, JsonObject query, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove matching documents from a collection and return the handler with MongoClientDeleteResult result
    `MongoService` | MongoService.`removeDocuments(String collection, JsonObject query, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)`
    `MongoClient` | MongoClient.`removeDocumentsWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove matching documents from a collection with the specified write option and return the handler with MongoClientDeleteResult result
    `MongoService` | MongoService.`removeDocumentsWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)`
    `MongoClient` | MongoClient.`removeDocumentWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove a single matching document from a collection with the specified write option and return the handler with MongoClientDeleteResult result
    `MongoService` | MongoService.`removeDocumentWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)`
    `MongoClient` | MongoClient.`removeOne(String collection, JsonObject query, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoService` | MongoService.`removeOne(String collection, JsonObject query, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoClient` | MongoClient.`removeOneWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoService` | MongoService.`removeOneWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoClient` | MongoClient.`removeWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoService` | MongoService.`removeWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoClient` | MongoClient.`replace(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoService` | MongoService.`replace(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoClient` | MongoClient.`replaceDocuments(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Replace matching documents in the specified collection and return the handler with MongoClientUpdateResult result
    `MongoService` | MongoService.`replaceDocuments(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)`
    `MongoClient` | MongoClient.`replaceDocumentsWithOptions(String collection, JsonObject query, JsonObject replace, UpdateOptions options, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Replace matching documents in the specified collection, specifying options and return the handler with MongoClientUpdateResult result
    `MongoService` | MongoService.`replaceDocumentsWithOptions(String collection, JsonObject query, JsonObject replace, UpdateOptions options, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)`
    `MongoClient` | MongoClient.`replaceWithOptions(String collection, JsonObject query, JsonObject replace, UpdateOptions options, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoService` | MongoService.`replaceWithOptions(String collection, JsonObject query, JsonObject replace, UpdateOptions options, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoClient` | MongoClient.`runCommand(String commandName, JsonObject command, Handler<AsyncResult<JsonObject>> resultHandler)` Run an arbitrary MongoDB command.
    `MongoService` | MongoService.`runCommand(String commandName, JsonObject command, Handler<AsyncResult<JsonObject>> resultHandler)`
    `MongoClient` | MongoClient.`save(String collection, JsonObject document, Handler<AsyncResult<String>> resultHandler)` Save a document in the specified collection
    `MongoService` | MongoService.`save(String collection, JsonObject document, Handler<AsyncResult<String>> resultHandler)`
    `MongoClient` | MongoClient.`saveWithOptions(String collection, JsonObject document, WriteOption writeOption, Handler<AsyncResult<String>> resultHandler)` Save a document in the specified collection with the specified write option
    `MongoService` | MongoService.`saveWithOptions(String collection, JsonObject document, WriteOption writeOption, Handler<AsyncResult<String>> resultHandler)`
    `MongoClient` | MongoClient.`update(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoService` | MongoService.`update(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoClient` | MongoClient.`updateCollection(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Update matching documents in the specified collection and return the handler with MongoClientUpdateResult result
    `MongoService` | MongoService.`updateCollection(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)`
    `MongoClient` | MongoClient.`updateCollectionWithOptions(String collection, JsonObject query, JsonObject update, UpdateOptions options, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Update matching documents in the specified collection, specifying options and return the handler with MongoClientUpdateResult result
    `MongoService` | MongoService.`updateCollectionWithOptions(String collection, JsonObject query, JsonObject update, UpdateOptions options, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)`
    `MongoClient` | MongoClient.`updateWithOptions(String collection, JsonObject query, JsonObject update, UpdateOptions options, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoService` | MongoService.`updateWithOptions(String collection, JsonObject query, JsonObject update, UpdateOptions options, Handler<AsyncResult<Void>> resultHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.reactivex.ext.shell

    Methods in io.vertx.reactivex.ext.shell with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ShellServer.`close(Handler<AsyncResult<Void>> completionHandler)` Close the shell server, this is an asynchronous close.
    `ShellServer` | ShellServer.`listen(Handler<AsyncResult<Void>> listenHandler)` Start the shell service, this is an asynchronous start.
    `void` | ShellServer.`shellHandler(Handler<Shell> shellHandler)` Called when a new shell is created.
    `void` | ShellService.`start(Handler<AsyncResult<Void>> startHandler)` Start the shell service, this is an asynchronous start.
    `void` | ShellService.`stop(Handler<AsyncResult<Void>> stopHandler)` Stop the shell service, this is an asynchronous start.

  - ### Uses of Handler in io.vertx.reactivex.ext.shell.command

    Methods in io.vertx.reactivex.ext.shell.command with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `CommandProcess` | CommandProcess.`backgroundHandler(Handler<Void> handler)` Set a background handler, this handler is called when the command is running and put to background.
    `CommandBuilder` | CommandBuilder.`completionHandler(Handler<Completion> handler)` Set the command completion handler, the completion handler when the user asks for contextual command line completion, usually hitting the tab key.
    `CommandProcess` | CommandProcess.`endHandler(Handler<Void> handler)` Set an end handler, this handler is called when the command is ended, for instance the command is running and the shell closes.
    `CommandProcess` | CommandProcess.`foregroundHandler(Handler<Void> handler)` Set a foreground handler, this handler is called when the command is running and put to foreground.
    `CommandProcess` | CommandProcess.`interruptHandler(Handler<Void> handler)` Set an interrupt handler, this handler is called when the command is interrupted, for instance user press `Ctrl-C`.
    `CommandBuilder` | CommandBuilder.`processHandler(Handler<CommandProcess> handler)` Set the command process handler, the process handler is called when the command is executed.
    `CommandRegistry` | CommandRegistry.`registerCommand(Command command, Handler<AsyncResult<Command>> completionHandler)` Register a command
    `CommandRegistry` | CommandRegistry.`registerCommands(List<Command> commands, Handler<AsyncResult<List<Command>>> completionHandler)` Register a list of commands.
    `CommandProcess` | CommandProcess.`resizehandler(Handler<Void> handler)`
    `CommandProcess` | CommandProcess.`resumeHandler(Handler<Void> handler)` Set a resume handler, this handler is called when the command is resumed, for instance user types `bg` or `fg` to resume the command.
    `CommandProcess` | CommandProcess.`stdinHandler(Handler<String> handler)`
    `CommandProcess` | CommandProcess.`suspendHandler(Handler<Void> handler)` Set a suspend handler, this handler is called when the command is suspended, for instance user press `Ctrl-Z`.
    `CommandRegistry` | CommandRegistry.`unregisterCommand(String commandName, Handler<AsyncResult<Void>> completionHandler)` Unregister a command.

  - ### Uses of Handler in io.vertx.reactivex.ext.shell.system

    Methods in io.vertx.reactivex.ext.shell.system with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | JobController.`close(Handler<Void> completionHandler)` Close the controller and terminate all the underlying jobs, a closed controller does not accept anymore jobs.
    `boolean` | Process.`interrupt(Handler<Void> completionHandler)` Attempt to interrupt the process.
    `void` | Process.`resume(boolean foreground, Handler<Void> completionHandler)` Suspend the process.
    `void` | Process.`resume(Handler<Void> completionHandler)` Suspend the process.
    `Job` | Job.`statusUpdateHandler(Handler<ExecStatus> handler)` Set an handler called when the job terminates.
    `void` | Process.`suspend(Handler<Void> completionHandler)` Resume the process.
    `void` | Process.`terminate(Handler<Void> completionHandler)` Terminate the process.
    `Process` | Process.`terminatedHandler(Handler<Integer> handler)` Set an handler for being notified when the process terminates.
    `void` | Process.`toBackground(Handler<Void> completionHandler)` Set the process in background.
    `void` | Process.`toForeground(Handler<Void> completionHandler)` Set the process in foreground.

  - ### Uses of Handler in io.vertx.reactivex.ext.shell.term

    Methods in io.vertx.reactivex.ext.shell.term with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | TermServer.`close(Handler<AsyncResult<Void>> completionHandler)` Like `TermServer.close()` but supplying a handler that will be notified when close is complete.
    `Term` | Term.`closeHandler(Handler<Void> handler)` Set a handler that will be called when the terminal is closed.
    `TermServer` | TermServer.`listen(Handler<AsyncResult<TermServer>> listenHandler)` Bind the term server, the `TermServer.termHandler(io.vertx.core.Handler<io.vertx.reactivex.ext.shell.term.Term>)` must be set before.
    `void` | Term.`readline(String prompt, Handler<String> lineHandler)` Prompt the user a line of text.
    `void` | Term.`readline(String prompt, Handler<String> lineHandler, Handler<Completion> completionHandler)` Prompt the user a line of text, providing a completion handler to handle user's completion.
    `void` | Term.`readline(String prompt, Handler<String> lineHandler, Handler<Completion> completionHandler)` Prompt the user a line of text, providing a completion handler to handle user's completion.
    `Tty` | Tty.`resizehandler(Handler<Void> handler)` Set a resize handler, the handler is called when the tty size changes.
    `Term` | Term.`resizehandler(Handler<Void> handler)`
    `Tty` | Tty.`stdinHandler(Handler<String> handler)` Set a stream handler on the standard input to read the data.
    `Term` | Term.`stdinHandler(Handler<String> handler)`
    `Pty` | Pty.`stdoutHandler(Handler<String> handler)` Set the standard out handler of the pseudo terminal.
    `SockJSTermHandler` | SockJSTermHandler.`termHandler(Handler<Term> handler)`
    `TermServer` | TermServer.`termHandler(Handler<Term> handler)` Set the term handler that will receive incoming client connections.

  - ### Uses of Handler in io.vertx.reactivex.ext.sql

    Methods in io.vertx.reactivex.ext.sql with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `SQLConnection` | SQLConnection.`batch(List<String> sqlStatements, Handler<AsyncResult<List<Integer>>> handler)` Batch simple SQL strings and execute the batch where the async result contains a array of Integers.
    `SQLConnection` | SQLConnection.`batchCallableWithParams(String sqlStatement, List<JsonArray> inArgs, List<JsonArray> outArgs, Handler<AsyncResult<List<Integer>>> handler)` Batch a callable statement with all entries from the args list.
    `SQLConnection` | SQLConnection.`batchWithParams(String sqlStatement, List<JsonArray> args, Handler<AsyncResult<List<Integer>>> handler)` Batch a prepared statement with all entries from the args list.
    `SQLConnection` | SQLConnection.`call(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLClient` | SQLClient.`call(String sql, Handler<AsyncResult<ResultSet>> handler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLOperations` | SQLOperations.`call(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLConnection` | SQLConnection.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLClient` | SQLClient.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> handler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLOperations` | SQLOperations.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `void` | SQLRowStream.`close(Handler<AsyncResult<Void>> handler)` Closes the stream/underlying cursor(s).
    `void` | SQLConnection.`close(Handler<AsyncResult<Void>> handler)` Closes the connection.
    `void` | SQLClient.`close(Handler<AsyncResult<Void>> handler)` Close the client and release all resources.
    `SQLConnection` | SQLConnection.`commit(Handler<AsyncResult<Void>> handler)` Commits all changes made since the previous commit/rollback.
    `SQLRowStream` | SQLRowStream.`endHandler(Handler<Void> endHandler)`
    `SQLRowStream` | SQLRowStream.`exceptionHandler(Handler<Throwable> handler)`
    `SQLConnection` | SQLConnection.`execute(String sql, Handler<AsyncResult<Void>> resultHandler)` Executes the given SQL statement
    `SQLClient` | SQLClient.`getConnection(Handler<AsyncResult<SQLConnection>> handler)` Returns a connection that can be used to perform SQL operations on.
    `SQLConnection` | SQLConnection.`getTransactionIsolation(Handler<AsyncResult<TransactionIsolation>> handler)` Attempts to return the transaction isolation level for this Connection object to the one given.
    `SQLRowStream` | SQLRowStream.`handler(Handler<JsonArray> handler)`
    `void` | SQLRowStream.`pipeTo(WriteStream<JsonArray> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `SQLConnection` | SQLConnection.`query(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` statement which returns the results of the query.
    `SQLClient` | SQLClient.`query(String sql, Handler<AsyncResult<ResultSet>> handler)` Execute a single SQL statement, this method acquires a connection from the the pool and executes the SQL statement and returns it back after the execution.
    `SQLOperations` | SQLOperations.`query(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` statement which returns the results of the query.
    `SQLOperations` | SQLConnection.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | SQLClient.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | SQLOperations.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | SQLConnection.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | SQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | SQLOperations.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLConnection` | SQLConnection.`queryStream(String sql, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLClient` | SQLClient.`queryStream(String sql, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLOperations` | SQLOperations.`queryStream(String sql, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLConnection` | SQLConnection.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLClient` | SQLClient.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLOperations` | SQLOperations.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLConnection` | SQLConnection.`queryWithParams(String sql, JsonArray params, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` prepared statement which returns the results of the query.
    `SQLClient` | SQLClient.`queryWithParams(String sql, JsonArray arguments, Handler<AsyncResult<ResultSet>> handler)` Execute a single SQL prepared statement, this method acquires a connection from the the pool and executes the SQL prepared statement and returns it back after the execution.
    `SQLOperations` | SQLOperations.`queryWithParams(String sql, JsonArray params, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` prepared statement which returns the results of the query.
    `SQLRowStream` | SQLRowStream.`resultSetClosedHandler(Handler<Void> handler)` Event handler when a resultset is closed.
    `SQLConnection` | SQLConnection.`rollback(Handler<AsyncResult<Void>> handler)` Rolls back all changes made since the previous commit/rollback.
    `SQLConnection` | SQLConnection.`setAutoCommit(boolean autoCommit, Handler<AsyncResult<Void>> resultHandler)` Sets the auto commit flag for this connection.
    `SQLConnection` | SQLConnection.`setTransactionIsolation(TransactionIsolation isolation, Handler<AsyncResult<Void>> handler)` Attempts to change the transaction isolation level for this Connection object to the one given.
    `SQLConnection` | SQLConnection.`update(String sql, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
    `SQLClient` | SQLClient.`update(String sql, Handler<AsyncResult<UpdateResult>> handler)` Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
    `SQLOperations` | SQLOperations.`update(String sql, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
    `SQLConnection` | SQLConnection.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
    `SQLClient` | SQLClient.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> handler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
    `SQLOperations` | SQLOperations.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters

  - ### Uses of Handler in io.vertx.reactivex.ext.stomp

    Methods in io.vertx.reactivex.ext.stomp that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<ServerWebSocket>` | StompServer.`webSocketHandler()` Gets the able to manage web socket connections.

    Methods in io.vertx.reactivex.ext.stomp with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `StompClientConnection` | StompClientConnection.`abort(String id, Handler<Frame> receiptHandler)` Aborts a transaction.
    `StompClientConnection` | StompClientConnection.`abort(String id, Map<String,String> headers, Handler<Frame> receiptHandler)` Aborts a transaction.
    `StompServerHandler` | StompServerHandler.`abortHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `ABORT` frame is received.
    `StompClientConnection` | StompClientConnection.`ack(String id, Handler<Frame> receiptHandler)` Sends an acknowledgement for a specific message.
    `StompClientConnection` | StompClientConnection.`ack(String id, String txId, Handler<Frame> receiptHandler)` Sends an acknowledgement for the given frame.
    `StompServerHandler` | StompServerHandler.`ackHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `ACK` frame is received.
    `StompServerHandler` | StompServerHandler.`beginHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `BEGIN` frame is received.
    `StompClientConnection` | StompClientConnection.`beginTX(String id, Handler<Frame> receiptHandler)` Begins a transaction.
    `StompClientConnection` | StompClientConnection.`beginTX(String id, Map<String,String> headers, Handler<Frame> receiptHandler)` Begins a transaction.
    `void` | StompServer.`close(Handler<AsyncResult<Void>> completionHandler)` Closes the server.
    `StompClientConnection` | StompClientConnection.`closeHandler(Handler<StompClientConnection> handler)` Sets a handler notified when the STOMP connection is closed.
    `StompServerHandler` | StompServerHandler.`closeHandler(Handler<StompServerConnection> handler)` Configures the action to execute when a connection with the client is closed.
    `StompClientConnection` | StompClientConnection.`commit(String id, Handler<Frame> receiptHandler)` Commits a transaction.
    `StompClientConnection` | StompClientConnection.`commit(String id, Map<String,String> headers, Handler<Frame> receiptHandler)` Commits a transaction.
    `StompServerHandler` | StompServerHandler.`commitHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `COMMIT` frame is received.
    `void` | StompServerConnection.`configureHeartbeat(long ping, long pong, Handler<StompServerConnection> pingHandler)` Configures the heartbeat.
    `StompClient` | StompClient.`connect(Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server using the host and port configured in the client's options.
    `StompClient` | StompClient.`connect(int port, String host, Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server.
    `StompClient` | StompClient.`connect(int port, String host, NetClient net, Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server.
    `StompClient` | StompClient.`connect(NetClient net, Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server.
    `StompServerHandler` | StompServerHandler.`connectHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `CONNECT` frame is received.
    `StompClientConnection` | StompClientConnection.`connectionDroppedHandler(Handler<StompClientConnection> handler)` Sets a handler notified when the server does not respond to a `ping` request in time.
    `StompClientConnection` | StompClientConnection.`disconnect(Frame frame, Handler<Frame> receiptHandler)` Disconnects the client.
    `StompClientConnection` | StompClientConnection.`disconnect(Handler<Frame> receiptHandler)` Disconnects the client.
    `StompServerHandler` | StompServerHandler.`disconnectHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `DISCONNECT` frame is received.
    `StompClient` | StompClient.`errorFrameHandler(Handler<Frame> handler)` A general error frame handler.
    `StompClientConnection` | StompClientConnection.`errorHandler(Handler<Frame> handler)` Sets a handler notified when an `ERROR` frame is received by the client.
    `StompClientConnection` | StompClientConnection.`exceptionHandler(Handler<Throwable> exceptionHandler)` Configures the exception handler notified upon TCP-level errors.
    `StompClient` | StompClient.`exceptionHandler(Handler<Throwable> handler)` Sets an exception handler notified for TCP-level errors.
    `StompServer` | StompServer.`listen(Handler<AsyncResult<StompServer>> handler)` Connects the STOMP server default port (61613) and network interface (`0.0.0.0`).
    `StompServer` | StompServer.`listen(int port, Handler<AsyncResult<StompServer>> handler)` Connects the STOMP server to the given port.
    `StompServer` | StompServer.`listen(int port, String host, Handler<AsyncResult<StompServer>> handler)` Connects the STOMP server to the given port / interface.
    `StompClientConnection` | StompClientConnection.`nack(String id, Handler<Frame> receiptHandler)` Sends a non-acknowledgement for the given message.
    `StompClientConnection` | StompClientConnection.`nack(String id, String txId, Handler<Frame> receiptHandler)` Sends a non-acknowledgement for the given frame.
    `StompServerHandler` | StompServerHandler.`nackHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `NACK` frame is received.
    `StompServerHandler` | StompServerHandler.`onAckHandler(Handler<Acknowledgement> handler)` Configures the action to execute when messages are acknowledged.
    `StompServerHandler` | StompServerHandler.`onAuthenticationRequest(StompServerConnection connection, String login, String passcode, Handler<AsyncResult<Boolean>> handler)` Called when the client connects to a server requiring authentication.
    `StompServerHandler` | StompServerHandler.`onNackHandler(Handler<Acknowledgement> handler)` Configures the action to execute when messages are not acknowledged.
    `StompClientConnection` | StompClientConnection.`pingHandler(Handler<StompClientConnection> handler)` Sets a handler that let customize the behavior when a ping needs to be sent to the server.
    `StompServerHandler` | StompServerHandler.`pingHandler(Handler<StompServerConnection> handler)` Allows customizing the action to do when the server needs to send a `PING` to the client.
    `StompClientConnection` | StompClientConnection.`receivedFrameHandler(Handler<Frame> handler)` Configures a received handler that get notified when a STOMP frame is received by the client.
    `StompClient` | StompClient.`receivedFrameHandler(Handler<Frame> handler)` Configures a received handler that gets notified when a STOMP frame is received by the client.
    `StompServerHandler` | StompServerHandler.`receivedFrameHandler(Handler<ServerFrame> handler)` Configures a handler that get notified when a STOMP frame is received by the server.
    `StompClientConnection` | StompClientConnection.`send(Frame frame, Handler<Frame> receiptHandler)` Sends the given frame to the server.
    `StompClientConnection` | StompClientConnection.`send(Map<String,String> headers, Buffer body, Handler<Frame> receiptHandler)` Sends a `SEND` frame to the server.
    `StompClientConnection` | StompClientConnection.`send(String destination, Buffer body, Handler<Frame> receiptHandler)` Sends a `SEND` frame to the server to the given destination.
    `StompClientConnection` | StompClientConnection.`send(String destination, Map<String,String> headers, Buffer body, Handler<Frame> receiptHandler)` Sends a `SEND` frame to the server to the given destination.
    `StompServerHandler` | StompServerHandler.`sendHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `SEND` frame is received.
    `StompServerHandler` | StompServerHandler.`stompHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `STOMP` frame is received.
    `String` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler)` Subscribes to the given destination.
    `String` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler, Handler<Frame> receiptHandler)` Subscribes to the given destination.
    `String` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler, Handler<Frame> receiptHandler)` Subscribes to the given destination.
    `String` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler)` Subscribes to the given destination.
    `String` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler, Handler<Frame> receiptHandler)` Subscribes to the given destination.
    `String` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler, Handler<Frame> receiptHandler)` Subscribes to the given destination.
    `StompServerHandler` | StompServerHandler.`subscribeHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `SUBSCRIBE` frame is received.
    `StompClientConnection` | StompClientConnection.`unsubscribe(String destination, Handler<Frame> receiptHandler)` Un-subscribes from the given destination.
    `StompClientConnection` | StompClientConnection.`unsubscribe(String destination, Map<String,String> headers, Handler<Frame> receiptHandler)` Un-subscribes from the given destination.
    `StompServerHandler` | StompServerHandler.`unsubscribeHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `UNSUBSCRIBE` frame is received.
    `StompClientConnection` | StompClientConnection.`writingFrameHandler(Handler<Frame> handler)` Configures a handler notified when a frame is going to be written on the wire.
    `StompClient` | StompClient.`writingFrameHandler(Handler<Frame> handler)` Configures a writing handler that gets notified when a STOMP frame is written on the wire.
    `StompServer` | StompServer.`writingFrameHandler(Handler<ServerFrame> handler)` Configures the handler that is invoked every time a frame is going to be written to the "wire".

  - ### Uses of Handler in io.vertx.reactivex.ext.unit

    Methods in io.vertx.reactivex.ext.unit that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure()` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure(Handler<Throwable> causeHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess()` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it completes the async operation. When the returned handler is called back with a failed result it fails the test with the cause of the failure.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess(Handler<T> resultHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it invokes the `resultHandler` argument with the async result.
    `Handler<Throwable>` | TestContext.`exceptionHandler()`

    Methods in io.vertx.reactivex.ext.unit with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `TestSuite` | TestSuite.`after(Handler<TestContext> callback)` Set a callback executed after the tests.
    `TestSuite` | TestSuite.`afterEach(Handler<TestContext> callback)` Set a callback executed after each test and before the suite `after` callback.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure(Handler<Throwable> causeHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess(Handler<T> resultHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it invokes the `resultHandler` argument with the async result.
    `TestSuite` | TestSuite.`before(Handler<TestContext> callback)` Set a callback executed before the tests.
    `TestSuite` | TestSuite.`beforeEach(Handler<TestContext> callback)` Set a callback executed before each test and after the suite `before` callback.
    `static TestCase` | TestCase.`create(String name, Handler<TestContext> testCase)` Create a test case.
    `void` | Completion.`handler(Handler<AsyncResult<T>> completionHandler)` Completion handler to receive a completion signal when this completions completes.
    `void` | Async.`handler(Handler<AsyncResult<Void>> completionHandler)` Completion handler to receive a completion signal when this completions completes.
    `void` | TestCompletion.`handler(Handler<AsyncResult<Void>> completionHandler)` Completion handler to receive a completion signal when this completions completes.
    `TestSuite` | TestSuite.`test(String name, Handler<TestContext> testCase)` Add a new test case to the suite.
    `TestSuite` | TestSuite.`test(String name, int repeat, Handler<TestContext> testCase)` Add a new test case to the suite.
    `TestContext` | TestContext.`verify(Handler<Void> block)` Execute the provided handler, which may contain assertions, possibly from any third-party assertion framework.

  - ### Uses of Handler in io.vertx.reactivex.ext.unit.collect

    Methods in io.vertx.reactivex.ext.unit.collect with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static EventBusCollector` | EventBusCollector.`create(Vertx vertx, Handler<TestSuiteReport> reporter)`

  - ### Uses of Handler in io.vertx.reactivex.ext.unit.report

    Methods in io.vertx.reactivex.ext.unit.report with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `TestCaseReport` | TestCaseReport.`endHandler(Handler<TestResult> handler)` Set a callback for completion, the specified `handler` is invoked when the test exec has completed.
    `TestSuiteReport` | TestSuiteReport.`endHandler(Handler<Void> endHandler)`
    `TestSuiteReport` | TestSuiteReport.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler, the exception handler reports the test suite errors, it can be called mulitple times before the test ends.
    `TestSuiteReport` | TestSuiteReport.`handler(Handler<TestCaseReport> handler)`
    `void` | TestSuiteReport.`pipeTo(WriteStream<TestCaseReport> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.

  - ### Uses of Handler in io.vertx.reactivex.ext.web

    Methods in io.vertx.reactivex.ext.web with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `int` | RoutingContext.`addBodyEndHandler(Handler<Void> handler)` Provides a handler that will be called after the last part of the body is written to the wire.
    `int` | RoutingContext.`addHeadersEndHandler(Handler<Void> handler)` Add a handler that will be called just before headers are written to the response.
    `Route` | Route.`blockingHandler(Handler<RoutingContext> requestHandler)` Like `Route.blockingHandler(io.vertx.core.Handler<io.vertx.reactivex.ext.web.RoutingContext>)` called with ordered = true
    `Route` | Route.`blockingHandler(Handler<RoutingContext> requestHandler, boolean ordered)` Specify a blocking request handler for the route.
    `Router` | Router.`errorHandler(int statusCode, Handler<RoutingContext> errorHandler)` Specify an handler to handle an error for a particular status code.
    `Router` | Router.`exceptionHandler(Handler<Throwable> exceptionHandler)` Deprecated.
    `Route` | Route.`failureHandler(Handler<RoutingContext> failureHandler)` Append a failure handler to the route failure handlers list.
    `Route` | Route.`handler(Handler<RoutingContext> requestHandler)` Append a request handler to the route handlers list.
    `Router` | Router.`modifiedHandler(Handler<Router> handler)` When a Router routes are changed this handler is notified.

  - ### Uses of Handler in io.vertx.reactivex.ext.web.api.contract

    Methods in io.vertx.reactivex.ext.web.api.contract that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<RoutingContext>` | RouterFactory.`getValidationFailureHandler()` Deprecated.

    Methods in io.vertx.reactivex.ext.web.api.contract with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `RouterFactory` | RouterFactory.`addGlobalHandler(Handler<RoutingContext> globalHandler)` Add global handler to be applied prior to `Router` being generated.
    `RouterFactory` | RouterFactory.`addSecurityHandler(String securitySchemaName, Handler<RoutingContext> handler)` Mount to paths that have to follow a security schema a security handler
    `RouterFactory` | RouterFactory.`setNotImplementedFailureHandler(Handler<RoutingContext> notImplementedFailureHandler)` Deprecated.
    `RouterFactory` | RouterFactory.`setValidationFailureHandler(Handler<RoutingContext> validationFailureHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.reactivex.ext.web.api.contract.openapi3

    Methods in io.vertx.reactivex.ext.web.api.contract.openapi3 that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<RoutingContext>` | OpenAPI3RouterFactory.`getValidationFailureHandler()` Deprecated.

    Methods in io.vertx.reactivex.ext.web.api.contract.openapi3 with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `OpenAPI3RouterFactory` | OpenAPI3RouterFactory.`addFailureHandlerByOperationId(String operationId, Handler<RoutingContext> failureHandler)` Add a failure handler by operation_id field in Operation object
    `RouterFactory` | OpenAPI3RouterFactory.`addGlobalHandler(Handler<RoutingContext> globalHandler)` Add global handler to be applied prior to `Router` being generated.
    `OpenAPI3RouterFactory` | OpenAPI3RouterFactory.`addHandlerByOperationId(String operationId, Handler<RoutingContext> handler)` Add an handler by operation_id field in Operation object
    `RouterFactory` | OpenAPI3RouterFactory.`addSecurityHandler(String securitySchemaName, Handler<RoutingContext> handler)` Mount to paths that have to follow a security schema a security handler
    `OpenAPI3RouterFactory` | OpenAPI3RouterFactory.`addSecuritySchemaScopeValidator(String securitySchemaName, String scopeName, Handler<RoutingContext> handler)` Add a particular scope validator.
    `static void` | OpenAPI3RouterFactory.`create(Vertx vertx, String url, Handler<AsyncResult<OpenAPI3RouterFactory>> handler)` Create a new OpenAPI3RouterFactory
    `static void` | OpenAPI3RouterFactory.`create(Vertx vertx, String url, List<JsonObject> auth, Handler<AsyncResult<OpenAPI3RouterFactory>> handler)` Create a new OpenAPI3RouterFactory
    `RouterFactory` | OpenAPI3RouterFactory.`setNotImplementedFailureHandler(Handler<RoutingContext> notImplementedFailureHandler)` Deprecated.
    `RouterFactory` | OpenAPI3RouterFactory.`setValidationFailureHandler(Handler<RoutingContext> validationFailureHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.reactivex.ext.web.client

    Methods in io.vertx.reactivex.ext.web.client with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | HttpRequest.`send(Handler<AsyncResult<HttpResponse<T>>> handler)` Send a request, the `handler` will receive the response as an `HttpResponse`.
    `void` | HttpRequest.`sendBuffer(Buffer body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` buffer.
    `void` | HttpRequest.`sendForm(MultiMap body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` multimap encoded as form and the content type set to `application/x-www-form-urlencoded`.
    `void` | HttpRequest.`sendJson(Object body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
    `void` | HttpRequest.`sendJsonObject(JsonObject body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
    `void` | HttpRequest.`sendMultipartForm(MultipartForm body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` multimap encoded as form and the content type set to `multipart/form-data`.
    `void` | HttpRequest.`sendStream(Flowable<Buffer> body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
    `void` | HttpRequest.`sendStream(Observable<Buffer> body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
    `void` | HttpRequest.`sendStream(ReadStream<Buffer> body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.

  - ### Uses of Handler in io.vertx.reactivex.ext.web.common.template

    Methods in io.vertx.reactivex.ext.web.common.template with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | TemplateEngine.`render(JsonObject context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Render the template.
    `void` | TemplateEngine.`render(Map<String,Object> context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Render the template.

  - ### Uses of Handler in io.vertx.reactivex.ext.web.handler

    Methods in io.vertx.reactivex.ext.web.handler with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MultiTenantHandler` | MultiTenantHandler.`addDefaultHandler(Handler<RoutingContext> handler)` Add a default handler for the case when no tenant was matched.
    `MultiTenantHandler` | MultiTenantHandler.`addTenantHandler(String tenant, Handler<RoutingContext> handler)` Add a handler for a given tenant to this handler.
    `void` | AuthHandler.`authorize(User user, Handler<AsyncResult<Void>> handler)` Authorizes the given user against all added authorities.
    `void` | BasicAuthHandler.`authorize(User user, Handler<AsyncResult<Void>> handler)` Authorizes the given user against all added authorities.
    `void` | DigestAuthHandler.`authorize(User user, Handler<AsyncResult<Void>> handler)` Authorizes the given user against all added authorities.
    `void` | JWTAuthHandler.`authorize(User user, Handler<AsyncResult<Void>> handler)` Authorizes the given user against all added authorities.
    `void` | RedirectAuthHandler.`authorize(User user, Handler<AsyncResult<Void>> handler)` Authorizes the given user against all added authorities.
    `void` | ChainAuthHandler.`authorize(User user, Handler<AsyncResult<Void>> handler)` Authorizes the given user against all added authorities.
    `void` | OAuth2AuthHandler.`authorize(User user, Handler<AsyncResult<Void>> handler)` Authorizes the given user against all added authorities.
    `static VirtualHostHandler` | VirtualHostHandler.`create(String hostname, Handler<RoutingContext> handler)` Create a handler
    `void` | AuthHandler.`parseCredentials(RoutingContext context, Handler<AsyncResult<JsonObject>> handler)` Parses the credentials from the request into a JsonObject.
    `void` | BasicAuthHandler.`parseCredentials(RoutingContext context, Handler<AsyncResult<JsonObject>> handler)` Parses the credentials from the request into a JsonObject.
    `void` | DigestAuthHandler.`parseCredentials(RoutingContext context, Handler<AsyncResult<JsonObject>> handler)` Parses the credentials from the request into a JsonObject.
    `void` | JWTAuthHandler.`parseCredentials(RoutingContext context, Handler<AsyncResult<JsonObject>> handler)` Parses the credentials from the request into a JsonObject.
    `void` | RedirectAuthHandler.`parseCredentials(RoutingContext context, Handler<AsyncResult<JsonObject>> handler)` Parses the credentials from the request into a JsonObject.
    `void` | ChainAuthHandler.`parseCredentials(RoutingContext context, Handler<AsyncResult<JsonObject>> handler)` Parses the credentials from the request into a JsonObject.
    `void` | OAuth2AuthHandler.`parseCredentials(RoutingContext context, Handler<AsyncResult<JsonObject>> handler)` Parses the credentials from the request into a JsonObject.

  - ### Uses of Handler in io.vertx.reactivex.ext.web.handler.graphql

    Methods in io.vertx.reactivex.ext.web.handler.graphql with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `ApolloWSHandler` | ApolloWSHandler.`connectionHandler(Handler<ServerWebSocket> connectionHandler)` Customize the connection .
    `ApolloWSHandler` | ApolloWSHandler.`endHandler(Handler<ServerWebSocket> endHandler)` Customize the end .
    `ApolloWSHandler` | ApolloWSHandler.`messageHandler(Handler<ApolloWSMessage> messageHandler)` Customize the message .

  - ### Uses of Handler in io.vertx.reactivex.ext.web.handler.sockjs

    Methods in io.vertx.reactivex.ext.web.handler.sockjs with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `Router` | SockJSHandler.`bridge(BridgeOptions bridgeOptions, Handler<BridgeEvent> bridgeEventHandler)` Like `SockJSHandler.bridge(io.vertx.ext.web.handler.sockjs.BridgeOptions)` but specifying a handler that will receive bridge events.
    `SockJSSocket` | SockJSSocket.`drainHandler(Handler<Void> handler)`
    `void` | SockJSSocket.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | SockJSSocket.`end(Handler<AsyncResult<Void>> handler)` Same as `SockJSSocket.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `SockJSSocket` | SockJSSocket.`endHandler(Handler<Void> endHandler)`
    `SockJSSocket` | SockJSSocket.`exceptionHandler(Handler<Throwable> handler)`
    `SockJSSocket` | SockJSSocket.`handler(Handler<Buffer> handler)`
    `void` | SockJSSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `Router` | SockJSHandler.`socketHandler(Handler<SockJSSocket> handler)` Set a SockJS socket handler.
    `SockJSSocket` | SockJSSocket.`write(Buffer data, Handler<AsyncResult<Void>> handler)`
    `SockJSSocket` | SockJSSocket.`write(String data, Handler<AsyncResult<Void>> handler)`

  - ### Uses of Handler in io.vertx.reactivex.ext.web.sstore

    Methods in io.vertx.reactivex.ext.web.sstore with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | SessionStore.`clear(Handler<AsyncResult<Void>> resultHandler)` Remove all sessions from the store.
    `void` | SessionStore.`delete(String id, Handler<AsyncResult<Void>> resultHandler)` Delete the session with the specified ID.
    `void` | SessionStore.`get(String cookieValue, Handler<AsyncResult<Session>> resultHandler)` Get the session with the specified ID.
    `void` | SessionStore.`put(Session session, Handler<AsyncResult<Void>> resultHandler)` Add a session with the specified ID.
    `void` | SessionStore.`size(Handler<AsyncResult<Integer>> resultHandler)` Get the number of sessions in the store.

  - ### Uses of Handler in io.vertx.reactivex.ext.web.templ

    Methods in io.vertx.reactivex.ext.web.templ with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | TemplateEngine.`render(RoutingContext context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Deprecated.
    `void` | TemplateEngine.`render(RoutingContext context, String templateDirectory, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Deprecated.

  - ### Uses of Handler in io.vertx.reactivex.kafka.admin

    Methods in io.vertx.reactivex.kafka.admin with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | KafkaAdminClient.`close(Handler<AsyncResult<Void>> completionHandler)` Close the admin client
    `void` | KafkaAdminClient.`close(long timeout, Handler<AsyncResult<Void>> completionHandler)` Close the admin client
    `void` | KafkaAdminClient.`createTopics(List<NewTopic> topics, Handler<AsyncResult<Void>> completionHandler)` Creates a batch of new Kafka topics
    `void` | KafkaAdminClient.`deleteTopics(List<String> topicNames, Handler<AsyncResult<Void>> completionHandler)` Deletes a batch of Kafka topics
    `void` | KafkaAdminClient.`listConsumerGroups(Handler<AsyncResult<List<ConsumerGroupListing>>> completionHandler)` Get the the consumer groups available in the cluster with the default options
    `void` | KafkaAdminClient.`listTopics(Handler<AsyncResult<Set<String>>> completionHandler)` List the topics available in the cluster with the default options.

  - ### Uses of Handler in io.vertx.reactivex.kafka.client.consumer

    Methods in io.vertx.reactivex.kafka.client.consumer with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `KafkaConsumer<K,V>` | KafkaConsumer.`assign(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Manually assign a list of partition to this consumer.
    `KafkaConsumer<K,V>` | KafkaConsumer.`assign(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Manually assign a partition to this consumer.
    `KafkaConsumer<K,V>` | KafkaConsumer.`assignment(Handler<AsyncResult<Set<TopicPartition>>> handler)` Get the set of partitions currently assigned to this consumer.
    `KafkaConsumer<K,V>` | KafkaConsumer.`batchHandler(Handler<KafkaConsumerRecords<K,V>> handler)` Set the handler to be used when batches of messages are fetched from the Kafka server.
    `void` | KafkaConsumer.`beginningOffsets(TopicPartition topicPartition, Handler<AsyncResult<Long>> handler)` Get the first offset for the given partitions.
    `void` | KafkaConsumer.`close(Handler<AsyncResult<Void>> completionHandler)` Close the consumer
    `void` | KafkaConsumer.`commit(Handler<AsyncResult<Void>> completionHandler)` Commit current offsets for all the subscribed list of topics and partition.
    `void` | KafkaConsumer.`committed(TopicPartition topicPartition, Handler<AsyncResult<OffsetAndMetadata>> handler)` Get the last committed offset for the given partition (whether the commit happened by this process or another).
    `KafkaConsumer<K,V>` | KafkaConsumer.`endHandler(Handler<Void> endHandler)`
    `void` | KafkaConsumer.`endOffsets(TopicPartition topicPartition, Handler<AsyncResult<Long>> handler)` Get the last offset for the given partition.
    `KafkaConsumer<K,V>` | KafkaConsumer.`exceptionHandler(Handler<Throwable> handler)`
    `KafkaConsumer<K,V>` | KafkaConsumer.`handler(Handler<KafkaConsumerRecord<K,V>> handler)`
    `void` | KafkaConsumer.`offsetsForTimes(TopicPartition topicPartition, Long timestamp, Handler<AsyncResult<OffsetAndTimestamp>> handler)` Look up the offset for the given partition by timestamp.
    `KafkaConsumer<K,V>` | KafkaConsumer.`partitionsAssignedHandler(Handler<Set<TopicPartition>> handler)` Set the handler called when topic partitions are assigned to the consumer
    `KafkaConsumer<K,V>` | KafkaConsumer.`partitionsFor(String topic, Handler<AsyncResult<List<PartitionInfo>>> handler)` Get metadata about the partitions for a given topic.
    `KafkaConsumer<K,V>` | KafkaConsumer.`partitionsRevokedHandler(Handler<Set<TopicPartition>> handler)` Set the handler called when topic partitions are revoked to the consumer
    `KafkaConsumer<K,V>` | KafkaConsumer.`pause(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Suspend fetching from the requested partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`pause(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Suspend fetching from the requested partition.
    `void` | KafkaConsumer.`paused(Handler<AsyncResult<Set<TopicPartition>>> handler)` Get the set of partitions that were previously paused by a call to pause(Set).
    `void` | KafkaConsumer.`pipeTo(WriteStream<KafkaConsumerRecord<K,V>> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | KafkaConsumer.`poll(long timeout, Handler<AsyncResult<KafkaConsumerRecords<K,V>>> handler)` Executes a poll for getting messages from Kafka
    `void` | KafkaConsumer.`position(TopicPartition partition, Handler<AsyncResult<Long>> handler)` Get the offset of the next record that will be fetched (if a record with that offset exists).
    `KafkaConsumer<K,V>` | KafkaConsumer.`resume(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Resume specified partitions which have been paused with pause.
    `KafkaConsumer<K,V>` | KafkaConsumer.`resume(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Resume specified partition which have been paused with pause.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seek(TopicPartition topicPartition, long offset, Handler<AsyncResult<Void>> completionHandler)` Overrides the fetch offsets that the consumer will use on the next poll.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seekToBeginning(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Seek to the first offset for each of the given partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seekToBeginning(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Seek to the first offset for each of the given partition.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seekToEnd(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Seek to the last offset for each of the given partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seekToEnd(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Seek to the last offset for each of the given partition.
    `KafkaConsumer<K,V>` | KafkaConsumer.`subscribe(Set<String> topics, Handler<AsyncResult<Void>> completionHandler)` Subscribe to the given list of topics to get dynamically assigned partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`subscribe(String topic, Handler<AsyncResult<Void>> completionHandler)` Subscribe to the given topic to get dynamically assigned partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`subscription(Handler<AsyncResult<Set<String>>> handler)` Get the current subscription.
    `KafkaConsumer<K,V>` | KafkaConsumer.`unsubscribe(Handler<AsyncResult<Void>> completionHandler)` Unsubscribe from topics currently subscribed with subscribe.

  - ### Uses of Handler in io.vertx.reactivex.kafka.client.producer

    Methods in io.vertx.reactivex.kafka.client.producer with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | KafkaProducer.`close(Handler<AsyncResult<Void>> completionHandler)` Close the producer
    `void` | KafkaProducer.`close(long timeout, Handler<AsyncResult<Void>> completionHandler)` Close the producer
    `KafkaProducer<K,V>` | KafkaProducer.`drainHandler(Handler<Void> handler)`
    `void` | KafkaProducer.`end(Handler<AsyncResult<Void>> handler)` Same as `WriteStream.end()` but with an `handler` called when the operation completes
    `void` | KafkaProducer.`end(KafkaProducerRecord<K,V> data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `KafkaProducer<K,V>` | KafkaProducer.`exceptionHandler(Handler<Throwable> handler)`
    `KafkaProducer<K,V>` | KafkaProducer.`flush(Handler<Void> completionHandler)` Invoking this method makes all buffered records immediately available to write
    `KafkaProducer<K,V>` | KafkaProducer.`partitionsFor(String topic, Handler<AsyncResult<List<PartitionInfo>>> handler)` Get the partition metadata for the give topic.
    `KafkaProducer<K,V>` | KafkaProducer.`send(KafkaProducerRecord<K,V> record, Handler<AsyncResult<RecordMetadata>> handler)` Asynchronously write a record to a topic
    `KafkaProducer<K,V>` | KafkaProducer.`write(KafkaProducerRecord<K,V> data, Handler<AsyncResult<Void>> handler)`

  - ### Uses of Handler in io.vertx.reactivex.micrometer

    Methods in io.vertx.reactivex.micrometer that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `static Handler<RoutingContext>` | PrometheusScrapingHandler.`create()` Creates a Vert.x Web `Route` handler for Prometheus metrics scraping.
    `static Handler<RoutingContext>` | PrometheusScrapingHandler.`create(String registryName)` Creates a Vert.x Web `Route` handler for Prometheus metrics scraping.

  - ### Uses of Handler in io.vertx.reactivex.mqtt

    Methods in io.vertx.reactivex.mqtt with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | MqttServer.`close(Handler<AsyncResult<Void>> completionHandler)` Close the server supplying an handler that will be called when the server is actually closed (or has failed).
    `MqttClient` | MqttClient.`closeHandler(Handler<Void> closeHandler)` Set a handler that will be called when the connection with server is closed
    `MqttEndpoint` | MqttEndpoint.`closeHandler(Handler<Void> handler)` Set a close handler.
    `MqttClient` | MqttClient.`connect(int port, String host, Handler<AsyncResult<MqttConnAckMessage>> connectHandler)` Connects to an MQTT server calling connectHandler after connection
    `MqttClient` | MqttClient.`connect(int port, String host, String serverName, Handler<AsyncResult<MqttConnAckMessage>> connectHandler)` Connects to an MQTT server calling connectHandler after connection
    `MqttClient` | MqttClient.`disconnect(Handler<AsyncResult<Void>> disconnectHandler)` Disconnects from the MQTT server calling disconnectHandler after disconnection
    `MqttEndpoint` | MqttEndpoint.`disconnectHandler(Handler<Void> handler)` Set a disconnect handler on the MQTT endpoint.
    `MqttServer` | MqttServer.`endpointHandler(Handler<MqttEndpoint> handler)` Set the endpoint handler for the server.
    `MqttClient` | MqttClient.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler for the client, that will be called when an error happens in internal netty structures.
    `MqttEndpoint` | MqttEndpoint.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler.
    `MqttServer` | MqttServer.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler for the server, that will be called when an error happens independantly of an accepted `MqttEndpoint`, like a rejected connection
    `MqttServer` | MqttServer.`listen(Handler<AsyncResult<MqttServer>> listenHandler)` Start the server listening for incoming connections using the specified options through the constructor
    `MqttServer` | MqttServer.`listen(int port, Handler<AsyncResult<MqttServer>> listenHandler)` Start the server listening for incoming connections on the port specified but on "0.0.0.0" as host.
    `MqttServer` | MqttServer.`listen(int port, String host, Handler<AsyncResult<MqttServer>> listenHandler)` Start the server listening for incoming connections on the port and host specified It ignores any options specified through the constructor
    `MqttEndpoint` | MqttEndpoint.`pingHandler(Handler<Void> handler)` Set the pingreq handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`pingResponseHandler(Handler<Void> pingResponseHandler)` Sets handler which will be called after PINGRESP packet receiving
    `MqttClient` | MqttClient.`publish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server
    `MqttEndpoint` | MqttEndpoint.`publish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server
    `MqttEndpoint` | MqttEndpoint.`publish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
    `MqttEndpoint` | MqttEndpoint.`publishAcknowledgeHandler(Handler<Integer> handler)` Set the puback handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`publishCompletionHandler(Handler<Integer> publishCompletionHandler)` Sets handler which will be called each time publish is completed
    `MqttEndpoint` | MqttEndpoint.`publishCompletionHandler(Handler<Integer> handler)` Set the pubcomp handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`publishHandler(Handler<MqttPublishMessage> publishHandler)` Sets handler which will be called each time server publish something to client
    `MqttEndpoint` | MqttEndpoint.`publishHandler(Handler<MqttPublishMessage> handler)` Set the publish handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishReceivedHandler(Handler<Integer> handler)` Set the pubrec handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishReleaseHandler(Handler<Integer> handler)` Set the pubrel handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`subscribe(Map<String,Integer> topics, Handler<AsyncResult<Integer>> subscribeSentHandler)` Subscribes to the topic and adds a handler which will be called after the request is sent
    `MqttClient` | MqttClient.`subscribe(String topic, int qos, Handler<AsyncResult<Integer>> subscribeSentHandler)` Subscribes to the topic with a specified QoS level
    `MqttClient` | MqttClient.`subscribeCompletionHandler(Handler<MqttSubAckMessage> subscribeCompletionHandler)` Sets handler which will be called after SUBACK packet receiving
    `MqttEndpoint` | MqttEndpoint.`subscribeHandler(Handler<MqttSubscribeMessage> handler)` Set a subscribe handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`unsubscribe(String topic, Handler<AsyncResult<Integer>> unsubscribeSentHandler)` Unsubscribe from receiving messages on given topic
    `MqttClient` | MqttClient.`unsubscribeCompletionHandler(Handler<Integer> unsubscribeCompletionHandler)` Sets handler which will be called after UNSUBACK packet receiving
    `MqttEndpoint` | MqttEndpoint.`unsubscribeHandler(Handler<MqttUnsubscribeMessage> handler)` Set a unsubscribe handler on the MQTT endpoint.

  - ### Uses of Handler in io.vertx.reactivex.mysqlclient

    Methods in io.vertx.reactivex.mysqlclient with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MySQLConnection` | MySQLConnection.`changeUser(MySQLAuthOptions options, Handler<AsyncResult<Void>> handler)` Send a CHANGE_USER command to change the user of the current connection, this operation will also reset connection state.
    `MySQLConnection` | MySQLConnection.`closeHandler(Handler<Void> handler)`
    `static void` | MySQLConnection.`connect(Vertx vertx, MySQLConnectOptions connectOptions, Handler<AsyncResult<MySQLConnection>> handler)` Create a connection to MySQL server with the given `connectOptions`.
    `static void` | MySQLConnection.`connect(Vertx vertx, String connectionUri, Handler<AsyncResult<MySQLConnection>> handler)` Like `MySQLConnection.connect(io.vertx.reactivex.core.Vertx, io.vertx.mysqlclient.MySQLConnectOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.mysqlclient.MySQLConnection>>)` with options build from `connectionUri`.
    `MySQLConnection` | MySQLConnection.`debug(Handler<AsyncResult<Void>> handler)` Send a DEBUG command to dump debug information to the server's stdout.
    `MySQLConnection` | MySQLConnection.`exceptionHandler(Handler<Throwable> handler)`
    `MySQLConnection` | MySQLConnection.`getInternalStatistics(Handler<AsyncResult<String>> handler)` Send a STATISTICS command to get a human readable string of the server internal status.
    `MySQLConnection` | MySQLConnection.`ping(Handler<AsyncResult<Void>> handler)` Send a PING command to check if the server is alive.
    `MySQLConnection` | MySQLConnection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)`
    `MySQLConnection` | MySQLConnection.`resetConnection(Handler<AsyncResult<Void>> handler)` Send a RESET_CONNECTION command to reset the session state.
    `MySQLConnection` | MySQLConnection.`setOption(MySQLSetOption option, Handler<AsyncResult<Void>> handler)` Send a SET_OPTION command to set options for the current connection.
    `MySQLConnection` | MySQLConnection.`specifySchema(String schemaName, Handler<AsyncResult<Void>> handler)` Send a INIT_DB command to change the default schema of the connection.

  - ### Uses of Handler in io.vertx.reactivex.pgclient

    Methods in io.vertx.reactivex.pgclient with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `PgConnection` | PgConnection.`cancelRequest(Handler<AsyncResult<Void>> handler)` Send a request cancellation message to tell the server to cancel processing request in this connection.
    `PgConnection` | PgConnection.`closeHandler(Handler<Void> handler)`
    `static void` | PgConnection.`connect(Vertx vertx, Handler<AsyncResult<PgConnection>> handler)` Like `PgConnection.connect(io.vertx.reactivex.core.Vertx, io.vertx.pgclient.PgConnectOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.pgclient.PgConnection>>)` with options build from the environment variables.
    `static void` | PgConnection.`connect(Vertx vertx, PgConnectOptions options, Handler<AsyncResult<PgConnection>> handler)` Connects to the database and returns the connection if that succeeds.
    `static void` | PgConnection.`connect(Vertx vertx, String connectionUri, Handler<AsyncResult<PgConnection>> handler)` Like `PgConnection.connect(io.vertx.reactivex.core.Vertx, io.vertx.pgclient.PgConnectOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.pgclient.PgConnection>>)` with options build from `connectionUri`.
    `PgConnection` | PgConnection.`exceptionHandler(Handler<Throwable> handler)`
    `PgConnection` | PgConnection.`notificationHandler(Handler<PgNotification> handler)` Set an handler called when the connection receives notification on a channel.
    `PgConnection` | PgConnection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)`

  - ### Uses of Handler in io.vertx.reactivex.pgclient.pubsub

    Methods in io.vertx.reactivex.pgclient.pubsub with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `PgSubscriber` | PgSubscriber.`closeHandler(Handler<Void> handler)` Set an handler called when the subscriber is closed.
    `PgSubscriber` | PgSubscriber.`connect(Handler<AsyncResult<Void>> handler)` Connect the subscriber to Postgres.
    `PgChannel` | PgChannel.`endHandler(Handler<Void> endHandler)` Set an handler to be called when no more notifications will be received.
    `PgChannel` | PgChannel.`exceptionHandler(Handler<Throwable> handler)`
    `PgChannel` | PgChannel.`handler(Handler<String> handler)` Set or unset an handler to be called when a the channel is notified by Postgres.
    `void` | PgChannel.`pipeTo(WriteStream<String> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `PgChannel` | PgChannel.`subscribeHandler(Handler<Void> handler)` Set an handler called when the the channel get subscribed.

  - ### Uses of Handler in io.vertx.reactivex.rabbitmq

    Methods in io.vertx.reactivex.rabbitmq with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | RabbitMQClient.`basicAck(long deliveryTag, boolean multiple, Handler<AsyncResult<JsonObject>> resultHandler)` Acknowledge one or several received messages.
    `void` | RabbitMQClient.`basicCancel(String consumerTag, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `void` | RabbitMQClient.`basicConsume(String queue, String address, boolean autoAck, Handler<AsyncResult<String>> resultHandler)` Deprecated.
    `void` | RabbitMQClient.`basicConsume(String queue, String address, boolean autoAck, Handler<AsyncResult<String>> resultHandler, Handler<Throwable> errorHandler)` Deprecated.
    `void` | RabbitMQClient.`basicConsume(String queue, String address, boolean autoAck, Handler<AsyncResult<String>> resultHandler, Handler<Throwable> errorHandler)` Deprecated.
    `void` | RabbitMQClient.`basicConsume(String queue, String address, Handler<AsyncResult<String>> resultHandler)` Deprecated.
    `void` | RabbitMQClient.`basicConsumer(String queue, Handler<AsyncResult<RabbitMQConsumer>> resultHandler)`
    `void` | RabbitMQClient.`basicConsumer(String queue, QueueOptions options, Handler<AsyncResult<RabbitMQConsumer>> resultHandler)` Create a consumer with the given `options`.
    `void` | RabbitMQClient.`basicGet(String queue, boolean autoAck, Handler<AsyncResult<JsonObject>> resultHandler)` Retrieve a message from a queue using AMQP.Basic.Get
    `void` | RabbitMQClient.`basicNack(long deliveryTag, boolean multiple, boolean requeue, Handler<AsyncResult<JsonObject>> resultHandler)` Reject one or several received messages.
    `void` | RabbitMQClient.`basicPublish(String exchange, String routingKey, JsonObject message, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `void` | RabbitMQClient.`basicQos(int prefetchCount, boolean global, Handler<AsyncResult<Void>> resultHandler)` Request a specific prefetchCount "quality of service" settings for this channel.
    `void` | RabbitMQClient.`basicQos(int prefetchCount, Handler<AsyncResult<Void>> resultHandler)` Request a specific prefetchCount "quality of service" settings for this channel.
    `void` | RabbitMQClient.`basicQos(int prefetchSize, int prefetchCount, boolean global, Handler<AsyncResult<Void>> resultHandler)` Request specific "quality of service" settings.
    `void` | RabbitMQConsumer.`cancel(Handler<AsyncResult<Void>> cancelResult)` Stop message consumption from a queue.
    `void` | RabbitMQClient.`confirmSelect(Handler<AsyncResult<Void>> resultHandler)` Enables publisher acknowledgements on this channel.
    `RabbitMQConsumer` | RabbitMQConsumer.`endHandler(Handler<Void> endHandler)` Set an end handler.
    `RabbitMQConsumer` | RabbitMQConsumer.`exceptionHandler(Handler<Throwable> exceptionHandler)` Set an exception handler on the read stream.
    `void` | RabbitMQClient.`exchangeBind(String destination, String source, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Bind an exchange to an exchange.
    `void` | RabbitMQClient.`exchangeBind(String destination, String source, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Bind an exchange to an exchange.
    `void` | RabbitMQClient.`exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, Handler<AsyncResult<Void>> resultHandler)` Declare an exchange.
    `void` | RabbitMQClient.`exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, JsonObject config, Handler<AsyncResult<Void>> resultHandler)` Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
    `void` | RabbitMQClient.`exchangeDelete(String exchange, Handler<AsyncResult<Void>> resultHandler)` Delete an exchange, without regard for whether it is in use or not.
    `void` | RabbitMQClient.`exchangeUnbind(String destination, String source, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Unbind an exchange from an exchange.
    `void` | RabbitMQClient.`exchangeUnbind(String destination, String source, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Unbind an exchange from an exchange.
    `RabbitMQConsumer` | RabbitMQConsumer.`handler(Handler<RabbitMQMessage> messageArrived)` Set a message handler.
    `void` | RabbitMQClient.`messageCount(String queue, Handler<AsyncResult<Long>> resultHandler)` Returns the number of messages in a queue ready to be delivered.
    `void` | RabbitMQConsumer.`pipeTo(WriteStream<RabbitMQMessage> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | RabbitMQClient.`queueBind(String queue, String exchange, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Bind a queue to an exchange
    `void` | RabbitMQClient.`queueBind(String queue, String exchange, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Bind a queue to an exchange
    `void` | RabbitMQClient.`queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Handler<AsyncResult<JsonObject>> resultHandler)` Declare a queue
    `void` | RabbitMQClient.`queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, JsonObject config, Handler<AsyncResult<JsonObject>> resultHandler)` Declare a queue with config options
    `void` | RabbitMQClient.`queueDeclareAuto(Handler<AsyncResult<JsonObject>> resultHandler)` Actively declare a server-named exclusive, autodelete, non-durable queue.
    `void` | RabbitMQClient.`queueDelete(String queue, Handler<AsyncResult<JsonObject>> resultHandler)` Delete a queue, without regard for whether it is in use or has messages on it
    `void` | RabbitMQClient.`queueDeleteIf(String queue, boolean ifUnused, boolean ifEmpty, Handler<AsyncResult<JsonObject>> resultHandler)` Delete a queue
    `void` | RabbitMQClient.`queueUnbind(String queue, String exchange, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Unbind a queue from an exchange
    `void` | RabbitMQClient.`queueUnbind(String queue, String exchange, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Unbind a queue from an exchange
    `void` | RabbitMQClient.`start(Handler<AsyncResult<Void>> resultHandler)` Start the rabbitMQ client.
    `void` | RabbitMQClient.`stop(Handler<AsyncResult<Void>> resultHandler)` Stop the rabbitMQ client.
    `void` | RabbitMQClient.`waitForConfirms(Handler<AsyncResult<Void>> resultHandler)` Wait until all messages published since the last call have been either ack'd or nack'd by the broker.
    `void` | RabbitMQClient.`waitForConfirms(long timeout, Handler<AsyncResult<Void>> resultHandler)` Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses.

  - ### Uses of Handler in io.vertx.reactivex.redis

    Methods in io.vertx.reactivex.redis with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `RedisClient` | RedisClient.`append(String key, String value, Handler<AsyncResult<Long>> handler)` Append a value to a key
    `RedisTransaction` | RedisTransaction.`append(String key, String value, Handler<AsyncResult<String>> handler)` Append a value to a key
    `RedisTransaction` | RedisTransaction.`auth(String password, Handler<AsyncResult<String>> handler)` Authenticate to the server
    `RedisClient` | RedisClient.`auth(String password, Handler<AsyncResult<String>> handler)` Authenticate to the server
    `RedisTransaction` | RedisTransaction.`bgrewriteaof(Handler<AsyncResult<String>> handler)` Asynchronously rewrite the append-only file
    `RedisClient` | RedisClient.`bgrewriteaof(Handler<AsyncResult<String>> handler)` Asynchronously rewrite the append-only file
    `RedisTransaction` | RedisTransaction.`bgsave(Handler<AsyncResult<String>> handler)` Asynchronously save the dataset to disk
    `RedisClient` | RedisClient.`bgsave(Handler<AsyncResult<String>> handler)` Asynchronously save the dataset to disk
    `RedisClient` | RedisClient.`bitcount(String key, Handler<AsyncResult<Long>> handler)` Count set bits in a string
    `RedisTransaction` | RedisTransaction.`bitcount(String key, Handler<AsyncResult<String>> handler)` Count set bits in a string
    `RedisClient` | RedisClient.`bitcountRange(String key, long start, long end, Handler<AsyncResult<Long>> handler)` Count set bits in a string
    `RedisTransaction` | RedisTransaction.`bitcountRange(String key, long start, long end, Handler<AsyncResult<String>> handler)` Count set bits in a string
    `RedisClient` | RedisClient.`bitfield(String key, BitFieldOptions bitFieldOptions, Handler<AsyncResult<JsonArray>> handler)` Perform arbitrary bitfield integer operations on strings.
    `RedisClient` | RedisClient.`bitfieldWithOverflow(String key, BitFieldOptions commands, BitFieldOverflowOptions overflow, Handler<AsyncResult<JsonArray>> handler)` Perform arbitrary bitfield integer operations on strings.
    `RedisClient` | RedisClient.`bitop(BitOperation operation, String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Perform bitwise operations between strings
    `RedisTransaction` | RedisTransaction.`bitop(BitOperation operation, String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Perform bitwise operations between strings
    `RedisClient` | RedisClient.`bitpos(String key, int bit, Handler<AsyncResult<Long>> handler)` Find first bit set or clear in a string
    `RedisTransaction` | RedisTransaction.`bitpos(String key, int bit, Handler<AsyncResult<String>> handler)` Find first bit set or clear in a string
    `RedisClient` | RedisClient.`bitposFrom(String key, int bit, int start, Handler<AsyncResult<Long>> handler)` Find first bit set or clear in a string See also bitposRange() method, which takes start, and stop offset.
    `RedisTransaction` | RedisTransaction.`bitposFrom(String key, int bit, int start, Handler<AsyncResult<String>> handler)` Find first bit set or clear in a string
    `RedisClient` | RedisClient.`bitposRange(String key, int bit, int start, int stop, Handler<AsyncResult<Long>> handler)` Find first bit set or clear in a string Note: when both start, and stop offsets are specified, behaviour is slightly different than if only start is specified
    `RedisTransaction` | RedisTransaction.`bitposRange(String key, int bit, int start, int stop, Handler<AsyncResult<String>> handler)` Find first bit set or clear in a string
    `RedisClient` | RedisClient.`blpop(String key, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the first element in a list, or block until one is available
    `RedisTransaction` | RedisTransaction.`blpop(String key, int seconds, Handler<AsyncResult<String>> handler)` Remove and get the first element in a list, or block until one is available
    `RedisClient` | RedisClient.`blpopMany(List<String> keys, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the first element in any of the lists, or block until one is available
    `RedisTransaction` | RedisTransaction.`blpopMany(List<String> keys, int seconds, Handler<AsyncResult<String>> handler)` Remove and get the first element in any of the lists, or block until one is available
    `RedisClient` | RedisClient.`brpop(String key, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the last element in a list, or block until one is available
    `RedisTransaction` | RedisTransaction.`brpop(String key, int seconds, Handler<AsyncResult<String>> handler)` Remove and get the last element in a list, or block until one is available
    `RedisTransaction` | RedisTransaction.`brpoplpush(String key, String destkey, int seconds, Handler<AsyncResult<String>> handler)` Pop a value from a list, push it to another list and return it; or block until one is available
    `RedisClient` | RedisClient.`brpoplpush(String key, String destkey, int seconds, Handler<AsyncResult<String>> handler)` Pop a value from a list, push it to another list and return it; or block until one is available
    `RedisClient` | RedisClient.`brpopMany(List<String> keys, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the last element in any of the lists, or block until one is available
    `RedisTransaction` | RedisTransaction.`brpopMany(List<String> keys, int seconds, Handler<AsyncResult<String>> handler)` Remove and get the last element in any of the lists, or block until one is available
    `RedisTransaction` | RedisTransaction.`clientGetname(Handler<AsyncResult<String>> handler)` Get the current connection name
    `RedisClient` | RedisClient.`clientGetname(Handler<AsyncResult<String>> handler)` Get the current connection name
    `RedisClient` | RedisClient.`clientKill(KillFilter filter, Handler<AsyncResult<Long>> handler)` Kill the connection of a client
    `RedisTransaction` | RedisTransaction.`clientKill(KillFilter filter, Handler<AsyncResult<String>> handler)` Kill the connection of a client
    `RedisTransaction` | RedisTransaction.`clientList(Handler<AsyncResult<String>> handler)` Get the list of client connections
    `RedisClient` | RedisClient.`clientList(Handler<AsyncResult<String>> handler)` Get the list of client connections
    `RedisTransaction` | RedisTransaction.`clientPause(long millis, Handler<AsyncResult<String>> handler)` Stop processing commands from clients for some time
    `RedisClient` | RedisClient.`clientPause(long millis, Handler<AsyncResult<String>> handler)` Stop processing commands from clients for some time
    `RedisClient` | RedisClient.`clientReply(ClientReplyOptions options, Handler<AsyncResult<String>> handler)` Instruct the server whether to reply to commands.
    `RedisTransaction` | RedisTransaction.`clientSetname(String name, Handler<AsyncResult<String>> handler)` Set the current connection name
    `RedisClient` | RedisClient.`clientSetname(String name, Handler<AsyncResult<String>> handler)` Set the current connection name
    `void` | RedisTransaction.`close(Handler<AsyncResult<Void>> handler)` Close the client - when it is fully closed the handler will be called.
    `void` | RedisClient.`close(Handler<AsyncResult<Void>> handler)` Close the client - when it is fully closed the handler will be called.
    `RedisClient` | RedisClient.`clusterAddslots(List<Long> slots, Handler<AsyncResult<Void>> handler)` Assign new hash slots to receiving node.
    `RedisTransaction` | RedisTransaction.`clusterAddslots(List<String> slots, Handler<AsyncResult<String>> handler)` Assign new hash slots to receiving node.
    `RedisClient` | RedisClient.`clusterCountFailureReports(String nodeId, Handler<AsyncResult<Long>> handler)` Return the number of failure reports active for a given node.
    `RedisTransaction` | RedisTransaction.`clusterCountFailureReports(String nodeId, Handler<AsyncResult<String>> handler)` Return the number of failure reports active for a given node.
    `RedisClient` | RedisClient.`clusterCountkeysinslot(long slot, Handler<AsyncResult<Long>> handler)` Return the number of local keys in the specified hash slot.
    `RedisTransaction` | RedisTransaction.`clusterCountkeysinslot(long slot, Handler<AsyncResult<String>> handler)` Return the number of local keys in the specified hash slot.
    `RedisTransaction` | RedisTransaction.`clusterDelslots(long slot, Handler<AsyncResult<String>> handler)` Set hash slots as unbound in receiving node.
    `RedisClient` | RedisClient.`clusterDelslots(long slot, Handler<AsyncResult<Void>> handler)` Set hash slots as unbound in receiving node.
    `RedisClient` | RedisClient.`clusterDelslotsMany(List<Long> slots, Handler<AsyncResult<Void>> handler)` Set hash slots as unbound in receiving node.
    `RedisTransaction` | RedisTransaction.`clusterDelslotsMany(List<String> slots, Handler<AsyncResult<String>> handler)` Set hash slots as unbound in receiving node.
    `RedisTransaction` | RedisTransaction.`clusterFailover(Handler<AsyncResult<String>> handler)` Forces a slave to perform a manual failover of its master.
    `RedisClient` | RedisClient.`clusterFailover(Handler<AsyncResult<Void>> handler)` Forces a slave to perform a manual failover of its master.
    `RedisTransaction` | RedisTransaction.`clusterFailOverWithOptions(FailoverOptions options, Handler<AsyncResult<String>> handler)` Forces a slave to perform a manual failover of its master.
    `RedisClient` | RedisClient.`clusterFailOverWithOptions(FailoverOptions options, Handler<AsyncResult<Void>> handler)` Forces a slave to perform a manual failover of its master.
    `RedisTransaction` | RedisTransaction.`clusterForget(String nodeId, Handler<AsyncResult<String>> handler)` Remove a node from the nodes table.
    `RedisClient` | RedisClient.`clusterForget(String nodeId, Handler<AsyncResult<Void>> handler)` Remove a node from the nodes table.
    `RedisClient` | RedisClient.`clusterGetkeysinslot(long slot, long count, Handler<AsyncResult<JsonArray>> handler)` Return local key names in the specified hash slot.
    `RedisTransaction` | RedisTransaction.`clusterGetkeysinslot(long slot, long count, Handler<AsyncResult<String>> handler)` Return local key names in the specified hash slot.
    `RedisClient` | RedisClient.`clusterInfo(Handler<AsyncResult<JsonArray>> handler)` Provides info about Redis Cluster node state.
    `RedisTransaction` | RedisTransaction.`clusterInfo(Handler<AsyncResult<String>> handler)` Provides info about Redis Cluster node state.
    `RedisClient` | RedisClient.`clusterKeyslot(String key, Handler<AsyncResult<Long>> handler)` Returns the hash slot of the specified key.
    `RedisTransaction` | RedisTransaction.`clusterKeyslot(String key, Handler<AsyncResult<String>> handler)` Returns the hash slot of the specified key.
    `RedisTransaction` | RedisTransaction.`clusterMeet(String ip, long port, Handler<AsyncResult<String>> handler)` Force a node cluster to handshake with another node.
    `RedisClient` | RedisClient.`clusterMeet(String ip, long port, Handler<AsyncResult<Void>> handler)` Force a node cluster to handshake with another node.
    `RedisClient` | RedisClient.`clusterNodes(Handler<AsyncResult<JsonArray>> handler)` Get Cluster config for the node.
    `RedisTransaction` | RedisTransaction.`clusterNodes(Handler<AsyncResult<String>> handler)` Get Cluster config for the node.
    `RedisTransaction` | RedisTransaction.`clusterReplicate(String nodeId, Handler<AsyncResult<String>> handler)` Reconfigure a node as a slave of the specified master node.
    `RedisClient` | RedisClient.`clusterReplicate(String nodeId, Handler<AsyncResult<Void>> handler)` Reconfigure a node as a slave of the specified master node.
    `RedisTransaction` | RedisTransaction.`clusterReset(Handler<AsyncResult<String>> handler)` Reset a Redis Cluster node.
    `RedisClient` | RedisClient.`clusterReset(Handler<AsyncResult<Void>> handler)` Reset a Redis Cluster node.
    `RedisTransaction` | RedisTransaction.`clusterResetWithOptions(ResetOptions options, Handler<AsyncResult<String>> handler)` Reset a Redis Cluster node.
    `RedisClient` | RedisClient.`clusterResetWithOptions(ResetOptions options, Handler<AsyncResult<Void>> handler)` Reset a Redis Cluster node.
    `RedisTransaction` | RedisTransaction.`clusterSaveconfig(Handler<AsyncResult<String>> handler)` Forces the node to save cluster state on disk.
    `RedisClient` | RedisClient.`clusterSaveconfig(Handler<AsyncResult<Void>> handler)` Forces the node to save cluster state on disk.
    `RedisTransaction` | RedisTransaction.`clusterSetConfigEpoch(long epoch, Handler<AsyncResult<String>> handler)` Set the configuration epoch in a new node.
    `RedisClient` | RedisClient.`clusterSetConfigEpoch(long epoch, Handler<AsyncResult<Void>> handler)` Set the configuration epoch in a new node.
    `RedisTransaction` | RedisTransaction.`clusterSetslot(long slot, SlotCmd subcommand, Handler<AsyncResult<String>> handler)` Bind an hash slot to a specific node.
    `RedisClient` | RedisClient.`clusterSetslot(long slot, SlotCmd subcommand, Handler<AsyncResult<Void>> handler)` Bind an hash slot to a specific node.
    `RedisTransaction` | RedisTransaction.`clusterSetslotWithNode(long slot, SlotCmd subcommand, String nodeId, Handler<AsyncResult<String>> handler)` Bind an hash slot to a specific node.
    `RedisClient` | RedisClient.`clusterSetslotWithNode(long slot, SlotCmd subcommand, String nodeId, Handler<AsyncResult<Void>> handler)` Bind an hash slot to a specific node.
    `RedisClient` | RedisClient.`clusterSlaves(String nodeId, Handler<AsyncResult<JsonArray>> handler)` List slave nodes of the specified master node.
    `RedisTransaction` | RedisTransaction.`clusterSlaves(String nodeId, Handler<AsyncResult<String>> handler)` List slave nodes of the specified master node.
    `RedisClient` | RedisClient.`clusterSlots(Handler<AsyncResult<JsonArray>> handler)` Get array of Cluster slot to node mappings
    `RedisTransaction` | RedisTransaction.`clusterSlots(Handler<AsyncResult<String>> handler)` Get array of Cluster slot to node mappings
    `RedisClient` | RedisClient.`command(Handler<AsyncResult<JsonArray>> handler)` Get array of Redis command details
    `RedisTransaction` | RedisTransaction.`command(Handler<AsyncResult<String>> handler)` Get array of Redis command details
    `RedisClient` | RedisClient.`commandCount(Handler<AsyncResult<Long>> handler)` Get total number of Redis commands
    `RedisTransaction` | RedisTransaction.`commandCount(Handler<AsyncResult<String>> handler)` Get total number of Redis commands
    `RedisClient` | RedisClient.`commandGetkeys(Handler<AsyncResult<JsonArray>> handler)` Extract keys given a full Redis command
    `RedisTransaction` | RedisTransaction.`commandGetkeys(Handler<AsyncResult<String>> handler)` Extract keys given a full Redis command
    `RedisClient` | RedisClient.`commandInfo(List<String> commands, Handler<AsyncResult<JsonArray>> handler)` Get array of specific Redis command details
    `RedisTransaction` | RedisTransaction.`commandInfo(List<String> commands, Handler<AsyncResult<String>> handler)` Get array of specific Redis command details
    `RedisClient` | RedisClient.`configGet(String parameter, Handler<AsyncResult<JsonArray>> handler)` Get the value of a configuration parameter
    `RedisTransaction` | RedisTransaction.`configGet(String parameter, Handler<AsyncResult<String>> handler)` Get the value of a configuration parameter
    `RedisTransaction` | RedisTransaction.`configResetstat(Handler<AsyncResult<String>> handler)` Reset the stats returned by INFO
    `RedisClient` | RedisClient.`configResetstat(Handler<AsyncResult<String>> handler)` Reset the stats returned by INFO
    `RedisTransaction` | RedisTransaction.`configRewrite(Handler<AsyncResult<String>> handler)` Rewrite the configuration file with the in memory configuration
    `RedisClient` | RedisClient.`configRewrite(Handler<AsyncResult<String>> handler)` Rewrite the configuration file with the in memory configuration
    `RedisTransaction` | RedisTransaction.`configSet(String parameter, String value, Handler<AsyncResult<String>> handler)` Set a configuration parameter to the given value
    `RedisClient` | RedisClient.`configSet(String parameter, String value, Handler<AsyncResult<String>> handler)` Set a configuration parameter to the given value
    `RedisClient` | RedisClient.`dbsize(Handler<AsyncResult<Long>> handler)` Return the number of keys in the selected database
    `RedisTransaction` | RedisTransaction.`dbsize(Handler<AsyncResult<String>> handler)` Return the number of keys in the selected database
    `RedisTransaction` | RedisTransaction.`debugObject(String key, Handler<AsyncResult<String>> handler)` Get debugging information about a key
    `RedisClient` | RedisClient.`debugObject(String key, Handler<AsyncResult<String>> handler)` Get debugging information about a key
    `RedisTransaction` | RedisTransaction.`debugSegfault(Handler<AsyncResult<String>> handler)` Make the server crash
    `RedisClient` | RedisClient.`debugSegfault(Handler<AsyncResult<String>> handler)` Make the server crash
    `RedisClient` | RedisClient.`decr(String key, Handler<AsyncResult<Long>> handler)` Decrement the integer value of a key by one
    `RedisTransaction` | RedisTransaction.`decr(String key, Handler<AsyncResult<String>> handler)` Decrement the integer value of a key by one
    `RedisClient` | RedisClient.`decrby(String key, long decrement, Handler<AsyncResult<Long>> handler)` Decrement the integer value of a key by the given number
    `RedisTransaction` | RedisTransaction.`decrby(String key, long decrement, Handler<AsyncResult<String>> handler)` Decrement the integer value of a key by the given number
    `RedisClient` | RedisClient.`del(String key, Handler<AsyncResult<Long>> handler)` Delete a key
    `RedisTransaction` | RedisTransaction.`del(String key, Handler<AsyncResult<String>> handler)` Delete a key
    `RedisClient` | RedisClient.`delMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Delete many keys
    `RedisTransaction` | RedisTransaction.`delMany(List<String> keys, Handler<AsyncResult<String>> handler)` Delete many keys
    `RedisTransaction` | RedisTransaction.`discard(Handler<AsyncResult<String>> handler)` Discard all commands issued after MULTI
    `RedisTransaction` | RedisTransaction.`dump(String key, Handler<AsyncResult<String>> handler)` Return a serialized version of the value stored at the specified key.
    `RedisClient` | RedisClient.`dump(String key, Handler<AsyncResult<String>> handler)` Return a serialized version of the value stored at the specified key.
    `RedisTransaction` | RedisTransaction.`echo(String message, Handler<AsyncResult<String>> handler)` Echo the given string
    `RedisClient` | RedisClient.`echo(String message, Handler<AsyncResult<String>> handler)` Echo the given string
    `RedisClient` | RedisClient.`eval(String script, List<String> keys, List<String> args, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `RedisTransaction` | RedisTransaction.`eval(String script, List<String> keys, List<String> args, Handler<AsyncResult<String>> handler)` Execute a Lua script server side.
    `RedisClient` | RedisClient.`evalScript(Script script, List<String> keys, List<String> args, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `RedisClient` | RedisClient.`evalsha(String sha1, List<String> keys, List<String> values, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `RedisTransaction` | RedisTransaction.`evalsha(String sha1, List<String> keys, List<String> values, Handler<AsyncResult<String>> handler)` Execute a Lua script server side.
    `RedisTransaction` | RedisTransaction.`exec(Handler<AsyncResult<JsonArray>> handler)` Execute all commands issued after MULTI
    `RedisClient` | RedisClient.`exists(String key, Handler<AsyncResult<Long>> handler)` Determine if a key exists
    `RedisTransaction` | RedisTransaction.`exists(String key, Handler<AsyncResult<String>> handler)` Determine if a key exists
    `RedisClient` | RedisClient.`existsMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Determine if one or many keys exist
    `RedisTransaction` | RedisTransaction.`existsMany(List<String> keys, Handler<AsyncResult<String>> handler)` Determine if one or many keys exist
    `RedisTransaction` | RedisTransaction.`expire(String key, int seconds, Handler<AsyncResult<String>> handler)` Set a key's time to live in seconds
    `RedisClient` | RedisClient.`expire(String key, long seconds, Handler<AsyncResult<Long>> handler)` Set a key's time to live in seconds
    `RedisClient` | RedisClient.`expireat(String key, long seconds, Handler<AsyncResult<Long>> handler)` Set the expiration for a key as a UNIX timestamp
    `RedisTransaction` | RedisTransaction.`expireat(String key, long seconds, Handler<AsyncResult<String>> handler)` Set the expiration for a key as a UNIX timestamp
    `RedisTransaction` | RedisTransaction.`flushall(Handler<AsyncResult<String>> handler)` Remove all keys from all databases
    `RedisClient` | RedisClient.`flushall(Handler<AsyncResult<String>> handler)` Remove all keys from all databases
    `RedisTransaction` | RedisTransaction.`flushdb(Handler<AsyncResult<String>> handler)` Remove all keys from the current database
    `RedisClient` | RedisClient.`flushdb(Handler<AsyncResult<String>> handler)` Remove all keys from the current database
    `RedisClient` | RedisClient.`geoadd(String key, double longitude, double latitude, String member, Handler<AsyncResult<Long>> handler)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `RedisTransaction` | RedisTransaction.`geoadd(String key, double longitude, double latitude, String member, Handler<AsyncResult<String>> handler)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `RedisClient` | RedisClient.`geoaddMany(String key, List<GeoMember> members, Handler<AsyncResult<Long>> handler)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `RedisTransaction` | RedisTransaction.`geoaddMany(String key, List<GeoMember> members, Handler<AsyncResult<String>> handler)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `RedisTransaction` | RedisTransaction.`geodist(String key, String member1, String member2, Handler<AsyncResult<String>> handler)` Return the distance between two members in the geospatial index represented by the sorted set.
    `RedisClient` | RedisClient.`geodist(String key, String member1, String member2, Handler<AsyncResult<String>> handler)` Return the distance between two members in the geospatial index represented by the sorted set.
    `RedisTransaction` | RedisTransaction.`geodistWithUnit(String key, String member1, String member2, GeoUnit unit, Handler<AsyncResult<String>> handler)` Return the distance between two members in the geospatial index represented by the sorted set.
    `RedisClient` | RedisClient.`geodistWithUnit(String key, String member1, String member2, GeoUnit unit, Handler<AsyncResult<String>> handler)` Return the distance between two members in the geospatial index represented by the sorted set.
    `RedisClient` | RedisClient.`geohash(String key, String member, Handler<AsyncResult<JsonArray>> handler)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `RedisTransaction` | RedisTransaction.`geohash(String key, String member, Handler<AsyncResult<String>> handler)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `RedisClient` | RedisClient.`geohashMany(String key, List<String> members, Handler<AsyncResult<JsonArray>> handler)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `RedisTransaction` | RedisTransaction.`geohashMany(String key, List<String> members, Handler<AsyncResult<String>> handler)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `RedisClient` | RedisClient.`geopos(String key, String member, Handler<AsyncResult<JsonArray>> handler)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `RedisTransaction` | RedisTransaction.`geopos(String key, String member, Handler<AsyncResult<String>> handler)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `RedisClient` | RedisClient.`geoposMany(String key, List<String> members, Handler<AsyncResult<JsonArray>> handler)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `RedisTransaction` | RedisTransaction.`geoposMany(String key, List<String> members, Handler<AsyncResult<String>> handler)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `RedisClient` | RedisClient.`georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, Handler<AsyncResult<JsonArray>> handler)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `RedisTransaction` | RedisTransaction.`georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, Handler<AsyncResult<String>> handler)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `RedisClient` | RedisClient.`georadiusbymember(String key, String member, double radius, GeoUnit unit, Handler<AsyncResult<JsonArray>> handler)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `RedisTransaction` | RedisTransaction.`georadiusbymember(String key, String member, double radius, GeoUnit unit, Handler<AsyncResult<String>> handler)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `RedisClient` | RedisClient.`georadiusbymemberWithOptions(String key, String member, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<JsonArray>> handler)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `RedisTransaction` | RedisTransaction.`georadiusbymemberWithOptions(String key, String member, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<String>> handler)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `RedisClient` | RedisClient.`georadiusWithOptions(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<JsonArray>> handler)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `RedisTransaction` | RedisTransaction.`georadiusWithOptions(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<String>> handler)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `RedisTransaction` | RedisTransaction.`get(String key, Handler<AsyncResult<String>> handler)` Get the value of a key
    `RedisClient` | RedisClient.`get(String key, Handler<AsyncResult<String>> handler)` Get the value of a key
    `RedisTransaction` | RedisTransaction.`getBinary(String key, Handler<AsyncResult<Buffer>> handler)` Get the value of a key - without decoding as utf-8
    `RedisClient` | RedisClient.`getBinary(String key, Handler<AsyncResult<Buffer>> handler)` Get the value of a key - without decoding as utf-8
    `RedisClient` | RedisClient.`getbit(String key, long offset, Handler<AsyncResult<Long>> handler)` Returns the bit value at offset in the string value stored at key
    `RedisTransaction` | RedisTransaction.`getbit(String key, long offset, Handler<AsyncResult<String>> handler)` Returns the bit value at offset in the string value stored at key
    `RedisTransaction` | RedisTransaction.`getrange(String key, long start, long end, Handler<AsyncResult<String>> handler)` Get a substring of the string stored at a key
    `RedisClient` | RedisClient.`getrange(String key, long start, long end, Handler<AsyncResult<String>> handler)` Get a substring of the string stored at a key
    `RedisTransaction` | RedisTransaction.`getset(String key, String value, Handler<AsyncResult<String>> handler)` Set the string value of a key and return its old value
    `RedisClient` | RedisClient.`getset(String key, String value, Handler<AsyncResult<String>> handler)` Set the string value of a key and return its old value
    `RedisClient` | RedisClient.`hdel(String key, String field, Handler<AsyncResult<Long>> handler)` Delete one or more hash fields
    `RedisTransaction` | RedisTransaction.`hdel(String key, String field, Handler<AsyncResult<String>> handler)` Delete one or more hash fields
    `RedisClient` | RedisClient.`hdelMany(String key, List<String> fields, Handler<AsyncResult<Long>> handler)` Delete one or more hash fields
    `RedisTransaction` | RedisTransaction.`hdelMany(String key, List<String> fields, Handler<AsyncResult<String>> handler)` Delete one or more hash fields
    `RedisClient` | RedisClient.`hexists(String key, String field, Handler<AsyncResult<Long>> handler)` Determine if a hash field exists
    `RedisTransaction` | RedisTransaction.`hexists(String key, String field, Handler<AsyncResult<String>> handler)` Determine if a hash field exists
    `RedisTransaction` | RedisTransaction.`hget(String key, String field, Handler<AsyncResult<String>> handler)` Get the value of a hash field
    `RedisClient` | RedisClient.`hget(String key, String field, Handler<AsyncResult<String>> handler)` Get the value of a hash field
    `RedisClient` | RedisClient.`hgetall(String key, Handler<AsyncResult<JsonObject>> handler)` Get all the fields and values in a hash
    `RedisTransaction` | RedisTransaction.`hgetall(String key, Handler<AsyncResult<String>> handler)` Get all the fields and values in a hash
    `RedisClient` | RedisClient.`hincrby(String key, String field, long increment, Handler<AsyncResult<Long>> handler)` Increment the integer value of a hash field by the given number
    `RedisTransaction` | RedisTransaction.`hincrby(String key, String field, long increment, Handler<AsyncResult<String>> handler)` Increment the integer value of a hash field by the given number
    `RedisTransaction` | RedisTransaction.`hincrbyfloat(String key, String field, double increment, Handler<AsyncResult<String>> handler)` Increment the float value of a hash field by the given amount
    `RedisClient` | RedisClient.`hincrbyfloat(String key, String field, double increment, Handler<AsyncResult<String>> handler)` Increment the float value of a hash field by the given amount
    `RedisClient` | RedisClient.`hkeys(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the fields in a hash
    `RedisTransaction` | RedisTransaction.`hkeys(String key, Handler<AsyncResult<String>> handler)` Get all the fields in a hash
    `RedisClient` | RedisClient.`hlen(String key, Handler<AsyncResult<Long>> handler)` Get the number of fields in a hash
    `RedisTransaction` | RedisTransaction.`hlen(String key, Handler<AsyncResult<String>> handler)` Get the number of fields in a hash
    `RedisClient` | RedisClient.`hmget(String key, List<String> fields, Handler<AsyncResult<JsonArray>> handler)` Get the values of all the given hash fields
    `RedisTransaction` | RedisTransaction.`hmget(String key, List<String> fields, Handler<AsyncResult<String>> handler)` Get the values of all the given hash fields
    `RedisTransaction` | RedisTransaction.`hmset(String key, JsonObject values, Handler<AsyncResult<String>> handler)` Set multiple hash fields to multiple values
    `RedisClient` | RedisClient.`hmset(String key, JsonObject values, Handler<AsyncResult<String>> handler)` Set multiple hash fields to multiple values
    `RedisClient` | RedisClient.`hscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate hash fields and associated values
    `RedisTransaction` | RedisTransaction.`hscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<String>> handler)` Incrementally iterate hash fields and associated values
    `RedisClient` | RedisClient.`hset(String key, String field, String value, Handler<AsyncResult<Long>> handler)` Set the string value of a hash field
    `RedisTransaction` | RedisTransaction.`hset(String key, String field, String value, Handler<AsyncResult<String>> handler)` Set the string value of a hash field
    `RedisClient` | RedisClient.`hsetnx(String key, String field, String value, Handler<AsyncResult<Long>> handler)` Set the value of a hash field, only if the field does not exist
    `RedisTransaction` | RedisTransaction.`hsetnx(String key, String field, String value, Handler<AsyncResult<String>> handler)` Set the value of a hash field, only if the field does not exist
    `RedisClient` | RedisClient.`hstrlen(String key, String field, Handler<AsyncResult<Long>> handler)` Get the length of the value of a hash field.
    `RedisClient` | RedisClient.`hvals(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the values in a hash
    `RedisTransaction` | RedisTransaction.`hvals(String key, Handler<AsyncResult<String>> handler)` Get all the values in a hash
    `RedisClient` | RedisClient.`incr(String key, Handler<AsyncResult<Long>> handler)` Increment the integer value of a key by one
    `RedisTransaction` | RedisTransaction.`incr(String key, Handler<AsyncResult<String>> handler)` Increment the integer value of a key by one
    `RedisClient` | RedisClient.`incrby(String key, long increment, Handler<AsyncResult<Long>> handler)` Increment the integer value of a key by the given amount
    `RedisTransaction` | RedisTransaction.`incrby(String key, long increment, Handler<AsyncResult<String>> handler)` Increment the integer value of a key by the given amount
    `RedisTransaction` | RedisTransaction.`incrbyfloat(String key, double increment, Handler<AsyncResult<String>> handler)` Increment the float value of a key by the given amount
    `RedisClient` | RedisClient.`incrbyfloat(String key, double increment, Handler<AsyncResult<String>> handler)` Increment the float value of a key by the given amount
    `RedisClient` | RedisClient.`info(Handler<AsyncResult<JsonObject>> handler)` Get information and statistics about the server
    `RedisTransaction` | RedisTransaction.`info(Handler<AsyncResult<String>> handler)` Get information and statistics about the server
    `RedisClient` | RedisClient.`infoSection(String section, Handler<AsyncResult<JsonObject>> handler)` Get information and statistics about the server
    `RedisTransaction` | RedisTransaction.`infoSection(String section, Handler<AsyncResult<String>> handler)` Get information and statistics about the server
    `RedisClient` | RedisClient.`keys(String pattern, Handler<AsyncResult<JsonArray>> handler)` Find all keys matching the given pattern
    `RedisTransaction` | RedisTransaction.`keys(String pattern, Handler<AsyncResult<String>> handler)` Find all keys matching the given pattern
    `RedisClient` | RedisClient.`lastsave(Handler<AsyncResult<Long>> handler)` Get the UNIX time stamp of the last successful save to disk
    `RedisTransaction` | RedisTransaction.`lastsave(Handler<AsyncResult<String>> handler)` Get the UNIX time stamp of the last successful save to disk
    `RedisTransaction` | RedisTransaction.`lindex(String key, int index, Handler<AsyncResult<String>> handler)` Get an element from a list by its index
    `RedisClient` | RedisClient.`lindex(String key, int index, Handler<AsyncResult<String>> handler)` Get an element from a list by its index
    `RedisClient` | RedisClient.`linsert(String key, InsertOptions option, String pivot, String value, Handler<AsyncResult<Long>> handler)` Insert an element before or after another element in a list
    `RedisTransaction` | RedisTransaction.`linsert(String key, InsertOptions option, String pivot, String value, Handler<AsyncResult<String>> handler)` Insert an element before or after another element in a list
    `RedisClient` | RedisClient.`llen(String key, Handler<AsyncResult<Long>> handler)` Get the length of a list
    `RedisTransaction` | RedisTransaction.`llen(String key, Handler<AsyncResult<String>> handler)` Get the length of a list
    `RedisTransaction` | RedisTransaction.`lpop(String key, Handler<AsyncResult<String>> handler)` Remove and get the first element in a list
    `RedisClient` | RedisClient.`lpop(String key, Handler<AsyncResult<String>> handler)` Remove and get the first element in a list
    `RedisClient` | RedisClient.`lpush(String key, String value, Handler<AsyncResult<Long>> handler)` Prepend one value to a list
    `RedisTransaction` | RedisTransaction.`lpush(String key, String value, Handler<AsyncResult<String>> handler)` Prepend one value to a list
    `RedisClient` | RedisClient.`lpushMany(String key, List<String> values, Handler<AsyncResult<Long>> handler)` Prepend one or multiple values to a list
    `RedisTransaction` | RedisTransaction.`lpushMany(String key, List<String> values, Handler<AsyncResult<String>> handler)` Prepend one or multiple values to a list
    `RedisClient` | RedisClient.`lpushx(String key, String value, Handler<AsyncResult<Long>> handler)` Prepend a value to a list, only if the list exists
    `RedisTransaction` | RedisTransaction.`lpushx(String key, String value, Handler<AsyncResult<String>> handler)` Prepend a value to a list, only if the list exists
    `RedisClient` | RedisClient.`lrange(String key, long from, long to, Handler<AsyncResult<JsonArray>> handler)` Get a range of elements from a list
    `RedisTransaction` | RedisTransaction.`lrange(String key, long from, long to, Handler<AsyncResult<String>> handler)` Get a range of elements from a list
    `RedisClient` | RedisClient.`lrem(String key, long count, String value, Handler<AsyncResult<Long>> handler)` Remove elements from a list
    `RedisTransaction` | RedisTransaction.`lrem(String key, long count, String value, Handler<AsyncResult<String>> handler)` Remove elements from a list
    `RedisTransaction` | RedisTransaction.`lset(String key, long index, String value, Handler<AsyncResult<String>> handler)` Set the value of an element in a list by its index
    `RedisClient` | RedisClient.`lset(String key, long index, String value, Handler<AsyncResult<String>> handler)` Set the value of an element in a list by its index
    `RedisTransaction` | RedisTransaction.`ltrim(String key, long from, long to, Handler<AsyncResult<String>> handler)` Trim a list to the specified range
    `RedisClient` | RedisClient.`ltrim(String key, long from, long to, Handler<AsyncResult<String>> handler)` Trim a list to the specified range
    `RedisClient` | RedisClient.`mget(String key, Handler<AsyncResult<JsonArray>> handler)` Get the value of the given key
    `RedisTransaction` | RedisTransaction.`mget(String key, Handler<AsyncResult<String>> handler)` Get the value of the given key
    `RedisClient` | RedisClient.`mgetMany(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Get the values of all the given keys
    `RedisTransaction` | RedisTransaction.`mgetMany(List<String> keys, Handler<AsyncResult<String>> handler)` Get the values of all the given keys
    `RedisTransaction` | RedisTransaction.`migrate(String host, int port, String key, int destdb, long timeout, MigrateOptions options, Handler<AsyncResult<String>> handler)` Atomically transfer a key from a Redis instance to another one.
    `RedisClient` | RedisClient.`migrate(String host, int port, String key, int destdb, long timeout, MigrateOptions options, Handler<AsyncResult<String>> handler)` Atomically transfer a key from a Redis instance to another one.
    `RedisTransaction` | RedisTransaction.`monitor(Handler<AsyncResult<String>> handler)` Listen for all requests received by the server in real time
    `RedisClient` | RedisClient.`monitor(Handler<AsyncResult<Void>> handler)` Listen for all requests received by the server in real time
    `RedisClient` | RedisClient.`move(String key, int destdb, Handler<AsyncResult<Long>> handler)` Move a key to another database
    `RedisTransaction` | RedisTransaction.`move(String key, int destdb, Handler<AsyncResult<String>> handler)` Move a key to another database
    `RedisTransaction` | RedisTransaction.`mset(JsonObject keyvals, Handler<AsyncResult<String>> handler)` Set multiple keys to multiple values
    `RedisClient` | RedisClient.`mset(JsonObject keyvals, Handler<AsyncResult<String>> handler)` Set multiple keys to multiple values
    `RedisClient` | RedisClient.`msetnx(JsonObject keyvals, Handler<AsyncResult<Long>> handler)` Set multiple keys to multiple values, only if none of the keys exist
    `RedisTransaction` | RedisTransaction.`msetnx(JsonObject keyvals, Handler<AsyncResult<String>> handler)` Set multiple keys to multiple values, only if none of the keys exist
    `RedisTransaction` | RedisTransaction.`multi(Handler<AsyncResult<String>> handler)` Mark the start of a RedisTransaction block
    `RedisTransaction` | RedisTransaction.`object(String key, ObjectCmd cmd, Handler<AsyncResult<String>> handler)` Inspect the internals of Redis objects
    `RedisClient` | RedisClient.`object(String key, ObjectCmd cmd, Handler<AsyncResult<Void>> handler)` Inspect the internals of Redis objects
    `RedisClient` | RedisClient.`persist(String key, Handler<AsyncResult<Long>> handler)` Remove the expiration from a key
    `RedisTransaction` | RedisTransaction.`persist(String key, Handler<AsyncResult<String>> handler)` Remove the expiration from a key
    `RedisClient` | RedisClient.`pexpire(String key, long millis, Handler<AsyncResult<Long>> handler)` Set a key's time to live in milliseconds
    `RedisTransaction` | RedisTransaction.`pexpire(String key, long millis, Handler<AsyncResult<String>> handler)` Set a key's time to live in milliseconds
    `RedisClient` | RedisClient.`pexpireat(String key, long millis, Handler<AsyncResult<Long>> handler)` Set the expiration for a key as a UNIX timestamp specified in milliseconds
    `RedisTransaction` | RedisTransaction.`pexpireat(String key, long millis, Handler<AsyncResult<String>> handler)` Set the expiration for a key as a UNIX timestamp specified in milliseconds
    `RedisClient` | RedisClient.`pfadd(String key, String element, Handler<AsyncResult<Long>> handler)` Adds the specified element to the specified HyperLogLog.
    `RedisTransaction` | RedisTransaction.`pfadd(String key, String element, Handler<AsyncResult<String>> handler)` Adds the specified element to the specified HyperLogLog.
    `RedisClient` | RedisClient.`pfaddMany(String key, List<String> elements, Handler<AsyncResult<Long>> handler)` Adds the specified elements to the specified HyperLogLog.
    `RedisTransaction` | RedisTransaction.`pfaddMany(String key, List<String> elements, Handler<AsyncResult<String>> handler)` Adds the specified elements to the specified HyperLogLog.
    `RedisClient` | RedisClient.`pfcount(String key, Handler<AsyncResult<Long>> handler)` Return the approximated cardinality of the set observed by the HyperLogLog at key.
    `RedisTransaction` | RedisTransaction.`pfcount(String key, Handler<AsyncResult<String>> handler)` Return the approximated cardinality of the set observed by the HyperLogLog at key.
    `RedisClient` | RedisClient.`pfcountMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    `RedisTransaction` | RedisTransaction.`pfcountMany(List<String> keys, Handler<AsyncResult<String>> handler)` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    `RedisTransaction` | RedisTransaction.`pfmerge(String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Merge N different HyperLogLogs into a single one.
    `RedisClient` | RedisClient.`pfmerge(String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Merge N different HyperLogLogs into a single one.
    `RedisTransaction` | RedisTransaction.`ping(Handler<AsyncResult<String>> handler)` Ping the server
    `RedisClient` | RedisClient.`ping(Handler<AsyncResult<String>> handler)` Ping the server
    `RedisTransaction` | RedisTransaction.`psetex(String key, long millis, String value, Handler<AsyncResult<String>> handler)` Set the value and expiration in milliseconds of a key
    `RedisClient` | RedisClient.`psetex(String key, long millis, String value, Handler<AsyncResult<Void>> handler)` Set the value and expiration in milliseconds of a key
    `RedisClient` | RedisClient.`psubscribe(String pattern, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to channels matching the given pattern
    `RedisTransaction` | RedisTransaction.`psubscribe(String pattern, Handler<AsyncResult<String>> handler)` Listen for messages published to channels matching the given pattern
    `RedisClient` | RedisClient.`psubscribeMany(List<String> patterns, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to channels matching the given patterns
    `RedisTransaction` | RedisTransaction.`psubscribeMany(List<String> patterns, Handler<AsyncResult<String>> handler)` Listen for messages published to channels matching the given patterns
    `RedisClient` | RedisClient.`pttl(String key, Handler<AsyncResult<Long>> handler)` Get the time to live for a key in milliseconds
    `RedisTransaction` | RedisTransaction.`pttl(String key, Handler<AsyncResult<String>> handler)` Get the time to live for a key in milliseconds
    `RedisClient` | RedisClient.`publish(String channel, String message, Handler<AsyncResult<Long>> handler)` Post a message to a channel
    `RedisTransaction` | RedisTransaction.`publish(String channel, String message, Handler<AsyncResult<String>> handler)` Post a message to a channel
    `RedisClient` | RedisClient.`pubsubChannels(String pattern, Handler<AsyncResult<JsonArray>> handler)` Lists the currently active channels - only those matching the pattern
    `RedisTransaction` | RedisTransaction.`pubsubChannels(String pattern, Handler<AsyncResult<String>> handler)` Lists the currently active channels - only those matching the pattern
    `RedisClient` | RedisClient.`pubsubNumpat(Handler<AsyncResult<Long>> handler)` Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
    `RedisTransaction` | RedisTransaction.`pubsubNumpat(Handler<AsyncResult<String>> handler)` Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
    `RedisClient` | RedisClient.`pubsubNumsub(List<String> channels, Handler<AsyncResult<JsonArray>> handler)` Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
    `RedisTransaction` | RedisTransaction.`pubsubNumsub(List<String> channels, Handler<AsyncResult<String>> handler)` Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
    `RedisTransaction` | RedisTransaction.`punsubscribe(List<String> patterns, Handler<AsyncResult<String>> handler)` Stop listening for messages posted to channels matching the given patterns
    `RedisClient` | RedisClient.`punsubscribe(List<String> patterns, Handler<AsyncResult<Void>> handler)` Stop listening for messages posted to channels matching the given patterns
    `RedisTransaction` | RedisTransaction.`randomkey(Handler<AsyncResult<String>> handler)` Return a random key from the keyspace
    `RedisClient` | RedisClient.`randomkey(Handler<AsyncResult<String>> handler)` Return a random key from the keyspace
    `RedisTransaction` | RedisTransaction.`rename(String key, String newkey, Handler<AsyncResult<String>> handler)` Rename a key
    `RedisClient` | RedisClient.`rename(String key, String newkey, Handler<AsyncResult<String>> handler)` Rename a key
    `RedisClient` | RedisClient.`renamenx(String key, String newkey, Handler<AsyncResult<Long>> handler)` Rename a key, only if the new key does not exist
    `RedisTransaction` | RedisTransaction.`renamenx(String key, String newkey, Handler<AsyncResult<String>> handler)` Rename a key, only if the new key does not exist
    `RedisTransaction` | RedisTransaction.`restore(String key, long millis, String serialized, Handler<AsyncResult<String>> handler)` Create a key using the provided serialized value, previously obtained using DUMP.
    `RedisClient` | RedisClient.`restore(String key, long millis, String serialized, Handler<AsyncResult<String>> handler)` Create a key using the provided serialized value, previously obtained using DUMP.
    `RedisClient` | RedisClient.`role(Handler<AsyncResult<JsonArray>> handler)` Return the role of the instance in the context of replication
    `RedisTransaction` | RedisTransaction.`role(Handler<AsyncResult<String>> handler)` Return the role of the instance in the context of replication
    `RedisTransaction` | RedisTransaction.`rpop(String key, Handler<AsyncResult<String>> handler)` Remove and get the last element in a list
    `RedisClient` | RedisClient.`rpop(String key, Handler<AsyncResult<String>> handler)` Remove and get the last element in a list
    `RedisTransaction` | RedisTransaction.`rpoplpush(String key, String destkey, Handler<AsyncResult<String>> handler)` Remove the last element in a list, append it to another list and return it
    `RedisClient` | RedisClient.`rpoplpush(String key, String destkey, Handler<AsyncResult<String>> handler)` Remove the last element in a list, append it to another list and return it
    `RedisClient` | RedisClient.`rpush(String key, String value, Handler<AsyncResult<Long>> handler)` Append one or multiple values to a list
    `RedisTransaction` | RedisTransaction.`rpush(String key, String value, Handler<AsyncResult<String>> handler)` Append one or multiple values to a list
    `RedisClient` | RedisClient.`rpushMany(String key, List<String> values, Handler<AsyncResult<Long>> handler)` Append one or multiple values to a list
    `RedisTransaction` | RedisTransaction.`rpushMany(String key, List<String> values, Handler<AsyncResult<String>> handler)` Append one or multiple values to a list
    `RedisClient` | RedisClient.`rpushx(String key, String value, Handler<AsyncResult<Long>> handler)` Append a value to a list, only if the list exists
    `RedisTransaction` | RedisTransaction.`rpushx(String key, String value, Handler<AsyncResult<String>> handler)` Append a value to a list, only if the list exists
    `RedisClient` | RedisClient.`sadd(String key, String member, Handler<AsyncResult<Long>> handler)` Add a member to a set
    `RedisTransaction` | RedisTransaction.`sadd(String key, String member, Handler<AsyncResult<String>> handler)` Add a member to a set
    `RedisClient` | RedisClient.`saddMany(String key, List<String> members, Handler<AsyncResult<Long>> handler)` Add one or more members to a set
    `RedisTransaction` | RedisTransaction.`saddMany(String key, List<String> members, Handler<AsyncResult<String>> handler)` Add one or more members to a set
    `RedisTransaction` | RedisTransaction.`save(Handler<AsyncResult<String>> handler)` Synchronously save the dataset to disk
    `RedisClient` | RedisClient.`save(Handler<AsyncResult<String>> handler)` Synchronously save the dataset to disk
    `RedisClient` | RedisClient.`scan(String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate the keys space
    `RedisTransaction` | RedisTransaction.`scan(String cursor, ScanOptions options, Handler<AsyncResult<String>> handler)` Incrementally iterate the keys space
    `RedisClient` | RedisClient.`scard(String key, Handler<AsyncResult<Long>> handler)` Get the number of members in a set
    `RedisTransaction` | RedisTransaction.`scard(String key, Handler<AsyncResult<String>> handler)` Get the number of members in a set
    `RedisClient` | RedisClient.`scriptDebug(ScriptDebugOptions scriptDebugOptions, Handler<AsyncResult<String>> handler)` Set the debug mode for executed scripts.
    `RedisClient` | RedisClient.`scriptExists(String script, Handler<AsyncResult<JsonArray>> handler)` Check existence of script in the script cache.
    `RedisTransaction` | RedisTransaction.`scriptExists(String script, Handler<AsyncResult<String>> handler)` Check existence of script in the script cache.
    `RedisClient` | RedisClient.`scriptExistsMany(List<String> scripts, Handler<AsyncResult<JsonArray>> handler)` Check existence of scripts in the script cache.
    `RedisTransaction` | RedisTransaction.`scriptExistsMany(List<String> scripts, Handler<AsyncResult<String>> handler)` Check existence of scripts in the script cache.
    `RedisTransaction` | RedisTransaction.`scriptFlush(Handler<AsyncResult<String>> handler)` Remove all the scripts from the script cache.
    `RedisClient` | RedisClient.`scriptFlush(Handler<AsyncResult<String>> handler)` Remove all the scripts from the script cache.
    `RedisTransaction` | RedisTransaction.`scriptKill(Handler<AsyncResult<String>> handler)` Kill the script currently in execution.
    `RedisClient` | RedisClient.`scriptKill(Handler<AsyncResult<String>> handler)` Kill the script currently in execution.
    `RedisTransaction` | RedisTransaction.`scriptLoad(String script, Handler<AsyncResult<String>> handler)` Load the specified Lua script into the script cache.
    `RedisClient` | RedisClient.`scriptLoad(String script, Handler<AsyncResult<String>> handler)` Load the specified Lua script into the script cache.
    `RedisClient` | RedisClient.`sdiff(String key, List<String> cmpkeys, Handler<AsyncResult<JsonArray>> handler)` Subtract multiple sets
    `RedisTransaction` | RedisTransaction.`sdiff(String key, List<String> cmpkeys, Handler<AsyncResult<String>> handler)` Subtract multiple sets
    `RedisClient` | RedisClient.`sdiffstore(String destkey, String key, List<String> cmpkeys, Handler<AsyncResult<Long>> handler)` Subtract multiple sets and store the resulting set in a key
    `RedisTransaction` | RedisTransaction.`sdiffstore(String destkey, String key, List<String> cmpkeys, Handler<AsyncResult<String>> handler)` Subtract multiple sets and store the resulting set in a key
    `RedisTransaction` | RedisTransaction.`select(int dbindex, Handler<AsyncResult<String>> handler)` Change the selected database for the current connection
    `RedisClient` | RedisClient.`select(int dbindex, Handler<AsyncResult<String>> handler)` Change the selected database for the current connection
    `RedisTransaction` | RedisTransaction.`set(String key, String value, Handler<AsyncResult<String>> handler)` Set the string value of a key
    `RedisClient` | RedisClient.`set(String key, String value, Handler<AsyncResult<Void>> handler)` Set the string value of a key
    `RedisTransaction` | RedisTransaction.`setBinary(String key, Buffer value, Handler<AsyncResult<String>> handler)` Set the binary string value of a key - without encoding as utf-8
    `RedisClient` | RedisClient.`setBinary(String key, Buffer value, Handler<AsyncResult<Void>> handler)` Set the binary string value of a key - without encoding as utf-8
    `RedisTransaction` | RedisTransaction.`setBinaryWithOptions(String key, Buffer value, SetOptions options, Handler<AsyncResult<String>> handler)` Set the string value of a key
    `RedisClient` | RedisClient.`setBinaryWithOptions(String key, Buffer value, SetOptions options, Handler<AsyncResult<Void>> handler)` Set the string value of a key
    `RedisClient` | RedisClient.`setbit(String key, long offset, int bit, Handler<AsyncResult<Long>> handler)` Sets or clears the bit at offset in the string value stored at key
    `RedisTransaction` | RedisTransaction.`setbit(String key, long offset, int bit, Handler<AsyncResult<String>> handler)` Sets or clears the bit at offset in the string value stored at key
    `RedisTransaction` | RedisTransaction.`setex(String key, long seconds, String value, Handler<AsyncResult<String>> handler)` Set the value and expiration of a key
    `RedisClient` | RedisClient.`setex(String key, long seconds, String value, Handler<AsyncResult<String>> handler)` Set the value and expiration of a key
    `RedisClient` | RedisClient.`setnx(String key, String value, Handler<AsyncResult<Long>> handler)` Set the value of a key, only if the key does not exist
    `RedisTransaction` | RedisTransaction.`setnx(String key, String value, Handler<AsyncResult<String>> handler)` Set the value of a key, only if the key does not exist
    `RedisClient` | RedisClient.`setrange(String key, int offset, String value, Handler<AsyncResult<Long>> handler)` Overwrite part of a string at key starting at the specified offset
    `RedisTransaction` | RedisTransaction.`setrange(String key, int offset, String value, Handler<AsyncResult<String>> handler)` Overwrite part of a string at key starting at the specified offset
    `RedisTransaction` | RedisTransaction.`setWithOptions(String key, String value, SetOptions options, Handler<AsyncResult<String>> handler)` Set the string value of a key
    `RedisClient` | RedisClient.`setWithOptions(String key, String value, SetOptions options, Handler<AsyncResult<String>> handler)` Set the string value of a key
    `RedisClient` | RedisClient.`sinter(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Intersect multiple sets
    `RedisTransaction` | RedisTransaction.`sinter(List<String> keys, Handler<AsyncResult<String>> handler)` Intersect multiple sets
    `RedisClient` | RedisClient.`sinterstore(String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Intersect multiple sets and store the resulting set in a key
    `RedisTransaction` | RedisTransaction.`sinterstore(String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Intersect multiple sets and store the resulting set in a key
    `RedisClient` | RedisClient.`sismember(String key, String member, Handler<AsyncResult<Long>> handler)` Determine if a given value is a member of a set
    `RedisTransaction` | RedisTransaction.`sismember(String key, String member, Handler<AsyncResult<String>> handler)` Determine if a given value is a member of a set
    `RedisTransaction` | RedisTransaction.`slaveof(String host, int port, Handler<AsyncResult<String>> handler)` Make the server a slave of another instance
    `RedisClient` | RedisClient.`slaveof(String host, int port, Handler<AsyncResult<String>> handler)` Make the server a slave of another instance
    `RedisTransaction` | RedisTransaction.`slaveofNoone(Handler<AsyncResult<String>> handler)` Make this server a master
    `RedisClient` | RedisClient.`slaveofNoone(Handler<AsyncResult<String>> handler)` Make this server a master
    `RedisClient` | RedisClient.`slowlogGet(int limit, Handler<AsyncResult<JsonArray>> handler)` Read the Redis slow queries log
    `RedisTransaction` | RedisTransaction.`slowlogGet(int limit, Handler<AsyncResult<String>> handler)` Read the Redis slow queries log
    `RedisClient` | RedisClient.`slowlogLen(Handler<AsyncResult<Long>> handler)` Get the length of the Redis slow queries log
    `RedisTransaction` | RedisTransaction.`slowlogLen(Handler<AsyncResult<String>> handler)` Get the length of the Redis slow queries log
    `RedisTransaction` | RedisTransaction.`slowlogReset(Handler<AsyncResult<String>> handler)` Reset the Redis slow queries log
    `RedisClient` | RedisClient.`slowlogReset(Handler<AsyncResult<Void>> handler)` Reset the Redis slow queries log
    `RedisTransaction` | RedisTransaction.`smembers(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the members in a set
    `RedisClient` | RedisClient.`smembers(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the members in a set
    `RedisClient` | RedisClient.`smove(String key, String destkey, String member, Handler<AsyncResult<Long>> handler)` Move a member from one set to another
    `RedisTransaction` | RedisTransaction.`smove(String key, String destkey, String member, Handler<AsyncResult<String>> handler)` Move a member from one set to another
    `RedisClient` | RedisClient.`sort(String key, SortOptions options, Handler<AsyncResult<JsonArray>> handler)` Sort the elements in a list, set or sorted set
    `RedisTransaction` | RedisTransaction.`sort(String key, SortOptions options, Handler<AsyncResult<String>> handler)` Sort the elements in a list, set or sorted set
    `RedisTransaction` | RedisTransaction.`spop(String key, Handler<AsyncResult<String>> handler)` Remove and return a random member from a set
    `RedisClient` | RedisClient.`spop(String key, Handler<AsyncResult<String>> handler)` Remove and return a random member from a set
    `RedisClient` | RedisClient.`spopMany(String key, int count, Handler<AsyncResult<JsonArray>> handler)` Remove and return random members from a set
    `RedisTransaction` | RedisTransaction.`spopMany(String key, int count, Handler<AsyncResult<String>> handler)` Remove and return random members from a set
    `RedisTransaction` | RedisTransaction.`srandmember(String key, Handler<AsyncResult<String>> handler)` Get one or multiple random members from a set
    `RedisClient` | RedisClient.`srandmember(String key, Handler<AsyncResult<String>> handler)` Get one or multiple random members from a set
    `RedisClient` | RedisClient.`srandmemberCount(String key, int count, Handler<AsyncResult<JsonArray>> handler)` Get one or multiple random members from a set
    `RedisTransaction` | RedisTransaction.`srandmemberCount(String key, int count, Handler<AsyncResult<String>> handler)` Get one or multiple random members from a set
    `RedisClient` | RedisClient.`srem(String key, String member, Handler<AsyncResult<Long>> handler)` Remove one member from a set
    `RedisTransaction` | RedisTransaction.`srem(String key, String member, Handler<AsyncResult<String>> handler)` Remove one member from a set
    `RedisClient` | RedisClient.`sremMany(String key, List<String> members, Handler<AsyncResult<Long>> handler)` Remove one or more members from a set
    `RedisTransaction` | RedisTransaction.`sremMany(String key, List<String> members, Handler<AsyncResult<String>> handler)` Remove one or more members from a set
    `RedisClient` | RedisClient.`sscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate Set elements
    `RedisTransaction` | RedisTransaction.`sscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<String>> handler)` Incrementally iterate Set elements
    `RedisClient` | RedisClient.`strlen(String key, Handler<AsyncResult<Long>> handler)` Get the length of the value stored in a key
    `RedisTransaction` | RedisTransaction.`strlen(String key, Handler<AsyncResult<String>> handler)` Get the length of the value stored in a key
    `RedisClient` | RedisClient.`subscribe(String channel, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to the given channels
    `RedisTransaction` | RedisTransaction.`subscribe(String channel, Handler<AsyncResult<String>> handler)` Listen for messages published to the given channels
    `RedisClient` | RedisClient.`subscribeMany(List<String> channels, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to the given channels
    `RedisTransaction` | RedisTransaction.`subscribeMany(List<String> channels, Handler<AsyncResult<String>> handler)` Listen for messages published to the given channels
    `RedisClient` | RedisClient.`sunion(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Add multiple sets
    `RedisTransaction` | RedisTransaction.`sunion(List<String> keys, Handler<AsyncResult<String>> handler)` Add multiple sets
    `RedisClient` | RedisClient.`sunionstore(String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Add multiple sets and store the resulting set in a key
    `RedisTransaction` | RedisTransaction.`sunionstore(String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Add multiple sets and store the resulting set in a key
    `RedisTransaction` | RedisTransaction.`swapdb(int index1, int index2, Handler<AsyncResult<String>> handler)` Swaps two Redis databases
    `RedisClient` | RedisClient.`swapdb(int index1, int index2, Handler<AsyncResult<String>> handler)` Swaps two Redis databases
    `RedisTransaction` | RedisTransaction.`sync(Handler<AsyncResult<String>> handler)` Internal command used for replication
    `RedisClient` | RedisClient.`sync(Handler<AsyncResult<Void>> handler)` Internal command used for replication
    `RedisClient` | RedisClient.`time(Handler<AsyncResult<JsonArray>> handler)` Return the current server time
    `RedisTransaction` | RedisTransaction.`time(Handler<AsyncResult<String>> handler)` Return the current server time
    `RedisClient` | RedisClient.`touch(String key, Handler<AsyncResult<Long>> handler)` Alters the last access time of a key(s).
    `RedisClient` | RedisClient.`touchMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Alters the last access time of a key(s).
    `RedisClient` | RedisClient.`ttl(String key, Handler<AsyncResult<Long>> handler)` Get the time to live for a key
    `RedisTransaction` | RedisTransaction.`ttl(String key, Handler<AsyncResult<String>> handler)` Get the time to live for a key
    `RedisTransaction` | RedisTransaction.`type(String key, Handler<AsyncResult<String>> handler)` Determine the type stored at key
    `RedisClient` | RedisClient.`type(String key, Handler<AsyncResult<String>> handler)` Determine the type stored at key
    `RedisClient` | RedisClient.`unlink(String key, Handler<AsyncResult<Long>> handler)` Delete a key asynchronously in another thread.
    `RedisTransaction` | RedisTransaction.`unlink(String key, Handler<AsyncResult<String>> handler)` Delete a key asynchronously in another thread.
    `RedisClient` | RedisClient.`unlinkMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Delete multiple keys asynchronously in another thread.
    `RedisTransaction` | RedisTransaction.`unlinkMany(List<String> keys, Handler<AsyncResult<String>> handler)` Delete multiple keys asynchronously in another thread.
    `RedisTransaction` | RedisTransaction.`unsubscribe(List<String> channels, Handler<AsyncResult<String>> handler)` Stop listening for messages posted to the given channels
    `RedisClient` | RedisClient.`unsubscribe(List<String> channels, Handler<AsyncResult<Void>> handler)` Stop listening for messages posted to the given channels
    `RedisTransaction` | RedisTransaction.`unwatch(Handler<AsyncResult<String>> handler)` Forget about all watched keys
    `RedisTransaction` | RedisTransaction.`wait(long numSlaves, long timeout, Handler<AsyncResult<String>> handler)` Wait for the synchronous replication of all the write commands sent in the context of the current connection.
    `RedisClient` | RedisClient.`wait(long numSlaves, long timeout, Handler<AsyncResult<String>> handler)` Wait for the synchronous replication of all the write commands sent in the context of the current connection.
    `RedisTransaction` | RedisTransaction.`watch(String key, Handler<AsyncResult<String>> handler)` Watch the given keys to determine execution of the MULTI/EXEC block
    `RedisTransaction` | RedisTransaction.`watchMany(List<String> keys, Handler<AsyncResult<String>> handler)` Watch the given keys to determine execution of the MULTI/EXEC block
    `RedisClient` | RedisClient.`zadd(String key, double score, String member, Handler<AsyncResult<Long>> handler)` Add one or more members to a sorted set, or update its score if it already exists
    `RedisTransaction` | RedisTransaction.`zadd(String key, double score, String member, Handler<AsyncResult<String>> handler)` Add one or more members to a sorted set, or update its score if it already exists
    `RedisClient` | RedisClient.`zaddMany(String key, Map<String,Double> members, Handler<AsyncResult<Long>> handler)` Add one or more members to a sorted set, or update its score if it already exists
    `RedisTransaction` | RedisTransaction.`zaddMany(String key, Map<String,Double> members, Handler<AsyncResult<String>> handler)` Add one or more members to a sorted set, or update its score if it already exists
    `RedisClient` | RedisClient.`zcard(String key, Handler<AsyncResult<Long>> handler)` Get the number of members in a sorted set
    `RedisTransaction` | RedisTransaction.`zcard(String key, Handler<AsyncResult<String>> handler)` Get the number of members in a sorted set
    `RedisClient` | RedisClient.`zcount(String key, double min, double max, Handler<AsyncResult<Long>> handler)` Count the members in a sorted set with scores within the given values
    `RedisTransaction` | RedisTransaction.`zcount(String key, double min, double max, Handler<AsyncResult<String>> handler)` Count the members in a sorted set with scores within the given values
    `RedisTransaction` | RedisTransaction.`zincrby(String key, double increment, String member, Handler<AsyncResult<String>> handler)` Increment the score of a member in a sorted set
    `RedisClient` | RedisClient.`zincrby(String key, double increment, String member, Handler<AsyncResult<String>> handler)` Increment the score of a member in a sorted set
    `RedisClient` | RedisClient.`zinterstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key
    `RedisTransaction` | RedisTransaction.`zinterstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<String>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key
    `RedisClient` | RedisClient.`zinterstoreWeighed(String destkey, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
    `RedisTransaction` | RedisTransaction.`zinterstoreWeighed(String destkey, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<String>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
    `RedisClient` | RedisClient.`zlexcount(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Count the number of members in a sorted set between a given lexicographical range
    `RedisTransaction` | RedisTransaction.`zlexcount(String key, String min, String max, Handler<AsyncResult<String>> handler)` Count the number of members in a sorted set between a given lexicographical range
    `RedisClient` | RedisClient.`zrange(String key, long start, long stop, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index
    `RedisTransaction` | RedisTransaction.`zrange(String key, long start, long stop, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by index
    `RedisClient` | RedisClient.`zrangebylex(String key, String min, String max, LimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by lexicographical range
    `RedisTransaction` | RedisTransaction.`zrangebylex(String key, String min, String max, LimitOptions options, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by lexicographical range
    `RedisClient` | RedisClient.`zrangebyscore(String key, String min, String max, RangeLimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score
    `RedisTransaction` | RedisTransaction.`zrangebyscore(String key, String min, String max, RangeLimitOptions options, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by score
    `RedisClient` | RedisClient.`zrangeWithOptions(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index
    `RedisTransaction` | RedisTransaction.`zrangeWithOptions(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by index
    `RedisClient` | RedisClient.`zrank(String key, String member, Handler<AsyncResult<Long>> handler)` Determine the index of a member in a sorted set
    `RedisTransaction` | RedisTransaction.`zrank(String key, String member, Handler<AsyncResult<String>> handler)` Determine the index of a member in a sorted set
    `RedisClient` | RedisClient.`zrem(String key, String member, Handler<AsyncResult<Long>> handler)` Remove one member from a sorted set
    `RedisTransaction` | RedisTransaction.`zrem(String key, String member, Handler<AsyncResult<String>> handler)` Remove one member from a sorted set
    `RedisClient` | RedisClient.`zremMany(String key, List<String> members, Handler<AsyncResult<Long>> handler)` Remove one or more members from a sorted set
    `RedisTransaction` | RedisTransaction.`zremMany(String key, List<String> members, Handler<AsyncResult<String>> handler)` Remove one or more members from a sorted set
    `RedisClient` | RedisClient.`zremrangebylex(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Remove all members in a sorted set between the given lexicographical range
    `RedisTransaction` | RedisTransaction.`zremrangebylex(String key, String min, String max, Handler<AsyncResult<String>> handler)` Remove all members in a sorted set between the given lexicographical range
    `RedisClient` | RedisClient.`zremrangebyrank(String key, long start, long stop, Handler<AsyncResult<Long>> handler)` Remove all members in a sorted set within the given indexes
    `RedisTransaction` | RedisTransaction.`zremrangebyrank(String key, long start, long stop, Handler<AsyncResult<String>> handler)` Remove all members in a sorted set within the given indexes
    `RedisClient` | RedisClient.`zremrangebyscore(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Remove all members in a sorted set within the given scores
    `RedisTransaction` | RedisTransaction.`zremrangebyscore(String key, String min, String max, Handler<AsyncResult<String>> handler)` Remove all members in a sorted set within the given scores
    `RedisClient` | RedisClient.`zrevrange(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index, with scores ordered from high to low
    `RedisTransaction` | RedisTransaction.`zrevrange(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by index, with scores ordered from high to low
    `RedisClient` | RedisClient.`zrevrangebylex(String key, String max, String min, LimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
    `RedisTransaction` | RedisTransaction.`zrevrangebylex(String key, String max, String min, LimitOptions options, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
    `RedisClient` | RedisClient.`zrevrangebyscore(String key, String max, String min, RangeLimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score, with scores ordered from high to low
    `RedisTransaction` | RedisTransaction.`zrevrangebyscore(String key, String max, String min, RangeLimitOptions options, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by score, with scores ordered from high to low
    `RedisClient` | RedisClient.`zrevrank(String key, String member, Handler<AsyncResult<Long>> handler)` Determine the index of a member in a sorted set, with scores ordered from high to low
    `RedisTransaction` | RedisTransaction.`zrevrank(String key, String member, Handler<AsyncResult<String>> handler)` Determine the index of a member in a sorted set, with scores ordered from high to low
    `RedisClient` | RedisClient.`zscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate sorted sets elements and associated scores
    `RedisTransaction` | RedisTransaction.`zscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<String>> handler)` Incrementally iterate sorted sets elements and associated scores
    `RedisTransaction` | RedisTransaction.`zscore(String key, String member, Handler<AsyncResult<String>> handler)` Get the score associated with the given member in a sorted set
    `RedisClient` | RedisClient.`zscore(String key, String member, Handler<AsyncResult<String>> handler)` Get the score associated with the given member in a sorted set
    `RedisClient` | RedisClient.`zunionstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Add multiple sorted sets and store the resulting sorted set in a new key
    `RedisTransaction` | RedisTransaction.`zunionstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<String>> handler)` Add multiple sorted sets and store the resulting sorted set in a new key
    `RedisClient` | RedisClient.`zunionstoreWeighed(String key, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Add multiple sorted sets using weights, and store the resulting sorted set in a new key
    `RedisTransaction` | RedisTransaction.`zunionstoreWeighed(String key, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<String>> handler)` Add multiple sorted sets using weights, and store the resulting sorted set in a new key

  - ### Uses of Handler in io.vertx.reactivex.redis.client

    Methods in io.vertx.reactivex.redis.client with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `RedisAPI` | RedisAPI.`append(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command append.
    `RedisAPI` | RedisAPI.`asking(Handler<AsyncResult<Response>> handler)` Redis command asking.
    `RedisAPI` | RedisAPI.`auth(String arg0, Handler<AsyncResult<Response>> handler)` Redis command auth.
    `Redis` | Redis.`batch(List<Request> commands, Handler<AsyncResult<List<Response>>> onSend)` Sends a list of commands in a single IO operation, this prevents any inter twinning to happen from other client users.
    `RedisConnection` | RedisConnection.`batch(List<Request> commands, Handler<AsyncResult<List<Response>>> onSend)` Sends a list of commands in a single IO operation, this prevents any inter twinning to happen from other client users.
    `RedisAPI` | RedisAPI.`bgrewriteaof(Handler<AsyncResult<Response>> handler)` Redis command bgrewriteaof.
    `RedisAPI` | RedisAPI.`bgsave(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bgsave.
    `RedisAPI` | RedisAPI.`bitcount(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bitcount.
    `RedisAPI` | RedisAPI.`bitfield(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bitfield.
    `RedisAPI` | RedisAPI.`bitop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bitop.
    `RedisAPI` | RedisAPI.`bitpos(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bitpos.
    `RedisAPI` | RedisAPI.`blpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command blpop.
    `RedisAPI` | RedisAPI.`brpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command brpop.
    `RedisAPI` | RedisAPI.`brpoplpush(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command brpoplpush.
    `RedisAPI` | RedisAPI.`bzpopmax(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bzpopmax.
    `RedisAPI` | RedisAPI.`bzpopmin(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bzpopmin.
    `RedisAPI` | RedisAPI.`client(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command client.
    `RedisAPI` | RedisAPI.`cluster(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command cluster.
    `RedisAPI` | RedisAPI.`command(Handler<AsyncResult<Response>> handler)` Redis command command.
    `RedisAPI` | RedisAPI.`config(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command config.
    `Redis` | Redis.`connect(Handler<AsyncResult<RedisConnection>> handler)` Connects to the redis server.
    `RedisAPI` | RedisAPI.`dbsize(Handler<AsyncResult<Response>> handler)` Redis command dbsize.
    `RedisAPI` | RedisAPI.`debug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command debug.
    `RedisAPI` | RedisAPI.`decr(String arg0, Handler<AsyncResult<Response>> handler)` Redis command decr.
    `RedisAPI` | RedisAPI.`decrby(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command decrby.
    `RedisAPI` | RedisAPI.`del(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command del.
    `RedisAPI` | RedisAPI.`discard(Handler<AsyncResult<Response>> handler)` Redis command discard.
    `RedisAPI` | RedisAPI.`dump(String arg0, Handler<AsyncResult<Response>> handler)` Redis command dump.
    `RedisAPI` | RedisAPI.`echo(String arg0, Handler<AsyncResult<Response>> handler)` Redis command echo.
    `RedisConnection` | RedisConnection.`endHandler(Handler<Void> endHandler)`
    `RedisAPI` | RedisAPI.`eval(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command eval.
    `RedisAPI` | RedisAPI.`evalsha(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command evalsha.
    `RedisConnection` | RedisConnection.`exceptionHandler(Handler<Throwable> handler)`
    `RedisAPI` | RedisAPI.`exec(Handler<AsyncResult<Response>> handler)` Redis command exec.
    `RedisAPI` | RedisAPI.`exists(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command exists.
    `RedisAPI` | RedisAPI.`expire(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command expire.
    `RedisAPI` | RedisAPI.`expireat(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command expireat.
    `RedisAPI` | RedisAPI.`flushall(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command flushall.
    `RedisAPI` | RedisAPI.`flushdb(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command flushdb.
    `RedisAPI` | RedisAPI.`geoadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command geoadd.
    `RedisAPI` | RedisAPI.`geodist(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command geodist.
    `RedisAPI` | RedisAPI.`geohash(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command geohash.
    `RedisAPI` | RedisAPI.`geopos(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command geopos.
    `RedisAPI` | RedisAPI.`georadius(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command georadius.
    `RedisAPI` | RedisAPI.`georadiusbymember(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command georadiusbymember.
    `RedisAPI` | RedisAPI.`georadiusbymemberRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command georadiusbymemberRo.
    `RedisAPI` | RedisAPI.`georadiusRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command georadiusRo.
    `RedisAPI` | RedisAPI.`get(String arg0, Handler<AsyncResult<Response>> handler)` Redis command get.
    `RedisAPI` | RedisAPI.`getbit(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command getbit.
    `RedisAPI` | RedisAPI.`getrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command getrange.
    `RedisAPI` | RedisAPI.`getset(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command getset.
    `RedisConnection` | RedisConnection.`handler(Handler<Response> handler)`
    `RedisAPI` | RedisAPI.`hdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command hdel.
    `RedisAPI` | RedisAPI.`hexists(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command hexists.
    `RedisAPI` | RedisAPI.`hget(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command hget.
    `RedisAPI` | RedisAPI.`hgetall(String arg0, Handler<AsyncResult<Response>> handler)` Redis command hgetall.
    `RedisAPI` | RedisAPI.`hincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command hincrby.
    `RedisAPI` | RedisAPI.`hincrbyfloat(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command hincrbyfloat.
    `RedisAPI` | RedisAPI.`hkeys(String arg0, Handler<AsyncResult<Response>> handler)` Redis command hkeys.
    `RedisAPI` | RedisAPI.`hlen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command hlen.
    `RedisAPI` | RedisAPI.`hmget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command hmget.
    `RedisAPI` | RedisAPI.`hmset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command hmset.
    `RedisAPI` | RedisAPI.`host(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command host.
    `RedisAPI` | RedisAPI.`hscan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command hscan.
    `RedisAPI` | RedisAPI.`hset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command hset.
    `RedisAPI` | RedisAPI.`hsetnx(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command hsetnx.
    `RedisAPI` | RedisAPI.`hstrlen(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command hstrlen.
    `RedisAPI` | RedisAPI.`hvals(String arg0, Handler<AsyncResult<Response>> handler)` Redis command hvals.
    `RedisAPI` | RedisAPI.`incr(String arg0, Handler<AsyncResult<Response>> handler)` Redis command incr.
    `RedisAPI` | RedisAPI.`incrby(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command incrby.
    `RedisAPI` | RedisAPI.`incrbyfloat(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command incrbyfloat.
    `RedisAPI` | RedisAPI.`info(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command info.
    `RedisAPI` | RedisAPI.`keys(String arg0, Handler<AsyncResult<Response>> handler)` Redis command keys.
    `RedisAPI` | RedisAPI.`lastsave(Handler<AsyncResult<Response>> handler)` Redis command lastsave.
    `RedisAPI` | RedisAPI.`latency(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command latency.
    `RedisAPI` | RedisAPI.`lindex(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command lindex.
    `RedisAPI` | RedisAPI.`linsert(String arg0, String arg1, String arg2, String arg3, Handler<AsyncResult<Response>> handler)` Redis command linsert.
    `RedisAPI` | RedisAPI.`llen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command llen.
    `RedisAPI` | RedisAPI.`lolwut(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command lolwut.
    `RedisAPI` | RedisAPI.`lpop(String arg0, Handler<AsyncResult<Response>> handler)` Redis command lpop.
    `RedisAPI` | RedisAPI.`lpush(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command lpush.
    `RedisAPI` | RedisAPI.`lpushx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command lpushx.
    `RedisAPI` | RedisAPI.`lrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command lrange.
    `RedisAPI` | RedisAPI.`lrem(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command lrem.
    `RedisAPI` | RedisAPI.`lset(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command lset.
    `RedisAPI` | RedisAPI.`ltrim(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ltrim.
    `RedisAPI` | RedisAPI.`memory(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command memory.
    `RedisAPI` | RedisAPI.`mget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command mget.
    `RedisAPI` | RedisAPI.`migrate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command migrate.
    `RedisAPI` | RedisAPI.`module(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command module.
    `RedisAPI` | RedisAPI.`monitor(Handler<AsyncResult<Response>> handler)` Redis command monitor.
    `RedisAPI` | RedisAPI.`move(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command move.
    `RedisAPI` | RedisAPI.`mset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command mset.
    `RedisAPI` | RedisAPI.`msetnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command msetnx.
    `RedisAPI` | RedisAPI.`multi(Handler<AsyncResult<Response>> handler)` Redis command multi.
    `RedisAPI` | RedisAPI.`object(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command object.
    `RedisAPI` | RedisAPI.`persist(String arg0, Handler<AsyncResult<Response>> handler)` Redis command persist.
    `RedisAPI` | RedisAPI.`pexpire(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command pexpire.
    `RedisAPI` | RedisAPI.`pexpireat(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command pexpireat.
    `RedisAPI` | RedisAPI.`pfadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command pfadd.
    `RedisAPI` | RedisAPI.`pfcount(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command pfcount.
    `RedisAPI` | RedisAPI.`pfdebug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command pfdebug.
    `RedisAPI` | RedisAPI.`pfmerge(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command pfmerge.
    `RedisAPI` | RedisAPI.`pfselftest(Handler<AsyncResult<Response>> handler)` Redis command pfselftest.
    `RedisAPI` | RedisAPI.`ping(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ping.
    `void` | RedisConnection.`pipeTo(WriteStream<Response> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `RedisAPI` | RedisAPI.`post(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command post.
    `RedisAPI` | RedisAPI.`psetex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command psetex.
    `RedisAPI` | RedisAPI.`psubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command psubscribe.
    `RedisAPI` | RedisAPI.`psync(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command psync.
    `RedisAPI` | RedisAPI.`pttl(String arg0, Handler<AsyncResult<Response>> handler)` Redis command pttl.
    `RedisAPI` | RedisAPI.`publish(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command publish.
    `RedisAPI` | RedisAPI.`pubsub(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command pubsub.
    `RedisAPI` | RedisAPI.`punsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command punsubscribe.
    `RedisAPI` | RedisAPI.`randomkey(Handler<AsyncResult<Response>> handler)` Redis command randomkey.
    `RedisAPI` | RedisAPI.`readonly(Handler<AsyncResult<Response>> handler)` Redis command readonly.
    `RedisAPI` | RedisAPI.`readwrite(Handler<AsyncResult<Response>> handler)` Redis command readwrite.
    `RedisAPI` | RedisAPI.`rename(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command rename.
    `RedisAPI` | RedisAPI.`renamenx(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command renamenx.
    `RedisAPI` | RedisAPI.`replconf(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command replconf.
    `RedisAPI` | RedisAPI.`replicaof(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command replicaof.
    `RedisAPI` | RedisAPI.`restore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command restore.
    `RedisAPI` | RedisAPI.`restoreAsking(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command restoreAsking.
    `RedisAPI` | RedisAPI.`role(Handler<AsyncResult<Response>> handler)` Redis command role.
    `RedisAPI` | RedisAPI.`rpop(String arg0, Handler<AsyncResult<Response>> handler)` Redis command rpop.
    `RedisAPI` | RedisAPI.`rpoplpush(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command rpoplpush.
    `RedisAPI` | RedisAPI.`rpush(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command rpush.
    `RedisAPI` | RedisAPI.`rpushx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command rpushx.
    `RedisAPI` | RedisAPI.`sadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sadd.
    `RedisAPI` | RedisAPI.`save(Handler<AsyncResult<Response>> handler)` Redis command save.
    `RedisAPI` | RedisAPI.`scan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command scan.
    `RedisAPI` | RedisAPI.`scard(String arg0, Handler<AsyncResult<Response>> handler)` Redis command scard.
    `RedisAPI` | RedisAPI.`script(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command script.
    `RedisAPI` | RedisAPI.`sdiff(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sdiff.
    `RedisAPI` | RedisAPI.`sdiffstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sdiffstore.
    `RedisAPI` | RedisAPI.`select(String arg0, Handler<AsyncResult<Response>> handler)` Redis command select.
    `Redis` | Redis.`send(Request command, Handler<AsyncResult<Response>> onSend)` Send the given command to the redis server or cluster.
    `RedisConnection` | RedisConnection.`send(Request command, Handler<AsyncResult<Response>> onSend)` Send the given command to the redis server or cluster.
    `RedisAPI` | RedisAPI.`set(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command set.
    `RedisAPI` | RedisAPI.`setbit(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command setbit.
    `RedisAPI` | RedisAPI.`setex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command setex.
    `RedisAPI` | RedisAPI.`setnx(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command setnx.
    `RedisAPI` | RedisAPI.`setrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command setrange.
    `RedisAPI` | RedisAPI.`shutdown(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command shutdown.
    `RedisAPI` | RedisAPI.`sinter(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sinter.
    `RedisAPI` | RedisAPI.`sinterstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sinterstore.
    `RedisAPI` | RedisAPI.`sismember(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command sismember.
    `RedisAPI` | RedisAPI.`slaveof(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command slaveof.
    `RedisAPI` | RedisAPI.`slowlog(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command slowlog.
    `RedisAPI` | RedisAPI.`smembers(String arg0, Handler<AsyncResult<Response>> handler)` Redis command smembers.
    `RedisAPI` | RedisAPI.`smove(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command smove.
    `RedisAPI` | RedisAPI.`sort(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sort.
    `RedisAPI` | RedisAPI.`spop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command spop.
    `RedisAPI` | RedisAPI.`srandmember(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command srandmember.
    `RedisAPI` | RedisAPI.`srem(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command srem.
    `RedisAPI` | RedisAPI.`sscan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sscan.
    `RedisAPI` | RedisAPI.`strlen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command strlen.
    `RedisAPI` | RedisAPI.`subscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command subscribe.
    `RedisAPI` | RedisAPI.`substr(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command substr.
    `RedisAPI` | RedisAPI.`sunion(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sunion.
    `RedisAPI` | RedisAPI.`sunionstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sunionstore.
    `RedisAPI` | RedisAPI.`swapdb(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command swapdb.
    `RedisAPI` | RedisAPI.`sync(Handler<AsyncResult<Response>> handler)` Redis command sync.
    `RedisAPI` | RedisAPI.`time(Handler<AsyncResult<Response>> handler)` Redis command time.
    `RedisAPI` | RedisAPI.`touch(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command touch.
    `RedisAPI` | RedisAPI.`ttl(String arg0, Handler<AsyncResult<Response>> handler)` Redis command ttl.
    `RedisAPI` | RedisAPI.`type(String arg0, Handler<AsyncResult<Response>> handler)` Redis command type.
    `RedisAPI` | RedisAPI.`unlink(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command unlink.
    `RedisAPI` | RedisAPI.`unsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command unsubscribe.
    `RedisAPI` | RedisAPI.`unwatch(Handler<AsyncResult<Response>> handler)` Redis command unwatch.
    `RedisAPI` | RedisAPI.`wait(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command wait.
    `RedisAPI` | RedisAPI.`watch(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command watch.
    `RedisAPI` | RedisAPI.`xack(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xack.
    `RedisAPI` | RedisAPI.`xadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xadd.
    `RedisAPI` | RedisAPI.`xclaim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xclaim.
    `RedisAPI` | RedisAPI.`xdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xdel.
    `RedisAPI` | RedisAPI.`xgroup(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xgroup.
    `RedisAPI` | RedisAPI.`xinfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xinfo.
    `RedisAPI` | RedisAPI.`xlen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command xlen.
    `RedisAPI` | RedisAPI.`xpending(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xpending.
    `RedisAPI` | RedisAPI.`xrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xrange.
    `RedisAPI` | RedisAPI.`xread(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xread.
    `RedisAPI` | RedisAPI.`xreadgroup(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xreadgroup.
    `RedisAPI` | RedisAPI.`xrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xrevrange.
    `RedisAPI` | RedisAPI.`xsetid(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command xsetid.
    `RedisAPI` | RedisAPI.`xtrim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xtrim.
    `RedisAPI` | RedisAPI.`zadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zadd.
    `RedisAPI` | RedisAPI.`zcard(String arg0, Handler<AsyncResult<Response>> handler)` Redis command zcard.
    `RedisAPI` | RedisAPI.`zcount(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command zcount.
    `RedisAPI` | RedisAPI.`zincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command zincrby.
    `RedisAPI` | RedisAPI.`zinterstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zinterstore.
    `RedisAPI` | RedisAPI.`zlexcount(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command zlexcount.
    `RedisAPI` | RedisAPI.`zpopmax(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zpopmax.
    `RedisAPI` | RedisAPI.`zpopmin(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zpopmin.
    `RedisAPI` | RedisAPI.`zrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrange.
    `RedisAPI` | RedisAPI.`zrangebylex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrangebylex.
    `RedisAPI` | RedisAPI.`zrangebyscore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrangebyscore.
    `RedisAPI` | RedisAPI.`zrank(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command zrank.
    `RedisAPI` | RedisAPI.`zrem(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrem.
    `RedisAPI` | RedisAPI.`zremrangebylex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command zremrangebylex.
    `RedisAPI` | RedisAPI.`zremrangebyrank(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command zremrangebyrank.
    `RedisAPI` | RedisAPI.`zremrangebyscore(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command zremrangebyscore.
    `RedisAPI` | RedisAPI.`zrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrevrange.
    `RedisAPI` | RedisAPI.`zrevrangebylex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrevrangebylex.
    `RedisAPI` | RedisAPI.`zrevrangebyscore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrevrangebyscore.
    `RedisAPI` | RedisAPI.`zrevrank(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command zrevrank.
    `RedisAPI` | RedisAPI.`zscan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zscan.
    `RedisAPI` | RedisAPI.`zscore(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command zscore.
    `RedisAPI` | RedisAPI.`zunionstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zunionstore.

  - ### Uses of Handler in io.vertx.reactivex.redis.sentinel

    Methods in io.vertx.reactivex.redis.sentinel with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `RedisSentinel` | RedisSentinel.`ckquorum(String name, Handler<AsyncResult<String>> handler)` Check if the current Sentinel configuration is able to reach the quorum needed to failover a master, and the majority needed to authorize the failover.
    `void` | RedisSentinel.`close(Handler<AsyncResult<Void>> handler)` Close the client - when it is fully closed the handler will be called.
    `RedisSentinel` | RedisSentinel.`failover(String name, Handler<AsyncResult<String>> handler)` Force a failover as if the master was not reachable, and without asking for agreement to other Sentinels (however a new version of the configuration will be published so that the other Sentinels will update their configurations)
    `RedisSentinel` | RedisSentinel.`flushConfig(Handler<AsyncResult<Void>> handler)` Force Sentinel to rewrite its configuration on disk, including the current Sentinel state.
    `RedisSentinel` | RedisSentinel.`getMasterAddrByName(String name, Handler<AsyncResult<JsonArray>> handler)` Return the ip and port number of the master with that name.
    `RedisSentinel` | RedisSentinel.`master(String name, Handler<AsyncResult<JsonArray>> handler)` Show the state and info of the specified master
    `RedisSentinel` | RedisSentinel.`masters(Handler<AsyncResult<JsonArray>> handler)` Show a list of monitored masters and their state
    `RedisSentinel` | RedisSentinel.`reset(String pattern, Handler<AsyncResult<Void>> handler)` Reset all the masters with matching name.
    `RedisSentinel` | RedisSentinel.`sentinels(String name, Handler<AsyncResult<JsonArray>> handler)` Show a list of sentinel instances for this master, and their state
    `RedisSentinel` | RedisSentinel.`slaves(String name, Handler<AsyncResult<JsonArray>> handler)` Show a list of slaves for this master, and their state

  - ### Uses of Handler in io.vertx.reactivex.servicediscovery

    Methods in io.vertx.reactivex.servicediscovery with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static ServiceDiscovery` | ServiceDiscovery.`create(Vertx vertx, Handler<ServiceDiscovery> completionHandler)` Deprecated.
    `static ServiceDiscovery` | ServiceDiscovery.`create(Vertx vertx, ServiceDiscoveryOptions options, Handler<ServiceDiscovery> completionHandler)` Deprecated.
    `void` | ServiceDiscovery.`getRecord(java.util.function.Function<Record,Boolean> filter, boolean includeOutOfService, Handler<AsyncResult<Record>> resultHandler)` Lookups for a single record.
    `void` | ServiceDiscovery.`getRecord(java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<Record>> resultHandler)` Lookups for a single record.
    `void` | ServiceDiscovery.`getRecord(JsonObject filter, Handler<AsyncResult<Record>> resultHandler)` Lookups for a single record.
    `void` | ServiceDiscovery.`getRecords(java.util.function.Function<Record,Boolean> filter, boolean includeOutOfService, Handler<AsyncResult<List<Record>>> resultHandler)` Lookups for a set of records.
    `void` | ServiceDiscovery.`getRecords(java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<List<Record>>> resultHandler)` Lookups for a set of records.
    `void` | ServiceDiscovery.`getRecords(JsonObject filter, Handler<AsyncResult<List<Record>>> resultHandler)` Lookups for a set of records.
    `void` | ServiceDiscovery.`publish(Record record, Handler<AsyncResult<Record>> resultHandler)` Publishes a record.
    `ServiceDiscovery` | ServiceDiscovery.`registerServiceExporter(ServiceExporter exporter, JsonObject configuration, Handler<AsyncResult<Void>> completionHandler)` Registers a discovery bridge.
    `ServiceDiscovery` | ServiceDiscovery.`registerServiceImporter(ServiceImporter importer, JsonObject configuration, Handler<AsyncResult<Void>> completionHandler)` Registers a discovery service importer.
    `void` | ServiceDiscovery.`unpublish(String id, Handler<AsyncResult<Void>> resultHandler)` Un-publishes a record.
    `void` | ServiceDiscovery.`update(Record record, Handler<AsyncResult<Record>> resultHandler)` Updates the given record.

  - ### Uses of Handler in io.vertx.reactivex.servicediscovery.spi

    Methods in io.vertx.reactivex.servicediscovery.spi with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ServiceExporter.`close(Handler<Void> closeHandler)` Close the exporter
    `void` | ServiceImporter.`close(Handler<Void> closeHandler)` Closes the importer
    `void` | ServicePublisher.`publish(Record record, Handler<AsyncResult<Record>> resultHandler)` Publishes a record.
    `void` | ServicePublisher.`unpublish(String id, Handler<AsyncResult<Void>> resultHandler)` Un-publishes a record.
    `void` | ServicePublisher.`update(Record record, Handler<AsyncResult<Record>> resultHandler)` Updates an existing record.

  - ### Uses of Handler in io.vertx.reactivex.servicediscovery.types

    Methods in io.vertx.reactivex.servicediscovery.types with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static void` | HttpEndpoint.`getClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<HttpClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static void` | HttpEndpoint.`getClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, JsonObject conf, Handler<AsyncResult<HttpClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static void` | HttpEndpoint.`getClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<HttpClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static void` | HttpEndpoint.`getClient(ServiceDiscovery discovery, JsonObject filter, JsonObject conf, Handler<AsyncResult<HttpClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static <T> void` | MessageSource.`getConsumer(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<MessageConsumer<T>>> resultHandler)` Convenient method that looks for a message source and provides the configured .
    `static <T> void` | MessageSource.`getConsumer(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<MessageConsumer<T>>> resultHandler)` Convenient method that looks for a message source and provides the configured .
    `static void` | JDBCDataSource.`getJDBCClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<JDBCClient>> resultHandler)` Convenient method that looks for a JDBC datasource source and provides the configured `JDBCClient`.
    `static void` | JDBCDataSource.`getJDBCClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, JsonObject consumerConfiguration, Handler<AsyncResult<JDBCClient>> resultHandler)` Convenient method that looks for a JDBC datasource source and provides the configured `JDBCClient`.
    `static void` | JDBCDataSource.`getJDBCClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<JDBCClient>> resultHandler)` Convenient method that looks for a JDBC datasource source and provides the configured `JDBCClient`.
    `static void` | JDBCDataSource.`getJDBCClient(ServiceDiscovery discovery, JsonObject filter, JsonObject consumerConfiguration, Handler<AsyncResult<JDBCClient>> resultHandler)` Convenient method that looks for a JDBC datasource source and provides the configured `JDBCClient`.
    `static void` | MongoDataSource.`getMongoClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<MongoClient>> resultHandler)` Convenient method that looks for a Mongo datasource source and provides the configured `MongoClient`.
    `static void` | MongoDataSource.`getMongoClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<MongoClient>> resultHandler)` Convenient method that looks for a Mongo datasource source and provides the configured `MongoClient`.
    `static void` | MongoDataSource.`getMongoClient(ServiceDiscovery discovery, JsonObject filter, JsonObject consumerConfiguration, Handler<AsyncResult<MongoClient>> resultHandler)` Convenient method that looks for a Mongo datasource source and provides the configured `MongoClient`.
    `static void` | RedisDataSource.`getRedisClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<RedisClient>> resultHandler)` Convenient method that looks for a Redis data source and provides the configured `RedisClient`.
    `static void` | RedisDataSource.`getRedisClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, JsonObject consumerConfiguration, Handler<AsyncResult<RedisClient>> resultHandler)` Convenient method that looks for a Redis data source and provides the configured `RedisClient`.
    `static void` | RedisDataSource.`getRedisClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<RedisClient>> resultHandler)` Convenient method that looks for a Redis data source and provides the configured `RedisClient`.
    `static void` | RedisDataSource.`getRedisClient(ServiceDiscovery discovery, JsonObject filter, JsonObject consumerConfiguration, Handler<AsyncResult<RedisClient>> resultHandler)` Convenient method that looks for a Redis data source and provides the configured `RedisClient`.
    `static <T> T` | EventBusService.`getServiceProxy(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Class<T> clientClass, Handler<AsyncResult<T>> resultHandler)` Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
    `static <T> T` | EventBusService.`getServiceProxy(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Class<T> clientClass, JsonObject conf, Handler<AsyncResult<T>> resultHandler)` Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
    `static <T> T` | EventBusService.`getServiceProxyWithJsonFilter(ServiceDiscovery discovery, JsonObject filter, Class<T> clientClass, Handler<AsyncResult<T>> resultHandler)` Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
    `static <T> T` | EventBusService.`getServiceProxyWithJsonFilter(ServiceDiscovery discovery, JsonObject filter, Class<T> clientClass, JsonObject conf, Handler<AsyncResult<T>> resultHandler)` Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
    `static void` | HttpEndpoint.`getWebClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<WebClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static void` | HttpEndpoint.`getWebClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, JsonObject conf, Handler<AsyncResult<WebClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static void` | HttpEndpoint.`getWebClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<WebClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static void` | HttpEndpoint.`getWebClient(ServiceDiscovery discovery, JsonObject filter, JsonObject conf, Handler<AsyncResult<WebClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .

  - ### Uses of Handler in io.vertx.reactivex.sqlclient

    Methods in io.vertx.reactivex.sqlclient with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `Transaction` | Transaction.`abortHandler(Handler<Void> handler)` Set an handler to be called when the transaction is aborted.
    `void` | Pool.`begin(Handler<AsyncResult<Transaction>> handler)` Borrow a connection from the pool and begin a transaction, the underlying connection will be returned to the pool when the transaction ends.
    `void` | PreparedStatement.`close(Handler<AsyncResult<Void>> completionHandler)` Like `PreparedStatement.close()` but notifies the `completionHandler` when it's closed.
    `void` | RowStream.`close(Handler<AsyncResult<Void>> completionHandler)` Close the stream and release the resources.
    `void` | Cursor.`close(Handler<AsyncResult<Void>> completionHandler)` Like `Cursor.close()` but with a `completionHandler` called when the cursor has been released.
    `SqlConnection` | SqlConnection.`closeHandler(Handler<Void> handler)` Set an handler called when the connection is closed.
    `void` | Transaction.`commit(Handler<AsyncResult<Void>> handler)` Like `Transaction.commit()` with an handler to be notified when the transaction commit has completed
    `RowStream<T>` | RowStream.`endHandler(Handler<Void> endHandler)`
    `SqlConnection` | SqlConnection.`exceptionHandler(Handler<Throwable> handler)` Set an handler called with connection errors.
    `RowStream<T>` | RowStream.`exceptionHandler(Handler<Throwable> handler)`
    `void` | PreparedQuery.`execute(Handler<AsyncResult<T>> handler)` Execute the query.
    `void` | Query.`execute(Handler<AsyncResult<T>> handler)` Execute the query.
    `void` | PreparedQuery.`execute(Tuple tuple, Handler<AsyncResult<T>> handler)` Execute the query.
    `void` | PreparedQuery.`executeBatch(List<Tuple> batch, Handler<AsyncResult<T>> handler)` Execute the query with a batch of tuples.
    `void` | Pool.`getConnection(Handler<AsyncResult<SqlConnection>> handler)` Get a connection from the pool.
    `RowStream<T>` | RowStream.`handler(Handler<T> handler)`
    `void` | RowStream.`pipeTo(WriteStream<T> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `SqlConnection` | SqlConnection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)` Create a prepared query.
    `Transaction` | Transaction.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)` Create a prepared query.
    `void` | Cursor.`read(int count, Handler<AsyncResult<RowSet<Row>>> handler)` Read rows from the cursor, the result is provided asynchronously to the `handler`.
    `void` | Transaction.`rollback(Handler<AsyncResult<Void>> handler)` Like `Transaction.rollback()` with an handler to be notified when the transaction rollback has completed

  - ### Uses of Handler in io.vertx.redis

    Methods in io.vertx.redis with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `RedisClient` | RedisClient.`append(String key, String value, Handler<AsyncResult<Long>> handler)` Deprecated. Append a value to a key
    `RedisTransaction` | RedisTransaction.`append(String key, String value, Handler<AsyncResult<String>> handler)` Deprecated. Append a value to a key
    `RedisTransaction` | RedisTransaction.`auth(String password, Handler<AsyncResult<String>> handler)` Deprecated. Authenticate to the server
    `RedisClient` | RedisClient.`auth(String password, Handler<AsyncResult<String>> handler)` Deprecated. Authenticate to the server
    `RedisTransaction` | RedisTransaction.`bgrewriteaof(Handler<AsyncResult<String>> handler)` Deprecated. Asynchronously rewrite the append-only file
    `RedisClient` | RedisClient.`bgrewriteaof(Handler<AsyncResult<String>> handler)` Deprecated. Asynchronously rewrite the append-only file
    `RedisTransaction` | RedisTransaction.`bgsave(Handler<AsyncResult<String>> handler)` Deprecated. Asynchronously save the dataset to disk
    `RedisClient` | RedisClient.`bgsave(Handler<AsyncResult<String>> handler)` Deprecated. Asynchronously save the dataset to disk
    `RedisClient` | RedisClient.`bitcount(String key, Handler<AsyncResult<Long>> handler)` Deprecated. Count set bits in a string
    `RedisTransaction` | RedisTransaction.`bitcount(String key, Handler<AsyncResult<String>> handler)` Deprecated. Count set bits in a string
    `RedisClient` | RedisClient.`bitcountRange(String key, long start, long end, Handler<AsyncResult<Long>> handler)` Deprecated. Count set bits in a string
    `RedisTransaction` | RedisTransaction.`bitcountRange(String key, long start, long end, Handler<AsyncResult<String>> handler)` Deprecated. Count set bits in a string
    `RedisClient` | RedisClient.`bitfield(String key, BitFieldOptions bitFieldOptions, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Perform arbitrary bitfield integer operations on strings.
    `RedisClient` | RedisClient.`bitfieldWithOverflow(String key, BitFieldOptions commands, BitFieldOverflowOptions overflow, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Perform arbitrary bitfield integer operations on strings.
    `RedisClient` | RedisClient.`bitop(BitOperation operation, String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Deprecated. Perform bitwise operations between strings
    `RedisTransaction` | RedisTransaction.`bitop(BitOperation operation, String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Deprecated. Perform bitwise operations between strings
    `RedisClient` | RedisClient.`bitpos(String key, int bit, Handler<AsyncResult<Long>> handler)` Deprecated. Find first bit set or clear in a string
    `RedisTransaction` | RedisTransaction.`bitpos(String key, int bit, Handler<AsyncResult<String>> handler)` Deprecated. Find first bit set or clear in a string
    `RedisClient` | RedisClient.`bitposFrom(String key, int bit, int start, Handler<AsyncResult<Long>> handler)` Deprecated. Find first bit set or clear in a string See also bitposRange() method, which takes start, and stop offset.
    `RedisTransaction` | RedisTransaction.`bitposFrom(String key, int bit, int start, Handler<AsyncResult<String>> handler)` Deprecated. Find first bit set or clear in a string
    `RedisClient` | RedisClient.`bitposRange(String key, int bit, int start, int stop, Handler<AsyncResult<Long>> handler)` Deprecated. Find first bit set or clear in a string Note: when both start, and stop offsets are specified, behaviour is slightly different than if only start is specified
    `RedisTransaction` | RedisTransaction.`bitposRange(String key, int bit, int start, int stop, Handler<AsyncResult<String>> handler)` Deprecated. Find first bit set or clear in a string
    `RedisClient` | RedisClient.`blpop(String key, int seconds, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Remove and get the first element in a list, or block until one is available
    `RedisTransaction` | RedisTransaction.`blpop(String key, int seconds, Handler<AsyncResult<String>> handler)` Deprecated. Remove and get the first element in a list, or block until one is available
    `RedisClient` | RedisClient.`blpopMany(List<String> keys, int seconds, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Remove and get the first element in any of the lists, or block until one is available
    `RedisTransaction` | RedisTransaction.`blpopMany(List<String> keys, int seconds, Handler<AsyncResult<String>> handler)` Deprecated. Remove and get the first element in any of the lists, or block until one is available
    `RedisClient` | RedisClient.`brpop(String key, int seconds, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Remove and get the last element in a list, or block until one is available
    `RedisTransaction` | RedisTransaction.`brpop(String key, int seconds, Handler<AsyncResult<String>> handler)` Deprecated. Remove and get the last element in a list, or block until one is available
    `RedisTransaction` | RedisTransaction.`brpoplpush(String key, String destkey, int seconds, Handler<AsyncResult<String>> handler)` Deprecated. Pop a value from a list, push it to another list and return it; or block until one is available
    `RedisClient` | RedisClient.`brpoplpush(String key, String destkey, int seconds, Handler<AsyncResult<String>> handler)` Deprecated. Pop a value from a list, push it to another list and return it; or block until one is available
    `RedisClient` | RedisClient.`brpopMany(List<String> keys, int seconds, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Remove and get the last element in any of the lists, or block until one is available
    `RedisTransaction` | RedisTransaction.`brpopMany(List<String> keys, int seconds, Handler<AsyncResult<String>> handler)` Deprecated. Remove and get the last element in any of the lists, or block until one is available
    `RedisTransaction` | RedisTransaction.`clientGetname(Handler<AsyncResult<String>> handler)` Deprecated. Get the current connection name
    `RedisClient` | RedisClient.`clientGetname(Handler<AsyncResult<String>> handler)` Deprecated. Get the current connection name
    `RedisClient` | RedisClient.`clientKill(KillFilter filter, Handler<AsyncResult<Long>> handler)` Deprecated. Kill the connection of a client
    `RedisTransaction` | RedisTransaction.`clientKill(KillFilter filter, Handler<AsyncResult<String>> handler)` Deprecated. Kill the connection of a client
    `RedisTransaction` | RedisTransaction.`clientList(Handler<AsyncResult<String>> handler)` Deprecated. Get the list of client connections
    `RedisClient` | RedisClient.`clientList(Handler<AsyncResult<String>> handler)` Deprecated. Get the list of client connections
    `RedisTransaction` | RedisTransaction.`clientPause(long millis, Handler<AsyncResult<String>> handler)` Deprecated. Stop processing commands from clients for some time
    `RedisClient` | RedisClient.`clientPause(long millis, Handler<AsyncResult<String>> handler)` Deprecated. Stop processing commands from clients for some time
    `RedisClient` | RedisClient.`clientReply(ClientReplyOptions options, Handler<AsyncResult<String>> handler)` Deprecated. Instruct the server whether to reply to commands.
    `RedisTransaction` | RedisTransaction.`clientSetname(String name, Handler<AsyncResult<String>> handler)` Deprecated. Set the current connection name
    `RedisClient` | RedisClient.`clientSetname(String name, Handler<AsyncResult<String>> handler)` Deprecated. Set the current connection name
    `void` | RedisTransaction.`close(Handler<AsyncResult<Void>> handler)` Deprecated. Close the client - when it is fully closed the handler will be called.
    `void` | RedisClient.`close(Handler<AsyncResult<Void>> handler)` Deprecated. Close the client - when it is fully closed the handler will be called.
    `RedisClient` | RedisClient.`clusterAddslots(List<Long> slots, Handler<AsyncResult<Void>> handler)` Deprecated. Assign new hash slots to receiving node.
    `RedisTransaction` | RedisTransaction.`clusterAddslots(List<String> slots, Handler<AsyncResult<String>> handler)` Deprecated. Assign new hash slots to receiving node.
    `RedisClient` | RedisClient.`clusterCountFailureReports(String nodeId, Handler<AsyncResult<Long>> handler)` Deprecated. Return the number of failure reports active for a given node.
    `RedisTransaction` | RedisTransaction.`clusterCountFailureReports(String nodeId, Handler<AsyncResult<String>> handler)` Deprecated. Return the number of failure reports active for a given node.
    `RedisClient` | RedisClient.`clusterCountkeysinslot(long slot, Handler<AsyncResult<Long>> handler)` Deprecated. Return the number of local keys in the specified hash slot.
    `RedisTransaction` | RedisTransaction.`clusterCountkeysinslot(long slot, Handler<AsyncResult<String>> handler)` Deprecated. Return the number of local keys in the specified hash slot.
    `RedisTransaction` | RedisTransaction.`clusterDelslots(long slot, Handler<AsyncResult<String>> handler)` Deprecated. Set hash slots as unbound in receiving node.
    `RedisClient` | RedisClient.`clusterDelslots(long slot, Handler<AsyncResult<Void>> handler)` Deprecated. Set hash slots as unbound in receiving node.
    `RedisClient` | RedisClient.`clusterDelslotsMany(List<Long> slots, Handler<AsyncResult<Void>> handler)` Deprecated. Set hash slots as unbound in receiving node.
    `RedisTransaction` | RedisTransaction.`clusterDelslotsMany(List<String> slots, Handler<AsyncResult<String>> handler)` Deprecated. Set hash slots as unbound in receiving node.
    `RedisTransaction` | RedisTransaction.`clusterFailover(Handler<AsyncResult<String>> handler)` Deprecated. Forces a slave to perform a manual failover of its master.
    `RedisClient` | RedisClient.`clusterFailover(Handler<AsyncResult<Void>> handler)` Deprecated. Forces a slave to perform a manual failover of its master.
    `RedisTransaction` | RedisTransaction.`clusterFailOverWithOptions(FailoverOptions options, Handler<AsyncResult<String>> handler)` Deprecated. Forces a slave to perform a manual failover of its master.
    `RedisClient` | RedisClient.`clusterFailOverWithOptions(FailoverOptions options, Handler<AsyncResult<Void>> handler)` Deprecated. Forces a slave to perform a manual failover of its master.
    `RedisTransaction` | RedisTransaction.`clusterForget(String nodeId, Handler<AsyncResult<String>> handler)` Deprecated. Remove a node from the nodes table.
    `RedisClient` | RedisClient.`clusterForget(String nodeId, Handler<AsyncResult<Void>> handler)` Deprecated. Remove a node from the nodes table.
    `RedisClient` | RedisClient.`clusterGetkeysinslot(long slot, long count, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Return local key names in the specified hash slot.
    `RedisTransaction` | RedisTransaction.`clusterGetkeysinslot(long slot, long count, Handler<AsyncResult<String>> handler)` Deprecated. Return local key names in the specified hash slot.
    `RedisClient` | RedisClient.`clusterInfo(Handler<AsyncResult<JsonArray>> handler)` Deprecated. Provides info about Redis Cluster node state.
    `RedisTransaction` | RedisTransaction.`clusterInfo(Handler<AsyncResult<String>> handler)` Deprecated. Provides info about Redis Cluster node state.
    `RedisClient` | RedisClient.`clusterKeyslot(String key, Handler<AsyncResult<Long>> handler)` Deprecated. Returns the hash slot of the specified key.
    `RedisTransaction` | RedisTransaction.`clusterKeyslot(String key, Handler<AsyncResult<String>> handler)` Deprecated. Returns the hash slot of the specified key.
    `RedisTransaction` | RedisTransaction.`clusterMeet(String ip, long port, Handler<AsyncResult<String>> handler)` Deprecated. Force a node cluster to handshake with another node.
    `RedisClient` | RedisClient.`clusterMeet(String ip, long port, Handler<AsyncResult<Void>> handler)` Deprecated. Force a node cluster to handshake with another node.
    `RedisClient` | RedisClient.`clusterNodes(Handler<AsyncResult<JsonArray>> handler)` Deprecated. Get Cluster config for the node.
    `RedisTransaction` | RedisTransaction.`clusterNodes(Handler<AsyncResult<String>> handler)` Deprecated. Get Cluster config for the node.
    `RedisTransaction` | RedisTransaction.`clusterReplicate(String nodeId, Handler<AsyncResult<String>> handler)` Deprecated. Reconfigure a node as a slave of the specified master node.
    `RedisClient` | RedisClient.`clusterReplicate(String nodeId, Handler<AsyncResult<Void>> handler)` Deprecated. Reconfigure a node as a slave of the specified master node.
    `RedisTransaction` | RedisTransaction.`clusterReset(Handler<AsyncResult<String>> handler)` Deprecated. Reset a Redis Cluster node.
    `RedisClient` | RedisClient.`clusterReset(Handler<AsyncResult<Void>> handler)` Deprecated. Reset a Redis Cluster node.
    `RedisTransaction` | RedisTransaction.`clusterResetWithOptions(ResetOptions options, Handler<AsyncResult<String>> handler)` Deprecated. Reset a Redis Cluster node.
    `RedisClient` | RedisClient.`clusterResetWithOptions(ResetOptions options, Handler<AsyncResult<Void>> handler)` Deprecated. Reset a Redis Cluster node.
    `RedisTransaction` | RedisTransaction.`clusterSaveconfig(Handler<AsyncResult<String>> handler)` Deprecated. Forces the node to save cluster state on disk.
    `RedisClient` | RedisClient.`clusterSaveconfig(Handler<AsyncResult<Void>> handler)` Deprecated. Forces the node to save cluster state on disk.
    `RedisTransaction` | RedisTransaction.`clusterSetConfigEpoch(long epoch, Handler<AsyncResult<String>> handler)` Deprecated. Set the configuration epoch in a new node.
    `RedisClient` | RedisClient.`clusterSetConfigEpoch(long epoch, Handler<AsyncResult<Void>> handler)` Deprecated. Set the configuration epoch in a new node.
    `RedisTransaction` | RedisTransaction.`clusterSetslot(long slot, SlotCmd subcommand, Handler<AsyncResult<String>> handler)` Deprecated. Bind an hash slot to a specific node.
    `RedisClient` | RedisClient.`clusterSetslot(long slot, SlotCmd subcommand, Handler<AsyncResult<Void>> handler)` Deprecated. Bind an hash slot to a specific node.
    `RedisTransaction` | RedisTransaction.`clusterSetslotWithNode(long slot, SlotCmd subcommand, String nodeId, Handler<AsyncResult<String>> handler)` Deprecated. Bind an hash slot to a specific node.
    `RedisClient` | RedisClient.`clusterSetslotWithNode(long slot, SlotCmd subcommand, String nodeId, Handler<AsyncResult<Void>> handler)` Deprecated. Bind an hash slot to a specific node.
    `RedisClient` | RedisClient.`clusterSlaves(String nodeId, Handler<AsyncResult<JsonArray>> handler)` Deprecated. List slave nodes of the specified master node.
    `RedisTransaction` | RedisTransaction.`clusterSlaves(String nodeId, Handler<AsyncResult<String>> handler)` Deprecated. List slave nodes of the specified master node.
    `RedisClient` | RedisClient.`clusterSlots(Handler<AsyncResult<JsonArray>> handler)` Deprecated. Get array of Cluster slot to node mappings
    `RedisTransaction` | RedisTransaction.`clusterSlots(Handler<AsyncResult<String>> handler)` Deprecated. Get array of Cluster slot to node mappings
    `RedisClient` | RedisClient.`command(Handler<AsyncResult<JsonArray>> handler)` Deprecated. Get array of Redis command details
    `RedisTransaction` | RedisTransaction.`command(Handler<AsyncResult<String>> handler)` Deprecated. Get array of Redis command details
    `RedisClient` | RedisClient.`commandCount(Handler<AsyncResult<Long>> handler)` Deprecated. Get total number of Redis commands
    `RedisTransaction` | RedisTransaction.`commandCount(Handler<AsyncResult<String>> handler)` Deprecated. Get total number of Redis commands
    `RedisClient` | RedisClient.`commandGetkeys(Handler<AsyncResult<JsonArray>> handler)` Deprecated. Extract keys given a full Redis command
    `RedisTransaction` | RedisTransaction.`commandGetkeys(Handler<AsyncResult<String>> handler)` Deprecated. Extract keys given a full Redis command
    `RedisClient` | RedisClient.`commandInfo(List<String> commands, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Get array of specific Redis command details
    `RedisTransaction` | RedisTransaction.`commandInfo(List<String> commands, Handler<AsyncResult<String>> handler)` Deprecated. Get array of specific Redis command details
    `RedisClient` | RedisClient.`configGet(String parameter, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Get the value of a configuration parameter
    `RedisTransaction` | RedisTransaction.`configGet(String parameter, Handler<AsyncResult<String>> handler)` Deprecated. Get the value of a configuration parameter
    `RedisTransaction` | RedisTransaction.`configResetstat(Handler<AsyncResult<String>> handler)` Deprecated. Reset the stats returned by INFO
    `RedisClient` | RedisClient.`configResetstat(Handler<AsyncResult<String>> handler)` Deprecated. Reset the stats returned by INFO
    `RedisTransaction` | RedisTransaction.`configRewrite(Handler<AsyncResult<String>> handler)` Deprecated. Rewrite the configuration file with the in memory configuration
    `RedisClient` | RedisClient.`configRewrite(Handler<AsyncResult<String>> handler)` Deprecated. Rewrite the configuration file with the in memory configuration
    `RedisTransaction` | RedisTransaction.`configSet(String parameter, String value, Handler<AsyncResult<String>> handler)` Deprecated. Set a configuration parameter to the given value
    `RedisClient` | RedisClient.`configSet(String parameter, String value, Handler<AsyncResult<String>> handler)` Deprecated. Set a configuration parameter to the given value
    `RedisClient` | RedisClient.`dbsize(Handler<AsyncResult<Long>> handler)` Deprecated. Return the number of keys in the selected database
    `RedisTransaction` | RedisTransaction.`dbsize(Handler<AsyncResult<String>> handler)` Deprecated. Return the number of keys in the selected database
    `RedisTransaction` | RedisTransaction.`debugObject(String key, Handler<AsyncResult<String>> handler)` Deprecated. Get debugging information about a key
    `RedisClient` | RedisClient.`debugObject(String key, Handler<AsyncResult<String>> handler)` Deprecated. Get debugging information about a key
    `RedisTransaction` | RedisTransaction.`debugSegfault(Handler<AsyncResult<String>> handler)` Deprecated. Make the server crash
    `RedisClient` | RedisClient.`debugSegfault(Handler<AsyncResult<String>> handler)` Deprecated. Make the server crash
    `RedisClient` | RedisClient.`decr(String key, Handler<AsyncResult<Long>> handler)` Deprecated. Decrement the integer value of a key by one
    `RedisTransaction` | RedisTransaction.`decr(String key, Handler<AsyncResult<String>> handler)` Deprecated. Decrement the integer value of a key by one
    `RedisClient` | RedisClient.`decrby(String key, long decrement, Handler<AsyncResult<Long>> handler)` Deprecated. Decrement the integer value of a key by the given number
    `RedisTransaction` | RedisTransaction.`decrby(String key, long decrement, Handler<AsyncResult<String>> handler)` Deprecated. Decrement the integer value of a key by the given number
    `RedisClient` | RedisClient.`del(String key, Handler<AsyncResult<Long>> handler)` Deprecated. Delete a key
    `RedisTransaction` | RedisTransaction.`del(String key, Handler<AsyncResult<String>> handler)` Deprecated. Delete a key
    `RedisClient` | RedisClient.`delMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Deprecated. Delete many keys
    `RedisTransaction` | RedisTransaction.`delMany(List<String> keys, Handler<AsyncResult<String>> handler)` Deprecated. Delete many keys
    `RedisTransaction` | RedisTransaction.`discard(Handler<AsyncResult<String>> handler)` Deprecated. Discard all commands issued after MULTI
    `RedisTransaction` | RedisTransaction.`dump(String key, Handler<AsyncResult<String>> handler)` Deprecated. Return a serialized version of the value stored at the specified key.
    `RedisClient` | RedisClient.`dump(String key, Handler<AsyncResult<String>> handler)` Deprecated. Return a serialized version of the value stored at the specified key.
    `RedisTransaction` | RedisTransaction.`echo(String message, Handler<AsyncResult<String>> handler)` Deprecated. Echo the given string
    `RedisClient` | RedisClient.`echo(String message, Handler<AsyncResult<String>> handler)` Deprecated. Echo the given string
    `RedisClient` | RedisClient.`eval(String script, List<String> keys, List<String> args, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Execute a Lua script server side.
    `RedisTransaction` | RedisTransaction.`eval(String script, List<String> keys, List<String> args, Handler<AsyncResult<String>> handler)` Deprecated. Execute a Lua script server side.
    `RedisClient` | RedisClient.`evalScript(Script script, List<String> keys, List<String> args, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Execute a Lua script server side.
    `RedisClient` | RedisClient.`evalsha(String sha1, List<String> keys, List<String> values, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Execute a Lua script server side.
    `RedisTransaction` | RedisTransaction.`evalsha(String sha1, List<String> keys, List<String> values, Handler<AsyncResult<String>> handler)` Deprecated. Execute a Lua script server side.
    `RedisTransaction` | RedisTransaction.`exec(Handler<AsyncResult<JsonArray>> handler)` Deprecated. Execute all commands issued after MULTI
    `RedisClient` | RedisClient.`exists(String key, Handler<AsyncResult<Long>> handler)` Deprecated. Determine if a key exists
    `RedisTransaction` | RedisTransaction.`exists(String key, Handler<AsyncResult<String>> handler)` Deprecated. Determine if a key exists
    `RedisClient` | RedisClient.`existsMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Deprecated. Determine if one or many keys exist
    `RedisTransaction` | RedisTransaction.`existsMany(List<String> keys, Handler<AsyncResult<String>> handler)` Deprecated. Determine if one or many keys exist
    `RedisTransaction` | RedisTransaction.`expire(String key, int seconds, Handler<AsyncResult<String>> handler)` Deprecated. Set a key's time to live in seconds
    `RedisClient` | RedisClient.`expire(String key, long seconds, Handler<AsyncResult<Long>> handler)` Deprecated. Set a key's time to live in seconds
    `RedisClient` | RedisClient.`expireat(String key, long seconds, Handler<AsyncResult<Long>> handler)` Deprecated. Set the expiration for a key as a UNIX timestamp
    `RedisTransaction` | RedisTransaction.`expireat(String key, long seconds, Handler<AsyncResult<String>> handler)` Deprecated. Set the expiration for a key as a UNIX timestamp
    `RedisTransaction` | RedisTransaction.`flushall(Handler<AsyncResult<String>> handler)` Deprecated. Remove all keys from all databases
    `RedisClient` | RedisClient.`flushall(Handler<AsyncResult<String>> handler)` Deprecated. Remove all keys from all databases
    `RedisTransaction` | RedisTransaction.`flushdb(Handler<AsyncResult<String>> handler)` Deprecated. Remove all keys from the current database
    `RedisClient` | RedisClient.`flushdb(Handler<AsyncResult<String>> handler)` Deprecated. Remove all keys from the current database
    `RedisClient` | RedisClient.`geoadd(String key, double longitude, double latitude, String member, Handler<AsyncResult<Long>> handler)` Deprecated. Add one or more geospatial items in the geospatial index represented using a sorted set.
    `RedisTransaction` | RedisTransaction.`geoadd(String key, double longitude, double latitude, String member, Handler<AsyncResult<String>> handler)` Deprecated. Add one or more geospatial items in the geospatial index represented using a sorted set.
    `RedisClient` | RedisClient.`geoaddMany(String key, List<GeoMember> members, Handler<AsyncResult<Long>> handler)` Deprecated. Add one or more geospatial items in the geospatial index represented using a sorted set.
    `RedisTransaction` | RedisTransaction.`geoaddMany(String key, List<GeoMember> members, Handler<AsyncResult<String>> handler)` Deprecated. Add one or more geospatial items in the geospatial index represented using a sorted set.
    `RedisTransaction` | RedisTransaction.`geodist(String key, String member1, String member2, Handler<AsyncResult<String>> handler)` Deprecated. Return the distance between two members in the geospatial index represented by the sorted set.
    `RedisClient` | RedisClient.`geodist(String key, String member1, String member2, Handler<AsyncResult<String>> handler)` Deprecated. Return the distance between two members in the geospatial index represented by the sorted set.
    `RedisTransaction` | RedisTransaction.`geodistWithUnit(String key, String member1, String member2, GeoUnit unit, Handler<AsyncResult<String>> handler)` Deprecated. Return the distance between two members in the geospatial index represented by the sorted set.
    `RedisClient` | RedisClient.`geodistWithUnit(String key, String member1, String member2, GeoUnit unit, Handler<AsyncResult<String>> handler)` Deprecated. Return the distance between two members in the geospatial index represented by the sorted set.
    `RedisClient` | RedisClient.`geohash(String key, String member, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `RedisTransaction` | RedisTransaction.`geohash(String key, String member, Handler<AsyncResult<String>> handler)` Deprecated. Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `RedisClient` | RedisClient.`geohashMany(String key, List<String> members, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `RedisTransaction` | RedisTransaction.`geohashMany(String key, List<String> members, Handler<AsyncResult<String>> handler)` Deprecated. Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `RedisClient` | RedisClient.`geopos(String key, String member, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `RedisTransaction` | RedisTransaction.`geopos(String key, String member, Handler<AsyncResult<String>> handler)` Deprecated. Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `RedisClient` | RedisClient.`geoposMany(String key, List<String> members, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `RedisTransaction` | RedisTransaction.`geoposMany(String key, List<String> members, Handler<AsyncResult<String>> handler)` Deprecated. Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `RedisClient` | RedisClient.`georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `RedisTransaction` | RedisTransaction.`georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, Handler<AsyncResult<String>> handler)` Deprecated. Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `RedisClient` | RedisClient.`georadiusbymember(String key, String member, double radius, GeoUnit unit, Handler<AsyncResult<JsonArray>> handler)` Deprecated. This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `RedisTransaction` | RedisTransaction.`georadiusbymember(String key, String member, double radius, GeoUnit unit, Handler<AsyncResult<String>> handler)` Deprecated. This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `RedisClient` | RedisClient.`georadiusbymemberWithOptions(String key, String member, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<JsonArray>> handler)` Deprecated. This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `RedisTransaction` | RedisTransaction.`georadiusbymemberWithOptions(String key, String member, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<String>> handler)` Deprecated. This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `RedisClient` | RedisClient.`georadiusWithOptions(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `RedisTransaction` | RedisTransaction.`georadiusWithOptions(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<String>> handler)` Deprecated. Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `RedisTransaction` | RedisTransaction.`get(String key, Handler<AsyncResult<String>> handler)` Deprecated. Get the value of a key
    `RedisClient` | RedisClient.`get(String key, Handler<AsyncResult<String>> handler)` Deprecated. Get the value of a key
    `RedisTransaction` | RedisTransaction.`getBinary(String key, Handler<AsyncResult<Buffer>> handler)` Deprecated. Get the value of a key - without decoding as utf-8
    `RedisClient` | RedisClient.`getBinary(String key, Handler<AsyncResult<Buffer>> handler)` Deprecated. Get the value of a key - without decoding as utf-8
    `RedisClient` | RedisClient.`getbit(String key, long offset, Handler<AsyncResult<Long>> handler)` Deprecated. Returns the bit value at offset in the string value stored at key
    `RedisTransaction` | RedisTransaction.`getbit(String key, long offset, Handler<AsyncResult<String>> handler)` Deprecated. Returns the bit value at offset in the string value stored at key
    `RedisTransaction` | RedisTransaction.`getrange(String key, long start, long end, Handler<AsyncResult<String>> handler)` Deprecated. Get a substring of the string stored at a key
    `RedisClient` | RedisClient.`getrange(String key, long start, long end, Handler<AsyncResult<String>> handler)` Deprecated. Get a substring of the string stored at a key
    `RedisTransaction` | RedisTransaction.`getset(String key, String value, Handler<AsyncResult<String>> handler)` Deprecated. Set the string value of a key and return its old value
    `RedisClient` | RedisClient.`getset(String key, String value, Handler<AsyncResult<String>> handler)` Deprecated. Set the string value of a key and return its old value
    `RedisClient` | RedisClient.`hdel(String key, String field, Handler<AsyncResult<Long>> handler)` Deprecated. Delete one or more hash fields
    `RedisTransaction` | RedisTransaction.`hdel(String key, String field, Handler<AsyncResult<String>> handler)` Deprecated. Delete one or more hash fields
    `RedisClient` | RedisClient.`hdelMany(String key, List<String> fields, Handler<AsyncResult<Long>> handler)` Deprecated. Delete one or more hash fields
    `RedisTransaction` | RedisTransaction.`hdelMany(String key, List<String> fields, Handler<AsyncResult<String>> handler)` Deprecated. Delete one or more hash fields
    `RedisClient` | RedisClient.`hexists(String key, String field, Handler<AsyncResult<Long>> handler)` Deprecated. Determine if a hash field exists
    `RedisTransaction` | RedisTransaction.`hexists(String key, String field, Handler<AsyncResult<String>> handler)` Deprecated. Determine if a hash field exists
    `RedisTransaction` | RedisTransaction.`hget(String key, String field, Handler<AsyncResult<String>> handler)` Deprecated. Get the value of a hash field
    `RedisClient` | RedisClient.`hget(String key, String field, Handler<AsyncResult<String>> handler)` Deprecated. Get the value of a hash field
    `RedisClient` | RedisClient.`hgetall(String key, Handler<AsyncResult<JsonObject>> handler)` Deprecated. Get all the fields and values in a hash
    `RedisTransaction` | RedisTransaction.`hgetall(String key, Handler<AsyncResult<String>> handler)` Deprecated. Get all the fields and values in a hash
    `RedisClient` | RedisClient.`hincrby(String key, String field, long increment, Handler<AsyncResult<Long>> handler)` Deprecated. Increment the integer value of a hash field by the given number
    `RedisTransaction` | RedisTransaction.`hincrby(String key, String field, long increment, Handler<AsyncResult<String>> handler)` Deprecated. Increment the integer value of a hash field by the given number
    `RedisTransaction` | RedisTransaction.`hincrbyfloat(String key, String field, double increment, Handler<AsyncResult<String>> handler)` Deprecated. Increment the float value of a hash field by the given amount
    `RedisClient` | RedisClient.`hincrbyfloat(String key, String field, double increment, Handler<AsyncResult<String>> handler)` Deprecated. Increment the float value of a hash field by the given amount
    `RedisClient` | RedisClient.`hkeys(String key, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Get all the fields in a hash
    `RedisTransaction` | RedisTransaction.`hkeys(String key, Handler<AsyncResult<String>> handler)` Deprecated. Get all the fields in a hash
    `RedisClient` | RedisClient.`hlen(String key, Handler<AsyncResult<Long>> handler)` Deprecated. Get the number of fields in a hash
    `RedisTransaction` | RedisTransaction.`hlen(String key, Handler<AsyncResult<String>> handler)` Deprecated. Get the number of fields in a hash
    `RedisClient` | RedisClient.`hmget(String key, List<String> fields, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Get the values of all the given hash fields
    `RedisTransaction` | RedisTransaction.`hmget(String key, List<String> fields, Handler<AsyncResult<String>> handler)` Deprecated. Get the values of all the given hash fields
    `RedisTransaction` | RedisTransaction.`hmset(String key, JsonObject values, Handler<AsyncResult<String>> handler)` Deprecated. Set multiple hash fields to multiple values
    `RedisClient` | RedisClient.`hmset(String key, JsonObject values, Handler<AsyncResult<String>> handler)` Deprecated. Set multiple hash fields to multiple values
    `RedisClient` | RedisClient.`hscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Incrementally iterate hash fields and associated values
    `RedisTransaction` | RedisTransaction.`hscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<String>> handler)` Deprecated. Incrementally iterate hash fields and associated values
    `RedisClient` | RedisClient.`hset(String key, String field, String value, Handler<AsyncResult<Long>> handler)` Deprecated. Set the string value of a hash field
    `RedisTransaction` | RedisTransaction.`hset(String key, String field, String value, Handler<AsyncResult<String>> handler)` Deprecated. Set the string value of a hash field
    `RedisClient` | RedisClient.`hsetnx(String key, String field, String value, Handler<AsyncResult<Long>> handler)` Deprecated. Set the value of a hash field, only if the field does not exist
    `RedisTransaction` | RedisTransaction.`hsetnx(String key, String field, String value, Handler<AsyncResult<String>> handler)` Deprecated. Set the value of a hash field, only if the field does not exist
    `RedisClient` | RedisClient.`hstrlen(String key, String field, Handler<AsyncResult<Long>> handler)` Deprecated. Get the length of the value of a hash field.
    `RedisClient` | RedisClient.`hvals(String key, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Get all the values in a hash
    `RedisTransaction` | RedisTransaction.`hvals(String key, Handler<AsyncResult<String>> handler)` Deprecated. Get all the values in a hash
    `RedisClient` | RedisClient.`incr(String key, Handler<AsyncResult<Long>> handler)` Deprecated. Increment the integer value of a key by one
    `RedisTransaction` | RedisTransaction.`incr(String key, Handler<AsyncResult<String>> handler)` Deprecated. Increment the integer value of a key by one
    `RedisClient` | RedisClient.`incrby(String key, long increment, Handler<AsyncResult<Long>> handler)` Deprecated. Increment the integer value of a key by the given amount
    `RedisTransaction` | RedisTransaction.`incrby(String key, long increment, Handler<AsyncResult<String>> handler)` Deprecated. Increment the integer value of a key by the given amount
    `RedisTransaction` | RedisTransaction.`incrbyfloat(String key, double increment, Handler<AsyncResult<String>> handler)` Deprecated. Increment the float value of a key by the given amount
    `RedisClient` | RedisClient.`incrbyfloat(String key, double increment, Handler<AsyncResult<String>> handler)` Deprecated. Increment the float value of a key by the given amount
    `RedisClient` | RedisClient.`info(Handler<AsyncResult<JsonObject>> handler)` Deprecated. Get information and statistics about the server
    `RedisTransaction` | RedisTransaction.`info(Handler<AsyncResult<String>> handler)` Deprecated. Get information and statistics about the server
    `RedisClient` | RedisClient.`infoSection(String section, Handler<AsyncResult<JsonObject>> handler)` Deprecated. Get information and statistics about the server
    `RedisTransaction` | RedisTransaction.`infoSection(String section, Handler<AsyncResult<String>> handler)` Deprecated. Get information and statistics about the server
    `RedisClient` | RedisClient.`keys(String pattern, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Find all keys matching the given pattern
    `RedisTransaction` | RedisTransaction.`keys(String pattern, Handler<AsyncResult<String>> handler)` Deprecated. Find all keys matching the given pattern
    `RedisClient` | RedisClient.`lastsave(Handler<AsyncResult<Long>> handler)` Deprecated. Get the UNIX time stamp of the last successful save to disk
    `RedisTransaction` | RedisTransaction.`lastsave(Handler<AsyncResult<String>> handler)` Deprecated. Get the UNIX time stamp of the last successful save to disk
    `RedisTransaction` | RedisTransaction.`lindex(String key, int index, Handler<AsyncResult<String>> handler)` Deprecated. Get an element from a list by its index
    `RedisClient` | RedisClient.`lindex(String key, int index, Handler<AsyncResult<String>> handler)` Deprecated. Get an element from a list by its index
    `RedisClient` | RedisClient.`linsert(String key, InsertOptions option, String pivot, String value, Handler<AsyncResult<Long>> handler)` Deprecated. Insert an element before or after another element in a list
    `RedisTransaction` | RedisTransaction.`linsert(String key, InsertOptions option, String pivot, String value, Handler<AsyncResult<String>> handler)` Deprecated. Insert an element before or after another element in a list
    `RedisClient` | RedisClient.`llen(String key, Handler<AsyncResult<Long>> handler)` Deprecated. Get the length of a list
    `RedisTransaction` | RedisTransaction.`llen(String key, Handler<AsyncResult<String>> handler)` Deprecated. Get the length of a list
    `RedisTransaction` | RedisTransaction.`lpop(String key, Handler<AsyncResult<String>> handler)` Deprecated. Remove and get the first element in a list
    `RedisClient` | RedisClient.`lpop(String key, Handler<AsyncResult<String>> handler)` Deprecated. Remove and get the first element in a list
    `RedisClient` | RedisClient.`lpush(String key, String value, Handler<AsyncResult<Long>> handler)` Deprecated. Prepend one value to a list
    `RedisTransaction` | RedisTransaction.`lpush(String key, String value, Handler<AsyncResult<String>> handler)` Deprecated. Prepend one value to a list
    `RedisClient` | RedisClient.`lpushMany(String key, List<String> values, Handler<AsyncResult<Long>> handler)` Deprecated. Prepend one or multiple values to a list
    `RedisTransaction` | RedisTransaction.`lpushMany(String key, List<String> values, Handler<AsyncResult<String>> handler)` Deprecated. Prepend one or multiple values to a list
    `RedisClient` | RedisClient.`lpushx(String key, String value, Handler<AsyncResult<Long>> handler)` Deprecated. Prepend a value to a list, only if the list exists
    `RedisTransaction` | RedisTransaction.`lpushx(String key, String value, Handler<AsyncResult<String>> handler)` Deprecated. Prepend a value to a list, only if the list exists
    `RedisClient` | RedisClient.`lrange(String key, long from, long to, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Get a range of elements from a list
    `RedisTransaction` | RedisTransaction.`lrange(String key, long from, long to, Handler<AsyncResult<String>> handler)` Deprecated. Get a range of elements from a list
    `RedisClient` | RedisClient.`lrem(String key, long count, String value, Handler<AsyncResult<Long>> handler)` Deprecated. Remove elements from a list
    `RedisTransaction` | RedisTransaction.`lrem(String key, long count, String value, Handler<AsyncResult<String>> handler)` Deprecated. Remove elements from a list
    `RedisTransaction` | RedisTransaction.`lset(String key, long index, String value, Handler<AsyncResult<String>> handler)` Deprecated. Set the value of an element in a list by its index
    `RedisClient` | RedisClient.`lset(String key, long index, String value, Handler<AsyncResult<String>> handler)` Deprecated. Set the value of an element in a list by its index
    `RedisTransaction` | RedisTransaction.`ltrim(String key, long from, long to, Handler<AsyncResult<String>> handler)` Deprecated. Trim a list to the specified range
    `RedisClient` | RedisClient.`ltrim(String key, long from, long to, Handler<AsyncResult<String>> handler)` Deprecated. Trim a list to the specified range
    `RedisClient` | RedisClient.`mget(String key, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Get the value of the given key
    `RedisTransaction` | RedisTransaction.`mget(String key, Handler<AsyncResult<String>> handler)` Deprecated. Get the value of the given key
    `RedisClient` | RedisClient.`mgetMany(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Get the values of all the given keys
    `RedisTransaction` | RedisTransaction.`mgetMany(List<String> keys, Handler<AsyncResult<String>> handler)` Deprecated. Get the values of all the given keys
    `RedisTransaction` | RedisTransaction.`migrate(String host, int port, String key, int destdb, long timeout, MigrateOptions options, Handler<AsyncResult<String>> handler)` Deprecated. Atomically transfer a key from a Redis instance to another one.
    `RedisClient` | RedisClient.`migrate(String host, int port, String key, int destdb, long timeout, MigrateOptions options, Handler<AsyncResult<String>> handler)` Deprecated. Atomically transfer a key from a Redis instance to another one.
    `RedisTransaction` | RedisTransaction.`monitor(Handler<AsyncResult<String>> handler)` Deprecated. Listen for all requests received by the server in real time
    `RedisClient` | RedisClient.`monitor(Handler<AsyncResult<Void>> handler)` Deprecated. Listen for all requests received by the server in real time
    `RedisClient` | RedisClient.`move(String key, int destdb, Handler<AsyncResult<Long>> handler)` Deprecated. Move a key to another database
    `RedisTransaction` | RedisTransaction.`move(String key, int destdb, Handler<AsyncResult<String>> handler)` Deprecated. Move a key to another database
    `RedisTransaction` | RedisTransaction.`mset(JsonObject keyvals, Handler<AsyncResult<String>> handler)` Deprecated. Set multiple keys to multiple values
    `RedisClient` | RedisClient.`mset(JsonObject keyvals, Handler<AsyncResult<String>> handler)` Deprecated. Set multiple keys to multiple values
    `RedisClient` | RedisClient.`msetnx(JsonObject keyvals, Handler<AsyncResult<Long>> handler)` Deprecated. Set multiple keys to multiple values, only if none of the keys exist
    `RedisTransaction` | RedisTransaction.`msetnx(JsonObject keyvals, Handler<AsyncResult<String>> handler)` Deprecated. Set multiple keys to multiple values, only if none of the keys exist
    `RedisTransaction` | RedisTransaction.`multi(Handler<AsyncResult<String>> handler)` Deprecated. Mark the start of a RedisTransaction block
    `RedisTransaction` | RedisTransaction.`object(String key, ObjectCmd cmd, Handler<AsyncResult<String>> handler)` Deprecated. Inspect the internals of Redis objects
    `RedisClient` | RedisClient.`object(String key, ObjectCmd cmd, Handler<AsyncResult<Void>> handler)` Deprecated. Inspect the internals of Redis objects
    `RedisClient` | RedisClient.`persist(String key, Handler<AsyncResult<Long>> handler)` Deprecated. Remove the expiration from a key
    `RedisTransaction` | RedisTransaction.`persist(String key, Handler<AsyncResult<String>> handler)` Deprecated. Remove the expiration from a key
    `RedisClient` | RedisClient.`pexpire(String key, long millis, Handler<AsyncResult<Long>> handler)` Deprecated. Set a key's time to live in milliseconds
    `RedisTransaction` | RedisTransaction.`pexpire(String key, long millis, Handler<AsyncResult<String>> handler)` Deprecated. Set a key's time to live in milliseconds
    `RedisClient` | RedisClient.`pexpireat(String key, long millis, Handler<AsyncResult<Long>> handler)` Deprecated. Set the expiration for a key as a UNIX timestamp specified in milliseconds
    `RedisTransaction` | RedisTransaction.`pexpireat(String key, long millis, Handler<AsyncResult<String>> handler)` Deprecated. Set the expiration for a key as a UNIX timestamp specified in milliseconds
    `RedisClient` | RedisClient.`pfadd(String key, String element, Handler<AsyncResult<Long>> handler)` Deprecated. Adds the specified element to the specified HyperLogLog.
    `RedisTransaction` | RedisTransaction.`pfadd(String key, String element, Handler<AsyncResult<String>> handler)` Deprecated. Adds the specified element to the specified HyperLogLog.
    `RedisClient` | RedisClient.`pfaddMany(String key, List<String> elements, Handler<AsyncResult<Long>> handler)` Deprecated. Adds the specified elements to the specified HyperLogLog.
    `RedisTransaction` | RedisTransaction.`pfaddMany(String key, List<String> elements, Handler<AsyncResult<String>> handler)` Deprecated. Adds the specified elements to the specified HyperLogLog.
    `RedisClient` | RedisClient.`pfcount(String key, Handler<AsyncResult<Long>> handler)` Deprecated. Return the approximated cardinality of the set observed by the HyperLogLog at key.
    `RedisTransaction` | RedisTransaction.`pfcount(String key, Handler<AsyncResult<String>> handler)` Deprecated. Return the approximated cardinality of the set observed by the HyperLogLog at key.
    `RedisClient` | RedisClient.`pfcountMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Deprecated. Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    `RedisTransaction` | RedisTransaction.`pfcountMany(List<String> keys, Handler<AsyncResult<String>> handler)` Deprecated. Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    `RedisTransaction` | RedisTransaction.`pfmerge(String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Deprecated. Merge N different HyperLogLogs into a single one.
    `RedisClient` | RedisClient.`pfmerge(String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Deprecated. Merge N different HyperLogLogs into a single one.
    `RedisTransaction` | RedisTransaction.`ping(Handler<AsyncResult<String>> handler)` Deprecated. Ping the server
    `RedisClient` | RedisClient.`ping(Handler<AsyncResult<String>> handler)` Deprecated. Ping the server
    `RedisTransaction` | RedisTransaction.`psetex(String key, long millis, String value, Handler<AsyncResult<String>> handler)` Deprecated. Set the value and expiration in milliseconds of a key
    `RedisClient` | RedisClient.`psetex(String key, long millis, String value, Handler<AsyncResult<Void>> handler)` Deprecated. Set the value and expiration in milliseconds of a key
    `RedisClient` | RedisClient.`psubscribe(String pattern, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Listen for messages published to channels matching the given pattern
    `RedisTransaction` | RedisTransaction.`psubscribe(String pattern, Handler<AsyncResult<String>> handler)` Deprecated. Listen for messages published to channels matching the given pattern
    `RedisClient` | RedisClient.`psubscribeMany(List<String> patterns, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Listen for messages published to channels matching the given patterns
    `RedisTransaction` | RedisTransaction.`psubscribeMany(List<String> patterns, Handler<AsyncResult<String>> handler)` Deprecated. Listen for messages published to channels matching the given patterns
    `RedisClient` | RedisClient.`pttl(String key, Handler<AsyncResult<Long>> handler)` Deprecated. Get the time to live for a key in milliseconds
    `RedisTransaction` | RedisTransaction.`pttl(String key, Handler<AsyncResult<String>> handler)` Deprecated. Get the time to live for a key in milliseconds
    `RedisClient` | RedisClient.`publish(String channel, String message, Handler<AsyncResult<Long>> handler)` Deprecated. Post a message to a channel
    `RedisTransaction` | RedisTransaction.`publish(String channel, String message, Handler<AsyncResult<String>> handler)` Deprecated. Post a message to a channel
    `RedisClient` | RedisClient.`pubsubChannels(String pattern, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Lists the currently active channels - only those matching the pattern
    `RedisTransaction` | RedisTransaction.`pubsubChannels(String pattern, Handler<AsyncResult<String>> handler)` Deprecated. Lists the currently active channels - only those matching the pattern
    `RedisClient` | RedisClient.`pubsubNumpat(Handler<AsyncResult<Long>> handler)` Deprecated. Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
    `RedisTransaction` | RedisTransaction.`pubsubNumpat(Handler<AsyncResult<String>> handler)` Deprecated. Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
    `RedisClient` | RedisClient.`pubsubNumsub(List<String> channels, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
    `RedisTransaction` | RedisTransaction.`pubsubNumsub(List<String> channels, Handler<AsyncResult<String>> handler)` Deprecated. Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
    `RedisTransaction` | RedisTransaction.`punsubscribe(List<String> patterns, Handler<AsyncResult<String>> handler)` Deprecated. Stop listening for messages posted to channels matching the given patterns
    `RedisClient` | RedisClient.`punsubscribe(List<String> patterns, Handler<AsyncResult<Void>> handler)` Deprecated. Stop listening for messages posted to channels matching the given patterns
    `RedisTransaction` | RedisTransaction.`randomkey(Handler<AsyncResult<String>> handler)` Deprecated. Return a random key from the keyspace
    `RedisClient` | RedisClient.`randomkey(Handler<AsyncResult<String>> handler)` Deprecated. Return a random key from the keyspace
    `RedisTransaction` | RedisTransaction.`rename(String key, String newkey, Handler<AsyncResult<String>> handler)` Deprecated. Rename a key
    `RedisClient` | RedisClient.`rename(String key, String newkey, Handler<AsyncResult<String>> handler)` Deprecated. Rename a key
    `RedisClient` | RedisClient.`renamenx(String key, String newkey, Handler<AsyncResult<Long>> handler)` Deprecated. Rename a key, only if the new key does not exist
    `RedisTransaction` | RedisTransaction.`renamenx(String key, String newkey, Handler<AsyncResult<String>> handler)` Deprecated. Rename a key, only if the new key does not exist
    `RedisTransaction` | RedisTransaction.`restore(String key, long millis, String serialized, Handler<AsyncResult<String>> handler)` Deprecated. Create a key using the provided serialized value, previously obtained using DUMP.
    `RedisClient` | RedisClient.`restore(String key, long millis, String serialized, Handler<AsyncResult<String>> handler)` Deprecated. Create a key using the provided serialized value, previously obtained using DUMP.
    `RedisClient` | RedisClient.`role(Handler<AsyncResult<JsonArray>> handler)` Deprecated. Return the role of the instance in the context of replication
    `RedisTransaction` | RedisTransaction.`role(Handler<AsyncResult<String>> handler)` Deprecated. Return the role of the instance in the context of replication
    `RedisTransaction` | RedisTransaction.`rpop(String key, Handler<AsyncResult<String>> handler)` Deprecated. Remove and get the last element in a list
    `RedisClient` | RedisClient.`rpop(String key, Handler<AsyncResult<String>> handler)` Deprecated. Remove and get the last element in a list
    `RedisTransaction` | RedisTransaction.`rpoplpush(String key, String destkey, Handler<AsyncResult<String>> handler)` Deprecated. Remove the last element in a list, append it to another list and return it
    `RedisClient` | RedisClient.`rpoplpush(String key, String destkey, Handler<AsyncResult<String>> handler)` Deprecated. Remove the last element in a list, append it to another list and return it
    `RedisClient` | RedisClient.`rpush(String key, String value, Handler<AsyncResult<Long>> handler)` Deprecated. Append one or multiple values to a list
    `RedisTransaction` | RedisTransaction.`rpush(String key, String value, Handler<AsyncResult<String>> handler)` Deprecated. Append one or multiple values to a list
    `RedisClient` | RedisClient.`rpushMany(String key, List<String> values, Handler<AsyncResult<Long>> handler)` Deprecated. Append one or multiple values to a list
    `RedisTransaction` | RedisTransaction.`rpushMany(String key, List<String> values, Handler<AsyncResult<String>> handler)` Deprecated. Append one or multiple values to a list
    `RedisClient` | RedisClient.`rpushx(String key, String value, Handler<AsyncResult<Long>> handler)` Deprecated. Append a value to a list, only if the list exists
    `RedisTransaction` | RedisTransaction.`rpushx(String key, String value, Handler<AsyncResult<String>> handler)` Deprecated. Append a value to a list, only if the list exists
    `RedisClient` | RedisClient.`sadd(String key, String member, Handler<AsyncResult<Long>> handler)` Deprecated. Add a member to a set
    `RedisTransaction` | RedisTransaction.`sadd(String key, String member, Handler<AsyncResult<String>> handler)` Deprecated. Add a member to a set
    `RedisClient` | RedisClient.`saddMany(String key, List<String> members, Handler<AsyncResult<Long>> handler)` Deprecated. Add one or more members to a set
    `RedisTransaction` | RedisTransaction.`saddMany(String key, List<String> members, Handler<AsyncResult<String>> handler)` Deprecated. Add one or more members to a set
    `RedisTransaction` | RedisTransaction.`save(Handler<AsyncResult<String>> handler)` Deprecated. Synchronously save the dataset to disk
    `RedisClient` | RedisClient.`save(Handler<AsyncResult<String>> handler)` Deprecated. Synchronously save the dataset to disk
    `RedisClient` | RedisClient.`scan(String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Incrementally iterate the keys space
    `RedisTransaction` | RedisTransaction.`scan(String cursor, ScanOptions options, Handler<AsyncResult<String>> handler)` Deprecated. Incrementally iterate the keys space
    `RedisClient` | RedisClient.`scard(String key, Handler<AsyncResult<Long>> handler)` Deprecated. Get the number of members in a set
    `RedisTransaction` | RedisTransaction.`scard(String key, Handler<AsyncResult<String>> handler)` Deprecated. Get the number of members in a set
    `RedisClient` | RedisClient.`scriptDebug(ScriptDebugOptions scriptDebugOptions, Handler<AsyncResult<String>> handler)` Deprecated. Set the debug mode for executed scripts.
    `RedisClient` | RedisClient.`scriptExists(String script, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Check existence of script in the script cache.
    `RedisTransaction` | RedisTransaction.`scriptExists(String script, Handler<AsyncResult<String>> handler)` Deprecated. Check existence of script in the script cache.
    `RedisClient` | RedisClient.`scriptExistsMany(List<String> scripts, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Check existence of scripts in the script cache.
    `RedisTransaction` | RedisTransaction.`scriptExistsMany(List<String> scripts, Handler<AsyncResult<String>> handler)` Deprecated. Check existence of scripts in the script cache.
    `RedisTransaction` | RedisTransaction.`scriptFlush(Handler<AsyncResult<String>> handler)` Deprecated. Remove all the scripts from the script cache.
    `RedisClient` | RedisClient.`scriptFlush(Handler<AsyncResult<String>> handler)` Deprecated. Remove all the scripts from the script cache.
    `RedisTransaction` | RedisTransaction.`scriptKill(Handler<AsyncResult<String>> handler)` Deprecated. Kill the script currently in execution.
    `RedisClient` | RedisClient.`scriptKill(Handler<AsyncResult<String>> handler)` Deprecated. Kill the script currently in execution.
    `RedisTransaction` | RedisTransaction.`scriptLoad(String script, Handler<AsyncResult<String>> handler)` Deprecated. Load the specified Lua script into the script cache.
    `RedisClient` | RedisClient.`scriptLoad(String script, Handler<AsyncResult<String>> handler)` Deprecated. Load the specified Lua script into the script cache.
    `RedisClient` | RedisClient.`sdiff(String key, List<String> cmpkeys, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Subtract multiple sets
    `RedisTransaction` | RedisTransaction.`sdiff(String key, List<String> cmpkeys, Handler<AsyncResult<String>> handler)` Deprecated. Subtract multiple sets
    `RedisClient` | RedisClient.`sdiffstore(String destkey, String key, List<String> cmpkeys, Handler<AsyncResult<Long>> handler)` Deprecated. Subtract multiple sets and store the resulting set in a key
    `RedisTransaction` | RedisTransaction.`sdiffstore(String destkey, String key, List<String> cmpkeys, Handler<AsyncResult<String>> handler)` Deprecated. Subtract multiple sets and store the resulting set in a key
    `RedisTransaction` | RedisTransaction.`select(int dbindex, Handler<AsyncResult<String>> handler)` Deprecated. Change the selected database for the current connection
    `RedisClient` | RedisClient.`select(int dbindex, Handler<AsyncResult<String>> handler)` Deprecated. Change the selected database for the current connection
    `RedisTransaction` | RedisTransaction.`set(String key, String value, Handler<AsyncResult<String>> handler)` Deprecated. Set the string value of a key
    `RedisClient` | RedisClient.`set(String key, String value, Handler<AsyncResult<Void>> handler)` Deprecated. Set the string value of a key
    `RedisTransaction` | RedisTransaction.`setBinary(String key, Buffer value, Handler<AsyncResult<String>> handler)` Deprecated. Set the binary string value of a key - without encoding as utf-8
    `RedisClient` | RedisClient.`setBinary(String key, Buffer value, Handler<AsyncResult<Void>> handler)` Deprecated. Set the binary string value of a key - without encoding as utf-8
    `RedisTransaction` | RedisTransaction.`setBinaryWithOptions(String key, Buffer value, SetOptions options, Handler<AsyncResult<String>> handler)` Deprecated. Set the string value of a key
    `RedisClient` | RedisClient.`setBinaryWithOptions(String key, Buffer value, SetOptions options, Handler<AsyncResult<Void>> handler)` Deprecated. Set the string value of a key
    `RedisClient` | RedisClient.`setbit(String key, long offset, int bit, Handler<AsyncResult<Long>> handler)` Deprecated. Sets or clears the bit at offset in the string value stored at key
    `RedisTransaction` | RedisTransaction.`setbit(String key, long offset, int bit, Handler<AsyncResult<String>> handler)` Deprecated. Sets or clears the bit at offset in the string value stored at key
    `RedisTransaction` | RedisTransaction.`setex(String key, long seconds, String value, Handler<AsyncResult<String>> handler)` Deprecated. Set the value and expiration of a key
    `RedisClient` | RedisClient.`setex(String key, long seconds, String value, Handler<AsyncResult<String>> handler)` Deprecated. Set the value and expiration of a key
    `RedisClient` | RedisClient.`setnx(String key, String value, Handler<AsyncResult<Long>> handler)` Deprecated. Set the value of a key, only if the key does not exist
    `RedisTransaction` | RedisTransaction.`setnx(String key, String value, Handler<AsyncResult<String>> handler)` Deprecated. Set the value of a key, only if the key does not exist
    `RedisClient` | RedisClient.`setrange(String key, int offset, String value, Handler<AsyncResult<Long>> handler)` Deprecated. Overwrite part of a string at key starting at the specified offset
    `RedisTransaction` | RedisTransaction.`setrange(String key, int offset, String value, Handler<AsyncResult<String>> handler)` Deprecated. Overwrite part of a string at key starting at the specified offset
    `RedisTransaction` | RedisTransaction.`setWithOptions(String key, String value, SetOptions options, Handler<AsyncResult<String>> handler)` Deprecated. Set the string value of a key
    `RedisClient` | RedisClient.`setWithOptions(String key, String value, SetOptions options, Handler<AsyncResult<String>> handler)` Deprecated. Set the string value of a key
    `RedisClient` | RedisClient.`sinter(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Intersect multiple sets
    `RedisTransaction` | RedisTransaction.`sinter(List<String> keys, Handler<AsyncResult<String>> handler)` Deprecated. Intersect multiple sets
    `RedisClient` | RedisClient.`sinterstore(String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Deprecated. Intersect multiple sets and store the resulting set in a key
    `RedisTransaction` | RedisTransaction.`sinterstore(String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Deprecated. Intersect multiple sets and store the resulting set in a key
    `RedisClient` | RedisClient.`sismember(String key, String member, Handler<AsyncResult<Long>> handler)` Deprecated. Determine if a given value is a member of a set
    `RedisTransaction` | RedisTransaction.`sismember(String key, String member, Handler<AsyncResult<String>> handler)` Deprecated. Determine if a given value is a member of a set
    `RedisTransaction` | RedisTransaction.`slaveof(String host, int port, Handler<AsyncResult<String>> handler)` Deprecated. Make the server a slave of another instance
    `RedisClient` | RedisClient.`slaveof(String host, int port, Handler<AsyncResult<String>> handler)` Deprecated. Make the server a slave of another instance
    `RedisTransaction` | RedisTransaction.`slaveofNoone(Handler<AsyncResult<String>> handler)` Deprecated. Make this server a master
    `RedisClient` | RedisClient.`slaveofNoone(Handler<AsyncResult<String>> handler)` Deprecated. Make this server a master
    `RedisClient` | RedisClient.`slowlogGet(int limit, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Read the Redis slow queries log
    `RedisTransaction` | RedisTransaction.`slowlogGet(int limit, Handler<AsyncResult<String>> handler)` Deprecated. Read the Redis slow queries log
    `RedisClient` | RedisClient.`slowlogLen(Handler<AsyncResult<Long>> handler)` Deprecated. Get the length of the Redis slow queries log
    `RedisTransaction` | RedisTransaction.`slowlogLen(Handler<AsyncResult<String>> handler)` Deprecated. Get the length of the Redis slow queries log
    `RedisTransaction` | RedisTransaction.`slowlogReset(Handler<AsyncResult<String>> handler)` Deprecated. Reset the Redis slow queries log
    `RedisClient` | RedisClient.`slowlogReset(Handler<AsyncResult<Void>> handler)` Deprecated. Reset the Redis slow queries log
    `RedisTransaction` | RedisTransaction.`smembers(String key, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Get all the members in a set
    `RedisClient` | RedisClient.`smembers(String key, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Get all the members in a set
    `RedisClient` | RedisClient.`smove(String key, String destkey, String member, Handler<AsyncResult<Long>> handler)` Deprecated. Move a member from one set to another
    `RedisTransaction` | RedisTransaction.`smove(String key, String destkey, String member, Handler<AsyncResult<String>> handler)` Deprecated. Move a member from one set to another
    `RedisClient` | RedisClient.`sort(String key, SortOptions options, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Sort the elements in a list, set or sorted set
    `RedisTransaction` | RedisTransaction.`sort(String key, SortOptions options, Handler<AsyncResult<String>> handler)` Deprecated. Sort the elements in a list, set or sorted set
    `RedisTransaction` | RedisTransaction.`spop(String key, Handler<AsyncResult<String>> handler)` Deprecated. Remove and return a random member from a set
    `RedisClient` | RedisClient.`spop(String key, Handler<AsyncResult<String>> handler)` Deprecated. Remove and return a random member from a set
    `RedisClient` | RedisClient.`spopMany(String key, int count, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Remove and return random members from a set
    `RedisTransaction` | RedisTransaction.`spopMany(String key, int count, Handler<AsyncResult<String>> handler)` Deprecated. Remove and return random members from a set
    `RedisTransaction` | RedisTransaction.`srandmember(String key, Handler<AsyncResult<String>> handler)` Deprecated. Get one or multiple random members from a set
    `RedisClient` | RedisClient.`srandmember(String key, Handler<AsyncResult<String>> handler)` Deprecated. Get one or multiple random members from a set
    `RedisClient` | RedisClient.`srandmemberCount(String key, int count, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Get one or multiple random members from a set
    `RedisTransaction` | RedisTransaction.`srandmemberCount(String key, int count, Handler<AsyncResult<String>> handler)` Deprecated. Get one or multiple random members from a set
    `RedisClient` | RedisClient.`srem(String key, String member, Handler<AsyncResult<Long>> handler)` Deprecated. Remove one member from a set
    `RedisTransaction` | RedisTransaction.`srem(String key, String member, Handler<AsyncResult<String>> handler)` Deprecated. Remove one member from a set
    `RedisClient` | RedisClient.`sremMany(String key, List<String> members, Handler<AsyncResult<Long>> handler)` Deprecated. Remove one or more members from a set
    `RedisTransaction` | RedisTransaction.`sremMany(String key, List<String> members, Handler<AsyncResult<String>> handler)` Deprecated. Remove one or more members from a set
    `RedisClient` | RedisClient.`sscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Incrementally iterate Set elements
    `RedisTransaction` | RedisTransaction.`sscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<String>> handler)` Deprecated. Incrementally iterate Set elements
    `RedisClient` | RedisClient.`strlen(String key, Handler<AsyncResult<Long>> handler)` Deprecated. Get the length of the value stored in a key
    `RedisTransaction` | RedisTransaction.`strlen(String key, Handler<AsyncResult<String>> handler)` Deprecated. Get the length of the value stored in a key
    `RedisClient` | RedisClient.`subscribe(String channel, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Listen for messages published to the given channels
    `RedisTransaction` | RedisTransaction.`subscribe(String channel, Handler<AsyncResult<String>> handler)` Deprecated. Listen for messages published to the given channels
    `RedisClient` | RedisClient.`subscribeMany(List<String> channels, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Listen for messages published to the given channels
    `RedisTransaction` | RedisTransaction.`subscribeMany(List<String> channels, Handler<AsyncResult<String>> handler)` Deprecated. Listen for messages published to the given channels
    `RedisClient` | RedisClient.`sunion(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Add multiple sets
    `RedisTransaction` | RedisTransaction.`sunion(List<String> keys, Handler<AsyncResult<String>> handler)` Deprecated. Add multiple sets
    `RedisClient` | RedisClient.`sunionstore(String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Deprecated. Add multiple sets and store the resulting set in a key
    `RedisTransaction` | RedisTransaction.`sunionstore(String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Deprecated. Add multiple sets and store the resulting set in a key
    `RedisTransaction` | RedisTransaction.`swapdb(int index1, int index2, Handler<AsyncResult<String>> handler)` Deprecated. Swaps two Redis databases
    `RedisClient` | RedisClient.`swapdb(int index1, int index2, Handler<AsyncResult<String>> handler)` Deprecated. Swaps two Redis databases
    `RedisTransaction` | RedisTransaction.`sync(Handler<AsyncResult<String>> handler)` Deprecated. Internal command used for replication
    `RedisClient` | RedisClient.`sync(Handler<AsyncResult<Void>> handler)` Deprecated. Internal command used for replication
    `RedisClient` | RedisClient.`time(Handler<AsyncResult<JsonArray>> handler)` Deprecated. Return the current server time
    `RedisTransaction` | RedisTransaction.`time(Handler<AsyncResult<String>> handler)` Deprecated. Return the current server time
    `RedisClient` | RedisClient.`touch(String key, Handler<AsyncResult<Long>> handler)` Deprecated. Alters the last access time of a key(s).
    `RedisClient` | RedisClient.`touchMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Deprecated. Alters the last access time of a key(s).
    `RedisClient` | RedisClient.`ttl(String key, Handler<AsyncResult<Long>> handler)` Deprecated. Get the time to live for a key
    `RedisTransaction` | RedisTransaction.`ttl(String key, Handler<AsyncResult<String>> handler)` Deprecated. Get the time to live for a key
    `RedisTransaction` | RedisTransaction.`type(String key, Handler<AsyncResult<String>> handler)` Deprecated. Determine the type stored at key
    `RedisClient` | RedisClient.`type(String key, Handler<AsyncResult<String>> handler)` Deprecated. Determine the type stored at key
    `RedisClient` | RedisClient.`unlink(String key, Handler<AsyncResult<Long>> handler)` Deprecated. Delete a key asynchronously in another thread.
    `RedisTransaction` | RedisTransaction.`unlink(String key, Handler<AsyncResult<String>> handler)` Deprecated. Delete a key asynchronously in another thread.
    `RedisClient` | RedisClient.`unlinkMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Deprecated. Delete multiple keys asynchronously in another thread.
    `RedisTransaction` | RedisTransaction.`unlinkMany(List<String> keys, Handler<AsyncResult<String>> handler)` Deprecated. Delete multiple keys asynchronously in another thread.
    `RedisTransaction` | RedisTransaction.`unsubscribe(List<String> channels, Handler<AsyncResult<String>> handler)` Deprecated. Stop listening for messages posted to the given channels
    `RedisClient` | RedisClient.`unsubscribe(List<String> channels, Handler<AsyncResult<Void>> handler)` Deprecated. Stop listening for messages posted to the given channels
    `RedisTransaction` | RedisTransaction.`unwatch(Handler<AsyncResult<String>> handler)` Deprecated. Forget about all watched keys
    `RedisTransaction` | RedisTransaction.`wait(long numSlaves, long timeout, Handler<AsyncResult<String>> handler)` Deprecated. Wait for the synchronous replication of all the write commands sent in the context of the current connection.
    `RedisClient` | RedisClient.`wait(long numSlaves, long timeout, Handler<AsyncResult<String>> handler)` Deprecated. Wait for the synchronous replication of all the write commands sent in the context of the current connection.
    `RedisTransaction` | RedisTransaction.`watch(String key, Handler<AsyncResult<String>> handler)` Deprecated. Watch the given keys to determine execution of the MULTI/EXEC block
    `RedisTransaction` | RedisTransaction.`watchMany(List<String> keys, Handler<AsyncResult<String>> handler)` Deprecated. Watch the given keys to determine execution of the MULTI/EXEC block
    `RedisClient` | RedisClient.`zadd(String key, double score, String member, Handler<AsyncResult<Long>> handler)` Deprecated. Add one or more members to a sorted set, or update its score if it already exists
    `RedisTransaction` | RedisTransaction.`zadd(String key, double score, String member, Handler<AsyncResult<String>> handler)` Deprecated. Add one or more members to a sorted set, or update its score if it already exists
    `RedisClient` | RedisClient.`zaddMany(String key, Map<String,Double> members, Handler<AsyncResult<Long>> handler)` Deprecated. Add one or more members to a sorted set, or update its score if it already exists
    `RedisTransaction` | RedisTransaction.`zaddMany(String key, Map<String,Double> members, Handler<AsyncResult<String>> handler)` Deprecated. Add one or more members to a sorted set, or update its score if it already exists
    `RedisClient` | RedisClient.`zcard(String key, Handler<AsyncResult<Long>> handler)` Deprecated. Get the number of members in a sorted set
    `RedisTransaction` | RedisTransaction.`zcard(String key, Handler<AsyncResult<String>> handler)` Deprecated. Get the number of members in a sorted set
    `RedisClient` | RedisClient.`zcount(String key, double min, double max, Handler<AsyncResult<Long>> handler)` Deprecated. Count the members in a sorted set with scores within the given values
    `RedisTransaction` | RedisTransaction.`zcount(String key, double min, double max, Handler<AsyncResult<String>> handler)` Deprecated. Count the members in a sorted set with scores within the given values
    `RedisTransaction` | RedisTransaction.`zincrby(String key, double increment, String member, Handler<AsyncResult<String>> handler)` Deprecated. Increment the score of a member in a sorted set
    `RedisClient` | RedisClient.`zincrby(String key, double increment, String member, Handler<AsyncResult<String>> handler)` Deprecated. Increment the score of a member in a sorted set
    `RedisClient` | RedisClient.`zinterstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Deprecated. Intersect multiple sorted sets and store the resulting sorted set in a new key
    `RedisTransaction` | RedisTransaction.`zinterstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<String>> handler)` Deprecated. Intersect multiple sorted sets and store the resulting sorted set in a new key
    `RedisClient` | RedisClient.`zinterstoreWeighed(String destkey, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Deprecated. Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
    `RedisTransaction` | RedisTransaction.`zinterstoreWeighed(String destkey, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<String>> handler)` Deprecated. Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
    `RedisClient` | RedisClient.`zlexcount(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Deprecated. Count the number of members in a sorted set between a given lexicographical range
    `RedisTransaction` | RedisTransaction.`zlexcount(String key, String min, String max, Handler<AsyncResult<String>> handler)` Deprecated. Count the number of members in a sorted set between a given lexicographical range
    `RedisClient` | RedisClient.`zrange(String key, long start, long stop, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Return a range of members in a sorted set, by index
    `RedisTransaction` | RedisTransaction.`zrange(String key, long start, long stop, Handler<AsyncResult<String>> handler)` Deprecated. Return a range of members in a sorted set, by index
    `RedisClient` | RedisClient.`zrangebylex(String key, String min, String max, LimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Return a range of members in a sorted set, by lexicographical range
    `RedisTransaction` | RedisTransaction.`zrangebylex(String key, String min, String max, LimitOptions options, Handler<AsyncResult<String>> handler)` Deprecated. Return a range of members in a sorted set, by lexicographical range
    `RedisClient` | RedisClient.`zrangebyscore(String key, String min, String max, RangeLimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Return a range of members in a sorted set, by score
    `RedisTransaction` | RedisTransaction.`zrangebyscore(String key, String min, String max, RangeLimitOptions options, Handler<AsyncResult<String>> handler)` Deprecated. Return a range of members in a sorted set, by score
    `RedisClient` | RedisClient.`zrangeWithOptions(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Return a range of members in a sorted set, by index
    `RedisTransaction` | RedisTransaction.`zrangeWithOptions(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<String>> handler)` Deprecated. Return a range of members in a sorted set, by index
    `RedisClient` | RedisClient.`zrank(String key, String member, Handler<AsyncResult<Long>> handler)` Deprecated. Determine the index of a member in a sorted set
    `RedisTransaction` | RedisTransaction.`zrank(String key, String member, Handler<AsyncResult<String>> handler)` Deprecated. Determine the index of a member in a sorted set
    `RedisClient` | RedisClient.`zrem(String key, String member, Handler<AsyncResult<Long>> handler)` Deprecated. Remove one member from a sorted set
    `RedisTransaction` | RedisTransaction.`zrem(String key, String member, Handler<AsyncResult<String>> handler)` Deprecated. Remove one member from a sorted set
    `RedisClient` | RedisClient.`zremMany(String key, List<String> members, Handler<AsyncResult<Long>> handler)` Deprecated. Remove one or more members from a sorted set
    `RedisTransaction` | RedisTransaction.`zremMany(String key, List<String> members, Handler<AsyncResult<String>> handler)` Deprecated. Remove one or more members from a sorted set
    `RedisClient` | RedisClient.`zremrangebylex(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Deprecated. Remove all members in a sorted set between the given lexicographical range
    `RedisTransaction` | RedisTransaction.`zremrangebylex(String key, String min, String max, Handler<AsyncResult<String>> handler)` Deprecated. Remove all members in a sorted set between the given lexicographical range
    `RedisClient` | RedisClient.`zremrangebyrank(String key, long start, long stop, Handler<AsyncResult<Long>> handler)` Deprecated. Remove all members in a sorted set within the given indexes
    `RedisTransaction` | RedisTransaction.`zremrangebyrank(String key, long start, long stop, Handler<AsyncResult<String>> handler)` Deprecated. Remove all members in a sorted set within the given indexes
    `RedisClient` | RedisClient.`zremrangebyscore(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Deprecated. Remove all members in a sorted set within the given scores
    `RedisTransaction` | RedisTransaction.`zremrangebyscore(String key, String min, String max, Handler<AsyncResult<String>> handler)` Deprecated. Remove all members in a sorted set within the given scores
    `RedisClient` | RedisClient.`zrevrange(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Return a range of members in a sorted set, by index, with scores ordered from high to low
    `RedisTransaction` | RedisTransaction.`zrevrange(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<String>> handler)` Deprecated. Return a range of members in a sorted set, by index, with scores ordered from high to low
    `RedisClient` | RedisClient.`zrevrangebylex(String key, String max, String min, LimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
    `RedisTransaction` | RedisTransaction.`zrevrangebylex(String key, String max, String min, LimitOptions options, Handler<AsyncResult<String>> handler)` Deprecated. Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
    `RedisClient` | RedisClient.`zrevrangebyscore(String key, String max, String min, RangeLimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Return a range of members in a sorted set, by score, with scores ordered from high to low
    `RedisTransaction` | RedisTransaction.`zrevrangebyscore(String key, String max, String min, RangeLimitOptions options, Handler<AsyncResult<String>> handler)` Deprecated. Return a range of members in a sorted set, by score, with scores ordered from high to low
    `RedisClient` | RedisClient.`zrevrank(String key, String member, Handler<AsyncResult<Long>> handler)` Deprecated. Determine the index of a member in a sorted set, with scores ordered from high to low
    `RedisTransaction` | RedisTransaction.`zrevrank(String key, String member, Handler<AsyncResult<String>> handler)` Deprecated. Determine the index of a member in a sorted set, with scores ordered from high to low
    `RedisClient` | RedisClient.`zscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Incrementally iterate sorted sets elements and associated scores
    `RedisTransaction` | RedisTransaction.`zscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<String>> handler)` Deprecated. Incrementally iterate sorted sets elements and associated scores
    `RedisTransaction` | RedisTransaction.`zscore(String key, String member, Handler<AsyncResult<String>> handler)` Deprecated. Get the score associated with the given member in a sorted set
    `RedisClient` | RedisClient.`zscore(String key, String member, Handler<AsyncResult<String>> handler)` Deprecated. Get the score associated with the given member in a sorted set
    `RedisClient` | RedisClient.`zunionstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Deprecated. Add multiple sorted sets and store the resulting sorted set in a new key
    `RedisTransaction` | RedisTransaction.`zunionstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<String>> handler)` Deprecated. Add multiple sorted sets and store the resulting sorted set in a new key
    `RedisClient` | RedisClient.`zunionstoreWeighed(String key, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Deprecated. Add multiple sorted sets using weights, and store the resulting sorted set in a new key
    `RedisTransaction` | RedisTransaction.`zunionstoreWeighed(String key, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<String>> handler)` Deprecated. Add multiple sorted sets using weights, and store the resulting sorted set in a new key

  - ### Uses of Handler in io.vertx.redis.client

    Methods in io.vertx.redis.client with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `default RedisAPI` | RedisAPI.`append(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command append.
    `default RedisAPI` | RedisAPI.`asking(Handler<AsyncResult<Response>> handler)` Redis command asking.
    `default RedisAPI` | RedisAPI.`auth(String arg0, Handler<AsyncResult<Response>> handler)` Redis command auth.
    `default Redis` | Redis.`batch(List<Request> commands, Handler<AsyncResult<List<Response>>> onSend)` Sends a list of commands in a single IO operation, this prevents any inter twinning to happen from other client users.
    `RedisConnection` | RedisConnection.`batch(List<Request> commands, Handler<AsyncResult<List<Response>>> onSend)` Sends a list of commands in a single IO operation, this prevents any inter twinning to happen from other client users.
    `default RedisAPI` | RedisAPI.`bgrewriteaof(Handler<AsyncResult<Response>> handler)` Redis command bgrewriteaof.
    `default RedisAPI` | RedisAPI.`bgsave(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bgsave.
    `default RedisAPI` | RedisAPI.`bitcount(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bitcount.
    `default RedisAPI` | RedisAPI.`bitfield(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bitfield.
    `default RedisAPI` | RedisAPI.`bitop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bitop.
    `default RedisAPI` | RedisAPI.`bitpos(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bitpos.
    `default RedisAPI` | RedisAPI.`blpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command blpop.
    `default RedisAPI` | RedisAPI.`brpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command brpop.
    `default RedisAPI` | RedisAPI.`brpoplpush(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command brpoplpush.
    `default RedisAPI` | RedisAPI.`bzpopmax(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bzpopmax.
    `default RedisAPI` | RedisAPI.`bzpopmin(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bzpopmin.
    `default RedisAPI` | RedisAPI.`client(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command client.
    `default RedisAPI` | RedisAPI.`cluster(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command cluster.
    `default RedisAPI` | RedisAPI.`command(Handler<AsyncResult<Response>> handler)` Redis command command.
    `default RedisAPI` | RedisAPI.`config(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command config.
    `Redis` | Redis.`connect(Handler<AsyncResult<RedisConnection>> handler)` Connects to the redis server.
    `default RedisAPI` | RedisAPI.`dbsize(Handler<AsyncResult<Response>> handler)` Redis command dbsize.
    `default RedisAPI` | RedisAPI.`debug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command debug.
    `default RedisAPI` | RedisAPI.`decr(String arg0, Handler<AsyncResult<Response>> handler)` Redis command decr.
    `default RedisAPI` | RedisAPI.`decrby(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command decrby.
    `default RedisAPI` | RedisAPI.`del(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command del.
    `default RedisAPI` | RedisAPI.`discard(Handler<AsyncResult<Response>> handler)` Redis command discard.
    `default RedisAPI` | RedisAPI.`dump(String arg0, Handler<AsyncResult<Response>> handler)` Redis command dump.
    `default RedisAPI` | RedisAPI.`echo(String arg0, Handler<AsyncResult<Response>> handler)` Redis command echo.
    `RedisConnection` | RedisConnection.`endHandler(Handler<Void> endHandler)` Set an end handler.
    `default RedisAPI` | RedisAPI.`eval(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command eval.
    `default RedisAPI` | RedisAPI.`evalsha(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command evalsha.
    `RedisConnection` | RedisConnection.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the read stream.
    `default RedisAPI` | RedisAPI.`exec(Handler<AsyncResult<Response>> handler)` Redis command exec.
    `default RedisAPI` | RedisAPI.`exists(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command exists.
    `default RedisAPI` | RedisAPI.`expire(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command expire.
    `default RedisAPI` | RedisAPI.`expireat(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command expireat.
    `default RedisAPI` | RedisAPI.`flushall(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command flushall.
    `default RedisAPI` | RedisAPI.`flushdb(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command flushdb.
    `default RedisAPI` | RedisAPI.`geoadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command geoadd.
    `default RedisAPI` | RedisAPI.`geodist(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command geodist.
    `default RedisAPI` | RedisAPI.`geohash(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command geohash.
    `default RedisAPI` | RedisAPI.`geopos(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command geopos.
    `default RedisAPI` | RedisAPI.`georadius(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command georadius.
    `default RedisAPI` | RedisAPI.`georadiusbymember(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command georadiusbymember.
    `default RedisAPI` | RedisAPI.`georadiusbymemberRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command georadiusbymemberRo.
    `default RedisAPI` | RedisAPI.`georadiusRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command georadiusRo.
    `default RedisAPI` | RedisAPI.`get(String arg0, Handler<AsyncResult<Response>> handler)` Redis command get.
    `default RedisAPI` | RedisAPI.`getbit(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command getbit.
    `default RedisAPI` | RedisAPI.`getrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command getrange.
    `default RedisAPI` | RedisAPI.`getset(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command getset.
    `RedisConnection` | RedisConnection.`handler(Handler<Response> handler)` Set a data handler.
    `default RedisAPI` | RedisAPI.`hdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command hdel.
    `default RedisAPI` | RedisAPI.`hexists(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command hexists.
    `default RedisAPI` | RedisAPI.`hget(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command hget.
    `default RedisAPI` | RedisAPI.`hgetall(String arg0, Handler<AsyncResult<Response>> handler)` Redis command hgetall.
    `default RedisAPI` | RedisAPI.`hincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command hincrby.
    `default RedisAPI` | RedisAPI.`hincrbyfloat(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command hincrbyfloat.
    `default RedisAPI` | RedisAPI.`hkeys(String arg0, Handler<AsyncResult<Response>> handler)` Redis command hkeys.
    `default RedisAPI` | RedisAPI.`hlen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command hlen.
    `default RedisAPI` | RedisAPI.`hmget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command hmget.
    `default RedisAPI` | RedisAPI.`hmset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command hmset.
    `default RedisAPI` | RedisAPI.`host(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command host.
    `default RedisAPI` | RedisAPI.`hscan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command hscan.
    `default RedisAPI` | RedisAPI.`hset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command hset.
    `default RedisAPI` | RedisAPI.`hsetnx(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command hsetnx.
    `default RedisAPI` | RedisAPI.`hstrlen(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command hstrlen.
    `default RedisAPI` | RedisAPI.`hvals(String arg0, Handler<AsyncResult<Response>> handler)` Redis command hvals.
    `default RedisAPI` | RedisAPI.`incr(String arg0, Handler<AsyncResult<Response>> handler)` Redis command incr.
    `default RedisAPI` | RedisAPI.`incrby(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command incrby.
    `default RedisAPI` | RedisAPI.`incrbyfloat(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command incrbyfloat.
    `default RedisAPI` | RedisAPI.`info(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command info.
    `default RedisAPI` | RedisAPI.`keys(String arg0, Handler<AsyncResult<Response>> handler)` Redis command keys.
    `default RedisAPI` | RedisAPI.`lastsave(Handler<AsyncResult<Response>> handler)` Redis command lastsave.
    `default RedisAPI` | RedisAPI.`latency(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command latency.
    `default RedisAPI` | RedisAPI.`lindex(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command lindex.
    `default RedisAPI` | RedisAPI.`linsert(String arg0, String arg1, String arg2, String arg3, Handler<AsyncResult<Response>> handler)` Redis command linsert.
    `default RedisAPI` | RedisAPI.`llen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command llen.
    `default RedisAPI` | RedisAPI.`lolwut(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command lolwut.
    `default RedisAPI` | RedisAPI.`lpop(String arg0, Handler<AsyncResult<Response>> handler)` Redis command lpop.
    `default RedisAPI` | RedisAPI.`lpush(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command lpush.
    `default RedisAPI` | RedisAPI.`lpushx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command lpushx.
    `default RedisAPI` | RedisAPI.`lrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command lrange.
    `default RedisAPI` | RedisAPI.`lrem(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command lrem.
    `default RedisAPI` | RedisAPI.`lset(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command lset.
    `default RedisAPI` | RedisAPI.`ltrim(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ltrim.
    `default RedisAPI` | RedisAPI.`memory(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command memory.
    `default RedisAPI` | RedisAPI.`mget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command mget.
    `default RedisAPI` | RedisAPI.`migrate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command migrate.
    `default RedisAPI` | RedisAPI.`module(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command module.
    `default RedisAPI` | RedisAPI.`monitor(Handler<AsyncResult<Response>> handler)` Redis command monitor.
    `default RedisAPI` | RedisAPI.`move(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command move.
    `default RedisAPI` | RedisAPI.`mset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command mset.
    `default RedisAPI` | RedisAPI.`msetnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command msetnx.
    `default RedisAPI` | RedisAPI.`multi(Handler<AsyncResult<Response>> handler)` Redis command multi.
    `default RedisAPI` | RedisAPI.`object(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command object.
    `default RedisAPI` | RedisAPI.`persist(String arg0, Handler<AsyncResult<Response>> handler)` Redis command persist.
    `default RedisAPI` | RedisAPI.`pexpire(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command pexpire.
    `default RedisAPI` | RedisAPI.`pexpireat(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command pexpireat.
    `default RedisAPI` | RedisAPI.`pfadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command pfadd.
    `default RedisAPI` | RedisAPI.`pfcount(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command pfcount.
    `default RedisAPI` | RedisAPI.`pfdebug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command pfdebug.
    `default RedisAPI` | RedisAPI.`pfmerge(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command pfmerge.
    `default RedisAPI` | RedisAPI.`pfselftest(Handler<AsyncResult<Response>> handler)` Redis command pfselftest.
    `default RedisAPI` | RedisAPI.`ping(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ping.
    `default RedisAPI` | RedisAPI.`post(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command post.
    `default RedisAPI` | RedisAPI.`psetex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command psetex.
    `default RedisAPI` | RedisAPI.`psubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command psubscribe.
    `default RedisAPI` | RedisAPI.`psync(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command psync.
    `default RedisAPI` | RedisAPI.`pttl(String arg0, Handler<AsyncResult<Response>> handler)` Redis command pttl.
    `default RedisAPI` | RedisAPI.`publish(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command publish.
    `default RedisAPI` | RedisAPI.`pubsub(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command pubsub.
    `default RedisAPI` | RedisAPI.`punsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command punsubscribe.
    `default RedisAPI` | RedisAPI.`randomkey(Handler<AsyncResult<Response>> handler)` Redis command randomkey.
    `default RedisAPI` | RedisAPI.`readonly(Handler<AsyncResult<Response>> handler)` Redis command readonly.
    `default RedisAPI` | RedisAPI.`readwrite(Handler<AsyncResult<Response>> handler)` Redis command readwrite.
    `default RedisAPI` | RedisAPI.`rename(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command rename.
    `default RedisAPI` | RedisAPI.`renamenx(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command renamenx.
    `default RedisAPI` | RedisAPI.`replconf(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command replconf.
    `default RedisAPI` | RedisAPI.`replicaof(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command replicaof.
    `default RedisAPI` | RedisAPI.`restore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command restore.
    `default RedisAPI` | RedisAPI.`restoreAsking(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command restoreAsking.
    `default RedisAPI` | RedisAPI.`role(Handler<AsyncResult<Response>> handler)` Redis command role.
    `default RedisAPI` | RedisAPI.`rpop(String arg0, Handler<AsyncResult<Response>> handler)` Redis command rpop.
    `default RedisAPI` | RedisAPI.`rpoplpush(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command rpoplpush.
    `default RedisAPI` | RedisAPI.`rpush(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command rpush.
    `default RedisAPI` | RedisAPI.`rpushx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command rpushx.
    `default RedisAPI` | RedisAPI.`sadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sadd.
    `default RedisAPI` | RedisAPI.`save(Handler<AsyncResult<Response>> handler)` Redis command save.
    `default RedisAPI` | RedisAPI.`scan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command scan.
    `default RedisAPI` | RedisAPI.`scard(String arg0, Handler<AsyncResult<Response>> handler)` Redis command scard.
    `default RedisAPI` | RedisAPI.`script(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command script.
    `default RedisAPI` | RedisAPI.`sdiff(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sdiff.
    `default RedisAPI` | RedisAPI.`sdiffstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sdiffstore.
    `default RedisAPI` | RedisAPI.`select(String arg0, Handler<AsyncResult<Response>> handler)` Redis command select.
    `default Redis` | Redis.`send(Request command, Handler<AsyncResult<Response>> onSend)` Send the given command to the redis server or cluster.
    `RedisConnection` | RedisConnection.`send(Request command, Handler<AsyncResult<Response>> onSend)` Send the given command to the redis server or cluster.
    `default RedisAPI` | RedisAPI.`set(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command set.
    `default RedisAPI` | RedisAPI.`setbit(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command setbit.
    `default RedisAPI` | RedisAPI.`setex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command setex.
    `default RedisAPI` | RedisAPI.`setnx(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command setnx.
    `default RedisAPI` | RedisAPI.`setrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command setrange.
    `default RedisAPI` | RedisAPI.`shutdown(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command shutdown.
    `default RedisAPI` | RedisAPI.`sinter(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sinter.
    `default RedisAPI` | RedisAPI.`sinterstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sinterstore.
    `default RedisAPI` | RedisAPI.`sismember(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command sismember.
    `default RedisAPI` | RedisAPI.`slaveof(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command slaveof.
    `default RedisAPI` | RedisAPI.`slowlog(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command slowlog.
    `default RedisAPI` | RedisAPI.`smembers(String arg0, Handler<AsyncResult<Response>> handler)` Redis command smembers.
    `default RedisAPI` | RedisAPI.`smove(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command smove.
    `default RedisAPI` | RedisAPI.`sort(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sort.
    `default RedisAPI` | RedisAPI.`spop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command spop.
    `default RedisAPI` | RedisAPI.`srandmember(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command srandmember.
    `default RedisAPI` | RedisAPI.`srem(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command srem.
    `default RedisAPI` | RedisAPI.`sscan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sscan.
    `default RedisAPI` | RedisAPI.`strlen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command strlen.
    `default RedisAPI` | RedisAPI.`subscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command subscribe.
    `default RedisAPI` | RedisAPI.`substr(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command substr.
    `default RedisAPI` | RedisAPI.`sunion(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sunion.
    `default RedisAPI` | RedisAPI.`sunionstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sunionstore.
    `default RedisAPI` | RedisAPI.`swapdb(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command swapdb.
    `default RedisAPI` | RedisAPI.`sync(Handler<AsyncResult<Response>> handler)` Redis command sync.
    `default RedisAPI` | RedisAPI.`time(Handler<AsyncResult<Response>> handler)` Redis command time.
    `default RedisAPI` | RedisAPI.`touch(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command touch.
    `default RedisAPI` | RedisAPI.`ttl(String arg0, Handler<AsyncResult<Response>> handler)` Redis command ttl.
    `default RedisAPI` | RedisAPI.`type(String arg0, Handler<AsyncResult<Response>> handler)` Redis command type.
    `default RedisAPI` | RedisAPI.`unlink(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command unlink.
    `default RedisAPI` | RedisAPI.`unsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command unsubscribe.
    `default RedisAPI` | RedisAPI.`unwatch(Handler<AsyncResult<Response>> handler)` Redis command unwatch.
    `default RedisAPI` | RedisAPI.`wait(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command wait.
    `default RedisAPI` | RedisAPI.`watch(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command watch.
    `default RedisAPI` | RedisAPI.`xack(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xack.
    `default RedisAPI` | RedisAPI.`xadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xadd.
    `default RedisAPI` | RedisAPI.`xclaim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xclaim.
    `default RedisAPI` | RedisAPI.`xdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xdel.
    `default RedisAPI` | RedisAPI.`xgroup(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xgroup.
    `default RedisAPI` | RedisAPI.`xinfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xinfo.
    `default RedisAPI` | RedisAPI.`xlen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command xlen.
    `default RedisAPI` | RedisAPI.`xpending(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xpending.
    `default RedisAPI` | RedisAPI.`xrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xrange.
    `default RedisAPI` | RedisAPI.`xread(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xread.
    `default RedisAPI` | RedisAPI.`xreadgroup(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xreadgroup.
    `default RedisAPI` | RedisAPI.`xrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xrevrange.
    `default RedisAPI` | RedisAPI.`xsetid(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command xsetid.
    `default RedisAPI` | RedisAPI.`xtrim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xtrim.
    `default RedisAPI` | RedisAPI.`zadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zadd.
    `default RedisAPI` | RedisAPI.`zcard(String arg0, Handler<AsyncResult<Response>> handler)` Redis command zcard.
    `default RedisAPI` | RedisAPI.`zcount(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command zcount.
    `default RedisAPI` | RedisAPI.`zincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command zincrby.
    `default RedisAPI` | RedisAPI.`zinterstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zinterstore.
    `default RedisAPI` | RedisAPI.`zlexcount(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command zlexcount.
    `default RedisAPI` | RedisAPI.`zpopmax(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zpopmax.
    `default RedisAPI` | RedisAPI.`zpopmin(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zpopmin.
    `default RedisAPI` | RedisAPI.`zrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrange.
    `default RedisAPI` | RedisAPI.`zrangebylex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrangebylex.
    `default RedisAPI` | RedisAPI.`zrangebyscore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrangebyscore.
    `default RedisAPI` | RedisAPI.`zrank(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command zrank.
    `default RedisAPI` | RedisAPI.`zrem(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrem.
    `default RedisAPI` | RedisAPI.`zremrangebylex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command zremrangebylex.
    `default RedisAPI` | RedisAPI.`zremrangebyrank(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command zremrangebyrank.
    `default RedisAPI` | RedisAPI.`zremrangebyscore(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command zremrangebyscore.
    `default RedisAPI` | RedisAPI.`zrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrevrange.
    `default RedisAPI` | RedisAPI.`zrevrangebylex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrevrangebylex.
    `default RedisAPI` | RedisAPI.`zrevrangebyscore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrevrangebyscore.
    `default RedisAPI` | RedisAPI.`zrevrank(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command zrevrank.
    `default RedisAPI` | RedisAPI.`zscan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zscan.
    `default RedisAPI` | RedisAPI.`zscore(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command zscore.
    `default RedisAPI` | RedisAPI.`zunionstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zunionstore.

  - ### Uses of Handler in io.vertx.redis.sentinel

    Methods in io.vertx.redis.sentinel with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `RedisSentinel` | RedisSentinel.`ckquorum(String name, Handler<AsyncResult<String>> handler)` Deprecated. Check if the current Sentinel configuration is able to reach the quorum needed to failover a master, and the majority needed to authorize the failover.
    `void` | RedisSentinel.`close(Handler<AsyncResult<Void>> handler)` Deprecated. Close the client - when it is fully closed the handler will be called.
    `RedisSentinel` | RedisSentinel.`failover(String name, Handler<AsyncResult<String>> handler)` Deprecated. Force a failover as if the master was not reachable, and without asking for agreement to other Sentinels (however a new version of the configuration will be published so that the other Sentinels will update their configurations)
    `RedisSentinel` | RedisSentinel.`flushConfig(Handler<AsyncResult<Void>> handler)` Deprecated. Force Sentinel to rewrite its configuration on disk, including the current Sentinel state.
    `RedisSentinel` | RedisSentinel.`getMasterAddrByName(String name, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Return the ip and port number of the master with that name.
    `RedisSentinel` | RedisSentinel.`master(String name, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Show the state and info of the specified master
    `RedisSentinel` | RedisSentinel.`masters(Handler<AsyncResult<JsonArray>> handler)` Deprecated. Show a list of monitored masters and their state
    `RedisSentinel` | RedisSentinel.`reset(String pattern, Handler<AsyncResult<Void>> handler)` Deprecated. Reset all the masters with matching name.
    `RedisSentinel` | RedisSentinel.`sentinels(String name, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Show a list of sentinel instances for this master, and their state
    `RedisSentinel` | RedisSentinel.`slaves(String name, Handler<AsyncResult<JsonArray>> handler)` Deprecated. Show a list of slaves for this master, and their state

  - ### Uses of Handler in io.vertx.rxjava.amqp

    Methods in io.vertx.rxjava.amqp with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `AmqpConnection` | AmqpConnection.`close(Handler<AsyncResult<Void>> done)` Closes the AMQP connection, i.e.
    `void` | AmqpSender.`close(Handler<AsyncResult<Void>> handler)` Closes the sender.
    `void` | AmqpReceiver.`close(Handler<AsyncResult<Void>> handler)` Closes the receiver.
    `void` | AmqpClient.`close(Handler<AsyncResult<Void>> closeHandler)` Closes the client.
    `AmqpClient` | AmqpClient.`connect(Handler<AsyncResult<AmqpConnection>> connectionHandler)` Connects to the AMQP broker or router.
    `AmqpConnection` | AmqpConnection.`createAnonymousSender(Handler<AsyncResult<AmqpSender>> completionHandler)` Creates an anonymous sender.
    `AmqpConnection` | AmqpConnection.`createDynamicReceiver(Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a dynamic receiver.
    `AmqpConnection` | AmqpConnection.`createReceiver(String address, AmqpReceiverOptions receiverOptions, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consumer messages from the given address.
    `AmqpClient` | AmqpClient.`createReceiver(String address, AmqpReceiverOptions receiverOptions, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consumer messages from the given address.
    `AmqpConnection` | AmqpConnection.`createReceiver(String address, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consume messages from the given address.
    `AmqpClient` | AmqpClient.`createReceiver(String address, Handler<AsyncResult<AmqpReceiver>> completionHandler)` Creates a receiver used to consume messages from the given address.
    `AmqpConnection` | AmqpConnection.`createSender(String address, AmqpSenderOptions options, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `AmqpClient` | AmqpClient.`createSender(String address, AmqpSenderOptions options, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `AmqpConnection` | AmqpConnection.`createSender(String address, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `AmqpClient` | AmqpClient.`createSender(String address, Handler<AsyncResult<AmqpSender>> completionHandler)` Creates a sender used to send messages to the given address.
    `WriteStream<AmqpMessage>` | AmqpSender.`drainHandler(Handler<Void> handler)` Set a drain handler on the stream.
    `void` | AmqpSender.`end(AmqpMessage data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | AmqpSender.`end(Handler<AsyncResult<Void>> handler)` Same as `WriteStream.end()` but with an `handler` called when the operation completes
    `AmqpReceiver` | AmqpReceiver.`endHandler(Handler<Void> endHandler)`
    `AmqpConnection` | AmqpConnection.`exceptionHandler(Handler<Throwable> handler)` Registers a handler called on disconnection.
    `AmqpSender` | AmqpSender.`exceptionHandler(Handler<Throwable> handler)`
    `AmqpReceiver` | AmqpReceiver.`exceptionHandler(Handler<Throwable> handler)`
    `AmqpReceiver` | AmqpReceiver.`handler(Handler<AmqpMessage> handler)`
    `void` | AmqpReceiver.`pipeTo(WriteStream<AmqpMessage> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `AmqpSender` | AmqpSender.`sendWithAck(AmqpMessage message, Handler<AsyncResult<Void>> acknowledgementHandler)` Sends an AMQP message and waits for an acknowledgement.
    `AmqpSender` | AmqpSender.`write(AmqpMessage data, Handler<AsyncResult<Void>> handler)`

  - ### Uses of Handler in io.vertx.rxjava.amqpbridge

    Methods in io.vertx.rxjava.amqpbridge with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | AmqpBridge.`close(Handler<AsyncResult<Void>> resultHandler)` Shuts the bridge down, closing the underlying connection.
    `void` | AmqpBridge.`endHandler(Handler<Void> endHandler)` Set an end handler.
    `void` | AmqpBridge.`start(String hostname, int port, Handler<AsyncResult<AmqpBridge>> resultHandler)` Starts the bridge, establishing the underlying connection.
    `void` | AmqpBridge.`start(String hostname, int port, String username, String password, Handler<AsyncResult<AmqpBridge>> resultHandler)` Starts the bridge, establishing the underlying connection.

  - ### Uses of Handler in io.vertx.rxjava.cassandra

    Methods in io.vertx.rxjava.cassandra with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `ResultSet` | ResultSet.`all(Handler<AsyncResult<List<com.datastax.driver.core.Row>>> handler)` The method should not be used concurrently with others like `ResultSet.several(int, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.util.List<com.datastax.driver.core.Row>>>)` or `ResultSet.one(io.vertx.core.Handler<io.vertx.core.AsyncResult<com.datastax.driver.core.Row>>)`.
    `CassandraClient` | CassandraClient.`close(Handler<AsyncResult<Void>> closeHandler)` Closes this client.
    `void` | Mapper.`delete(List<Object> primaryKey, Handler<AsyncResult<Void>> handler)` Asynchronous delete method based on the column values of the primary key.
    `CassandraRowStream` | CassandraRowStream.`endHandler(Handler<Void> handler)`
    `CassandraRowStream` | CassandraRowStream.`exceptionHandler(Handler<Throwable> handler)`
    `CassandraClient` | CassandraClient.`execute(com.datastax.driver.core.Statement statement, Handler<AsyncResult<ResultSet>> resultHandler)` Execute the statement and provide a handler for consuming results.
    `CassandraClient` | CassandraClient.`execute(String query, Handler<AsyncResult<ResultSet>> resultHandler)` Execute the query and provide a handler for consuming results.
    `CassandraClient` | CassandraClient.`executeWithFullFetch(com.datastax.driver.core.Statement statement, Handler<AsyncResult<List<com.datastax.driver.core.Row>>> resultHandler)` Execute the query and provide a handler for consuming results.
    `CassandraClient` | CassandraClient.`executeWithFullFetch(String query, Handler<AsyncResult<List<com.datastax.driver.core.Row>>> resultHandler)` Execute the query and provide a handler for consuming results.
    `ResultSet` | ResultSet.`fetchMoreResults(Handler<AsyncResult<Void>> handler)`
    `void` | Mapper.`get(List<Object> primaryKey, Handler<AsyncResult<T>> handler)` Asynchronous get method based on the column values of the primary key.
    `CassandraRowStream` | CassandraRowStream.`handler(Handler<com.datastax.driver.core.Row> handler)`
    `ResultSet` | ResultSet.`one(Handler<AsyncResult<com.datastax.driver.core.Row>> handler)` The method should not be used concurrently with others like `ResultSet.several(int, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.util.List<com.datastax.driver.core.Row>>>)` or `ResultSet.all(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.util.List<com.datastax.driver.core.Row>>>)`.
    `void` | CassandraRowStream.`pipeTo(WriteStream<com.datastax.driver.core.Row> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `CassandraClient` | CassandraClient.`prepare(String query, Handler<AsyncResult<com.datastax.driver.core.PreparedStatement>> resultHandler)` Prepares the provided query string.
    `CassandraClient` | CassandraClient.`queryStream(com.datastax.driver.core.Statement statement, Handler<AsyncResult<CassandraRowStream>> rowStreamHandler)` Executes the given SQL statement which returns the results of the query as a read stream.
    `CassandraClient` | CassandraClient.`queryStream(String sql, Handler<AsyncResult<CassandraRowStream>> rowStreamHandler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `void` | Mapper.`save(T entity, Handler<AsyncResult<Void>> handler)` Asynchronous save method.
    `ResultSet` | ResultSet.`several(int amount, Handler<AsyncResult<List<com.datastax.driver.core.Row>>> handler)` Fetch a specific amount of rows and notify via a handler.

  - ### Uses of Handler in io.vertx.rxjava.circuitbreaker

    Classes in io.vertx.rxjava.circuitbreaker that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `HystrixMetricHandler` A Vert.x web handler to expose the circuit breaker to the Hystrix dasbboard.

    Methods in io.vertx.rxjava.circuitbreaker with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `CircuitBreaker` | CircuitBreaker.`closeHandler(Handler<Void> handler)` Sets a invoked when the circuit breaker state switches to close.
    `<T> void` | CircuitBreaker.`execute(Handler<Promise<T>> command, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using the circuit breaker default fallback.
    `<T> void` | CircuitBreaker.`execute(Handler<Promise<T>> command, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using the circuit breaker default fallback.
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReport(Promise<T> resultPromise, Handler<Promise<T>> command)` Same as `CircuitBreaker.executeAndReportWithFallback(io.vertx.rxjava.core.Promise<T>, io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker default fallback.
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReportWithFallback(Promise<T> resultPromise, Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback)` Executes the given operation with the circuit breaker control.
    `<T> void` | CircuitBreaker.`executeCommand(Handler<Promise<T>> command, Handler<AsyncResult<T>> handler)` Deprecated.
    `<T> void` | CircuitBreaker.`executeCommand(Handler<Promise<T>> command, Handler<AsyncResult<T>> handler)` Deprecated.
    `<T> void` | CircuitBreaker.`executeCommandWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback, Handler<AsyncResult<T>> handler)` Deprecated.
    `<T> void` | CircuitBreaker.`executeCommandWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback, Handler<AsyncResult<T>> handler)` Deprecated.
    `<T> void` | CircuitBreaker.`executeWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
    `<T> void` | CircuitBreaker.`executeWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
    `CircuitBreaker` | CircuitBreaker.`halfOpenHandler(Handler<Void> handler)` Sets a invoked when the circuit breaker state switches to half-open.
    `CircuitBreaker` | CircuitBreaker.`openHandler(Handler<Void> handler)` Sets a invoked when the circuit breaker state switches to open.
    `<T> Single<T>` | CircuitBreaker.`rxExecute(Handler<Promise<T>> command)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using the circuit breaker default fallback.
    `<T> Single<T>` | CircuitBreaker.`rxExecuteCommand(Handler<Promise<T>> command)` Deprecated.
    `<T> Single<T>` | CircuitBreaker.`rxExecuteCommandWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback)` Deprecated.
    `<T> Single<T>` | CircuitBreaker.`rxExecuteWithFallback(Handler<Promise<T>> command, java.util.function.Function<Throwable,T> fallback)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.

  - ### Uses of Handler in io.vertx.rxjava.config

    Methods in io.vertx.rxjava.config with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ConfigRetriever.`getConfig(Handler<AsyncResult<JsonObject>> completionHandler)` Reads the configuration from the different and computes the final configuration.
    `void` | ConfigRetriever.`listen(Handler<ConfigChange> listener)` Registers a listener receiving configuration changes.
    `ConfigRetriever` | ConfigRetriever.`setBeforeScanHandler(Handler<Void> function)` Registers a handler called before every scan.

  - ### Uses of Handler in io.vertx.rxjava.core

    Methods in io.vertx.rxjava.core that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<AsyncResult<T>>` | Future.`completer()` Deprecated.
    `Handler<AsyncResult<CompositeFuture>>` | CompositeFuture.`completer()` Deprecated.

    Methods in io.vertx.rxjava.core with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | Vertx.`close(Handler<AsyncResult<Void>> completionHandler)` Like `Vertx.close()` but the completionHandler will be called when the close is complete
    `static void` | Vertx.`clusteredVertx(VertxOptions options, Handler<AsyncResult<Vertx>> resultHandler)` Creates a clustered instance using the specified options.
    `void` | Vertx.`deployVerticle(String name, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(java.lang.String)` but `DeploymentOptions` are provided to configure the deployment.
    `void` | Vertx.`deployVerticle(String name, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(java.lang.String)` but the completionHandler will be notified when the deployment is complete.
    `void` | Vertx.`deployVerticle(java.util.function.Supplier<Verticle> verticleSupplier, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(java.lang.String)` but `Verticle` instance is created by invoking the `verticleSupplier`.
    `void` | Vertx.`deployVerticle(Verticle verticle, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(java.lang.String)` but `DeploymentOptions` are provided to configure the deployment.
    `void` | Vertx.`deployVerticle(Verticle verticle, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(java.lang.String)` but the completionHandler will be notified when the deployment is complete.
    `TimeoutStream` | TimeoutStream.`endHandler(Handler<Void> endHandler)`
    `Context` | Context.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler called when the context runs an action throwing an uncaught throwable. When this handler is called, `Vertx.currentContext()` will return this context.
    `TimeoutStream` | TimeoutStream.`exceptionHandler(Handler<Throwable> handler)`
    `Vertx` | Vertx.`exceptionHandler(Handler<Throwable> handler)` Set a default exception handler for `Context`, set on at creation.
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Invoke `Context.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` with order = true.
    `<T> void` | Context.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Invoke `Context.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` with order = true.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `Vertx.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` called with ordered = true.
    `<T> void` | Vertx.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `Vertx.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` called with ordered = true.
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `WorkerExecutor.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` called with ordered = true.
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `WorkerExecutor.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` called with ordered = true.
    `<T> Observable<T>` | Context.`executeBlockingObservable(Handler<Promise<T>> blockingCodeHandler)` Deprecated. use `Context.rxExecuteBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean)` instead
    `<T> Observable<T>` | Vertx.`executeBlockingObservable(Handler<Promise<T>> blockingCodeHandler)` Deprecated. use `Vertx.rxExecuteBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean)` instead
    `<T> Observable<T>` | WorkerExecutor.`executeBlockingObservable(Handler<Promise<T>> blockingCodeHandler)` Deprecated. use `WorkerExecutor.rxExecuteBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean)` instead
    `<T> Observable<T>` | Context.`executeBlockingObservable(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated. use `Context.rxExecuteBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean)` instead
    `<T> Observable<T>` | Vertx.`executeBlockingObservable(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated. use `Vertx.rxExecuteBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean)` instead
    `<T> Observable<T>` | WorkerExecutor.`executeBlockingObservable(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated. use `WorkerExecutor.rxExecuteBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean)` instead
    `static <T> Future<T>` | Future.`future(Handler<Promise<T>> handler)` Create a future that hasn't completed yet and that is passed to the `handler` before it is returned.
    `TimeoutStream` | TimeoutStream.`handler(Handler<Long> handler)`
    `CompositeFuture` | CompositeFuture.`onComplete(Handler<AsyncResult<CompositeFuture>> handler)`
    `Future<T>` | Future.`onComplete(Handler<AsyncResult<T>> handler)` Add a handler to be notified of the result.
    `Future<T>` | Future.`onFailure(Handler<Throwable> handler)` Add a handler to be notified of the failed result.
    `CompositeFuture` | CompositeFuture.`onFailure(Handler<Throwable> handler)`
    `CompositeFuture` | CompositeFuture.`onSuccess(Handler<CompositeFuture> handler)`
    `Future<T>` | Future.`onSuccess(Handler<T> handler)` Add a handler to be notified of the succeeded result.
    `void` | TimeoutStream.`pipeTo(WriteStream<Long> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | Context.`runOnContext(Handler<Void> action)` Run the specified action asynchronously on the same context, some time after the current execution has completed.
    `void` | Vertx.`runOnContext(Handler<Void> action)` Puts the handler on the event queue for the current context so it will be run asynchronously ASAP after all preceeding events have been handled.
    `<T> Single<T>` | Context.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)` Invoke `Context.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` with order = true.
    `<T> Single<T>` | Vertx.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)` Like `Vertx.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` called with ordered = true.
    `<T> Single<T>` | WorkerExecutor.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)` Like `WorkerExecutor.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` called with ordered = true.
    `<T> Single<T>` | Context.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Safely execute some blocking code.
    `<T> Single<T>` | Vertx.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Safely execute some blocking code.
    `<T> Single<T>` | WorkerExecutor.`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Safely execute some blocking code.
    `CompositeFuture` | CompositeFuture.`setHandler(Handler<AsyncResult<CompositeFuture>> handler)` Deprecated.
    `Future<T>` | Future.`setHandler(Handler<AsyncResult<T>> handler)` Deprecated.
    `long` | Vertx.`setPeriodic(long delay, Handler<Long> handler)` Set a periodic timer to fire every `delay` milliseconds, at which point `handler` will be called with the id of the timer.
    `long` | Vertx.`setTimer(long delay, Handler<Long> handler)` Set a one-shot timer to fire after `delay` milliseconds, at which point `handler` will be called with the id of the timer.
    `void` | Vertx.`undeploy(String deploymentID, Handler<AsyncResult<Void>> completionHandler)` Like `#undeploy(String)` but the completionHandler will be notified when the undeployment is complete.

  - ### Uses of Handler in io.vertx.rxjava.core.datagram

    Methods in io.vertx.rxjava.core.datagram with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `DatagramSocket` | DatagramSocket.`blockMulticastGroup(String multicastAddress, String sourceToBlock, Handler<AsyncResult<DatagramSocket>> handler)` Block the given address for the given multicast address and notifies the once the operation completes.
    `DatagramSocket` | DatagramSocket.`blockMulticastGroup(String multicastAddress, String networkInterface, String sourceToBlock, Handler<AsyncResult<DatagramSocket>> handler)` Block the given address for the given multicast address on the given network interface and notifies the once the operation completes.
    `void` | DatagramSocket.`close(Handler<AsyncResult<Void>> handler)` Closes the `DatagramSocket` implementation asynchronous and notifies the handler once done.
    `DatagramSocket` | DatagramSocket.`endHandler(Handler<Void> endHandler)`
    `DatagramSocket` | DatagramSocket.`exceptionHandler(Handler<Throwable> handler)`
    `DatagramSocket` | DatagramSocket.`handler(Handler<DatagramPacket> handler)`
    `DatagramSocket` | DatagramSocket.`listen(int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Start listening on the given port and host.
    `DatagramSocket` | DatagramSocket.`listenMulticastGroup(String multicastAddress, Handler<AsyncResult<DatagramSocket>> handler)` Joins a multicast group and listens for packets send to it.
    `DatagramSocket` | DatagramSocket.`listenMulticastGroup(String multicastAddress, String networkInterface, String source, Handler<AsyncResult<DatagramSocket>> handler)` Joins a multicast group and listens for packets send to it on the given network interface.
    `void` | DatagramSocket.`pipeTo(WriteStream<DatagramPacket> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `DatagramSocket` | DatagramSocket.`send(Buffer packet, int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Write the given `Buffer` to the `SocketAddress`.
    `DatagramSocket` | DatagramSocket.`send(String str, int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Write the given `String` to the `SocketAddress` using UTF8 encoding.
    `DatagramSocket` | DatagramSocket.`send(String str, String enc, int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Write the given `String` to the `SocketAddress` using the given encoding.
    `DatagramSocket` | DatagramSocket.`unlistenMulticastGroup(String multicastAddress, Handler<AsyncResult<DatagramSocket>> handler)` Leaves a multicast group and stops listening for packets send to it.
    `DatagramSocket` | DatagramSocket.`unlistenMulticastGroup(String multicastAddress, String networkInterface, String source, Handler<AsyncResult<DatagramSocket>> handler)` Leaves a multicast group and stops listening for packets send to it on the given network interface.

  - ### Uses of Handler in io.vertx.rxjava.core.dns

    Methods in io.vertx.rxjava.core.dns with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `DnsClient` | DnsClient.`lookup(String name, Handler<AsyncResult<String>> handler)` Try to lookup the A (ipv4) or AAAA (ipv6) record for the given name.
    `DnsClient` | DnsClient.`lookup4(String name, Handler<AsyncResult<String>> handler)` Try to lookup the A (ipv4) record for the given name.
    `DnsClient` | DnsClient.`lookup6(String name, Handler<AsyncResult<String>> handler)` Try to lookup the AAAA (ipv6) record for the given name.
    `DnsClient` | DnsClient.`resolveA(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve all A (ipv4) records for the given name.
    `DnsClient` | DnsClient.`resolveAAAA(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve all AAAA (ipv6) records for the given name.
    `DnsClient` | DnsClient.`resolveCNAME(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve the CNAME record for the given name.
    `DnsClient` | DnsClient.`resolveMX(String name, Handler<AsyncResult<List<MxRecord>>> handler)` Try to resolve the MX records for the given name.
    `DnsClient` | DnsClient.`resolveNS(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve the NS records for the given name.
    `DnsClient` | DnsClient.`resolvePTR(String name, Handler<AsyncResult<String>> handler)` Try to resolve the PTR record for the given name.
    `DnsClient` | DnsClient.`resolveSRV(String name, Handler<AsyncResult<List<SrvRecord>>> handler)` Try to resolve the SRV records for the given name.
    `DnsClient` | DnsClient.`resolveTXT(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve the TXT records for the given name.
    `DnsClient` | DnsClient.`reverseLookup(String ipaddress, Handler<AsyncResult<String>> handler)` Try to do a reverse lookup of an IP address.

  - ### Uses of Handler in io.vertx.rxjava.core.eventbus

    Methods in io.vertx.rxjava.core.eventbus with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `<T> EventBus` | EventBus.`addInboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Add an interceptor that will be called whenever a message is received by Vert.x
    `<T> EventBus` | EventBus.`addOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Add an interceptor that will be called whenever a message is sent from Vert.x
    `void` | MessageProducer.`close(Handler<AsyncResult<Void>> handler)` Same as `MessageProducer.close()` but with an `handler` called when the operation completes
    `void` | MessageConsumer.`completionHandler(Handler<AsyncResult<Void>> completionHandler)` Optional method which can be called to indicate when the registration has been propagated across the cluster.
    `<T> MessageConsumer<T>` | EventBus.`consumer(String address, Handler<Message<T>> handler)` Create a consumer and register it against the specified address.
    `MessageProducer<T>` | MessageProducer.`drainHandler(Handler<Void> handler)`
    `void` | MessageProducer.`end(Handler<AsyncResult<Void>> handler)` Closes the producer, calls `MessageProducer.close()`
    `void` | MessageProducer.`end(T data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `MessageConsumer<T>` | MessageConsumer.`endHandler(Handler<Void> endHandler)`
    `MessageConsumer<T>` | MessageConsumer.`exceptionHandler(Handler<Throwable> handler)`
    `MessageProducer<T>` | MessageProducer.`exceptionHandler(Handler<Throwable> handler)`
    `MessageConsumer<T>` | MessageConsumer.`handler(Handler<Message<T>> handler)`
    `<T> MessageConsumer<T>` | EventBus.`localConsumer(String address, Handler<Message<T>> handler)` Like `EventBus.consumer(java.lang.String)` but the address won't be propagated across the cluster.
    `void` | MessageConsumer.`pipeTo(WriteStream<Message<T>> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `<T> EventBus` | EventBus.`removeInboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Remove an interceptor that was added by `EventBus.addInboundInterceptor(io.vertx.core.Handler<io.vertx.rxjava.core.eventbus.DeliveryContext<T>>)`
    `<T> EventBus` | EventBus.`removeOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Remove an interceptor that was added by `EventBus.addOutboundInterceptor(io.vertx.core.Handler<io.vertx.rxjava.core.eventbus.DeliveryContext<T>>)`
    `<R> void` | Message.`reply(Object message, DeliveryOptions options, Handler<AsyncResult<Message<R>>> replyHandler)` Deprecated.
    `<R> void` | Message.`reply(Object message, Handler<AsyncResult<Message<R>>> replyHandler)` Deprecated.
    `<R> void` | Message.`replyAndRequest(Object message, DeliveryOptions options, Handler<AsyncResult<Message<R>>> replyHandler)` Like but specifying `options` that can be used to configure the delivery.
    `<R> void` | Message.`replyAndRequest(Object message, Handler<AsyncResult<Message<R>>> replyHandler)` Reply to this message, specifying a `replyHandler` for the reply - i.e.
    `<T> EventBus` | EventBus.`request(String address, Object message, DeliveryOptions options, Handler<AsyncResult<Message<T>>> replyHandler)` Like but specifying `options` that can be used to configure the delivery.
    `<T> EventBus` | EventBus.`request(String address, Object message, Handler<AsyncResult<Message<T>>> replyHandler)` Sends a message and and specify a `replyHandler` that will be called if the recipient subsequently replies to the message.
    `<T> EventBus` | EventBus.`send(String address, Object message, DeliveryOptions options, Handler<AsyncResult<Message<T>>> replyHandler)` Deprecated.
    `<T> EventBus` | EventBus.`send(String address, Object message, Handler<AsyncResult<Message<T>>> replyHandler)` Deprecated.
    `<R> MessageProducer<T>` | MessageProducer.`send(T message, Handler<AsyncResult<Message<R>>> replyHandler)` Deprecated.
    `void` | MessageConsumer.`unregister(Handler<AsyncResult<Void>> completionHandler)` Unregisters the handler which created this registration
    `MessageProducer<T>` | MessageProducer.`write(T data, Handler<AsyncResult<Void>> handler)`

  - ### Uses of Handler in io.vertx.rxjava.core.file

    Methods in io.vertx.rxjava.core.file with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `FileSystem` | FileSystem.`chmod(String path, String perms, Handler<AsyncResult<Void>> handler)` Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `FileSystem` | FileSystem.`chmodRecursive(String path, String perms, String dirPerms, Handler<AsyncResult<Void>> handler)` Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `FileSystem` | FileSystem.`chown(String path, String user, String group, Handler<AsyncResult<Void>> handler)` Change the ownership on the file represented by `path` to `user` and {code group}, asynchronously.
    `void` | AsyncFile.`close(Handler<AsyncResult<Void>> handler)` Close the file.
    `FileSystem` | FileSystem.`copy(String from, String to, CopyOptions options, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`copy(String from, String to, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`copyRecursive(String from, String to, boolean recursive, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`createFile(String path, Handler<AsyncResult<Void>> handler)` Creates an empty file with the specified `path`, asynchronously.
    `FileSystem` | FileSystem.`createFile(String path, String perms, Handler<AsyncResult<Void>> handler)` Creates an empty file with the specified `path` and permissions `perms`, asynchronously.
    `FileSystem` | FileSystem.`createTempDirectory(String prefix, Handler<AsyncResult<String>> handler)` Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempDirectory(String prefix, String perms, Handler<AsyncResult<String>> handler)` Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempDirectory(String dir, String prefix, String perms, Handler<AsyncResult<String>> handler)` Creates a new directory in the directory provided by the path `path`, using the given prefix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempFile(String prefix, String suffix, Handler<AsyncResult<String>> handler)` Creates a new file in the default temporary-file directory, using the given prefix and suffix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempFile(String prefix, String suffix, String perms, Handler<AsyncResult<String>> handler)` Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`createTempFile(String dir, String prefix, String suffix, String perms, Handler<AsyncResult<String>> handler)` Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.
    `FileSystem` | FileSystem.`delete(String path, Handler<AsyncResult<Void>> handler)` Deletes the file represented by the specified `path`, asynchronously.
    `FileSystem` | FileSystem.`deleteRecursive(String path, boolean recursive, Handler<AsyncResult<Void>> handler)` Deletes the file represented by the specified `path`, asynchronously.
    `AsyncFile` | AsyncFile.`drainHandler(Handler<Void> handler)`
    `void` | AsyncFile.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | AsyncFile.`end(Handler<AsyncResult<Void>> handler)` Close the file, see `AsyncFile.close()`.
    `AsyncFile` | AsyncFile.`endHandler(Handler<Void> endHandler)`
    `AsyncFile` | AsyncFile.`exceptionHandler(Handler<Throwable> handler)`
    `FileSystem` | FileSystem.`exists(String path, Handler<AsyncResult<Boolean>> handler)` Determines whether the file as specified by the path `path` exists, asynchronously.
    `AsyncFile` | AsyncFile.`flush(Handler<AsyncResult<Void>> handler)` Same as `AsyncFile.flush()` but the handler will be called when the flush is complete or if an error occurs
    `FileSystem` | FileSystem.`fsProps(String path, Handler<AsyncResult<FileSystemProps>> handler)` Returns properties of the file-system being used by the specified `path`, asynchronously.
    `AsyncFile` | AsyncFile.`handler(Handler<Buffer> handler)`
    `FileSystem` | FileSystem.`link(String link, String existing, Handler<AsyncResult<Void>> handler)` Create a hard link on the file system from `link` to `existing`, asynchronously.
    `FileSystem` | FileSystem.`lprops(String path, Handler<AsyncResult<FileProps>> handler)` Obtain properties for the link represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`mkdir(String path, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`mkdir(String path, String perms, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`mkdirs(String path, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path` and any non existent parents, asynchronously.
    `FileSystem` | FileSystem.`mkdirs(String path, String perms, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path` and any non existent parents, asynchronously.
    `FileSystem` | FileSystem.`move(String from, String to, CopyOptions options, Handler<AsyncResult<Void>> handler)` Move a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`move(String from, String to, Handler<AsyncResult<Void>> handler)` Move a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`open(String path, OpenOptions options, Handler<AsyncResult<AsyncFile>> handler)` Open the file represented by `path`, asynchronously.
    `void` | AsyncFile.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `FileSystem` | FileSystem.`props(String path, Handler<AsyncResult<FileProps>> handler)` Obtain properties for the file represented by `path`, asynchronously.
    `AsyncFile` | AsyncFile.`read(Buffer buffer, int offset, long position, int length, Handler<AsyncResult<Buffer>> handler)` Reads `length` bytes of data from the file at position `position` in the file, asynchronously.
    `FileSystem` | FileSystem.`readDir(String path, Handler<AsyncResult<List<String>>> handler)` Read the contents of the directory specified by `path`, asynchronously.
    `FileSystem` | FileSystem.`readDir(String path, String filter, Handler<AsyncResult<List<String>>> handler)` Read the contents of the directory specified by `path`, asynchronously.
    `FileSystem` | FileSystem.`readFile(String path, Handler<AsyncResult<Buffer>> handler)` Reads the entire file as represented by the path `path` as a , asynchronously.
    `FileSystem` | FileSystem.`readSymlink(String link, Handler<AsyncResult<String>> handler)` Returns the path representing the file that the symbolic link specified by `link` points to, asynchronously.
    `FileSystem` | FileSystem.`symlink(String link, String existing, Handler<AsyncResult<Void>> handler)` Create a symbolic link on the file system from `link` to `existing`, asynchronously.
    `FileSystem` | FileSystem.`truncate(String path, long len, Handler<AsyncResult<Void>> handler)` Truncate the file represented by `path` to length `len` in bytes, asynchronously.
    `FileSystem` | FileSystem.`unlink(String link, Handler<AsyncResult<Void>> handler)` Unlinks the link on the file system represented by the path `link`, asynchronously.
    `AsyncFile` | AsyncFile.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as `AsyncFile.write(io.vertx.rxjava.core.buffer.Buffer)` but with an `handler` called when the operation completes
    `AsyncFile` | AsyncFile.`write(Buffer buffer, long position, Handler<AsyncResult<Void>> handler)` Write a `Buffer` to the file at position `position` in the file, asynchronously.
    `FileSystem` | FileSystem.`writeFile(String path, Buffer data, Handler<AsyncResult<Void>> handler)` Creates the file, and writes the specified `Buffer data` to the file represented by the path `path`, asynchronously.

  - ### Uses of Handler in io.vertx.rxjava.core.http

    Methods in io.vertx.rxjava.core.http with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `WebSocketBase` | ServerWebSocket.`binaryMessageHandler(Handler<Buffer> handler)` Set a binary message handler on the connection.
    `WebSocketBase` | WebSocket.`binaryMessageHandler(Handler<Buffer> handler)` Set a binary message handler on the connection.
    `WebSocketBase` | WebSocketBase.`binaryMessageHandler(Handler<Buffer> handler)` Set a binary message handler on the connection.
    `HttpServerResponse` | HttpServerResponse.`bodyEndHandler(Handler<Void> handler)` Provides a handler that will be called after the last part of the body is written to the wire.
    `HttpClientResponse` | HttpClientResponse.`bodyHandler(Handler<Buffer> bodyHandler)` Convenience method for receiving the entire request body in one piece.
    `HttpServerRequest` | HttpServerRequest.`bodyHandler(Handler<Buffer> bodyHandler)` Convenience method for receiving the entire request body in one piece.
    `void` | ServerWebSocket.`close(Handler<AsyncResult<Void>> handler)` Same as `ServerWebSocket.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpServer.`close(Handler<AsyncResult<Void>> completionHandler)` Like `HttpServer.close()` but supplying a handler that will be called when the server is actually closed (or has failed).
    `void` | WebSocket.`close(Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close()` but with an `handler` called when the operation completes
    `void` | WebSocketBase.`close(Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close()` but with an `handler` called when the operation completes
    `void` | ServerWebSocket.`close(short statusCode, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close()` but with an `handler` called when the operation completes
    `void` | WebSocket.`close(short statusCode, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close()` but with an `handler` called when the operation completes
    `void` | WebSocketBase.`close(short statusCode, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.close()` but with an `handler` called when the operation completes
    `void` | ServerWebSocket.`close(short statusCode, String reason, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | WebSocket.`close(short statusCode, String reason, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | WebSocketBase.`close(short statusCode, String reason, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `HttpServerResponse` | HttpServerResponse.`closeHandler(Handler<Void> handler)` Set a close handler for the response, this is called when the underlying connection is closed and the response was still using the connection.
    `ServerWebSocket` | ServerWebSocket.`closeHandler(Handler<Void> handler)`
    `WebSocket` | WebSocket.`closeHandler(Handler<Void> handler)`
    `HttpConnection` | HttpConnection.`closeHandler(Handler<Void> handler)` Set a close handler.
    `WebSocketBase` | WebSocketBase.`closeHandler(Handler<Void> handler)` Set a close handler.
    `HttpServer` | HttpServer.`connectionHandler(Handler<HttpConnection> handler)` Set a connection handler for the server.
    `HttpClientRequest` | HttpClientRequest.`connectionHandler(Handler<HttpConnection> handler)` Deprecated.
    `HttpClient` | HttpClient.`connectionHandler(Handler<HttpConnection> handler)` Set a connection handler for the client.
    `HttpClientRequest` | HttpClientRequest.`continueHandler(Handler<Void> handler)` If you send an HTTP request with the header `Expect` set to the value `100-continue` and the server responds with an interim HTTP response with a status code of `100` and a continue handler has been set using this method, then the `handler` will be called.
    `HttpClientResponse` | HttpClientResponse.`customFrameHandler(Handler<HttpFrame> handler)` Set an custom frame handler.
    `HttpServerRequest` | HttpServerRequest.`customFrameHandler(Handler<HttpFrame> handler)` Set a custom frame handler.
    `HttpClientRequest` | HttpClient.`delete(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`delete(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`delete(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`delete(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`deleteAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpServerResponse` | HttpServerResponse.`drainHandler(Handler<Void> handler)`
    `ServerWebSocket` | ServerWebSocket.`drainHandler(Handler<Void> handler)`
    `HttpClientRequest` | HttpClientRequest.`drainHandler(Handler<Void> handler)`
    `WebSocket` | WebSocket.`drainHandler(Handler<Void> handler)`
    `WebSocketBase` | WebSocketBase.`drainHandler(Handler<Void> handler)`
    `void` | HttpServerResponse.`end(Buffer chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | ServerWebSocket.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`end(Buffer chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end(java.lang.String)` but with an `handler` called when the operation completes
    `void` | WebSocket.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | WebSocketBase.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`end(Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | ServerWebSocket.`end(Handler<AsyncResult<Void>> handler)` Calls `WebSocketBase.close()`
    `void` | HttpClientRequest.`end(Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end(java.lang.String)` but with an `handler` called when the operation completes
    `void` | WebSocket.`end(Handler<AsyncResult<Void>> handler)` Calls `WebSocketBase.close()`
    `void` | WebSocketBase.`end(Handler<AsyncResult<Void>> handler)` Calls `WebSocketBase.close()`
    `void` | HttpServerResponse.`end(String chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`end(String chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end(java.lang.String)` but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`end(String chunk, String enc, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`end(String chunk, String enc, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end(java.lang.String)` but with an `handler` called when the operation completes
    `HttpClientResponse` | HttpClientResponse.`endHandler(Handler<Void> endHandler)`
    `HttpServerResponse` | HttpServerResponse.`endHandler(Handler<Void> handler)` Set an end handler for the response.
    `ServerWebSocket` | ServerWebSocket.`endHandler(Handler<Void> endHandler)`
    `HttpClientRequest` | HttpClientRequest.`endHandler(Handler<Void> endHandler)` Deprecated.
    `WebSocket` | WebSocket.`endHandler(Handler<Void> endHandler)`
    `HttpServerFileUpload` | HttpServerFileUpload.`endHandler(Handler<Void> endHandler)`
    `HttpServerRequest` | HttpServerRequest.`endHandler(Handler<Void> endHandler)`
    `WebSocketBase` | WebSocketBase.`endHandler(Handler<Void> endHandler)`
    `HttpClientResponse` | HttpClientResponse.`exceptionHandler(Handler<Throwable> handler)`
    `HttpServerResponse` | HttpServerResponse.`exceptionHandler(Handler<Throwable> handler)`
    `ServerWebSocket` | ServerWebSocket.`exceptionHandler(Handler<Throwable> handler)`
    `HttpServer` | HttpServer.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler called for socket errors happening before the HTTP connection is established, e.g during the TLS handshake.
    `HttpClientRequest` | HttpClientRequest.`exceptionHandler(Handler<Throwable> handler)`
    `WebSocket` | WebSocket.`exceptionHandler(Handler<Throwable> handler)`
    `HttpConnection` | HttpConnection.`exceptionHandler(Handler<Throwable> handler)` Set an handler called when a connection error happens
    `HttpServerFileUpload` | HttpServerFileUpload.`exceptionHandler(Handler<Throwable> handler)`
    `HttpServerRequest` | HttpServerRequest.`exceptionHandler(Handler<Throwable> handler)`
    `WebSocketBase` | WebSocketBase.`exceptionHandler(Handler<Throwable> handler)`
    `ServerWebSocket` | ServerWebSocket.`frameHandler(Handler<WebSocketFrame> handler)`
    `WebSocket` | WebSocket.`frameHandler(Handler<WebSocketFrame> handler)`
    `WebSocketBase` | WebSocketBase.`frameHandler(Handler<WebSocketFrame> handler)` Set a frame handler on the connection.
    `HttpClientRequest` | HttpClient.`get(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`get(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`get(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`get(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`getAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClient` | HttpClient.`getNow(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClient` | HttpClient.`getNow(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClient` | HttpClient.`getNow(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClient` | HttpClient.`getNow(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpConnection` | HttpConnection.`goAwayHandler(Handler<GoAway> handler)` Set an handler called when a frame is received.
    `HttpClientResponse` | HttpClientResponse.`handler(Handler<Buffer> handler)`
    `ServerWebSocket` | ServerWebSocket.`handler(Handler<Buffer> handler)`
    `WebSocket` | WebSocket.`handler(Handler<Buffer> handler)`
    `HttpServerFileUpload` | HttpServerFileUpload.`handler(Handler<Buffer> handler)`
    `HttpServerRequest` | HttpServerRequest.`handler(Handler<Buffer> handler)`
    `WebSocketBase` | WebSocketBase.`handler(Handler<Buffer> handler)`
    `HttpClientRequest` | HttpClientRequest.`handler(Handler<HttpClientResponse> handler)` Deprecated.
    `HttpClientRequest` | HttpClient.`head(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`head(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`head(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`head(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`headAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpServerResponse` | HttpServerResponse.`headersEndHandler(Handler<Void> handler)` Provide a handler that will be called just before the headers are written to the wire.
    `HttpClient` | HttpClient.`headNow(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClient` | HttpClient.`headNow(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClient` | HttpClient.`headNow(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClient` | HttpClient.`headNow(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpServer` | HttpServer.`listen(Handler<AsyncResult<HttpServer>> listenHandler)` Like `HttpServer.listen()` but supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpServer` | HttpServer.`listen(int port, Handler<AsyncResult<HttpServer>> listenHandler)` Like `HttpServer.listen()` but supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpServer` | HttpServer.`listen(int port, String host, Handler<AsyncResult<HttpServer>> listenHandler)` Like `HttpServer.listen()` but supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpServer` | HttpServer.`listen(SocketAddress address, Handler<AsyncResult<HttpServer>> listenHandler)` Tell the server to start listening on the given address supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpClientRequest` | HttpClient.`options(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`options(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`options(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`options(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`optionsAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClient` | HttpClient.`optionsNow(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClient` | HttpClient.`optionsNow(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClient` | HttpClient.`optionsNow(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClient` | HttpClient.`optionsNow(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpConnection` | HttpConnection.`ping(Buffer data, Handler<AsyncResult<Buffer>> pongHandler)` Send a frame to the remote endpoint.
    `HttpConnection` | HttpConnection.`pingHandler(Handler<Buffer> handler)` Set an handler notified when a frame is received from the remote endpoint.
    `void` | HttpClientResponse.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | ServerWebSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | WebSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | HttpServerFileUpload.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | HttpServerRequest.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | WebSocketBase.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | HttpClientRequest.`pipeTo(WriteStream<HttpClientResponse> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `WebSocketBase` | ServerWebSocket.`pongHandler(Handler<Buffer> handler)` Set a pong frame handler on the connection.
    `WebSocketBase` | WebSocket.`pongHandler(Handler<Buffer> handler)` Set a pong frame handler on the connection.
    `WebSocketBase` | WebSocketBase.`pongHandler(Handler<Buffer> handler)` Set a pong frame handler on the connection.
    `HttpClientRequest` | HttpClient.`post(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`post(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`post(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`post(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`postAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler)` Like `HttpServerResponse.push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.http.HttpServerResponse>>)` with the host copied from the current request.
    `HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler)` Like `HttpServerResponse.push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.http.HttpServerResponse>>)` with the host copied from the current request.
    `HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, String host, String path, Handler<AsyncResult<HttpServerResponse>> handler)` Like `HttpServerResponse.push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.http.HttpServerResponse>>)` with no headers.
    `HttpServerResponse` | HttpServerResponse.`push(HttpMethod method, String host, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler)` Push a response to the client. The `handler` will be notified with a success when the push can be sent and with a failure when the client has disabled push or reset the push before it has been sent. The `handler` may be queued if the client has reduced the maximum number of streams the server can push concurrently. Push can be sent only for peer initiated streams and if the response is not ended.
    `HttpClientRequest` | HttpClientRequest.`pushHandler(Handler<HttpClientRequest> handler)` Set a push handler for this request. The handler is called when the client receives a push promise from the server.
    `HttpClientRequest` | HttpClient.`put(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`put(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`put(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`put(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`putAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpConnection` | HttpConnection.`remoteSettingsHandler(Handler<Http2Settings> handler)` Set an handler that is called when remote endpoint `Http2Settings` are updated.
    `HttpClientRequest` | HttpClient.`request(HttpMethod method, int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`request(HttpMethod method, RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`request(HttpMethod method, SocketAddress serverAddress, int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Like `HttpClient.request(io.vertx.core.http.HttpMethod, io.vertx.rxjava.core.net.SocketAddress, io.vertx.core.http.RequestOptions)` using the `serverAddress` parameter to connect to the server instead of the `absoluteURI` parameter.
    `HttpClientRequest` | HttpClient.`request(HttpMethod method, SocketAddress serverAddress, RequestOptions options, Handler<HttpClientResponse> responseHandler)` Like `HttpClient.request(io.vertx.core.http.HttpMethod, io.vertx.rxjava.core.net.SocketAddress, io.vertx.core.http.RequestOptions)` using the `serverAddress` parameter to connect to the server instead of the `absoluteURI` parameter.
    `HttpClientRequest` | HttpClient.`request(HttpMethod method, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`request(HttpMethod method, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpClientRequest` | HttpClient.`requestAbs(HttpMethod method, SocketAddress serverAddress, String absoluteURI, Handler<HttpClientResponse> responseHandler)` Like `HttpClient.requestAbs(io.vertx.core.http.HttpMethod, java.lang.String)` using the `serverAddress` parameter to connect to the server instead of the `absoluteURI` parameter.
    `HttpClientRequest` | HttpClient.`requestAbs(HttpMethod method, String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated.
    `HttpServer` | HttpServer.`requestHandler(Handler<HttpServerRequest> handler)` Set the request handler for the server to `requestHandler`.
    `HttpServerResponse` | HttpServerResponse.`sendFile(String filename, Handler<AsyncResult<Void>> resultHandler)` Like `HttpServerResponse.sendFile(java.lang.String)` but providing a handler which will be notified once the file has been completely written to the wire.
    `HttpServerResponse` | HttpServerResponse.`sendFile(String filename, long offset, Handler<AsyncResult<Void>> resultHandler)` Like `HttpServerResponse.sendFile(java.lang.String)` but providing a handler which will be notified once the file has been completely written to the wire.
    `HttpServerResponse` | HttpServerResponse.`sendFile(String filename, long offset, long length, Handler<AsyncResult<Void>> resultHandler)` Like `HttpServerResponse.sendFile(java.lang.String)` but providing a handler which will be notified once the file has been completely written to the wire.
    `HttpClientRequest` | HttpClientRequest.`sendHead(Handler<HttpVersion> completionHandler)` Like `HttpClientRequest.sendHead()` but with an handler after headers have been sent.
    `void` | ServerWebSocket.`setHandshake(Future<Integer> future, Handler<AsyncResult<Integer>> handler)` Set an asynchronous result for the handshake, upon completion of the specified `future`, the WebSocket will either be accepted when the `future` succeeds with the HTTP status code rejected when the `future` is succeeds with an HTTP status code different than rejected when the `future` fails with the HTTP status code `500` The provided future might be completed by the WebSocket itself, e.g calling the `ServerWebSocket.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` method will try to accept the handshake and close the WebSocket afterward.
    `HttpConnection` | HttpConnection.`shutdownHandler(Handler<Void> handler)` Set an handler called when a frame has been sent or received and all connections are closed.
    `HttpClientResponse` | HttpClientResponse.`streamPriorityHandler(Handler<StreamPriority> handler)` Set an handler for stream priority changes.
    `HttpServerRequest` | HttpServerRequest.`streamPriorityHandler(Handler<StreamPriority> handler)` Set an handler for stream priority changes
    `WebSocketBase` | ServerWebSocket.`textMessageHandler(Handler<String> handler)` Set a text message handler on the connection.
    `WebSocketBase` | WebSocket.`textMessageHandler(Handler<String> handler)` Set a text message handler on the connection.
    `WebSocketBase` | WebSocketBase.`textMessageHandler(Handler<String> handler)` Set a text message handler on the connection.
    `HttpConnection` | HttpConnection.`updateSettings(Http2Settings settings, Handler<AsyncResult<Void>> completionHandler)` Send to the remote endpoint an update of this endpoint settings The `completionHandler` will be notified when the remote endpoint has acknowledged the settings.
    `HttpServerRequest` | HttpServerRequest.`uploadHandler(Handler<HttpServerFileUpload> uploadHandler)` Set an upload handler.
    `void` | HttpClient.`webSocket(int port, String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket to the specified port, host and relative request URI
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(RequestOptions options, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(RequestOptions options, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(RequestOptions options, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `void` | HttpClient.`webSocket(String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket at the relative request URI using the default host and port
    `HttpClient` | HttpClient.`websocket(String requestURI, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `void` | HttpClient.`webSocket(String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket to the host and relative request URI and default port
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `void` | HttpClient.`webSocket(WebSocketConnectOptions options, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket with the specified options.
    `void` | HttpClient.`webSocketAbs(String url, MultiMap headers, WebsocketVersion version, List<String> subProtocols, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket with the specified absolute url, with the specified headers, using the specified version of WebSockets, and the specified WebSocket sub protocols.
    `HttpClient` | HttpClient.`websocketAbs(String url, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpClient` | HttpClient.`websocketAbs(String url, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated.
    `HttpServer` | HttpServer.`websocketHandler(Handler<ServerWebSocket> handler)` Deprecated.
    `HttpServer` | HttpServer.`webSocketHandler(Handler<ServerWebSocket> handler)` Set the WebSocket handler for the server to `wsHandler`.
    `HttpServerResponse` | HttpServerResponse.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.write(io.vertx.rxjava.core.buffer.Buffer)` but with an `handler` called when the operation completes
    `ServerWebSocket` | ServerWebSocket.`write(Buffer data, Handler<AsyncResult<Void>> handler)`
    `HttpClientRequest` | HttpClientRequest.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.write(io.vertx.rxjava.core.buffer.Buffer)` but with an `handler` called when the operation completes
    `WebSocket` | WebSocket.`write(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`write(Buffer data, Handler<AsyncResult<Void>> handler)`
    `HttpServerResponse` | HttpServerResponse.`write(String chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.write(io.vertx.rxjava.core.buffer.Buffer)` but with an `handler` called when the operation completes
    `HttpClientRequest` | HttpClientRequest.`write(String chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.write(io.vertx.rxjava.core.buffer.Buffer)` but with an `handler` called when the operation completes
    `HttpServerResponse` | HttpServerResponse.`write(String chunk, String enc, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.write(io.vertx.rxjava.core.buffer.Buffer)` but with an `handler` called when the operation completes
    `HttpClientRequest` | HttpClientRequest.`write(String chunk, String enc, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.write(io.vertx.rxjava.core.buffer.Buffer)` but with an `handler` called when the operation completes
    `ServerWebSocket` | ServerWebSocket.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeBinaryMessage(io.vertx.rxjava.core.buffer.Buffer)` but with an `handler` called when the operation completes
    `ServerWebSocket` | ServerWebSocket.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeFinalBinaryFrame(io.vertx.rxjava.core.buffer.Buffer)` but with an `handler` called when the operation completes
    `ServerWebSocket` | ServerWebSocket.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeFinalTextFrame(java.lang.String)` but with an `handler` called when the operation completes
    `ServerWebSocket` | ServerWebSocket.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeFrame(io.vertx.rxjava.core.http.WebSocketFrame)` but with an `handler` called when the operation completes
    `ServerWebSocket` | ServerWebSocket.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeTextMessage(String text, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeTextMessage(java.lang.String)` but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.rxjava.core.net

    Methods in io.vertx.rxjava.core.net with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | NetSocket.`close(Handler<AsyncResult<Void>> handler)` Close the NetSocket and notify the `handler` when the operation completes.
    `void` | NetServer.`close(Handler<AsyncResult<Void>> completionHandler)` Like `NetServer.close()` but supplying a handler that will be notified when close is complete.
    `NetSocket` | NetSocket.`closeHandler(Handler<Void> handler)` Set a handler that will be called when the NetSocket is closed
    `NetClient` | NetClient.`connect(int port, String host, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `port` and `host`.
    `NetClient` | NetClient.`connect(int port, String host, String serverName, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `port` and `host`.
    `NetClient` | NetClient.`connect(SocketAddress remoteAddress, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `remoteAddress`.
    `NetClient` | NetClient.`connect(SocketAddress remoteAddress, String serverName, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `remoteAddress`.
    `NetServer` | NetServer.`connectHandler(Handler<NetSocket> handler)` Supply a connect handler for this server.
    `NetSocket` | NetSocket.`drainHandler(Handler<Void> handler)`
    `void` | NetSocket.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | NetSocket.`end(Handler<AsyncResult<Void>> handler)` Calls `NetSocket.end(io.vertx.rxjava.core.buffer.Buffer)`
    `NetSocket` | NetSocket.`endHandler(Handler<Void> endHandler)` This handler might be called after the close handler when the socket is paused and there are still buffers to deliver.
    `NetSocket` | NetSocket.`exceptionHandler(Handler<Throwable> handler)`
    `NetSocket` | NetSocket.`handler(Handler<Buffer> handler)`
    `NetServer` | NetServer.`listen(Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen()` but providing a handler that will be notified when the server is listening, or fails.
    `NetServer` | NetServer.`listen(int port, Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen()` but providing a handler that will be notified when the server is listening, or fails.
    `NetServer` | NetServer.`listen(int port, String host, Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen()` but providing a handler that will be notified when the server is listening, or fails.
    `NetServer` | NetServer.`listen(SocketAddress localAddress, Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen()` but providing a handler that will be notified when the server is listening, or fails.
    `void` | NetSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `NetSocket` | NetSocket.`sendFile(String filename, Handler<AsyncResult<Void>> resultHandler)` Same as `NetSocket.sendFile(java.lang.String)` but also takes a handler that will be called when the send has completed or a failure has occurred
    `NetSocket` | NetSocket.`sendFile(String filename, long offset, Handler<AsyncResult<Void>> resultHandler)` Same as `NetSocket.sendFile(java.lang.String)` but also takes a handler that will be called when the send has completed or a failure has occurred
    `NetSocket` | NetSocket.`sendFile(String filename, long offset, long length, Handler<AsyncResult<Void>> resultHandler)` Same as `NetSocket.sendFile(java.lang.String)` but also takes a handler that will be called when the send has completed or a failure has occurred
    `NetSocket` | NetSocket.`upgradeToSsl(Handler<Void> handler)` Upgrade channel to use SSL/TLS.
    `NetSocket` | NetSocket.`upgradeToSsl(String serverName, Handler<Void> handler)` Upgrade channel to use SSL/TLS.
    `NetSocket` | NetSocket.`write(Buffer message, Handler<AsyncResult<Void>> handler)` Like but with an `handler` called when the message has been written or failed to be written.
    `NetSocket` | NetSocket.`write(String str, Handler<AsyncResult<Void>> handler)` Same as `NetSocket.write(io.vertx.rxjava.core.buffer.Buffer)` but with an `handler` called when the operation completes
    `NetSocket` | NetSocket.`write(String str, String enc, Handler<AsyncResult<Void>> handler)` Same as `NetSocket.write(io.vertx.rxjava.core.buffer.Buffer)` but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.rxjava.core.parsetools

    Classes in io.vertx.rxjava.core.parsetools that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `JsonParser` A parser class which allows to incrementally parse json elements and emit json parse events instead of parsing a json element fully.
    `class` | `RecordParser` A helper class which allows you to easily parse protocols which are delimited by a sequence of bytes, or fixed size records.

    Methods in io.vertx.rxjava.core.parsetools with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `RecordParser` | RecordParser.`endHandler(Handler<Void> endHandler)`
    `JsonParser` | JsonParser.`endHandler(Handler<Void> endHandler)`
    `RecordParser` | RecordParser.`exceptionHandler(Handler<Throwable> handler)`
    `JsonParser` | JsonParser.`exceptionHandler(Handler<Throwable> handler)`
    `RecordParser` | RecordParser.`handler(Handler<Buffer> handler)`
    `JsonParser` | JsonParser.`handler(Handler<JsonEvent> handler)`
    `static RecordParser` | RecordParser.`newDelimited(Buffer delim, Handler<Buffer> output)` Like `RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.rxjava.core.buffer.Buffer>)` but set the `output` that will receive whole records which have been parsed.
    `static RecordParser` | RecordParser.`newDelimited(String delim, Handler<Buffer> output)` Like `RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.rxjava.core.buffer.Buffer>)` but set the `output` that will receive whole records which have been parsed.
    `static RecordParser` | RecordParser.`newFixed(int size, Handler<Buffer> output)` Like `RecordParser.newFixed(int)` but set the `output` that will receive whole records which have been parsed.
    `void` | RecordParser.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | JsonParser.`pipeTo(WriteStream<JsonEvent> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | RecordParser.`setOutput(Handler<Buffer> output)`

  - ### Uses of Handler in io.vertx.rxjava.core.shareddata

    Methods in io.vertx.rxjava.core.shareddata with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | Counter.`addAndGet(long value, Handler<AsyncResult<Long>> resultHandler)` Add the value to the counter atomically and return the new count
    `void` | AsyncMap.`clear(Handler<AsyncResult<Void>> resultHandler)` Clear all entries in the map
    `void` | Counter.`compareAndSet(long expected, long value, Handler<AsyncResult<Boolean>> resultHandler)` Set the counter to the specified value only if the current value is the expectec value.
    `void` | Counter.`decrementAndGet(Handler<AsyncResult<Long>> resultHandler)` Decrement the counter atomically and return the new count
    `void` | Counter.`get(Handler<AsyncResult<Long>> resultHandler)` Get the current value of the counter
    `void` | AsyncMap.`get(K k, Handler<AsyncResult<V>> resultHandler)` Get a value from the map, asynchronously.
    `void` | Counter.`getAndAdd(long value, Handler<AsyncResult<Long>> resultHandler)` Add the value to the counter atomically and return the value before the add
    `void` | Counter.`getAndIncrement(Handler<AsyncResult<Long>> resultHandler)` Increment the counter atomically and return the value before the increment.
    `<K,V> void` | SharedData.`getAsyncMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)` Get the `AsyncMap` with the specified name.
    `<K,V> void` | SharedData.`getClusterWideMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)` Get the cluster wide map with the specified name.
    `void` | SharedData.`getCounter(String name, Handler<AsyncResult<Counter>> resultHandler)` Get an asynchronous counter.
    `<K,V> void` | SharedData.`getLocalAsyncMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)` Get the `AsyncMap` with the specified name.
    `void` | SharedData.`getLocalCounter(String name, Handler<AsyncResult<Counter>> resultHandler)` Get an asynchronous local counter.
    `void` | SharedData.`getLocalLock(String name, Handler<AsyncResult<Lock>> resultHandler)` Get an asynchronous local lock with the specified name.
    `void` | SharedData.`getLocalLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler)` Like `SharedData.getLocalLock(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.shareddata.Lock>>)` but specifying a timeout.
    `void` | SharedData.`getLock(String name, Handler<AsyncResult<Lock>> resultHandler)` Get an asynchronous lock with the specified name.
    `void` | SharedData.`getLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler)` Like `SharedData.getLock(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.shareddata.Lock>>)` but specifying a timeout.
    `void` | Counter.`incrementAndGet(Handler<AsyncResult<Long>> resultHandler)` Increment the counter atomically and return the new count
    `void` | AsyncMap.`put(K k, V v, Handler<AsyncResult<Void>> completionHandler)` Put a value in the map, asynchronously.
    `void` | AsyncMap.`put(K k, V v, long ttl, Handler<AsyncResult<Void>> completionHandler)` Like `AsyncMap.put(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but specifying a time to live for the entry.
    `void` | AsyncMap.`putIfAbsent(K k, V v, Handler<AsyncResult<V>> completionHandler)` Put the entry only if there is no entry with the key already present.
    `void` | AsyncMap.`putIfAbsent(K k, V v, long ttl, Handler<AsyncResult<V>> completionHandler)` Link `AsyncMap.putIfAbsent(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<V>>)` but specifying a time to live for the entry.
    `void` | AsyncMap.`remove(K k, Handler<AsyncResult<V>> resultHandler)` Remove a value from the map, asynchronously.
    `void` | AsyncMap.`removeIfPresent(K k, V v, Handler<AsyncResult<Boolean>> resultHandler)` Remove a value from the map, only if entry already exists with same value.
    `void` | AsyncMap.`replace(K k, V v, Handler<AsyncResult<V>> resultHandler)` Replace the entry only if it is currently mapped to some value
    `void` | AsyncMap.`replaceIfPresent(K k, V oldValue, V newValue, Handler<AsyncResult<Boolean>> resultHandler)` Replace the entry only if it is currently mapped to a specific value
    `void` | AsyncMap.`size(Handler<AsyncResult<Integer>> resultHandler)` Provide the number of entries in the map

  - ### Uses of Handler in io.vertx.rxjava.core.streams

    Methods in io.vertx.rxjava.core.streams with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `WriteStream<T>` | WriteStream.`drainHandler(Handler<Void> handler)` Set a drain handler on the stream.
    `void` | WriteStream.`end(Handler<AsyncResult<Void>> handler)` Same as `WriteStream.end()` but with an `handler` called when the operation completes
    `void` | WriteStream.`end(T data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `ReadStream<T>` | ReadStream.`endHandler(Handler<Void> endHandler)` Set an end handler.
    `ReadStream<T>` | ReadStream.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the read stream.
    `StreamBase` | StreamBase.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler.
    `WriteStream<T>` | WriteStream.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the write stream.
    `ReadStream<T>` | ReadStream.`handler(Handler<T> handler)` Set a data handler.
    `void` | ReadStream.`pipeTo(WriteStream<T> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | Pipe.`to(WriteStream<T> dst, Handler<AsyncResult<Void>> completionHandler)` Start to pipe the elements to the destination `WriteStream`.
    `WriteStream<T>` | WriteStream.`write(T data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes

  - ### Uses of Handler in io.vertx.rxjava.ext.asyncsql

    Methods in io.vertx.rxjava.ext.asyncsql with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `SQLOperations` | PostgreSQLClient.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | AsyncSQLClient.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | MySQLClient.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | PostgreSQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | AsyncSQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | MySQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.

  - ### Uses of Handler in io.vertx.rxjava.ext.auth

    Methods in io.vertx.rxjava.ext.auth with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | AuthProvider.`authenticate(JsonObject authInfo, Handler<AsyncResult<User>> resultHandler)` Authenticate a user.
    `User` | User.`isAuthorised(String authority, Handler<AsyncResult<Boolean>> resultHandler)` Deprecated.
    `User` | User.`isAuthorized(String authority, Handler<AsyncResult<Boolean>> resultHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.rxjava.ext.auth.mongo

    Methods in io.vertx.rxjava.ext.auth.mongo with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | MongoAuth.`insertUser(String username, String password, List<String> roles, List<String> permissions, Handler<AsyncResult<String>> resultHandler)` Insert a new user into mongo in the convenient way

  - ### Uses of Handler in io.vertx.rxjava.ext.auth.oauth2

    Methods in io.vertx.rxjava.ext.auth.oauth2 with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `OAuth2Auth` | OAuth2Auth.`decodeToken(String token, Handler<AsyncResult<AccessToken>> handler)` Deprecated.
    `AccessToken` | AccessToken.`fetch(HttpMethod method, String resource, JsonObject headers, Buffer payload, Handler<AsyncResult<OAuth2Response>> callback)` Fetches a JSON resource using this Access Token.
    `AccessToken` | AccessToken.`fetch(String resource, Handler<AsyncResult<OAuth2Response>> callback)` Fetches a JSON resource using this Access Token.
    `void` | OAuth2Auth.`getToken(JsonObject params, Handler<AsyncResult<AccessToken>> handler)` Deprecated.
    `AccessToken` | AccessToken.`introspect(Handler<AsyncResult<Void>> callback)` Introspect access token.
    `AccessToken` | AccessToken.`introspect(String tokenType, Handler<AsyncResult<Void>> callback)` Introspect access token.
    `OAuth2Auth` | OAuth2Auth.`introspectToken(String token, Handler<AsyncResult<AccessToken>> handler)` Deprecated.
    `OAuth2Auth` | OAuth2Auth.`introspectToken(String token, String tokenType, Handler<AsyncResult<AccessToken>> handler)` Deprecated.
    `void` | OAuth2RBAC.`isAuthorized(AccessToken user, String authority, Handler<AsyncResult<Boolean>> handler)` This method should verify if the user has the given authority and return either a boolean value or an error.
    `OAuth2Auth` | OAuth2Auth.`loadJWK(Handler<AsyncResult<Void>> handler)` Deprecated.
    `AccessToken` | AccessToken.`logout(Handler<AsyncResult<Void>> callback)` Revoke refresh token and calls the logout endpoint.
    `AccessToken` | AccessToken.`refresh(Handler<AsyncResult<Void>> callback)` Refresh the access token
    `AccessToken` | AccessToken.`revoke(String token_type, Handler<AsyncResult<Void>> callback)` Revoke access or refresh token
    `AccessToken` | AccessToken.`userInfo(Handler<AsyncResult<JsonObject>> callback)` Load the user info as per OIDC spec.

  - ### Uses of Handler in io.vertx.rxjava.ext.auth.oauth2.providers

    Methods in io.vertx.rxjava.ext.auth.oauth2.providers with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static void` | SalesforceAuth.`discover(Vertx vertx, OAuth2ClientOptions config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | GoogleAuth.`discover(Vertx vertx, OAuth2ClientOptions config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | AzureADAuth.`discover(Vertx vertx, OAuth2ClientOptions config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | OpenIDConnectAuth.`discover(Vertx vertx, OAuth2ClientOptions config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.
    `static void` | KeycloakAuth.`discover(Vertx vertx, OAuth2ClientOptions config, Handler<AsyncResult<OAuth2Auth>> handler)` Create a OAuth2Auth provider for OpenID Connect Discovery.

  - ### Uses of Handler in io.vertx.rxjava.ext.consul

    Methods in io.vertx.rxjava.ext.consul with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `ConsulClient` | ConsulClient.`agentInfo(Handler<AsyncResult<JsonObject>> resultHandler)` Returns the configuration and member information of the local agent
    `ConsulClient` | ConsulClient.`catalogDatacenters(Handler<AsyncResult<List<String>>> resultHandler)` Return all the datacenters that are known by the Consul server
    `ConsulClient` | ConsulClient.`catalogNodes(Handler<AsyncResult<NodeList>> resultHandler)` Returns the nodes registered in a datacenter
    `ConsulClient` | ConsulClient.`catalogNodeServices(String node, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the node's registered services
    `ConsulClient` | ConsulClient.`catalogNodeServicesWithOptions(String node, BlockingQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the node's registered services This is blocking query unlike `ConsulClient.catalogNodeServices(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.ServiceList>>)`
    `ConsulClient` | ConsulClient.`catalogNodesWithOptions(NodeQueryOptions options, Handler<AsyncResult<NodeList>> resultHandler)` Returns the nodes registered in a datacenter
    `ConsulClient` | ConsulClient.`catalogServiceNodes(String service, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the nodes providing a service
    `ConsulClient` | ConsulClient.`catalogServiceNodesWithOptions(String service, ServiceQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the nodes providing a service
    `ConsulClient` | ConsulClient.`catalogServices(Handler<AsyncResult<ServiceList>> resultHandler)` Returns the services registered in a datacenter
    `ConsulClient` | ConsulClient.`catalogServicesWithOptions(BlockingQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler)` Returns the services registered in a datacenter This is blocking query unlike `ConsulClient.catalogServices(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.ServiceList>>)`
    `ConsulClient` | ConsulClient.`cloneAclToken(String id, Handler<AsyncResult<String>> idHandler)` Clone Acl token
    `ConsulClient` | ConsulClient.`coordinateDatacenters(Handler<AsyncResult<List<DcCoordinates>>> resultHandler)` Returns the WAN network coordinates for all Consul servers, organized by DCs
    `ConsulClient` | ConsulClient.`coordinateNodes(Handler<AsyncResult<CoordinateList>> resultHandler)` Returns the LAN network coordinates for all nodes in a given DC
    `ConsulClient` | ConsulClient.`coordinateNodesWithOptions(BlockingQueryOptions options, Handler<AsyncResult<CoordinateList>> resultHandler)` Returns the LAN network coordinates for all nodes in a given DC This is blocking query unlike `ConsulClient.coordinateNodes(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.CoordinateList>>)`
    `ConsulClient` | ConsulClient.`createAclToken(AclToken token, Handler<AsyncResult<String>> idHandler)` Create new Acl token
    `ConsulClient` | ConsulClient.`createPreparedQuery(PreparedQueryDefinition definition, Handler<AsyncResult<String>> resultHandler)`
    `ConsulClient` | ConsulClient.`createSession(Handler<AsyncResult<String>> idHandler)` Initialize a new session
    `ConsulClient` | ConsulClient.`createSessionWithOptions(SessionOptions options, Handler<AsyncResult<String>> idHandler)` Initialize a new session
    `ConsulClient` | ConsulClient.`deletePreparedQuery(String id, Handler<AsyncResult<Void>> resultHandler)` Deletes an existing prepared query
    `ConsulClient` | ConsulClient.`deleteValue(String key, Handler<AsyncResult<Void>> resultHandler)` Remove the key/value pair that corresponding to the specified key
    `ConsulClient` | ConsulClient.`deleteValues(String keyPrefix, Handler<AsyncResult<Void>> resultHandler)` Removes all the key/value pair that corresponding to the specified key prefix
    `ConsulClient` | ConsulClient.`deregisterCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Remove a check from the local agent.
    `ConsulClient` | ConsulClient.`deregisterService(String id, Handler<AsyncResult<Void>> resultHandler)` Remove a service from the local agent.
    `ConsulClient` | ConsulClient.`destroyAclToken(String id, Handler<AsyncResult<Void>> resultHandler)` Destroy Acl token
    `ConsulClient` | ConsulClient.`destroySession(String id, Handler<AsyncResult<Void>> resultHandler)` Destroys the given session
    `ConsulClient` | ConsulClient.`executePreparedQuery(String query, Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)` Executes an existing prepared query.
    `ConsulClient` | ConsulClient.`executePreparedQueryWithOptions(String query, PreparedQueryExecuteOptions options, Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)` Executes an existing prepared query.
    `ConsulClient` | ConsulClient.`failCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "critical".
    `ConsulClient` | ConsulClient.`failCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "critical".
    `ConsulClient` | ConsulClient.`fireEvent(String name, Handler<AsyncResult<Event>> resultHandler)` Fires a new user event
    `ConsulClient` | ConsulClient.`fireEventWithOptions(String name, EventOptions options, Handler<AsyncResult<Event>> resultHandler)` Fires a new user event
    `ConsulClient` | ConsulClient.`getAllPreparedQueries(Handler<AsyncResult<List<PreparedQueryDefinition>>> resultHandler)` Returns a list of all prepared queries.
    `ConsulClient` | ConsulClient.`getKeys(String keyPrefix, Handler<AsyncResult<List<String>>> resultHandler)` Returns the list of keys that corresponding to the specified key prefix.
    `ConsulClient` | ConsulClient.`getKeysWithOptions(String keyPrefix, BlockingQueryOptions options, Handler<AsyncResult<List<String>>> resultHandler)` Returns the list of keys that corresponding to the specified key prefix.
    `ConsulClient` | ConsulClient.`getPreparedQuery(String id, Handler<AsyncResult<PreparedQueryDefinition>> resultHandler)` Returns an existing prepared query
    `ConsulClient` | ConsulClient.`getValue(String key, Handler<AsyncResult<KeyValue>> resultHandler)` Returns key/value pair that corresponding to the specified key.
    `ConsulClient` | ConsulClient.`getValues(String keyPrefix, Handler<AsyncResult<KeyValueList>> resultHandler)` Returns the list of key/value pairs that corresponding to the specified key prefix.
    `ConsulClient` | ConsulClient.`getValuesWithOptions(String keyPrefix, BlockingQueryOptions options, Handler<AsyncResult<KeyValueList>> resultHandler)` Returns the list of key/value pairs that corresponding to the specified key prefix.
    `ConsulClient` | ConsulClient.`getValueWithOptions(String key, BlockingQueryOptions options, Handler<AsyncResult<KeyValue>> resultHandler)` Returns key/value pair that corresponding to the specified key.
    `ConsulClient` | ConsulClient.`healthChecks(String service, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks associated with the service
    `ConsulClient` | ConsulClient.`healthChecksWithOptions(String service, CheckQueryOptions options, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks associated with the service
    `ConsulClient` | ConsulClient.`healthServiceNodes(String service, boolean passing, Handler<AsyncResult<ServiceEntryList>> resultHandler)` Returns the nodes providing the service.
    `ConsulClient` | ConsulClient.`healthServiceNodesWithOptions(String service, boolean passing, ServiceQueryOptions options, Handler<AsyncResult<ServiceEntryList>> resultHandler)` Returns the nodes providing the service.
    `ConsulClient` | ConsulClient.`healthState(HealthState healthState, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks in the specified status
    `ConsulClient` | ConsulClient.`healthStateWithOptions(HealthState healthState, CheckQueryOptions options, Handler<AsyncResult<CheckList>> resultHandler)` Returns the checks in the specified status
    `ConsulClient` | ConsulClient.`infoAclToken(String id, Handler<AsyncResult<AclToken>> tokenHandler)` Get info of Acl token
    `ConsulClient` | ConsulClient.`infoSession(String id, Handler<AsyncResult<Session>> resultHandler)` Returns the requested session information
    `ConsulClient` | ConsulClient.`infoSessionWithOptions(String id, BlockingQueryOptions options, Handler<AsyncResult<Session>> resultHandler)` Returns the requested session information This is blocking query unlike `ConsulClient.infoSession(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.Session>>)`
    `ConsulClient` | ConsulClient.`leaderStatus(Handler<AsyncResult<String>> resultHandler)` Get the Raft leader for the datacenter in which the agent is running.
    `ConsulClient` | ConsulClient.`listAclTokens(Handler<AsyncResult<List<AclToken>>> resultHandler)` Get list of Acl token
    `ConsulClient` | ConsulClient.`listEvents(Handler<AsyncResult<EventList>> resultHandler)` Returns the most recent events known by the agent
    `ConsulClient` | ConsulClient.`listEventsWithOptions(EventListOptions options, Handler<AsyncResult<EventList>> resultHandler)` Returns the most recent events known by the agent.
    `ConsulClient` | ConsulClient.`listNodeSessions(String nodeId, Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions for a given node
    `ConsulClient` | ConsulClient.`listNodeSessionsWithOptions(String nodeId, BlockingQueryOptions options, Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions for a given node This is blocking query unlike `ConsulClient.listNodeSessions(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.SessionList>>)`
    `ConsulClient` | ConsulClient.`listSessions(Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions
    `ConsulClient` | ConsulClient.`listSessionsWithOptions(BlockingQueryOptions options, Handler<AsyncResult<SessionList>> resultHandler)` Returns the active sessions This is blocking query unlike `ConsulClient.listSessions(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.SessionList>>)`
    `ConsulClient` | ConsulClient.`localChecks(Handler<AsyncResult<List<Check>>> resultHandler)` Return all the checks that are registered with the local agent.
    `ConsulClient` | ConsulClient.`localServices(Handler<AsyncResult<List<Service>>> resultHandler)` Returns list of services registered with the local agent.
    `ConsulClient` | ConsulClient.`maintenanceService(MaintenanceOptions maintenanceOptions, Handler<AsyncResult<Void>> resultHandler)` Places a given service into "maintenance mode"
    `ConsulClient` | ConsulClient.`passCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "passing".
    `ConsulClient` | ConsulClient.`passCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "passing".
    `ConsulClient` | ConsulClient.`peersStatus(Handler<AsyncResult<List<String>>> resultHandler)` Retrieves the Raft peers for the datacenter in which the the agent is running.
    `ConsulClient` | ConsulClient.`putValue(String key, String value, Handler<AsyncResult<Boolean>> resultHandler)` Adds specified key/value pair
    `ConsulClient` | ConsulClient.`putValueWithOptions(String key, String value, KeyValueOptions options, Handler<AsyncResult<Boolean>> resultHandler)`
    `ConsulClient` | ConsulClient.`registerCheck(CheckOptions checkOptions, Handler<AsyncResult<Void>> resultHandler)` Add a new check to the local agent.
    `ConsulClient` | ConsulClient.`registerService(ServiceOptions serviceOptions, Handler<AsyncResult<Void>> resultHandler)` Adds a new service, with an optional health check, to the local agent.
    `ConsulClient` | ConsulClient.`renewSession(String id, Handler<AsyncResult<Session>> resultHandler)` Renews the given session.
    `Watch<T>` | Watch.`setHandler(Handler<WatchResult<T>> handler)` Set the result handler.
    `ConsulClient` | ConsulClient.`transaction(TxnRequest request, Handler<AsyncResult<TxnResponse>> resultHandler)` Manages multiple operations inside a single, atomic transaction.
    `ConsulClient` | ConsulClient.`updateAclToken(AclToken token, Handler<AsyncResult<String>> idHandler)` Update Acl token
    `ConsulClient` | ConsulClient.`updateCheck(String checkId, CheckStatus status, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to given status.
    `ConsulClient` | ConsulClient.`updateCheckWithNote(String checkId, CheckStatus status, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to given status.
    `ConsulClient` | ConsulClient.`updatePreparedQuery(PreparedQueryDefinition definition, Handler<AsyncResult<Void>> resultHandler)`
    `ConsulClient` | ConsulClient.`warnCheck(String checkId, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "warning".
    `ConsulClient` | ConsulClient.`warnCheckWithNote(String checkId, String note, Handler<AsyncResult<Void>> resultHandler)` Set status of the check to "warning".

  - ### Uses of Handler in io.vertx.rxjava.ext.eventbus.bridge.tcp

    Methods in io.vertx.rxjava.ext.eventbus.bridge.tcp with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | TcpEventBusBridge.`close(Handler<AsyncResult<Void>> handler)` Close the current socket.
    `static TcpEventBusBridge` | TcpEventBusBridge.`create(Vertx vertx, BridgeOptions options, NetServerOptions netServerOptions, Handler<BridgeEvent> eventHandler)`
    `TcpEventBusBridge` | TcpEventBusBridge.`listen(Handler<AsyncResult<TcpEventBusBridge>> handler)` Listen on default port 7000 with a handler to report the state of the socket listen operation.
    `TcpEventBusBridge` | TcpEventBusBridge.`listen(int port, Handler<AsyncResult<TcpEventBusBridge>> handler)` Listen on specific port
    `TcpEventBusBridge` | TcpEventBusBridge.`listen(int port, String address, Handler<AsyncResult<TcpEventBusBridge>> handler)` Listen on specific port and bind to specific address

  - ### Uses of Handler in io.vertx.rxjava.ext.healthchecks

    Classes in io.vertx.rxjava.ext.healthchecks that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `HealthCheckHandler` A Vert.x Web handler on which you register health check procedure.

    Methods in io.vertx.rxjava.ext.healthchecks with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `HealthChecks` | HealthChecks.`invoke(Handler<JsonObject> resultHandler)` Invokes the registered procedures and computes the outcome.
    `HealthChecks` | HealthChecks.`invoke(String name, Handler<AsyncResult<JsonObject>> resultHandler)` Invokes the registered procedure with the given name and sub-procedures.
    `HealthChecks` | HealthChecks.`register(String name, Handler<Promise<Status>> procedure)` Registers a health check procedure.
    `HealthCheckHandler` | HealthCheckHandler.`register(String name, Handler<Promise<Status>> procedure)` Registers a health check procedure.
    `HealthChecks` | HealthChecks.`register(String name, long timeout, Handler<Promise<Status>> procedure)` Registers a health check procedure.
    `HealthCheckHandler` | HealthCheckHandler.`register(String name, long timeout, Handler<Promise<Status>> procedure)` Registers a health check procedure.

  - ### Uses of Handler in io.vertx.rxjava.ext.jdbc

    Methods in io.vertx.rxjava.ext.jdbc with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `SQLOperations` | JDBCClient.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | JDBCClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.

  - ### Uses of Handler in io.vertx.rxjava.ext.mail

    Methods in io.vertx.rxjava.ext.mail with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MailClient` | MailClient.`sendMail(MailMessage email, Handler<AsyncResult<MailResult>> resultHandler)` send a single mail via MailClient

  - ### Uses of Handler in io.vertx.rxjava.ext.mongo

    Methods in io.vertx.rxjava.ext.mongo with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MongoClient` | MongoClient.`bulkWrite(String collection, List<BulkOperation> operations, Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)` Execute a bulk operation.
    `MongoService` | MongoService.`bulkWrite(String collection, List<BulkOperation> operations, Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)`
    `MongoClient` | MongoClient.`bulkWriteWithOptions(String collection, List<BulkOperation> operations, BulkWriteOptions bulkWriteOptions, Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)` Execute a bulk operation with the specified write options.
    `MongoService` | MongoService.`bulkWriteWithOptions(String collection, List<BulkOperation> operations, BulkWriteOptions bulkWriteOptions, Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)`
    `MongoClient` | MongoClient.`count(String collection, JsonObject query, Handler<AsyncResult<Long>> resultHandler)` Count matching documents in a collection.
    `MongoService` | MongoService.`count(String collection, JsonObject query, Handler<AsyncResult<Long>> resultHandler)`
    `MongoClient` | MongoClient.`createCollection(String collectionName, Handler<AsyncResult<Void>> resultHandler)` Create a new collection
    `MongoService` | MongoService.`createCollection(String collectionName, Handler<AsyncResult<Void>> resultHandler)`
    `MongoClient` | MongoClient.`createIndex(String collection, JsonObject key, Handler<AsyncResult<Void>> resultHandler)` Creates an index.
    `MongoService` | MongoService.`createIndex(String collection, JsonObject key, Handler<AsyncResult<Void>> resultHandler)`
    `MongoClient` | MongoClient.`createIndexWithOptions(String collection, JsonObject key, IndexOptions options, Handler<AsyncResult<Void>> resultHandler)` Creates an index.
    `MongoService` | MongoService.`createIndexWithOptions(String collection, JsonObject key, IndexOptions options, Handler<AsyncResult<Void>> resultHandler)`
    `MongoClient` | MongoClient.`distinct(String collection, String fieldName, String resultClassname, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name.
    `MongoService` | MongoService.`distinct(String collection, String fieldName, String resultClassname, Handler<AsyncResult<JsonArray>> resultHandler)`
    `MongoClient` | MongoClient.`distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, Handler<AsyncResult<JsonArray>> resultHandler)` Gets the distinct values of the specified field name filtered by specified query.
    `MongoService` | MongoService.`distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, Handler<AsyncResult<JsonArray>> resultHandler)`
    `MongoClient` | MongoClient.`dropCollection(String collection, Handler<AsyncResult<Void>> resultHandler)` Drop a collection
    `MongoService` | MongoService.`dropCollection(String collection, Handler<AsyncResult<Void>> resultHandler)`
    `MongoClient` | MongoClient.`dropIndex(String collection, String indexName, Handler<AsyncResult<Void>> resultHandler)` Drops the index given its name.
    `MongoService` | MongoService.`dropIndex(String collection, String indexName, Handler<AsyncResult<Void>> resultHandler)`
    `MongoClient` | MongoClient.`find(String collection, JsonObject query, Handler<AsyncResult<List<JsonObject>>> resultHandler)` Find matching documents in the specified collection
    `MongoService` | MongoService.`find(String collection, JsonObject query, Handler<AsyncResult<List<JsonObject>>> resultHandler)`
    `MongoClient` | MongoClient.`findOne(String collection, JsonObject query, JsonObject fields, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection
    `MongoService` | MongoService.`findOne(String collection, JsonObject query, JsonObject fields, Handler<AsyncResult<JsonObject>> resultHandler)`
    `MongoClient` | MongoClient.`findOneAndDelete(String collection, JsonObject query, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and delete it.
    `MongoService` | MongoService.`findOneAndDelete(String collection, JsonObject query, Handler<AsyncResult<JsonObject>> resultHandler)`
    `MongoClient` | MongoClient.`findOneAndDeleteWithOptions(String collection, JsonObject query, FindOptions findOptions, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and delete it.
    `MongoService` | MongoService.`findOneAndDeleteWithOptions(String collection, JsonObject query, FindOptions findOptions, Handler<AsyncResult<JsonObject>> resultHandler)`
    `MongoClient` | MongoClient.`findOneAndReplace(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and replace it.
    `MongoService` | MongoService.`findOneAndReplace(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<JsonObject>> resultHandler)`
    `MongoClient` | MongoClient.`findOneAndReplaceWithOptions(String collection, JsonObject query, JsonObject replace, FindOptions findOptions, UpdateOptions updateOptions, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and replace it.
    `MongoService` | MongoService.`findOneAndReplaceWithOptions(String collection, JsonObject query, JsonObject update, FindOptions findOptions, UpdateOptions updateOptions, Handler<AsyncResult<JsonObject>> resultHandler)`
    `MongoClient` | MongoClient.`findOneAndUpdate(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and update it.
    `MongoService` | MongoService.`findOneAndUpdate(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<JsonObject>> resultHandler)`
    `MongoClient` | MongoClient.`findOneAndUpdateWithOptions(String collection, JsonObject query, JsonObject update, FindOptions findOptions, UpdateOptions updateOptions, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection and update it.
    `MongoService` | MongoService.`findOneAndUpdateWithOptions(String collection, JsonObject query, JsonObject update, FindOptions findOptions, UpdateOptions updateOptions, Handler<AsyncResult<JsonObject>> resultHandler)`
    `MongoClient` | MongoClient.`findWithOptions(String collection, JsonObject query, FindOptions options, Handler<AsyncResult<List<JsonObject>>> resultHandler)` Find matching documents in the specified collection, specifying options
    `MongoService` | MongoService.`findWithOptions(String collection, JsonObject query, FindOptions options, Handler<AsyncResult<List<JsonObject>>> resultHandler)`
    `MongoClient` | MongoClient.`getCollections(Handler<AsyncResult<List<String>>> resultHandler)` Get a list of all collections in the database.
    `MongoService` | MongoService.`getCollections(Handler<AsyncResult<List<String>>> resultHandler)`
    `MongoClient` | MongoClient.`insert(String collection, JsonObject document, Handler<AsyncResult<String>> resultHandler)` Insert a document in the specified collection
    `MongoService` | MongoService.`insert(String collection, JsonObject document, Handler<AsyncResult<String>> resultHandler)`
    `MongoClient` | MongoClient.`insertWithOptions(String collection, JsonObject document, WriteOption writeOption, Handler<AsyncResult<String>> resultHandler)` Insert a document in the specified collection with the specified write option
    `MongoService` | MongoService.`insertWithOptions(String collection, JsonObject document, WriteOption writeOption, Handler<AsyncResult<String>> resultHandler)`
    `MongoClient` | MongoClient.`listIndexes(String collection, Handler<AsyncResult<JsonArray>> resultHandler)` Get all the indexes in this collection.
    `MongoService` | MongoService.`listIndexes(String collection, Handler<AsyncResult<JsonArray>> resultHandler)`
    `MongoClient` | MongoClient.`remove(String collection, JsonObject query, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoService` | MongoService.`remove(String collection, JsonObject query, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoClient` | MongoClient.`removeDocument(String collection, JsonObject query, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove a single matching document from a collection and return the handler with MongoClientDeleteResult result
    `MongoService` | MongoService.`removeDocument(String collection, JsonObject query, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)`
    `MongoClient` | MongoClient.`removeDocuments(String collection, JsonObject query, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove matching documents from a collection and return the handler with MongoClientDeleteResult result
    `MongoService` | MongoService.`removeDocuments(String collection, JsonObject query, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)`
    `MongoClient` | MongoClient.`removeDocumentsWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove matching documents from a collection with the specified write option and return the handler with MongoClientDeleteResult result
    `MongoService` | MongoService.`removeDocumentsWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)`
    `MongoClient` | MongoClient.`removeDocumentWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)` Remove a single matching document from a collection with the specified write option and return the handler with MongoClientDeleteResult result
    `MongoService` | MongoService.`removeDocumentWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)`
    `MongoClient` | MongoClient.`removeOne(String collection, JsonObject query, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoService` | MongoService.`removeOne(String collection, JsonObject query, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoClient` | MongoClient.`removeOneWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoService` | MongoService.`removeOneWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoClient` | MongoClient.`removeWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoService` | MongoService.`removeWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoClient` | MongoClient.`replace(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoService` | MongoService.`replace(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoClient` | MongoClient.`replaceDocuments(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Replace matching documents in the specified collection and return the handler with MongoClientUpdateResult result
    `MongoService` | MongoService.`replaceDocuments(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)`
    `MongoClient` | MongoClient.`replaceDocumentsWithOptions(String collection, JsonObject query, JsonObject replace, UpdateOptions options, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Replace matching documents in the specified collection, specifying options and return the handler with MongoClientUpdateResult result
    `MongoService` | MongoService.`replaceDocumentsWithOptions(String collection, JsonObject query, JsonObject replace, UpdateOptions options, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)`
    `MongoClient` | MongoClient.`replaceWithOptions(String collection, JsonObject query, JsonObject replace, UpdateOptions options, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoService` | MongoService.`replaceWithOptions(String collection, JsonObject query, JsonObject replace, UpdateOptions options, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoClient` | MongoClient.`runCommand(String commandName, JsonObject command, Handler<AsyncResult<JsonObject>> resultHandler)` Run an arbitrary MongoDB command.
    `MongoService` | MongoService.`runCommand(String commandName, JsonObject command, Handler<AsyncResult<JsonObject>> resultHandler)`
    `MongoClient` | MongoClient.`save(String collection, JsonObject document, Handler<AsyncResult<String>> resultHandler)` Save a document in the specified collection
    `MongoService` | MongoService.`save(String collection, JsonObject document, Handler<AsyncResult<String>> resultHandler)`
    `MongoClient` | MongoClient.`saveWithOptions(String collection, JsonObject document, WriteOption writeOption, Handler<AsyncResult<String>> resultHandler)` Save a document in the specified collection with the specified write option
    `MongoService` | MongoService.`saveWithOptions(String collection, JsonObject document, WriteOption writeOption, Handler<AsyncResult<String>> resultHandler)`
    `MongoClient` | MongoClient.`update(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoService` | MongoService.`update(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoClient` | MongoClient.`updateCollection(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Update matching documents in the specified collection and return the handler with MongoClientUpdateResult result
    `MongoService` | MongoService.`updateCollection(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)`
    `MongoClient` | MongoClient.`updateCollectionWithOptions(String collection, JsonObject query, JsonObject update, UpdateOptions options, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)` Update matching documents in the specified collection, specifying options and return the handler with MongoClientUpdateResult result
    `MongoService` | MongoService.`updateCollectionWithOptions(String collection, JsonObject query, JsonObject update, UpdateOptions options, Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)`
    `MongoClient` | MongoClient.`updateWithOptions(String collection, JsonObject query, JsonObject update, UpdateOptions options, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `MongoService` | MongoService.`updateWithOptions(String collection, JsonObject query, JsonObject update, UpdateOptions options, Handler<AsyncResult<Void>> resultHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.rxjava.ext.shell

    Methods in io.vertx.rxjava.ext.shell with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ShellServer.`close(Handler<AsyncResult<Void>> completionHandler)` Close the shell server, this is an asynchronous close.
    `ShellServer` | ShellServer.`listen(Handler<AsyncResult<Void>> listenHandler)` Start the shell service, this is an asynchronous start.
    `void` | ShellServer.`shellHandler(Handler<Shell> shellHandler)` Called when a new shell is created.
    `void` | ShellService.`start(Handler<AsyncResult<Void>> startHandler)` Start the shell service, this is an asynchronous start.
    `void` | ShellService.`stop(Handler<AsyncResult<Void>> stopHandler)` Stop the shell service, this is an asynchronous start.

  - ### Uses of Handler in io.vertx.rxjava.ext.shell.command

    Methods in io.vertx.rxjava.ext.shell.command with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `CommandProcess` | CommandProcess.`backgroundHandler(Handler<Void> handler)` Set a background handler, this handler is called when the command is running and put to background.
    `CommandBuilder` | CommandBuilder.`completionHandler(Handler<Completion> handler)` Set the command completion handler, the completion handler when the user asks for contextual command line completion, usually hitting the tab key.
    `CommandProcess` | CommandProcess.`endHandler(Handler<Void> handler)` Set an end handler, this handler is called when the command is ended, for instance the command is running and the shell closes.
    `CommandProcess` | CommandProcess.`foregroundHandler(Handler<Void> handler)` Set a foreground handler, this handler is called when the command is running and put to foreground.
    `CommandProcess` | CommandProcess.`interruptHandler(Handler<Void> handler)` Set an interrupt handler, this handler is called when the command is interrupted, for instance user press `Ctrl-C`.
    `CommandBuilder` | CommandBuilder.`processHandler(Handler<CommandProcess> handler)` Set the command process handler, the process handler is called when the command is executed.
    `CommandRegistry` | CommandRegistry.`registerCommand(Command command, Handler<AsyncResult<Command>> completionHandler)` Register a command
    `CommandRegistry` | CommandRegistry.`registerCommands(List<Command> commands, Handler<AsyncResult<List<Command>>> completionHandler)` Register a list of commands.
    `CommandProcess` | CommandProcess.`resizehandler(Handler<Void> handler)`
    `CommandProcess` | CommandProcess.`resumeHandler(Handler<Void> handler)` Set a resume handler, this handler is called when the command is resumed, for instance user types `bg` or `fg` to resume the command.
    `CommandProcess` | CommandProcess.`stdinHandler(Handler<String> handler)`
    `CommandProcess` | CommandProcess.`suspendHandler(Handler<Void> handler)` Set a suspend handler, this handler is called when the command is suspended, for instance user press `Ctrl-Z`.
    `CommandRegistry` | CommandRegistry.`unregisterCommand(String commandName, Handler<AsyncResult<Void>> completionHandler)` Unregister a command.

  - ### Uses of Handler in io.vertx.rxjava.ext.shell.system

    Methods in io.vertx.rxjava.ext.shell.system with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | JobController.`close(Handler<Void> completionHandler)` Close the controller and terminate all the underlying jobs, a closed controller does not accept anymore jobs.
    `boolean` | Process.`interrupt(Handler<Void> completionHandler)` Attempt to interrupt the process.
    `void` | Process.`resume(boolean foreground, Handler<Void> completionHandler)` Suspend the process.
    `void` | Process.`resume(Handler<Void> completionHandler)` Suspend the process.
    `Job` | Job.`statusUpdateHandler(Handler<ExecStatus> handler)` Set an handler called when the job terminates.
    `void` | Process.`suspend(Handler<Void> completionHandler)` Resume the process.
    `void` | Process.`terminate(Handler<Void> completionHandler)` Terminate the process.
    `Process` | Process.`terminatedHandler(Handler<Integer> handler)` Set an handler for being notified when the process terminates.
    `void` | Process.`toBackground(Handler<Void> completionHandler)` Set the process in background.
    `void` | Process.`toForeground(Handler<Void> completionHandler)` Set the process in foreground.

  - ### Uses of Handler in io.vertx.rxjava.ext.shell.term

    Classes in io.vertx.rxjava.ext.shell.term that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `SockJSTermHandler` NOTE: This class has been automatically generated from the `original` non RX-ified interface using Vert.x codegen.

    Methods in io.vertx.rxjava.ext.shell.term with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | TermServer.`close(Handler<AsyncResult<Void>> completionHandler)` Like `TermServer.close()` but supplying a handler that will be notified when close is complete.
    `Term` | Term.`closeHandler(Handler<Void> handler)` Set a handler that will be called when the terminal is closed.
    `TermServer` | TermServer.`listen(Handler<AsyncResult<TermServer>> listenHandler)` Bind the term server, the `TermServer.termHandler(io.vertx.core.Handler<io.vertx.rxjava.ext.shell.term.Term>)` must be set before.
    `void` | Term.`readline(String prompt, Handler<String> lineHandler)` Prompt the user a line of text.
    `void` | Term.`readline(String prompt, Handler<String> lineHandler, Handler<Completion> completionHandler)` Prompt the user a line of text, providing a completion handler to handle user's completion.
    `void` | Term.`readline(String prompt, Handler<String> lineHandler, Handler<Completion> completionHandler)` Prompt the user a line of text, providing a completion handler to handle user's completion.
    `Tty` | Tty.`resizehandler(Handler<Void> handler)` Set a resize handler, the handler is called when the tty size changes.
    `Term` | Term.`resizehandler(Handler<Void> handler)`
    `Tty` | Tty.`stdinHandler(Handler<String> handler)` Set a stream handler on the standard input to read the data.
    `Term` | Term.`stdinHandler(Handler<String> handler)`
    `Pty` | Pty.`stdoutHandler(Handler<String> handler)` Set the standard out handler of the pseudo terminal.
    `SockJSTermHandler` | SockJSTermHandler.`termHandler(Handler<Term> handler)`
    `TermServer` | TermServer.`termHandler(Handler<Term> handler)` Set the term handler that will receive incoming client connections.

  - ### Uses of Handler in io.vertx.rxjava.ext.sql

    Methods in io.vertx.rxjava.ext.sql with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `SQLConnection` | SQLConnection.`batch(List<String> sqlStatements, Handler<AsyncResult<List<Integer>>> handler)` Batch simple SQL strings and execute the batch where the async result contains a array of Integers.
    `SQLConnection` | SQLConnection.`batchCallableWithParams(String sqlStatement, List<JsonArray> inArgs, List<JsonArray> outArgs, Handler<AsyncResult<List<Integer>>> handler)` Batch a callable statement with all entries from the args list.
    `SQLConnection` | SQLConnection.`batchWithParams(String sqlStatement, List<JsonArray> args, Handler<AsyncResult<List<Integer>>> handler)` Batch a prepared statement with all entries from the args list.
    `SQLConnection` | SQLConnection.`call(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLClient` | SQLClient.`call(String sql, Handler<AsyncResult<ResultSet>> handler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLOperations` | SQLOperations.`call(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLConnection` | SQLConnection.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLClient` | SQLClient.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> handler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `SQLOperations` | SQLOperations.`callWithParams(String sql, JsonArray params, JsonArray outputs, Handler<AsyncResult<ResultSet>> resultHandler)` Calls the given SQL `PROCEDURE` which returns the result from the procedure.
    `void` | SQLRowStream.`close(Handler<AsyncResult<Void>> handler)` Closes the stream/underlying cursor(s).
    `void` | SQLConnection.`close(Handler<AsyncResult<Void>> handler)` Closes the connection.
    `void` | SQLClient.`close(Handler<AsyncResult<Void>> handler)` Close the client and release all resources.
    `SQLConnection` | SQLConnection.`commit(Handler<AsyncResult<Void>> handler)` Commits all changes made since the previous commit/rollback.
    `SQLRowStream` | SQLRowStream.`endHandler(Handler<Void> endHandler)`
    `SQLRowStream` | SQLRowStream.`exceptionHandler(Handler<Throwable> handler)`
    `SQLConnection` | SQLConnection.`execute(String sql, Handler<AsyncResult<Void>> resultHandler)` Executes the given SQL statement
    `SQLClient` | SQLClient.`getConnection(Handler<AsyncResult<SQLConnection>> handler)` Returns a connection that can be used to perform SQL operations on.
    `SQLConnection` | SQLConnection.`getTransactionIsolation(Handler<AsyncResult<TransactionIsolation>> handler)` Attempts to return the transaction isolation level for this Connection object to the one given.
    `SQLRowStream` | SQLRowStream.`handler(Handler<JsonArray> handler)`
    `void` | SQLRowStream.`pipeTo(WriteStream<JsonArray> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `SQLConnection` | SQLConnection.`query(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` statement which returns the results of the query.
    `SQLClient` | SQLClient.`query(String sql, Handler<AsyncResult<ResultSet>> handler)` Execute a single SQL statement, this method acquires a connection from the the pool and executes the SQL statement and returns it back after the execution.
    `SQLOperations` | SQLOperations.`query(String sql, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` statement which returns the results of the query.
    `SQLOperations` | SQLConnection.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | SQLClient.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | SQLOperations.`querySingle(String sql, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement that returns a single SQL row.
    `SQLOperations` | SQLConnection.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | SQLClient.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLOperations` | SQLOperations.`querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler)` Execute a one shot SQL statement with arguments that returns a single SQL row.
    `SQLConnection` | SQLConnection.`queryStream(String sql, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLClient` | SQLClient.`queryStream(String sql, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLOperations` | SQLOperations.`queryStream(String sql, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLConnection` | SQLConnection.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLClient` | SQLClient.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLOperations` | SQLOperations.`queryStreamWithParams(String sql, JsonArray params, Handler<AsyncResult<SQLRowStream>> handler)` Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.
    `SQLConnection` | SQLConnection.`queryWithParams(String sql, JsonArray params, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` prepared statement which returns the results of the query.
    `SQLClient` | SQLClient.`queryWithParams(String sql, JsonArray arguments, Handler<AsyncResult<ResultSet>> handler)` Execute a single SQL prepared statement, this method acquires a connection from the the pool and executes the SQL prepared statement and returns it back after the execution.
    `SQLOperations` | SQLOperations.`queryWithParams(String sql, JsonArray params, Handler<AsyncResult<ResultSet>> resultHandler)` Executes the given SQL `SELECT` prepared statement which returns the results of the query.
    `SQLRowStream` | SQLRowStream.`resultSetClosedHandler(Handler<Void> handler)` Event handler when a resultset is closed.
    `SQLConnection` | SQLConnection.`rollback(Handler<AsyncResult<Void>> handler)` Rolls back all changes made since the previous commit/rollback.
    `SQLConnection` | SQLConnection.`setAutoCommit(boolean autoCommit, Handler<AsyncResult<Void>> resultHandler)` Sets the auto commit flag for this connection.
    `SQLConnection` | SQLConnection.`setTransactionIsolation(TransactionIsolation isolation, Handler<AsyncResult<Void>> handler)` Attempts to change the transaction isolation level for this Connection object to the one given.
    `SQLConnection` | SQLConnection.`update(String sql, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
    `SQLClient` | SQLClient.`update(String sql, Handler<AsyncResult<UpdateResult>> handler)` Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
    `SQLOperations` | SQLOperations.`update(String sql, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.
    `SQLConnection` | SQLConnection.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
    `SQLClient` | SQLClient.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> handler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters
    `SQLOperations` | SQLOperations.`updateWithParams(String sql, JsonArray params, Handler<AsyncResult<UpdateResult>> resultHandler)` Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters

  - ### Uses of Handler in io.vertx.rxjava.ext.stomp

    Classes in io.vertx.rxjava.ext.stomp that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `StompServerHandler` STOMP server handler implements the behavior of the STOMP server when a specific event occurs.

    Methods in io.vertx.rxjava.ext.stomp that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<ServerWebSocket>` | StompServer.`webSocketHandler()` Gets the able to manage web socket connections.

    Methods in io.vertx.rxjava.ext.stomp with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `StompClientConnection` | StompClientConnection.`abort(String id, Handler<Frame> receiptHandler)` Aborts a transaction.
    `StompClientConnection` | StompClientConnection.`abort(String id, Map<String,String> headers, Handler<Frame> receiptHandler)` Aborts a transaction.
    `StompServerHandler` | StompServerHandler.`abortHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `ABORT` frame is received.
    `StompClientConnection` | StompClientConnection.`ack(String id, Handler<Frame> receiptHandler)` Sends an acknowledgement for a specific message.
    `StompClientConnection` | StompClientConnection.`ack(String id, String txId, Handler<Frame> receiptHandler)` Sends an acknowledgement for the given frame.
    `StompServerHandler` | StompServerHandler.`ackHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `ACK` frame is received.
    `StompServerHandler` | StompServerHandler.`beginHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `BEGIN` frame is received.
    `StompClientConnection` | StompClientConnection.`beginTX(String id, Handler<Frame> receiptHandler)` Begins a transaction.
    `StompClientConnection` | StompClientConnection.`beginTX(String id, Map<String,String> headers, Handler<Frame> receiptHandler)` Begins a transaction.
    `void` | StompServer.`close(Handler<AsyncResult<Void>> completionHandler)` Closes the server.
    `StompClientConnection` | StompClientConnection.`closeHandler(Handler<StompClientConnection> handler)` Sets a handler notified when the STOMP connection is closed.
    `StompServerHandler` | StompServerHandler.`closeHandler(Handler<StompServerConnection> handler)` Configures the action to execute when a connection with the client is closed.
    `StompClientConnection` | StompClientConnection.`commit(String id, Handler<Frame> receiptHandler)` Commits a transaction.
    `StompClientConnection` | StompClientConnection.`commit(String id, Map<String,String> headers, Handler<Frame> receiptHandler)` Commits a transaction.
    `StompServerHandler` | StompServerHandler.`commitHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `COMMIT` frame is received.
    `void` | StompServerConnection.`configureHeartbeat(long ping, long pong, Handler<StompServerConnection> pingHandler)` Configures the heartbeat.
    `StompClient` | StompClient.`connect(Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server using the host and port configured in the client's options.
    `StompClient` | StompClient.`connect(int port, String host, Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server.
    `StompClient` | StompClient.`connect(int port, String host, NetClient net, Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server.
    `StompClient` | StompClient.`connect(NetClient net, Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server.
    `StompServerHandler` | StompServerHandler.`connectHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `CONNECT` frame is received.
    `StompClientConnection` | StompClientConnection.`connectionDroppedHandler(Handler<StompClientConnection> handler)` Sets a handler notified when the server does not respond to a `ping` request in time.
    `StompClientConnection` | StompClientConnection.`disconnect(Frame frame, Handler<Frame> receiptHandler)` Disconnects the client.
    `StompClientConnection` | StompClientConnection.`disconnect(Handler<Frame> receiptHandler)` Disconnects the client.
    `StompServerHandler` | StompServerHandler.`disconnectHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `DISCONNECT` frame is received.
    `StompClient` | StompClient.`errorFrameHandler(Handler<Frame> handler)` A general error frame handler.
    `StompClientConnection` | StompClientConnection.`errorHandler(Handler<Frame> handler)` Sets a handler notified when an `ERROR` frame is received by the client.
    `StompClientConnection` | StompClientConnection.`exceptionHandler(Handler<Throwable> exceptionHandler)` Configures the exception handler notified upon TCP-level errors.
    `StompClient` | StompClient.`exceptionHandler(Handler<Throwable> handler)` Sets an exception handler notified for TCP-level errors.
    `StompServer` | StompServer.`listen(Handler<AsyncResult<StompServer>> handler)` Connects the STOMP server default port (61613) and network interface (`0.0.0.0`).
    `StompServer` | StompServer.`listen(int port, Handler<AsyncResult<StompServer>> handler)` Connects the STOMP server to the given port.
    `StompServer` | StompServer.`listen(int port, String host, Handler<AsyncResult<StompServer>> handler)` Connects the STOMP server to the given port / interface.
    `StompClientConnection` | StompClientConnection.`nack(String id, Handler<Frame> receiptHandler)` Sends a non-acknowledgement for the given message.
    `StompClientConnection` | StompClientConnection.`nack(String id, String txId, Handler<Frame> receiptHandler)` Sends a non-acknowledgement for the given frame.
    `StompServerHandler` | StompServerHandler.`nackHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `NACK` frame is received.
    `StompServerHandler` | StompServerHandler.`onAckHandler(Handler<Acknowledgement> handler)` Configures the action to execute when messages are acknowledged.
    `StompServerHandler` | StompServerHandler.`onAuthenticationRequest(StompServerConnection connection, String login, String passcode, Handler<AsyncResult<Boolean>> handler)` Called when the client connects to a server requiring authentication.
    `StompServerHandler` | StompServerHandler.`onNackHandler(Handler<Acknowledgement> handler)` Configures the action to execute when messages are not acknowledged.
    `StompClientConnection` | StompClientConnection.`pingHandler(Handler<StompClientConnection> handler)` Sets a handler that let customize the behavior when a ping needs to be sent to the server.
    `StompServerHandler` | StompServerHandler.`pingHandler(Handler<StompServerConnection> handler)` Allows customizing the action to do when the server needs to send a `PING` to the client.
    `StompClientConnection` | StompClientConnection.`receivedFrameHandler(Handler<Frame> handler)` Configures a received handler that get notified when a STOMP frame is received by the client.
    `StompClient` | StompClient.`receivedFrameHandler(Handler<Frame> handler)` Configures a received handler that gets notified when a STOMP frame is received by the client.
    `StompServerHandler` | StompServerHandler.`receivedFrameHandler(Handler<ServerFrame> handler)` Configures a handler that get notified when a STOMP frame is received by the server.
    `StompClientConnection` | StompClientConnection.`send(Frame frame, Handler<Frame> receiptHandler)` Sends the given frame to the server.
    `StompClientConnection` | StompClientConnection.`send(Map<String,String> headers, Buffer body, Handler<Frame> receiptHandler)` Sends a `SEND` frame to the server.
    `StompClientConnection` | StompClientConnection.`send(String destination, Buffer body, Handler<Frame> receiptHandler)` Sends a `SEND` frame to the server to the given destination.
    `StompClientConnection` | StompClientConnection.`send(String destination, Map<String,String> headers, Buffer body, Handler<Frame> receiptHandler)` Sends a `SEND` frame to the server to the given destination.
    `StompServerHandler` | StompServerHandler.`sendHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `SEND` frame is received.
    `StompServerHandler` | StompServerHandler.`stompHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `STOMP` frame is received.
    `String` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler)` Subscribes to the given destination.
    `String` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler, Handler<Frame> receiptHandler)` Subscribes to the given destination.
    `String` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler, Handler<Frame> receiptHandler)` Subscribes to the given destination.
    `String` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler)` Subscribes to the given destination.
    `String` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler, Handler<Frame> receiptHandler)` Subscribes to the given destination.
    `String` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler, Handler<Frame> receiptHandler)` Subscribes to the given destination.
    `StompServerHandler` | StompServerHandler.`subscribeHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `SUBSCRIBE` frame is received.
    `StompClientConnection` | StompClientConnection.`unsubscribe(String destination, Handler<Frame> receiptHandler)` Un-subscribes from the given destination.
    `StompClientConnection` | StompClientConnection.`unsubscribe(String destination, Map<String,String> headers, Handler<Frame> receiptHandler)` Un-subscribes from the given destination.
    `StompServerHandler` | StompServerHandler.`unsubscribeHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `UNSUBSCRIBE` frame is received.
    `StompClientConnection` | StompClientConnection.`writingFrameHandler(Handler<Frame> handler)` Configures a handler notified when a frame is going to be written on the wire.
    `StompClient` | StompClient.`writingFrameHandler(Handler<Frame> handler)` Configures a writing handler that gets notified when a STOMP frame is written on the wire.
    `StompServer` | StompServer.`writingFrameHandler(Handler<ServerFrame> handler)` Configures the handler that is invoked every time a frame is going to be written to the "wire".

  - ### Uses of Handler in io.vertx.rxjava.ext.unit

    Methods in io.vertx.rxjava.ext.unit that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure()` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure(Handler<Throwable> causeHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess()` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it completes the async operation. When the returned handler is called back with a failed result it fails the test with the cause of the failure.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess(Handler<T> resultHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it invokes the `resultHandler` argument with the async result.
    `Handler<Throwable>` | TestContext.`exceptionHandler()`

    Methods in io.vertx.rxjava.ext.unit with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `TestSuite` | TestSuite.`after(Handler<TestContext> callback)` Set a callback executed after the tests.
    `TestSuite` | TestSuite.`afterEach(Handler<TestContext> callback)` Set a callback executed after each test and before the suite `after` callback.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure(Handler<Throwable> causeHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess(Handler<T> resultHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it invokes the `resultHandler` argument with the async result.
    `TestSuite` | TestSuite.`before(Handler<TestContext> callback)` Set a callback executed before the tests.
    `TestSuite` | TestSuite.`beforeEach(Handler<TestContext> callback)` Set a callback executed before each test and after the suite `before` callback.
    `static TestCase` | TestCase.`create(String name, Handler<TestContext> testCase)` Create a test case.
    `void` | Completion.`handler(Handler<AsyncResult<T>> completionHandler)` Completion handler to receive a completion signal when this completions completes.
    `void` | Async.`handler(Handler<AsyncResult<Void>> completionHandler)` Completion handler to receive a completion signal when this completions completes.
    `void` | TestCompletion.`handler(Handler<AsyncResult<Void>> completionHandler)` Completion handler to receive a completion signal when this completions completes.
    `TestSuite` | TestSuite.`test(String name, Handler<TestContext> testCase)` Add a new test case to the suite.
    `TestSuite` | TestSuite.`test(String name, int repeat, Handler<TestContext> testCase)` Add a new test case to the suite.
    `TestContext` | TestContext.`verify(Handler<Void> block)` Execute the provided handler, which may contain assertions, possibly from any third-party assertion framework.

  - ### Uses of Handler in io.vertx.rxjava.ext.unit.collect

    Methods in io.vertx.rxjava.ext.unit.collect with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static EventBusCollector` | EventBusCollector.`create(Vertx vertx, Handler<TestSuiteReport> reporter)`

  - ### Uses of Handler in io.vertx.rxjava.ext.unit.report

    Methods in io.vertx.rxjava.ext.unit.report with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `TestCaseReport` | TestCaseReport.`endHandler(Handler<TestResult> handler)` Set a callback for completion, the specified `handler` is invoked when the test exec has completed.
    `TestSuiteReport` | TestSuiteReport.`endHandler(Handler<Void> endHandler)`
    `TestSuiteReport` | TestSuiteReport.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler, the exception handler reports the test suite errors, it can be called mulitple times before the test ends.
    `TestSuiteReport` | TestSuiteReport.`handler(Handler<TestCaseReport> handler)`
    `void` | TestSuiteReport.`pipeTo(WriteStream<TestCaseReport> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.

  - ### Uses of Handler in io.vertx.rxjava.ext.web

    Classes in io.vertx.rxjava.ext.web that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `Router` A router receives request from an `HttpServer` and routes it to the first matching `Route` that it contains.

    Methods in io.vertx.rxjava.ext.web with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `int` | RoutingContext.`addBodyEndHandler(Handler<Void> handler)` Provides a handler that will be called after the last part of the body is written to the wire.
    `int` | RoutingContext.`addHeadersEndHandler(Handler<Void> handler)` Add a handler that will be called just before headers are written to the response.
    `Route` | Route.`blockingHandler(Handler<RoutingContext> requestHandler)` Like `Route.blockingHandler(io.vertx.core.Handler<io.vertx.rxjava.ext.web.RoutingContext>)` called with ordered = true
    `Route` | Route.`blockingHandler(Handler<RoutingContext> requestHandler, boolean ordered)` Specify a blocking request handler for the route.
    `Router` | Router.`errorHandler(int statusCode, Handler<RoutingContext> errorHandler)` Specify an handler to handle an error for a particular status code.
    `Router` | Router.`exceptionHandler(Handler<Throwable> exceptionHandler)` Deprecated.
    `Route` | Route.`failureHandler(Handler<RoutingContext> failureHandler)` Append a failure handler to the route failure handlers list.
    `Route` | Route.`handler(Handler<RoutingContext> requestHandler)` Append a request handler to the route handlers list.
    `Router` | Router.`modifiedHandler(Handler<Router> handler)` When a Router routes are changed this handler is notified.

  - ### Uses of Handler in io.vertx.rxjava.ext.web.api.contract

    Subinterfaces of Handler in io.vertx.rxjava.ext.web.api.contract
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `HTTPOperationRequestValidationHandler` Base interface for HTTP request validation with API specification NOTE: This class has been automatically generated from the `original` non RX-ified interface using Vert.x codegen.

    Methods in io.vertx.rxjava.ext.web.api.contract that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<RoutingContext>` | RouterFactory.`getValidationFailureHandler()` Deprecated.

    Methods in io.vertx.rxjava.ext.web.api.contract with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `RouterFactory` | RouterFactory.`addGlobalHandler(Handler<RoutingContext> globalHandler)` Add global handler to be applied prior to `Router` being generated.
    `RouterFactory` | RouterFactory.`addSecurityHandler(String securitySchemaName, Handler<RoutingContext> handler)` Mount to paths that have to follow a security schema a security handler
    `RouterFactory` | RouterFactory.`setNotImplementedFailureHandler(Handler<RoutingContext> notImplementedFailureHandler)` Deprecated.
    `RouterFactory` | RouterFactory.`setValidationFailureHandler(Handler<RoutingContext> validationFailureHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.rxjava.ext.web.api.contract.openapi3

    Classes in io.vertx.rxjava.ext.web.api.contract.openapi3 that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `OpenAPI3RequestValidationHandler` NOTE: This class has been automatically generated from the `original` non RX-ified interface using Vert.x codegen.

    Methods in io.vertx.rxjava.ext.web.api.contract.openapi3 that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<RoutingContext>` | OpenAPI3RouterFactory.`getValidationFailureHandler()` Deprecated.

    Methods in io.vertx.rxjava.ext.web.api.contract.openapi3 with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `OpenAPI3RouterFactory` | OpenAPI3RouterFactory.`addFailureHandlerByOperationId(String operationId, Handler<RoutingContext> failureHandler)` Add a failure handler by operation_id field in Operation object
    `RouterFactory` | OpenAPI3RouterFactory.`addGlobalHandler(Handler<RoutingContext> globalHandler)` Add global handler to be applied prior to `Router` being generated.
    `OpenAPI3RouterFactory` | OpenAPI3RouterFactory.`addHandlerByOperationId(String operationId, Handler<RoutingContext> handler)` Add an handler by operation_id field in Operation object
    `RouterFactory` | OpenAPI3RouterFactory.`addSecurityHandler(String securitySchemaName, Handler<RoutingContext> handler)` Mount to paths that have to follow a security schema a security handler
    `OpenAPI3RouterFactory` | OpenAPI3RouterFactory.`addSecuritySchemaScopeValidator(String securitySchemaName, String scopeName, Handler<RoutingContext> handler)` Add a particular scope validator.
    `static void` | OpenAPI3RouterFactory.`create(Vertx vertx, String url, Handler<AsyncResult<OpenAPI3RouterFactory>> handler)` Create a new OpenAPI3RouterFactory
    `static void` | OpenAPI3RouterFactory.`create(Vertx vertx, String url, List<JsonObject> auth, Handler<AsyncResult<OpenAPI3RouterFactory>> handler)` Create a new OpenAPI3RouterFactory
    `RouterFactory` | OpenAPI3RouterFactory.`setNotImplementedFailureHandler(Handler<RoutingContext> notImplementedFailureHandler)` Deprecated.
    `RouterFactory` | OpenAPI3RouterFactory.`setValidationFailureHandler(Handler<RoutingContext> validationFailureHandler)` Deprecated.

  - ### Uses of Handler in io.vertx.rxjava.ext.web.api.validation

    Classes in io.vertx.rxjava.ext.web.api.validation that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `HTTPRequestValidationHandler` An interface for add HTTP Request validation.

  - ### Uses of Handler in io.vertx.rxjava.ext.web.client

    Methods in io.vertx.rxjava.ext.web.client with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | HttpRequest.`send(Handler<AsyncResult<HttpResponse<T>>> handler)` Send a request, the `handler` will receive the response as an `HttpResponse`.
    `void` | HttpRequest.`sendBuffer(Buffer body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` buffer.
    `void` | HttpRequest.`sendForm(MultiMap body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` multimap encoded as form and the content type set to `application/x-www-form-urlencoded`.
    `void` | HttpRequest.`sendJson(Object body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
    `void` | HttpRequest.`sendJsonObject(JsonObject body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
    `void` | HttpRequest.`sendMultipartForm(MultipartForm body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` multimap encoded as form and the content type set to `multipart/form-data`.
    `void` | HttpRequest.`sendStream(Observable<Buffer> body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
    `void` | HttpRequest.`sendStream(ReadStream<Buffer> body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.

  - ### Uses of Handler in io.vertx.rxjava.ext.web.common.template

    Methods in io.vertx.rxjava.ext.web.common.template with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | TemplateEngine.`render(JsonObject context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Render the template.
    `void` | TemplateEngine.`render(Map<String,Object> context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Render the template.

  - ### Uses of Handler in io.vertx.rxjava.ext.web.handler

    Classes in io.vertx.rxjava.ext.web.handler that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `BasicAuthHandler` An auth handler that provides HTTP Basic Authentication support.
    `class` | `BodyHandler` A handler which gathers the entire request body and sets it on the .
    `class` | `ChainAuthHandler` An auth handler that chains to a sequence of handlers.
    `class` | `CookieHandler` A handler which decodes cookies from the request, makes them available in the and writes them back in the response.
    `class` | `CorsHandler` A handler which implements server side http://www.w3.org/TR/cors/[CORS] support for Vert.x-Web.
    `class` | `CSRFHandler` This handler adds a CSRF token to requests which mutate state.
    `class` | `DigestAuthHandler` An auth handler that provides HTTP Basic Authentication support.
    `class` | `ErrorHandler` A pretty error handler for rendering error pages.
    `class` | `FaviconHandler` A handler that serves favicons.
    `class` | `FormLoginHandler` Handler that handles login from a form on a custom login page.
    `class` | `JWTAuthHandler` An auth handler that provides JWT Authentication support.
    `class` | `LoggerHandler` A handler which logs request information to the Vert.x logger.
    `class` | `MultiTenantHandler` A handler which selectively executes another handler if a precondition is met.
    `class` | `OAuth2AuthHandler` An auth handler that provides OAuth2 Authentication support.
    `class` | `RedirectAuthHandler` An auth handler that's used to handle auth by redirecting user to a custom login page.
    `class` | `ResponseContentTypeHandler` A handler which sets the response content type automatically according to the best `Accept` header match.
    `class` | `ResponseTimeHandler` Handler which adds a header `x-response-time` in the response of matching requests containing the time taken in ms to process the request.
    `class` | `SessionHandler` A handler that maintains a `Session` for each browser session.
    `class` | `StaticHandler` A handler for serving static resources from the file system or classpath.
    `class` | `TemplateHandler` A handler which renders responses using a template engine and where the template name is selected from the URI path.
    `class` | `TimeoutHandler` Handler that will timeout requests if the response has not been written after a certain time.
    `class` | `UserSessionHandler` This handler should be used if you want to store the User object in the Session so it's available between different requests, without you having re-authenticate each time.
    `class` | `VirtualHostHandler` Handler that will filter requests based on the request Host name.

    Methods in io.vertx.rxjava.ext.web.handler with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MultiTenantHandler` | MultiTenantHandler.`addDefaultHandler(Handler<RoutingContext> handler)` Add a default handler for the case when no tenant was matched.
    `MultiTenantHandler` | MultiTenantHandler.`addTenantHandler(String tenant, Handler<RoutingContext> handler)` Add a handler for a given tenant to this handler.
    `void` | AuthHandler.`authorize(User user, Handler<AsyncResult<Void>> handler)` Authorizes the given user against all added authorities.
    `void` | BasicAuthHandler.`authorize(User user, Handler<AsyncResult<Void>> handler)` Authorizes the given user against all added authorities.
    `void` | DigestAuthHandler.`authorize(User user, Handler<AsyncResult<Void>> handler)` Authorizes the given user against all added authorities.
    `void` | JWTAuthHandler.`authorize(User user, Handler<AsyncResult<Void>> handler)` Authorizes the given user against all added authorities.
    `void` | RedirectAuthHandler.`authorize(User user, Handler<AsyncResult<Void>> handler)` Authorizes the given user against all added authorities.
    `void` | ChainAuthHandler.`authorize(User user, Handler<AsyncResult<Void>> handler)` Authorizes the given user against all added authorities.
    `void` | OAuth2AuthHandler.`authorize(User user, Handler<AsyncResult<Void>> handler)` Authorizes the given user against all added authorities.
    `static VirtualHostHandler` | VirtualHostHandler.`create(String hostname, Handler<RoutingContext> handler)` Create a handler
    `void` | AuthHandler.`parseCredentials(RoutingContext context, Handler<AsyncResult<JsonObject>> handler)` Parses the credentials from the request into a JsonObject.
    `void` | BasicAuthHandler.`parseCredentials(RoutingContext context, Handler<AsyncResult<JsonObject>> handler)` Parses the credentials from the request into a JsonObject.
    `void` | DigestAuthHandler.`parseCredentials(RoutingContext context, Handler<AsyncResult<JsonObject>> handler)` Parses the credentials from the request into a JsonObject.
    `void` | JWTAuthHandler.`parseCredentials(RoutingContext context, Handler<AsyncResult<JsonObject>> handler)` Parses the credentials from the request into a JsonObject.
    `void` | RedirectAuthHandler.`parseCredentials(RoutingContext context, Handler<AsyncResult<JsonObject>> handler)` Parses the credentials from the request into a JsonObject.
    `void` | ChainAuthHandler.`parseCredentials(RoutingContext context, Handler<AsyncResult<JsonObject>> handler)` Parses the credentials from the request into a JsonObject.
    `void` | OAuth2AuthHandler.`parseCredentials(RoutingContext context, Handler<AsyncResult<JsonObject>> handler)` Parses the credentials from the request into a JsonObject.

  - ### Uses of Handler in io.vertx.rxjava.ext.web.handler.graphql

    Classes in io.vertx.rxjava.ext.web.handler.graphql that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ApolloWSHandler` A handler for GraphQL requests sent over Apollo's `subscriptions-transport-ws` transport.
    `class` | `GraphiQLHandler` A `Route` handler for GraphiQL resources.
    `class` | `GraphQLHandler` A `Route` handler for GraphQL requests.

    Methods in io.vertx.rxjava.ext.web.handler.graphql with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `ApolloWSHandler` | ApolloWSHandler.`connectionHandler(Handler<ServerWebSocket> connectionHandler)` Customize the connection .
    `ApolloWSHandler` | ApolloWSHandler.`endHandler(Handler<ServerWebSocket> endHandler)` Customize the end .
    `ApolloWSHandler` | ApolloWSHandler.`messageHandler(Handler<ApolloWSMessage> messageHandler)` Customize the message .

  - ### Uses of Handler in io.vertx.rxjava.ext.web.handler.sockjs

    Classes in io.vertx.rxjava.ext.web.handler.sockjs that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `SockJSHandler` A handler that allows you to handle SockJS connections from clients.

    Methods in io.vertx.rxjava.ext.web.handler.sockjs with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `Router` | SockJSHandler.`bridge(BridgeOptions bridgeOptions, Handler<BridgeEvent> bridgeEventHandler)` Like `SockJSHandler.bridge(io.vertx.ext.web.handler.sockjs.BridgeOptions)` but specifying a handler that will receive bridge events.
    `SockJSSocket` | SockJSSocket.`drainHandler(Handler<Void> handler)`
    `void` | SockJSSocket.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | SockJSSocket.`end(Handler<AsyncResult<Void>> handler)` Same as `SockJSSocket.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `SockJSSocket` | SockJSSocket.`endHandler(Handler<Void> endHandler)`
    `SockJSSocket` | SockJSSocket.`exceptionHandler(Handler<Throwable> handler)`
    `SockJSSocket` | SockJSSocket.`handler(Handler<Buffer> handler)`
    `void` | SockJSSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `Router` | SockJSHandler.`socketHandler(Handler<SockJSSocket> handler)` Set a SockJS socket handler.
    `SockJSSocket` | SockJSSocket.`write(Buffer data, Handler<AsyncResult<Void>> handler)`
    `SockJSSocket` | SockJSSocket.`write(String data, Handler<AsyncResult<Void>> handler)`

  - ### Uses of Handler in io.vertx.rxjava.ext.web.sstore

    Methods in io.vertx.rxjava.ext.web.sstore with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | SessionStore.`clear(Handler<AsyncResult<Void>> resultHandler)` Remove all sessions from the store.
    `void` | SessionStore.`delete(String id, Handler<AsyncResult<Void>> resultHandler)` Delete the session with the specified ID.
    `void` | SessionStore.`get(String cookieValue, Handler<AsyncResult<Session>> resultHandler)` Get the session with the specified ID.
    `void` | SessionStore.`put(Session session, Handler<AsyncResult<Void>> resultHandler)` Add a session with the specified ID.
    `void` | SessionStore.`size(Handler<AsyncResult<Integer>> resultHandler)` Get the number of sessions in the store.

  - ### Uses of Handler in io.vertx.rxjava.ext.web.templ

    Methods in io.vertx.rxjava.ext.web.templ with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | TemplateEngine.`render(RoutingContext context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Deprecated.
    `void` | TemplateEngine.`render(RoutingContext context, String templateDirectory, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Deprecated.

  - ### Uses of Handler in io.vertx.rxjava.kafka.admin

    Methods in io.vertx.rxjava.kafka.admin with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | KafkaAdminClient.`close(Handler<AsyncResult<Void>> completionHandler)` Close the admin client
    `void` | KafkaAdminClient.`close(long timeout, Handler<AsyncResult<Void>> completionHandler)` Close the admin client
    `void` | KafkaAdminClient.`createTopics(List<NewTopic> topics, Handler<AsyncResult<Void>> completionHandler)` Creates a batch of new Kafka topics
    `void` | KafkaAdminClient.`deleteTopics(List<String> topicNames, Handler<AsyncResult<Void>> completionHandler)` Deletes a batch of Kafka topics
    `void` | KafkaAdminClient.`listConsumerGroups(Handler<AsyncResult<List<ConsumerGroupListing>>> completionHandler)` Get the the consumer groups available in the cluster with the default options
    `void` | KafkaAdminClient.`listTopics(Handler<AsyncResult<Set<String>>> completionHandler)` List the topics available in the cluster with the default options.

  - ### Uses of Handler in io.vertx.rxjava.kafka.client.consumer

    Methods in io.vertx.rxjava.kafka.client.consumer with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `KafkaConsumer<K,V>` | KafkaConsumer.`assign(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Manually assign a list of partition to this consumer.
    `KafkaConsumer<K,V>` | KafkaConsumer.`assign(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Manually assign a partition to this consumer.
    `KafkaConsumer<K,V>` | KafkaConsumer.`assignment(Handler<AsyncResult<Set<TopicPartition>>> handler)` Get the set of partitions currently assigned to this consumer.
    `KafkaConsumer<K,V>` | KafkaConsumer.`batchHandler(Handler<KafkaConsumerRecords<K,V>> handler)` Set the handler to be used when batches of messages are fetched from the Kafka server.
    `void` | KafkaConsumer.`beginningOffsets(TopicPartition topicPartition, Handler<AsyncResult<Long>> handler)` Get the first offset for the given partitions.
    `void` | KafkaConsumer.`close(Handler<AsyncResult<Void>> completionHandler)` Close the consumer
    `void` | KafkaConsumer.`commit(Handler<AsyncResult<Void>> completionHandler)` Commit current offsets for all the subscribed list of topics and partition.
    `void` | KafkaConsumer.`committed(TopicPartition topicPartition, Handler<AsyncResult<OffsetAndMetadata>> handler)` Get the last committed offset for the given partition (whether the commit happened by this process or another).
    `KafkaConsumer<K,V>` | KafkaConsumer.`endHandler(Handler<Void> endHandler)`
    `void` | KafkaConsumer.`endOffsets(TopicPartition topicPartition, Handler<AsyncResult<Long>> handler)` Get the last offset for the given partition.
    `KafkaConsumer<K,V>` | KafkaConsumer.`exceptionHandler(Handler<Throwable> handler)`
    `KafkaConsumer<K,V>` | KafkaConsumer.`handler(Handler<KafkaConsumerRecord<K,V>> handler)`
    `void` | KafkaConsumer.`offsetsForTimes(TopicPartition topicPartition, Long timestamp, Handler<AsyncResult<OffsetAndTimestamp>> handler)` Look up the offset for the given partition by timestamp.
    `KafkaConsumer<K,V>` | KafkaConsumer.`partitionsAssignedHandler(Handler<Set<TopicPartition>> handler)` Set the handler called when topic partitions are assigned to the consumer
    `KafkaConsumer<K,V>` | KafkaConsumer.`partitionsFor(String topic, Handler<AsyncResult<List<PartitionInfo>>> handler)` Get metadata about the partitions for a given topic.
    `KafkaConsumer<K,V>` | KafkaConsumer.`partitionsRevokedHandler(Handler<Set<TopicPartition>> handler)` Set the handler called when topic partitions are revoked to the consumer
    `KafkaConsumer<K,V>` | KafkaConsumer.`pause(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Suspend fetching from the requested partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`pause(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Suspend fetching from the requested partition.
    `void` | KafkaConsumer.`paused(Handler<AsyncResult<Set<TopicPartition>>> handler)` Get the set of partitions that were previously paused by a call to pause(Set).
    `void` | KafkaConsumer.`pipeTo(WriteStream<KafkaConsumerRecord<K,V>> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | KafkaConsumer.`poll(long timeout, Handler<AsyncResult<KafkaConsumerRecords<K,V>>> handler)` Executes a poll for getting messages from Kafka
    `void` | KafkaConsumer.`position(TopicPartition partition, Handler<AsyncResult<Long>> handler)` Get the offset of the next record that will be fetched (if a record with that offset exists).
    `KafkaConsumer<K,V>` | KafkaConsumer.`resume(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Resume specified partitions which have been paused with pause.
    `KafkaConsumer<K,V>` | KafkaConsumer.`resume(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Resume specified partition which have been paused with pause.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seek(TopicPartition topicPartition, long offset, Handler<AsyncResult<Void>> completionHandler)` Overrides the fetch offsets that the consumer will use on the next poll.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seekToBeginning(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Seek to the first offset for each of the given partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seekToBeginning(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Seek to the first offset for each of the given partition.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seekToEnd(Set<TopicPartition> topicPartitions, Handler<AsyncResult<Void>> completionHandler)` Seek to the last offset for each of the given partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`seekToEnd(TopicPartition topicPartition, Handler<AsyncResult<Void>> completionHandler)` Seek to the last offset for each of the given partition.
    `KafkaConsumer<K,V>` | KafkaConsumer.`subscribe(Set<String> topics, Handler<AsyncResult<Void>> completionHandler)` Subscribe to the given list of topics to get dynamically assigned partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`subscribe(String topic, Handler<AsyncResult<Void>> completionHandler)` Subscribe to the given topic to get dynamically assigned partitions.
    `KafkaConsumer<K,V>` | KafkaConsumer.`subscription(Handler<AsyncResult<Set<String>>> handler)` Get the current subscription.
    `KafkaConsumer<K,V>` | KafkaConsumer.`unsubscribe(Handler<AsyncResult<Void>> completionHandler)` Unsubscribe from topics currently subscribed with subscribe.

  - ### Uses of Handler in io.vertx.rxjava.kafka.client.producer

    Methods in io.vertx.rxjava.kafka.client.producer with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | KafkaProducer.`close(Handler<AsyncResult<Void>> completionHandler)` Close the producer
    `void` | KafkaProducer.`close(long timeout, Handler<AsyncResult<Void>> completionHandler)` Close the producer
    `KafkaProducer<K,V>` | KafkaProducer.`drainHandler(Handler<Void> handler)`
    `void` | KafkaProducer.`end(Handler<AsyncResult<Void>> handler)` Same as `WriteStream.end()` but with an `handler` called when the operation completes
    `void` | KafkaProducer.`end(KafkaProducerRecord<K,V> data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `KafkaProducer<K,V>` | KafkaProducer.`exceptionHandler(Handler<Throwable> handler)`
    `KafkaProducer<K,V>` | KafkaProducer.`flush(Handler<Void> completionHandler)` Invoking this method makes all buffered records immediately available to write
    `KafkaProducer<K,V>` | KafkaProducer.`partitionsFor(String topic, Handler<AsyncResult<List<PartitionInfo>>> handler)` Get the partition metadata for the give topic.
    `KafkaProducer<K,V>` | KafkaProducer.`send(KafkaProducerRecord<K,V> record, Handler<AsyncResult<RecordMetadata>> handler)` Asynchronously write a record to a topic
    `KafkaProducer<K,V>` | KafkaProducer.`write(KafkaProducerRecord<K,V> data, Handler<AsyncResult<Void>> handler)`

  - ### Uses of Handler in io.vertx.rxjava.micrometer

    Methods in io.vertx.rxjava.micrometer that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `static Handler<RoutingContext>` | PrometheusScrapingHandler.`create()` Creates a Vert.x Web `Route` handler for Prometheus metrics scraping.
    `static Handler<RoutingContext>` | PrometheusScrapingHandler.`create(String registryName)` Creates a Vert.x Web `Route` handler for Prometheus metrics scraping.

  - ### Uses of Handler in io.vertx.rxjava.mqtt

    Methods in io.vertx.rxjava.mqtt with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | MqttServer.`close(Handler<AsyncResult<Void>> completionHandler)` Close the server supplying an handler that will be called when the server is actually closed (or has failed).
    `MqttClient` | MqttClient.`closeHandler(Handler<Void> closeHandler)` Set a handler that will be called when the connection with server is closed
    `MqttEndpoint` | MqttEndpoint.`closeHandler(Handler<Void> handler)` Set a close handler.
    `MqttClient` | MqttClient.`connect(int port, String host, Handler<AsyncResult<MqttConnAckMessage>> connectHandler)` Connects to an MQTT server calling connectHandler after connection
    `MqttClient` | MqttClient.`connect(int port, String host, String serverName, Handler<AsyncResult<MqttConnAckMessage>> connectHandler)` Connects to an MQTT server calling connectHandler after connection
    `MqttClient` | MqttClient.`disconnect(Handler<AsyncResult<Void>> disconnectHandler)` Disconnects from the MQTT server calling disconnectHandler after disconnection
    `MqttEndpoint` | MqttEndpoint.`disconnectHandler(Handler<Void> handler)` Set a disconnect handler on the MQTT endpoint.
    `MqttServer` | MqttServer.`endpointHandler(Handler<MqttEndpoint> handler)` Set the endpoint handler for the server.
    `MqttClient` | MqttClient.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler for the client, that will be called when an error happens in internal netty structures.
    `MqttEndpoint` | MqttEndpoint.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler.
    `MqttServer` | MqttServer.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler for the server, that will be called when an error happens independantly of an accepted `MqttEndpoint`, like a rejected connection
    `MqttServer` | MqttServer.`listen(Handler<AsyncResult<MqttServer>> listenHandler)` Start the server listening for incoming connections using the specified options through the constructor
    `MqttServer` | MqttServer.`listen(int port, Handler<AsyncResult<MqttServer>> listenHandler)` Start the server listening for incoming connections on the port specified but on "0.0.0.0" as host.
    `MqttServer` | MqttServer.`listen(int port, String host, Handler<AsyncResult<MqttServer>> listenHandler)` Start the server listening for incoming connections on the port and host specified It ignores any options specified through the constructor
    `MqttEndpoint` | MqttEndpoint.`pingHandler(Handler<Void> handler)` Set the pingreq handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`pingResponseHandler(Handler<Void> pingResponseHandler)` Sets handler which will be called after PINGRESP packet receiving
    `MqttClient` | MqttClient.`publish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server
    `MqttEndpoint` | MqttEndpoint.`publish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server
    `MqttEndpoint` | MqttEndpoint.`publish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
    `MqttEndpoint` | MqttEndpoint.`publishAcknowledgeHandler(Handler<Integer> handler)` Set the puback handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`publishCompletionHandler(Handler<Integer> publishCompletionHandler)` Sets handler which will be called each time publish is completed
    `MqttEndpoint` | MqttEndpoint.`publishCompletionHandler(Handler<Integer> handler)` Set the pubcomp handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`publishHandler(Handler<MqttPublishMessage> publishHandler)` Sets handler which will be called each time server publish something to client
    `MqttEndpoint` | MqttEndpoint.`publishHandler(Handler<MqttPublishMessage> handler)` Set the publish handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishReceivedHandler(Handler<Integer> handler)` Set the pubrec handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishReleaseHandler(Handler<Integer> handler)` Set the pubrel handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`subscribe(Map<String,Integer> topics, Handler<AsyncResult<Integer>> subscribeSentHandler)` Subscribes to the topic and adds a handler which will be called after the request is sent
    `MqttClient` | MqttClient.`subscribe(String topic, int qos, Handler<AsyncResult<Integer>> subscribeSentHandler)` Subscribes to the topic with a specified QoS level
    `MqttClient` | MqttClient.`subscribeCompletionHandler(Handler<MqttSubAckMessage> subscribeCompletionHandler)` Sets handler which will be called after SUBACK packet receiving
    `MqttEndpoint` | MqttEndpoint.`subscribeHandler(Handler<MqttSubscribeMessage> handler)` Set a subscribe handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`unsubscribe(String topic, Handler<AsyncResult<Integer>> unsubscribeSentHandler)` Unsubscribe from receiving messages on given topic
    `MqttClient` | MqttClient.`unsubscribeCompletionHandler(Handler<Integer> unsubscribeCompletionHandler)` Sets handler which will be called after UNSUBACK packet receiving
    `MqttEndpoint` | MqttEndpoint.`unsubscribeHandler(Handler<MqttUnsubscribeMessage> handler)` Set a unsubscribe handler on the MQTT endpoint.

  - ### Uses of Handler in io.vertx.rxjava.mysqlclient

    Methods in io.vertx.rxjava.mysqlclient with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MySQLConnection` | MySQLConnection.`changeUser(MySQLAuthOptions options, Handler<AsyncResult<Void>> handler)` Send a CHANGE_USER command to change the user of the current connection, this operation will also reset connection state.
    `MySQLConnection` | MySQLConnection.`closeHandler(Handler<Void> handler)`
    `static void` | MySQLConnection.`connect(Vertx vertx, MySQLConnectOptions connectOptions, Handler<AsyncResult<MySQLConnection>> handler)` Create a connection to MySQL server with the given `connectOptions`.
    `static void` | MySQLConnection.`connect(Vertx vertx, String connectionUri, Handler<AsyncResult<MySQLConnection>> handler)` Like `MySQLConnection.connect(io.vertx.rxjava.core.Vertx, io.vertx.mysqlclient.MySQLConnectOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.mysqlclient.MySQLConnection>>)` with options build from `connectionUri`.
    `MySQLConnection` | MySQLConnection.`debug(Handler<AsyncResult<Void>> handler)` Send a DEBUG command to dump debug information to the server's stdout.
    `MySQLConnection` | MySQLConnection.`exceptionHandler(Handler<Throwable> handler)`
    `MySQLConnection` | MySQLConnection.`getInternalStatistics(Handler<AsyncResult<String>> handler)` Send a STATISTICS command to get a human readable string of the server internal status.
    `MySQLConnection` | MySQLConnection.`ping(Handler<AsyncResult<Void>> handler)` Send a PING command to check if the server is alive.
    `MySQLConnection` | MySQLConnection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)`
    `MySQLConnection` | MySQLConnection.`resetConnection(Handler<AsyncResult<Void>> handler)` Send a RESET_CONNECTION command to reset the session state.
    `MySQLConnection` | MySQLConnection.`setOption(MySQLSetOption option, Handler<AsyncResult<Void>> handler)` Send a SET_OPTION command to set options for the current connection.
    `MySQLConnection` | MySQLConnection.`specifySchema(String schemaName, Handler<AsyncResult<Void>> handler)` Send a INIT_DB command to change the default schema of the connection.

  - ### Uses of Handler in io.vertx.rxjava.pgclient

    Methods in io.vertx.rxjava.pgclient with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `PgConnection` | PgConnection.`cancelRequest(Handler<AsyncResult<Void>> handler)` Send a request cancellation message to tell the server to cancel processing request in this connection.
    `PgConnection` | PgConnection.`closeHandler(Handler<Void> handler)`
    `static void` | PgConnection.`connect(Vertx vertx, Handler<AsyncResult<PgConnection>> handler)` Like `PgConnection.connect(io.vertx.rxjava.core.Vertx, io.vertx.pgclient.PgConnectOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.pgclient.PgConnection>>)` with options build from the environment variables.
    `static void` | PgConnection.`connect(Vertx vertx, PgConnectOptions options, Handler<AsyncResult<PgConnection>> handler)` Connects to the database and returns the connection if that succeeds.
    `static void` | PgConnection.`connect(Vertx vertx, String connectionUri, Handler<AsyncResult<PgConnection>> handler)` Like `PgConnection.connect(io.vertx.rxjava.core.Vertx, io.vertx.pgclient.PgConnectOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.pgclient.PgConnection>>)` with options build from `connectionUri`.
    `PgConnection` | PgConnection.`exceptionHandler(Handler<Throwable> handler)`
    `PgConnection` | PgConnection.`notificationHandler(Handler<PgNotification> handler)` Set an handler called when the connection receives notification on a channel.
    `PgConnection` | PgConnection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)`

  - ### Uses of Handler in io.vertx.rxjava.pgclient.pubsub

    Methods in io.vertx.rxjava.pgclient.pubsub with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `PgSubscriber` | PgSubscriber.`closeHandler(Handler<Void> handler)` Set an handler called when the subscriber is closed.
    `PgSubscriber` | PgSubscriber.`connect(Handler<AsyncResult<Void>> handler)` Connect the subscriber to Postgres.
    `PgChannel` | PgChannel.`endHandler(Handler<Void> endHandler)` Set an handler to be called when no more notifications will be received.
    `PgChannel` | PgChannel.`exceptionHandler(Handler<Throwable> handler)`
    `PgChannel` | PgChannel.`handler(Handler<String> handler)` Set or unset an handler to be called when a the channel is notified by Postgres.
    `void` | PgChannel.`pipeTo(WriteStream<String> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `PgChannel` | PgChannel.`subscribeHandler(Handler<Void> handler)` Set an handler called when the the channel get subscribed.

  - ### Uses of Handler in io.vertx.rxjava.rabbitmq

    Methods in io.vertx.rxjava.rabbitmq with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | RabbitMQClient.`basicAck(long deliveryTag, boolean multiple, Handler<AsyncResult<JsonObject>> resultHandler)` Acknowledge one or several received messages.
    `void` | RabbitMQClient.`basicCancel(String consumerTag, Handler<AsyncResult<Void>> resultHandler)` Deprecated.
    `void` | RabbitMQClient.`basicConsume(String queue, String address, boolean autoAck, Handler<AsyncResult<String>> resultHandler)` Deprecated.
    `void` | RabbitMQClient.`basicConsume(String queue, String address, boolean autoAck, Handler<AsyncResult<String>> resultHandler, Handler<Throwable> errorHandler)` Deprecated.
    `void` | RabbitMQClient.`basicConsume(String queue, String address, boolean autoAck, Handler<AsyncResult<String>> resultHandler, Handler<Throwable> errorHandler)` Deprecated.
    `void` | RabbitMQClient.`basicConsume(String queue, String address, Handler<AsyncResult<String>> resultHandler)` Deprecated.
    `void` | RabbitMQClient.`basicConsumer(String queue, Handler<AsyncResult<RabbitMQConsumer>> resultHandler)`
    `void` | RabbitMQClient.`basicConsumer(String queue, QueueOptions options, Handler<AsyncResult<RabbitMQConsumer>> resultHandler)` Create a consumer with the given `options`.
    `void` | RabbitMQClient.`basicGet(String queue, boolean autoAck, Handler<AsyncResult<JsonObject>> resultHandler)` Retrieve a message from a queue using AMQP.Basic.Get
    `void` | RabbitMQClient.`basicNack(long deliveryTag, boolean multiple, boolean requeue, Handler<AsyncResult<JsonObject>> resultHandler)` Reject one or several received messages.
    `void` | RabbitMQClient.`basicPublish(String exchange, String routingKey, JsonObject message, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `void` | RabbitMQClient.`basicQos(int prefetchCount, boolean global, Handler<AsyncResult<Void>> resultHandler)` Request a specific prefetchCount "quality of service" settings for this channel.
    `void` | RabbitMQClient.`basicQos(int prefetchCount, Handler<AsyncResult<Void>> resultHandler)` Request a specific prefetchCount "quality of service" settings for this channel.
    `void` | RabbitMQClient.`basicQos(int prefetchSize, int prefetchCount, boolean global, Handler<AsyncResult<Void>> resultHandler)` Request specific "quality of service" settings.
    `void` | RabbitMQConsumer.`cancel(Handler<AsyncResult<Void>> cancelResult)` Stop message consumption from a queue.
    `void` | RabbitMQClient.`confirmSelect(Handler<AsyncResult<Void>> resultHandler)` Enables publisher acknowledgements on this channel.
    `RabbitMQConsumer` | RabbitMQConsumer.`endHandler(Handler<Void> endHandler)` Set an end handler.
    `RabbitMQConsumer` | RabbitMQConsumer.`exceptionHandler(Handler<Throwable> exceptionHandler)` Set an exception handler on the read stream.
    `void` | RabbitMQClient.`exchangeBind(String destination, String source, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Bind an exchange to an exchange.
    `void` | RabbitMQClient.`exchangeBind(String destination, String source, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Bind an exchange to an exchange.
    `void` | RabbitMQClient.`exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, Handler<AsyncResult<Void>> resultHandler)` Declare an exchange.
    `void` | RabbitMQClient.`exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, JsonObject config, Handler<AsyncResult<Void>> resultHandler)` Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
    `void` | RabbitMQClient.`exchangeDelete(String exchange, Handler<AsyncResult<Void>> resultHandler)` Delete an exchange, without regard for whether it is in use or not.
    `void` | RabbitMQClient.`exchangeUnbind(String destination, String source, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Unbind an exchange from an exchange.
    `void` | RabbitMQClient.`exchangeUnbind(String destination, String source, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Unbind an exchange from an exchange.
    `RabbitMQConsumer` | RabbitMQConsumer.`handler(Handler<RabbitMQMessage> messageArrived)` Set a message handler.
    `void` | RabbitMQClient.`messageCount(String queue, Handler<AsyncResult<Long>> resultHandler)` Returns the number of messages in a queue ready to be delivered.
    `void` | RabbitMQConsumer.`pipeTo(WriteStream<RabbitMQMessage> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | RabbitMQClient.`queueBind(String queue, String exchange, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Bind a queue to an exchange
    `void` | RabbitMQClient.`queueBind(String queue, String exchange, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Bind a queue to an exchange
    `void` | RabbitMQClient.`queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Handler<AsyncResult<JsonObject>> resultHandler)` Declare a queue
    `void` | RabbitMQClient.`queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, JsonObject config, Handler<AsyncResult<JsonObject>> resultHandler)` Declare a queue with config options
    `void` | RabbitMQClient.`queueDeclareAuto(Handler<AsyncResult<JsonObject>> resultHandler)` Actively declare a server-named exclusive, autodelete, non-durable queue.
    `void` | RabbitMQClient.`queueDelete(String queue, Handler<AsyncResult<JsonObject>> resultHandler)` Delete a queue, without regard for whether it is in use or has messages on it
    `void` | RabbitMQClient.`queueDeleteIf(String queue, boolean ifUnused, boolean ifEmpty, Handler<AsyncResult<JsonObject>> resultHandler)` Delete a queue
    `void` | RabbitMQClient.`queueUnbind(String queue, String exchange, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Unbind a queue from an exchange
    `void` | RabbitMQClient.`queueUnbind(String queue, String exchange, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)` Unbind a queue from an exchange
    `void` | RabbitMQClient.`start(Handler<AsyncResult<Void>> resultHandler)` Start the rabbitMQ client.
    `void` | RabbitMQClient.`stop(Handler<AsyncResult<Void>> resultHandler)` Stop the rabbitMQ client.
    `void` | RabbitMQClient.`waitForConfirms(Handler<AsyncResult<Void>> resultHandler)` Wait until all messages published since the last call have been either ack'd or nack'd by the broker.
    `void` | RabbitMQClient.`waitForConfirms(long timeout, Handler<AsyncResult<Void>> resultHandler)` Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses.

  - ### Uses of Handler in io.vertx.rxjava.redis

    Methods in io.vertx.rxjava.redis with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `RedisClient` | RedisClient.`append(String key, String value, Handler<AsyncResult<Long>> handler)` Append a value to a key
    `RedisTransaction` | RedisTransaction.`append(String key, String value, Handler<AsyncResult<String>> handler)` Append a value to a key
    `RedisTransaction` | RedisTransaction.`auth(String password, Handler<AsyncResult<String>> handler)` Authenticate to the server
    `RedisClient` | RedisClient.`auth(String password, Handler<AsyncResult<String>> handler)` Authenticate to the server
    `RedisTransaction` | RedisTransaction.`bgrewriteaof(Handler<AsyncResult<String>> handler)` Asynchronously rewrite the append-only file
    `RedisClient` | RedisClient.`bgrewriteaof(Handler<AsyncResult<String>> handler)` Asynchronously rewrite the append-only file
    `RedisTransaction` | RedisTransaction.`bgsave(Handler<AsyncResult<String>> handler)` Asynchronously save the dataset to disk
    `RedisClient` | RedisClient.`bgsave(Handler<AsyncResult<String>> handler)` Asynchronously save the dataset to disk
    `RedisClient` | RedisClient.`bitcount(String key, Handler<AsyncResult<Long>> handler)` Count set bits in a string
    `RedisTransaction` | RedisTransaction.`bitcount(String key, Handler<AsyncResult<String>> handler)` Count set bits in a string
    `RedisClient` | RedisClient.`bitcountRange(String key, long start, long end, Handler<AsyncResult<Long>> handler)` Count set bits in a string
    `RedisTransaction` | RedisTransaction.`bitcountRange(String key, long start, long end, Handler<AsyncResult<String>> handler)` Count set bits in a string
    `RedisClient` | RedisClient.`bitfield(String key, BitFieldOptions bitFieldOptions, Handler<AsyncResult<JsonArray>> handler)` Perform arbitrary bitfield integer operations on strings.
    `RedisClient` | RedisClient.`bitfieldWithOverflow(String key, BitFieldOptions commands, BitFieldOverflowOptions overflow, Handler<AsyncResult<JsonArray>> handler)` Perform arbitrary bitfield integer operations on strings.
    `RedisClient` | RedisClient.`bitop(BitOperation operation, String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Perform bitwise operations between strings
    `RedisTransaction` | RedisTransaction.`bitop(BitOperation operation, String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Perform bitwise operations between strings
    `RedisClient` | RedisClient.`bitpos(String key, int bit, Handler<AsyncResult<Long>> handler)` Find first bit set or clear in a string
    `RedisTransaction` | RedisTransaction.`bitpos(String key, int bit, Handler<AsyncResult<String>> handler)` Find first bit set or clear in a string
    `RedisClient` | RedisClient.`bitposFrom(String key, int bit, int start, Handler<AsyncResult<Long>> handler)` Find first bit set or clear in a string See also bitposRange() method, which takes start, and stop offset.
    `RedisTransaction` | RedisTransaction.`bitposFrom(String key, int bit, int start, Handler<AsyncResult<String>> handler)` Find first bit set or clear in a string
    `RedisClient` | RedisClient.`bitposRange(String key, int bit, int start, int stop, Handler<AsyncResult<Long>> handler)` Find first bit set or clear in a string Note: when both start, and stop offsets are specified, behaviour is slightly different than if only start is specified
    `RedisTransaction` | RedisTransaction.`bitposRange(String key, int bit, int start, int stop, Handler<AsyncResult<String>> handler)` Find first bit set or clear in a string
    `RedisClient` | RedisClient.`blpop(String key, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the first element in a list, or block until one is available
    `RedisTransaction` | RedisTransaction.`blpop(String key, int seconds, Handler<AsyncResult<String>> handler)` Remove and get the first element in a list, or block until one is available
    `RedisClient` | RedisClient.`blpopMany(List<String> keys, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the first element in any of the lists, or block until one is available
    `RedisTransaction` | RedisTransaction.`blpopMany(List<String> keys, int seconds, Handler<AsyncResult<String>> handler)` Remove and get the first element in any of the lists, or block until one is available
    `RedisClient` | RedisClient.`brpop(String key, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the last element in a list, or block until one is available
    `RedisTransaction` | RedisTransaction.`brpop(String key, int seconds, Handler<AsyncResult<String>> handler)` Remove and get the last element in a list, or block until one is available
    `RedisTransaction` | RedisTransaction.`brpoplpush(String key, String destkey, int seconds, Handler<AsyncResult<String>> handler)` Pop a value from a list, push it to another list and return it; or block until one is available
    `RedisClient` | RedisClient.`brpoplpush(String key, String destkey, int seconds, Handler<AsyncResult<String>> handler)` Pop a value from a list, push it to another list and return it; or block until one is available
    `RedisClient` | RedisClient.`brpopMany(List<String> keys, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the last element in any of the lists, or block until one is available
    `RedisTransaction` | RedisTransaction.`brpopMany(List<String> keys, int seconds, Handler<AsyncResult<String>> handler)` Remove and get the last element in any of the lists, or block until one is available
    `RedisTransaction` | RedisTransaction.`clientGetname(Handler<AsyncResult<String>> handler)` Get the current connection name
    `RedisClient` | RedisClient.`clientGetname(Handler<AsyncResult<String>> handler)` Get the current connection name
    `RedisClient` | RedisClient.`clientKill(KillFilter filter, Handler<AsyncResult<Long>> handler)` Kill the connection of a client
    `RedisTransaction` | RedisTransaction.`clientKill(KillFilter filter, Handler<AsyncResult<String>> handler)` Kill the connection of a client
    `RedisTransaction` | RedisTransaction.`clientList(Handler<AsyncResult<String>> handler)` Get the list of client connections
    `RedisClient` | RedisClient.`clientList(Handler<AsyncResult<String>> handler)` Get the list of client connections
    `RedisTransaction` | RedisTransaction.`clientPause(long millis, Handler<AsyncResult<String>> handler)` Stop processing commands from clients for some time
    `RedisClient` | RedisClient.`clientPause(long millis, Handler<AsyncResult<String>> handler)` Stop processing commands from clients for some time
    `RedisClient` | RedisClient.`clientReply(ClientReplyOptions options, Handler<AsyncResult<String>> handler)` Instruct the server whether to reply to commands.
    `RedisTransaction` | RedisTransaction.`clientSetname(String name, Handler<AsyncResult<String>> handler)` Set the current connection name
    `RedisClient` | RedisClient.`clientSetname(String name, Handler<AsyncResult<String>> handler)` Set the current connection name
    `void` | RedisTransaction.`close(Handler<AsyncResult<Void>> handler)` Close the client - when it is fully closed the handler will be called.
    `void` | RedisClient.`close(Handler<AsyncResult<Void>> handler)` Close the client - when it is fully closed the handler will be called.
    `RedisClient` | RedisClient.`clusterAddslots(List<Long> slots, Handler<AsyncResult<Void>> handler)` Assign new hash slots to receiving node.
    `RedisTransaction` | RedisTransaction.`clusterAddslots(List<String> slots, Handler<AsyncResult<String>> handler)` Assign new hash slots to receiving node.
    `RedisClient` | RedisClient.`clusterCountFailureReports(String nodeId, Handler<AsyncResult<Long>> handler)` Return the number of failure reports active for a given node.
    `RedisTransaction` | RedisTransaction.`clusterCountFailureReports(String nodeId, Handler<AsyncResult<String>> handler)` Return the number of failure reports active for a given node.
    `RedisClient` | RedisClient.`clusterCountkeysinslot(long slot, Handler<AsyncResult<Long>> handler)` Return the number of local keys in the specified hash slot.
    `RedisTransaction` | RedisTransaction.`clusterCountkeysinslot(long slot, Handler<AsyncResult<String>> handler)` Return the number of local keys in the specified hash slot.
    `RedisTransaction` | RedisTransaction.`clusterDelslots(long slot, Handler<AsyncResult<String>> handler)` Set hash slots as unbound in receiving node.
    `RedisClient` | RedisClient.`clusterDelslots(long slot, Handler<AsyncResult<Void>> handler)` Set hash slots as unbound in receiving node.
    `RedisClient` | RedisClient.`clusterDelslotsMany(List<Long> slots, Handler<AsyncResult<Void>> handler)` Set hash slots as unbound in receiving node.
    `RedisTransaction` | RedisTransaction.`clusterDelslotsMany(List<String> slots, Handler<AsyncResult<String>> handler)` Set hash slots as unbound in receiving node.
    `RedisTransaction` | RedisTransaction.`clusterFailover(Handler<AsyncResult<String>> handler)` Forces a slave to perform a manual failover of its master.
    `RedisClient` | RedisClient.`clusterFailover(Handler<AsyncResult<Void>> handler)` Forces a slave to perform a manual failover of its master.
    `RedisTransaction` | RedisTransaction.`clusterFailOverWithOptions(FailoverOptions options, Handler<AsyncResult<String>> handler)` Forces a slave to perform a manual failover of its master.
    `RedisClient` | RedisClient.`clusterFailOverWithOptions(FailoverOptions options, Handler<AsyncResult<Void>> handler)` Forces a slave to perform a manual failover of its master.
    `RedisTransaction` | RedisTransaction.`clusterForget(String nodeId, Handler<AsyncResult<String>> handler)` Remove a node from the nodes table.
    `RedisClient` | RedisClient.`clusterForget(String nodeId, Handler<AsyncResult<Void>> handler)` Remove a node from the nodes table.
    `RedisClient` | RedisClient.`clusterGetkeysinslot(long slot, long count, Handler<AsyncResult<JsonArray>> handler)` Return local key names in the specified hash slot.
    `RedisTransaction` | RedisTransaction.`clusterGetkeysinslot(long slot, long count, Handler<AsyncResult<String>> handler)` Return local key names in the specified hash slot.
    `RedisClient` | RedisClient.`clusterInfo(Handler<AsyncResult<JsonArray>> handler)` Provides info about Redis Cluster node state.
    `RedisTransaction` | RedisTransaction.`clusterInfo(Handler<AsyncResult<String>> handler)` Provides info about Redis Cluster node state.
    `RedisClient` | RedisClient.`clusterKeyslot(String key, Handler<AsyncResult<Long>> handler)` Returns the hash slot of the specified key.
    `RedisTransaction` | RedisTransaction.`clusterKeyslot(String key, Handler<AsyncResult<String>> handler)` Returns the hash slot of the specified key.
    `RedisTransaction` | RedisTransaction.`clusterMeet(String ip, long port, Handler<AsyncResult<String>> handler)` Force a node cluster to handshake with another node.
    `RedisClient` | RedisClient.`clusterMeet(String ip, long port, Handler<AsyncResult<Void>> handler)` Force a node cluster to handshake with another node.
    `RedisClient` | RedisClient.`clusterNodes(Handler<AsyncResult<JsonArray>> handler)` Get Cluster config for the node.
    `RedisTransaction` | RedisTransaction.`clusterNodes(Handler<AsyncResult<String>> handler)` Get Cluster config for the node.
    `RedisTransaction` | RedisTransaction.`clusterReplicate(String nodeId, Handler<AsyncResult<String>> handler)` Reconfigure a node as a slave of the specified master node.
    `RedisClient` | RedisClient.`clusterReplicate(String nodeId, Handler<AsyncResult<Void>> handler)` Reconfigure a node as a slave of the specified master node.
    `RedisTransaction` | RedisTransaction.`clusterReset(Handler<AsyncResult<String>> handler)` Reset a Redis Cluster node.
    `RedisClient` | RedisClient.`clusterReset(Handler<AsyncResult<Void>> handler)` Reset a Redis Cluster node.
    `RedisTransaction` | RedisTransaction.`clusterResetWithOptions(ResetOptions options, Handler<AsyncResult<String>> handler)` Reset a Redis Cluster node.
    `RedisClient` | RedisClient.`clusterResetWithOptions(ResetOptions options, Handler<AsyncResult<Void>> handler)` Reset a Redis Cluster node.
    `RedisTransaction` | RedisTransaction.`clusterSaveconfig(Handler<AsyncResult<String>> handler)` Forces the node to save cluster state on disk.
    `RedisClient` | RedisClient.`clusterSaveconfig(Handler<AsyncResult<Void>> handler)` Forces the node to save cluster state on disk.
    `RedisTransaction` | RedisTransaction.`clusterSetConfigEpoch(long epoch, Handler<AsyncResult<String>> handler)` Set the configuration epoch in a new node.
    `RedisClient` | RedisClient.`clusterSetConfigEpoch(long epoch, Handler<AsyncResult<Void>> handler)` Set the configuration epoch in a new node.
    `RedisTransaction` | RedisTransaction.`clusterSetslot(long slot, SlotCmd subcommand, Handler<AsyncResult<String>> handler)` Bind an hash slot to a specific node.
    `RedisClient` | RedisClient.`clusterSetslot(long slot, SlotCmd subcommand, Handler<AsyncResult<Void>> handler)` Bind an hash slot to a specific node.
    `RedisTransaction` | RedisTransaction.`clusterSetslotWithNode(long slot, SlotCmd subcommand, String nodeId, Handler<AsyncResult<String>> handler)` Bind an hash slot to a specific node.
    `RedisClient` | RedisClient.`clusterSetslotWithNode(long slot, SlotCmd subcommand, String nodeId, Handler<AsyncResult<Void>> handler)` Bind an hash slot to a specific node.
    `RedisClient` | RedisClient.`clusterSlaves(String nodeId, Handler<AsyncResult<JsonArray>> handler)` List slave nodes of the specified master node.
    `RedisTransaction` | RedisTransaction.`clusterSlaves(String nodeId, Handler<AsyncResult<String>> handler)` List slave nodes of the specified master node.
    `RedisClient` | RedisClient.`clusterSlots(Handler<AsyncResult<JsonArray>> handler)` Get array of Cluster slot to node mappings
    `RedisTransaction` | RedisTransaction.`clusterSlots(Handler<AsyncResult<String>> handler)` Get array of Cluster slot to node mappings
    `RedisClient` | RedisClient.`command(Handler<AsyncResult<JsonArray>> handler)` Get array of Redis command details
    `RedisTransaction` | RedisTransaction.`command(Handler<AsyncResult<String>> handler)` Get array of Redis command details
    `RedisClient` | RedisClient.`commandCount(Handler<AsyncResult<Long>> handler)` Get total number of Redis commands
    `RedisTransaction` | RedisTransaction.`commandCount(Handler<AsyncResult<String>> handler)` Get total number of Redis commands
    `RedisClient` | RedisClient.`commandGetkeys(Handler<AsyncResult<JsonArray>> handler)` Extract keys given a full Redis command
    `RedisTransaction` | RedisTransaction.`commandGetkeys(Handler<AsyncResult<String>> handler)` Extract keys given a full Redis command
    `RedisClient` | RedisClient.`commandInfo(List<String> commands, Handler<AsyncResult<JsonArray>> handler)` Get array of specific Redis command details
    `RedisTransaction` | RedisTransaction.`commandInfo(List<String> commands, Handler<AsyncResult<String>> handler)` Get array of specific Redis command details
    `RedisClient` | RedisClient.`configGet(String parameter, Handler<AsyncResult<JsonArray>> handler)` Get the value of a configuration parameter
    `RedisTransaction` | RedisTransaction.`configGet(String parameter, Handler<AsyncResult<String>> handler)` Get the value of a configuration parameter
    `RedisTransaction` | RedisTransaction.`configResetstat(Handler<AsyncResult<String>> handler)` Reset the stats returned by INFO
    `RedisClient` | RedisClient.`configResetstat(Handler<AsyncResult<String>> handler)` Reset the stats returned by INFO
    `RedisTransaction` | RedisTransaction.`configRewrite(Handler<AsyncResult<String>> handler)` Rewrite the configuration file with the in memory configuration
    `RedisClient` | RedisClient.`configRewrite(Handler<AsyncResult<String>> handler)` Rewrite the configuration file with the in memory configuration
    `RedisTransaction` | RedisTransaction.`configSet(String parameter, String value, Handler<AsyncResult<String>> handler)` Set a configuration parameter to the given value
    `RedisClient` | RedisClient.`configSet(String parameter, String value, Handler<AsyncResult<String>> handler)` Set a configuration parameter to the given value
    `RedisClient` | RedisClient.`dbsize(Handler<AsyncResult<Long>> handler)` Return the number of keys in the selected database
    `RedisTransaction` | RedisTransaction.`dbsize(Handler<AsyncResult<String>> handler)` Return the number of keys in the selected database
    `RedisTransaction` | RedisTransaction.`debugObject(String key, Handler<AsyncResult<String>> handler)` Get debugging information about a key
    `RedisClient` | RedisClient.`debugObject(String key, Handler<AsyncResult<String>> handler)` Get debugging information about a key
    `RedisTransaction` | RedisTransaction.`debugSegfault(Handler<AsyncResult<String>> handler)` Make the server crash
    `RedisClient` | RedisClient.`debugSegfault(Handler<AsyncResult<String>> handler)` Make the server crash
    `RedisClient` | RedisClient.`decr(String key, Handler<AsyncResult<Long>> handler)` Decrement the integer value of a key by one
    `RedisTransaction` | RedisTransaction.`decr(String key, Handler<AsyncResult<String>> handler)` Decrement the integer value of a key by one
    `RedisClient` | RedisClient.`decrby(String key, long decrement, Handler<AsyncResult<Long>> handler)` Decrement the integer value of a key by the given number
    `RedisTransaction` | RedisTransaction.`decrby(String key, long decrement, Handler<AsyncResult<String>> handler)` Decrement the integer value of a key by the given number
    `RedisClient` | RedisClient.`del(String key, Handler<AsyncResult<Long>> handler)` Delete a key
    `RedisTransaction` | RedisTransaction.`del(String key, Handler<AsyncResult<String>> handler)` Delete a key
    `RedisClient` | RedisClient.`delMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Delete many keys
    `RedisTransaction` | RedisTransaction.`delMany(List<String> keys, Handler<AsyncResult<String>> handler)` Delete many keys
    `RedisTransaction` | RedisTransaction.`discard(Handler<AsyncResult<String>> handler)` Discard all commands issued after MULTI
    `RedisTransaction` | RedisTransaction.`dump(String key, Handler<AsyncResult<String>> handler)` Return a serialized version of the value stored at the specified key.
    `RedisClient` | RedisClient.`dump(String key, Handler<AsyncResult<String>> handler)` Return a serialized version of the value stored at the specified key.
    `RedisTransaction` | RedisTransaction.`echo(String message, Handler<AsyncResult<String>> handler)` Echo the given string
    `RedisClient` | RedisClient.`echo(String message, Handler<AsyncResult<String>> handler)` Echo the given string
    `RedisClient` | RedisClient.`eval(String script, List<String> keys, List<String> args, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `RedisTransaction` | RedisTransaction.`eval(String script, List<String> keys, List<String> args, Handler<AsyncResult<String>> handler)` Execute a Lua script server side.
    `RedisClient` | RedisClient.`evalScript(Script script, List<String> keys, List<String> args, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `RedisClient` | RedisClient.`evalsha(String sha1, List<String> keys, List<String> values, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `RedisTransaction` | RedisTransaction.`evalsha(String sha1, List<String> keys, List<String> values, Handler<AsyncResult<String>> handler)` Execute a Lua script server side.
    `RedisTransaction` | RedisTransaction.`exec(Handler<AsyncResult<JsonArray>> handler)` Execute all commands issued after MULTI
    `RedisClient` | RedisClient.`exists(String key, Handler<AsyncResult<Long>> handler)` Determine if a key exists
    `RedisTransaction` | RedisTransaction.`exists(String key, Handler<AsyncResult<String>> handler)` Determine if a key exists
    `RedisClient` | RedisClient.`existsMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Determine if one or many keys exist
    `RedisTransaction` | RedisTransaction.`existsMany(List<String> keys, Handler<AsyncResult<String>> handler)` Determine if one or many keys exist
    `RedisTransaction` | RedisTransaction.`expire(String key, int seconds, Handler<AsyncResult<String>> handler)` Set a key's time to live in seconds
    `RedisClient` | RedisClient.`expire(String key, long seconds, Handler<AsyncResult<Long>> handler)` Set a key's time to live in seconds
    `RedisClient` | RedisClient.`expireat(String key, long seconds, Handler<AsyncResult<Long>> handler)` Set the expiration for a key as a UNIX timestamp
    `RedisTransaction` | RedisTransaction.`expireat(String key, long seconds, Handler<AsyncResult<String>> handler)` Set the expiration for a key as a UNIX timestamp
    `RedisTransaction` | RedisTransaction.`flushall(Handler<AsyncResult<String>> handler)` Remove all keys from all databases
    `RedisClient` | RedisClient.`flushall(Handler<AsyncResult<String>> handler)` Remove all keys from all databases
    `RedisTransaction` | RedisTransaction.`flushdb(Handler<AsyncResult<String>> handler)` Remove all keys from the current database
    `RedisClient` | RedisClient.`flushdb(Handler<AsyncResult<String>> handler)` Remove all keys from the current database
    `RedisClient` | RedisClient.`geoadd(String key, double longitude, double latitude, String member, Handler<AsyncResult<Long>> handler)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `RedisTransaction` | RedisTransaction.`geoadd(String key, double longitude, double latitude, String member, Handler<AsyncResult<String>> handler)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `RedisClient` | RedisClient.`geoaddMany(String key, List<GeoMember> members, Handler<AsyncResult<Long>> handler)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `RedisTransaction` | RedisTransaction.`geoaddMany(String key, List<GeoMember> members, Handler<AsyncResult<String>> handler)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `RedisTransaction` | RedisTransaction.`geodist(String key, String member1, String member2, Handler<AsyncResult<String>> handler)` Return the distance between two members in the geospatial index represented by the sorted set.
    `RedisClient` | RedisClient.`geodist(String key, String member1, String member2, Handler<AsyncResult<String>> handler)` Return the distance between two members in the geospatial index represented by the sorted set.
    `RedisTransaction` | RedisTransaction.`geodistWithUnit(String key, String member1, String member2, GeoUnit unit, Handler<AsyncResult<String>> handler)` Return the distance between two members in the geospatial index represented by the sorted set.
    `RedisClient` | RedisClient.`geodistWithUnit(String key, String member1, String member2, GeoUnit unit, Handler<AsyncResult<String>> handler)` Return the distance between two members in the geospatial index represented by the sorted set.
    `RedisClient` | RedisClient.`geohash(String key, String member, Handler<AsyncResult<JsonArray>> handler)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `RedisTransaction` | RedisTransaction.`geohash(String key, String member, Handler<AsyncResult<String>> handler)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `RedisClient` | RedisClient.`geohashMany(String key, List<String> members, Handler<AsyncResult<JsonArray>> handler)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `RedisTransaction` | RedisTransaction.`geohashMany(String key, List<String> members, Handler<AsyncResult<String>> handler)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `RedisClient` | RedisClient.`geopos(String key, String member, Handler<AsyncResult<JsonArray>> handler)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `RedisTransaction` | RedisTransaction.`geopos(String key, String member, Handler<AsyncResult<String>> handler)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `RedisClient` | RedisClient.`geoposMany(String key, List<String> members, Handler<AsyncResult<JsonArray>> handler)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `RedisTransaction` | RedisTransaction.`geoposMany(String key, List<String> members, Handler<AsyncResult<String>> handler)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `RedisClient` | RedisClient.`georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, Handler<AsyncResult<JsonArray>> handler)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `RedisTransaction` | RedisTransaction.`georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, Handler<AsyncResult<String>> handler)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `RedisClient` | RedisClient.`georadiusbymember(String key, String member, double radius, GeoUnit unit, Handler<AsyncResult<JsonArray>> handler)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `RedisTransaction` | RedisTransaction.`georadiusbymember(String key, String member, double radius, GeoUnit unit, Handler<AsyncResult<String>> handler)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `RedisClient` | RedisClient.`georadiusbymemberWithOptions(String key, String member, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<JsonArray>> handler)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `RedisTransaction` | RedisTransaction.`georadiusbymemberWithOptions(String key, String member, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<String>> handler)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `RedisClient` | RedisClient.`georadiusWithOptions(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<JsonArray>> handler)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `RedisTransaction` | RedisTransaction.`georadiusWithOptions(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<String>> handler)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `RedisTransaction` | RedisTransaction.`get(String key, Handler<AsyncResult<String>> handler)` Get the value of a key
    `RedisClient` | RedisClient.`get(String key, Handler<AsyncResult<String>> handler)` Get the value of a key
    `RedisTransaction` | RedisTransaction.`getBinary(String key, Handler<AsyncResult<Buffer>> handler)` Get the value of a key - without decoding as utf-8
    `RedisClient` | RedisClient.`getBinary(String key, Handler<AsyncResult<Buffer>> handler)` Get the value of a key - without decoding as utf-8
    `RedisClient` | RedisClient.`getbit(String key, long offset, Handler<AsyncResult<Long>> handler)` Returns the bit value at offset in the string value stored at key
    `RedisTransaction` | RedisTransaction.`getbit(String key, long offset, Handler<AsyncResult<String>> handler)` Returns the bit value at offset in the string value stored at key
    `RedisTransaction` | RedisTransaction.`getrange(String key, long start, long end, Handler<AsyncResult<String>> handler)` Get a substring of the string stored at a key
    `RedisClient` | RedisClient.`getrange(String key, long start, long end, Handler<AsyncResult<String>> handler)` Get a substring of the string stored at a key
    `RedisTransaction` | RedisTransaction.`getset(String key, String value, Handler<AsyncResult<String>> handler)` Set the string value of a key and return its old value
    `RedisClient` | RedisClient.`getset(String key, String value, Handler<AsyncResult<String>> handler)` Set the string value of a key and return its old value
    `RedisClient` | RedisClient.`hdel(String key, String field, Handler<AsyncResult<Long>> handler)` Delete one or more hash fields
    `RedisTransaction` | RedisTransaction.`hdel(String key, String field, Handler<AsyncResult<String>> handler)` Delete one or more hash fields
    `RedisClient` | RedisClient.`hdelMany(String key, List<String> fields, Handler<AsyncResult<Long>> handler)` Delete one or more hash fields
    `RedisTransaction` | RedisTransaction.`hdelMany(String key, List<String> fields, Handler<AsyncResult<String>> handler)` Delete one or more hash fields
    `RedisClient` | RedisClient.`hexists(String key, String field, Handler<AsyncResult<Long>> handler)` Determine if a hash field exists
    `RedisTransaction` | RedisTransaction.`hexists(String key, String field, Handler<AsyncResult<String>> handler)` Determine if a hash field exists
    `RedisTransaction` | RedisTransaction.`hget(String key, String field, Handler<AsyncResult<String>> handler)` Get the value of a hash field
    `RedisClient` | RedisClient.`hget(String key, String field, Handler<AsyncResult<String>> handler)` Get the value of a hash field
    `RedisClient` | RedisClient.`hgetall(String key, Handler<AsyncResult<JsonObject>> handler)` Get all the fields and values in a hash
    `RedisTransaction` | RedisTransaction.`hgetall(String key, Handler<AsyncResult<String>> handler)` Get all the fields and values in a hash
    `RedisClient` | RedisClient.`hincrby(String key, String field, long increment, Handler<AsyncResult<Long>> handler)` Increment the integer value of a hash field by the given number
    `RedisTransaction` | RedisTransaction.`hincrby(String key, String field, long increment, Handler<AsyncResult<String>> handler)` Increment the integer value of a hash field by the given number
    `RedisTransaction` | RedisTransaction.`hincrbyfloat(String key, String field, double increment, Handler<AsyncResult<String>> handler)` Increment the float value of a hash field by the given amount
    `RedisClient` | RedisClient.`hincrbyfloat(String key, String field, double increment, Handler<AsyncResult<String>> handler)` Increment the float value of a hash field by the given amount
    `RedisClient` | RedisClient.`hkeys(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the fields in a hash
    `RedisTransaction` | RedisTransaction.`hkeys(String key, Handler<AsyncResult<String>> handler)` Get all the fields in a hash
    `RedisClient` | RedisClient.`hlen(String key, Handler<AsyncResult<Long>> handler)` Get the number of fields in a hash
    `RedisTransaction` | RedisTransaction.`hlen(String key, Handler<AsyncResult<String>> handler)` Get the number of fields in a hash
    `RedisClient` | RedisClient.`hmget(String key, List<String> fields, Handler<AsyncResult<JsonArray>> handler)` Get the values of all the given hash fields
    `RedisTransaction` | RedisTransaction.`hmget(String key, List<String> fields, Handler<AsyncResult<String>> handler)` Get the values of all the given hash fields
    `RedisTransaction` | RedisTransaction.`hmset(String key, JsonObject values, Handler<AsyncResult<String>> handler)` Set multiple hash fields to multiple values
    `RedisClient` | RedisClient.`hmset(String key, JsonObject values, Handler<AsyncResult<String>> handler)` Set multiple hash fields to multiple values
    `RedisClient` | RedisClient.`hscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate hash fields and associated values
    `RedisTransaction` | RedisTransaction.`hscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<String>> handler)` Incrementally iterate hash fields and associated values
    `RedisClient` | RedisClient.`hset(String key, String field, String value, Handler<AsyncResult<Long>> handler)` Set the string value of a hash field
    `RedisTransaction` | RedisTransaction.`hset(String key, String field, String value, Handler<AsyncResult<String>> handler)` Set the string value of a hash field
    `RedisClient` | RedisClient.`hsetnx(String key, String field, String value, Handler<AsyncResult<Long>> handler)` Set the value of a hash field, only if the field does not exist
    `RedisTransaction` | RedisTransaction.`hsetnx(String key, String field, String value, Handler<AsyncResult<String>> handler)` Set the value of a hash field, only if the field does not exist
    `RedisClient` | RedisClient.`hstrlen(String key, String field, Handler<AsyncResult<Long>> handler)` Get the length of the value of a hash field.
    `RedisClient` | RedisClient.`hvals(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the values in a hash
    `RedisTransaction` | RedisTransaction.`hvals(String key, Handler<AsyncResult<String>> handler)` Get all the values in a hash
    `RedisClient` | RedisClient.`incr(String key, Handler<AsyncResult<Long>> handler)` Increment the integer value of a key by one
    `RedisTransaction` | RedisTransaction.`incr(String key, Handler<AsyncResult<String>> handler)` Increment the integer value of a key by one
    `RedisClient` | RedisClient.`incrby(String key, long increment, Handler<AsyncResult<Long>> handler)` Increment the integer value of a key by the given amount
    `RedisTransaction` | RedisTransaction.`incrby(String key, long increment, Handler<AsyncResult<String>> handler)` Increment the integer value of a key by the given amount
    `RedisTransaction` | RedisTransaction.`incrbyfloat(String key, double increment, Handler<AsyncResult<String>> handler)` Increment the float value of a key by the given amount
    `RedisClient` | RedisClient.`incrbyfloat(String key, double increment, Handler<AsyncResult<String>> handler)` Increment the float value of a key by the given amount
    `RedisClient` | RedisClient.`info(Handler<AsyncResult<JsonObject>> handler)` Get information and statistics about the server
    `RedisTransaction` | RedisTransaction.`info(Handler<AsyncResult<String>> handler)` Get information and statistics about the server
    `RedisClient` | RedisClient.`infoSection(String section, Handler<AsyncResult<JsonObject>> handler)` Get information and statistics about the server
    `RedisTransaction` | RedisTransaction.`infoSection(String section, Handler<AsyncResult<String>> handler)` Get information and statistics about the server
    `RedisClient` | RedisClient.`keys(String pattern, Handler<AsyncResult<JsonArray>> handler)` Find all keys matching the given pattern
    `RedisTransaction` | RedisTransaction.`keys(String pattern, Handler<AsyncResult<String>> handler)` Find all keys matching the given pattern
    `RedisClient` | RedisClient.`lastsave(Handler<AsyncResult<Long>> handler)` Get the UNIX time stamp of the last successful save to disk
    `RedisTransaction` | RedisTransaction.`lastsave(Handler<AsyncResult<String>> handler)` Get the UNIX time stamp of the last successful save to disk
    `RedisTransaction` | RedisTransaction.`lindex(String key, int index, Handler<AsyncResult<String>> handler)` Get an element from a list by its index
    `RedisClient` | RedisClient.`lindex(String key, int index, Handler<AsyncResult<String>> handler)` Get an element from a list by its index
    `RedisClient` | RedisClient.`linsert(String key, InsertOptions option, String pivot, String value, Handler<AsyncResult<Long>> handler)` Insert an element before or after another element in a list
    `RedisTransaction` | RedisTransaction.`linsert(String key, InsertOptions option, String pivot, String value, Handler<AsyncResult<String>> handler)` Insert an element before or after another element in a list
    `RedisClient` | RedisClient.`llen(String key, Handler<AsyncResult<Long>> handler)` Get the length of a list
    `RedisTransaction` | RedisTransaction.`llen(String key, Handler<AsyncResult<String>> handler)` Get the length of a list
    `RedisTransaction` | RedisTransaction.`lpop(String key, Handler<AsyncResult<String>> handler)` Remove and get the first element in a list
    `RedisClient` | RedisClient.`lpop(String key, Handler<AsyncResult<String>> handler)` Remove and get the first element in a list
    `RedisClient` | RedisClient.`lpush(String key, String value, Handler<AsyncResult<Long>> handler)` Prepend one value to a list
    `RedisTransaction` | RedisTransaction.`lpush(String key, String value, Handler<AsyncResult<String>> handler)` Prepend one value to a list
    `RedisClient` | RedisClient.`lpushMany(String key, List<String> values, Handler<AsyncResult<Long>> handler)` Prepend one or multiple values to a list
    `RedisTransaction` | RedisTransaction.`lpushMany(String key, List<String> values, Handler<AsyncResult<String>> handler)` Prepend one or multiple values to a list
    `RedisClient` | RedisClient.`lpushx(String key, String value, Handler<AsyncResult<Long>> handler)` Prepend a value to a list, only if the list exists
    `RedisTransaction` | RedisTransaction.`lpushx(String key, String value, Handler<AsyncResult<String>> handler)` Prepend a value to a list, only if the list exists
    `RedisClient` | RedisClient.`lrange(String key, long from, long to, Handler<AsyncResult<JsonArray>> handler)` Get a range of elements from a list
    `RedisTransaction` | RedisTransaction.`lrange(String key, long from, long to, Handler<AsyncResult<String>> handler)` Get a range of elements from a list
    `RedisClient` | RedisClient.`lrem(String key, long count, String value, Handler<AsyncResult<Long>> handler)` Remove elements from a list
    `RedisTransaction` | RedisTransaction.`lrem(String key, long count, String value, Handler<AsyncResult<String>> handler)` Remove elements from a list
    `RedisTransaction` | RedisTransaction.`lset(String key, long index, String value, Handler<AsyncResult<String>> handler)` Set the value of an element in a list by its index
    `RedisClient` | RedisClient.`lset(String key, long index, String value, Handler<AsyncResult<String>> handler)` Set the value of an element in a list by its index
    `RedisTransaction` | RedisTransaction.`ltrim(String key, long from, long to, Handler<AsyncResult<String>> handler)` Trim a list to the specified range
    `RedisClient` | RedisClient.`ltrim(String key, long from, long to, Handler<AsyncResult<String>> handler)` Trim a list to the specified range
    `RedisClient` | RedisClient.`mget(String key, Handler<AsyncResult<JsonArray>> handler)` Get the value of the given key
    `RedisTransaction` | RedisTransaction.`mget(String key, Handler<AsyncResult<String>> handler)` Get the value of the given key
    `RedisClient` | RedisClient.`mgetMany(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Get the values of all the given keys
    `RedisTransaction` | RedisTransaction.`mgetMany(List<String> keys, Handler<AsyncResult<String>> handler)` Get the values of all the given keys
    `RedisTransaction` | RedisTransaction.`migrate(String host, int port, String key, int destdb, long timeout, MigrateOptions options, Handler<AsyncResult<String>> handler)` Atomically transfer a key from a Redis instance to another one.
    `RedisClient` | RedisClient.`migrate(String host, int port, String key, int destdb, long timeout, MigrateOptions options, Handler<AsyncResult<String>> handler)` Atomically transfer a key from a Redis instance to another one.
    `RedisTransaction` | RedisTransaction.`monitor(Handler<AsyncResult<String>> handler)` Listen for all requests received by the server in real time
    `RedisClient` | RedisClient.`monitor(Handler<AsyncResult<Void>> handler)` Listen for all requests received by the server in real time
    `RedisClient` | RedisClient.`move(String key, int destdb, Handler<AsyncResult<Long>> handler)` Move a key to another database
    `RedisTransaction` | RedisTransaction.`move(String key, int destdb, Handler<AsyncResult<String>> handler)` Move a key to another database
    `RedisTransaction` | RedisTransaction.`mset(JsonObject keyvals, Handler<AsyncResult<String>> handler)` Set multiple keys to multiple values
    `RedisClient` | RedisClient.`mset(JsonObject keyvals, Handler<AsyncResult<String>> handler)` Set multiple keys to multiple values
    `RedisClient` | RedisClient.`msetnx(JsonObject keyvals, Handler<AsyncResult<Long>> handler)` Set multiple keys to multiple values, only if none of the keys exist
    `RedisTransaction` | RedisTransaction.`msetnx(JsonObject keyvals, Handler<AsyncResult<String>> handler)` Set multiple keys to multiple values, only if none of the keys exist
    `RedisTransaction` | RedisTransaction.`multi(Handler<AsyncResult<String>> handler)` Mark the start of a RedisTransaction block
    `RedisTransaction` | RedisTransaction.`object(String key, ObjectCmd cmd, Handler<AsyncResult<String>> handler)` Inspect the internals of Redis objects
    `RedisClient` | RedisClient.`object(String key, ObjectCmd cmd, Handler<AsyncResult<Void>> handler)` Inspect the internals of Redis objects
    `RedisClient` | RedisClient.`persist(String key, Handler<AsyncResult<Long>> handler)` Remove the expiration from a key
    `RedisTransaction` | RedisTransaction.`persist(String key, Handler<AsyncResult<String>> handler)` Remove the expiration from a key
    `RedisClient` | RedisClient.`pexpire(String key, long millis, Handler<AsyncResult<Long>> handler)` Set a key's time to live in milliseconds
    `RedisTransaction` | RedisTransaction.`pexpire(String key, long millis, Handler<AsyncResult<String>> handler)` Set a key's time to live in milliseconds
    `RedisClient` | RedisClient.`pexpireat(String key, long millis, Handler<AsyncResult<Long>> handler)` Set the expiration for a key as a UNIX timestamp specified in milliseconds
    `RedisTransaction` | RedisTransaction.`pexpireat(String key, long millis, Handler<AsyncResult<String>> handler)` Set the expiration for a key as a UNIX timestamp specified in milliseconds
    `RedisClient` | RedisClient.`pfadd(String key, String element, Handler<AsyncResult<Long>> handler)` Adds the specified element to the specified HyperLogLog.
    `RedisTransaction` | RedisTransaction.`pfadd(String key, String element, Handler<AsyncResult<String>> handler)` Adds the specified element to the specified HyperLogLog.
    `RedisClient` | RedisClient.`pfaddMany(String key, List<String> elements, Handler<AsyncResult<Long>> handler)` Adds the specified elements to the specified HyperLogLog.
    `RedisTransaction` | RedisTransaction.`pfaddMany(String key, List<String> elements, Handler<AsyncResult<String>> handler)` Adds the specified elements to the specified HyperLogLog.
    `RedisClient` | RedisClient.`pfcount(String key, Handler<AsyncResult<Long>> handler)` Return the approximated cardinality of the set observed by the HyperLogLog at key.
    `RedisTransaction` | RedisTransaction.`pfcount(String key, Handler<AsyncResult<String>> handler)` Return the approximated cardinality of the set observed by the HyperLogLog at key.
    `RedisClient` | RedisClient.`pfcountMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    `RedisTransaction` | RedisTransaction.`pfcountMany(List<String> keys, Handler<AsyncResult<String>> handler)` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    `RedisTransaction` | RedisTransaction.`pfmerge(String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Merge N different HyperLogLogs into a single one.
    `RedisClient` | RedisClient.`pfmerge(String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Merge N different HyperLogLogs into a single one.
    `RedisTransaction` | RedisTransaction.`ping(Handler<AsyncResult<String>> handler)` Ping the server
    `RedisClient` | RedisClient.`ping(Handler<AsyncResult<String>> handler)` Ping the server
    `RedisTransaction` | RedisTransaction.`psetex(String key, long millis, String value, Handler<AsyncResult<String>> handler)` Set the value and expiration in milliseconds of a key
    `RedisClient` | RedisClient.`psetex(String key, long millis, String value, Handler<AsyncResult<Void>> handler)` Set the value and expiration in milliseconds of a key
    `RedisClient` | RedisClient.`psubscribe(String pattern, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to channels matching the given pattern
    `RedisTransaction` | RedisTransaction.`psubscribe(String pattern, Handler<AsyncResult<String>> handler)` Listen for messages published to channels matching the given pattern
    `RedisClient` | RedisClient.`psubscribeMany(List<String> patterns, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to channels matching the given patterns
    `RedisTransaction` | RedisTransaction.`psubscribeMany(List<String> patterns, Handler<AsyncResult<String>> handler)` Listen for messages published to channels matching the given patterns
    `RedisClient` | RedisClient.`pttl(String key, Handler<AsyncResult<Long>> handler)` Get the time to live for a key in milliseconds
    `RedisTransaction` | RedisTransaction.`pttl(String key, Handler<AsyncResult<String>> handler)` Get the time to live for a key in milliseconds
    `RedisClient` | RedisClient.`publish(String channel, String message, Handler<AsyncResult<Long>> handler)` Post a message to a channel
    `RedisTransaction` | RedisTransaction.`publish(String channel, String message, Handler<AsyncResult<String>> handler)` Post a message to a channel
    `RedisClient` | RedisClient.`pubsubChannels(String pattern, Handler<AsyncResult<JsonArray>> handler)` Lists the currently active channels - only those matching the pattern
    `RedisTransaction` | RedisTransaction.`pubsubChannels(String pattern, Handler<AsyncResult<String>> handler)` Lists the currently active channels - only those matching the pattern
    `RedisClient` | RedisClient.`pubsubNumpat(Handler<AsyncResult<Long>> handler)` Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
    `RedisTransaction` | RedisTransaction.`pubsubNumpat(Handler<AsyncResult<String>> handler)` Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
    `RedisClient` | RedisClient.`pubsubNumsub(List<String> channels, Handler<AsyncResult<JsonArray>> handler)` Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
    `RedisTransaction` | RedisTransaction.`pubsubNumsub(List<String> channels, Handler<AsyncResult<String>> handler)` Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
    `RedisTransaction` | RedisTransaction.`punsubscribe(List<String> patterns, Handler<AsyncResult<String>> handler)` Stop listening for messages posted to channels matching the given patterns
    `RedisClient` | RedisClient.`punsubscribe(List<String> patterns, Handler<AsyncResult<Void>> handler)` Stop listening for messages posted to channels matching the given patterns
    `RedisTransaction` | RedisTransaction.`randomkey(Handler<AsyncResult<String>> handler)` Return a random key from the keyspace
    `RedisClient` | RedisClient.`randomkey(Handler<AsyncResult<String>> handler)` Return a random key from the keyspace
    `RedisTransaction` | RedisTransaction.`rename(String key, String newkey, Handler<AsyncResult<String>> handler)` Rename a key
    `RedisClient` | RedisClient.`rename(String key, String newkey, Handler<AsyncResult<String>> handler)` Rename a key
    `RedisClient` | RedisClient.`renamenx(String key, String newkey, Handler<AsyncResult<Long>> handler)` Rename a key, only if the new key does not exist
    `RedisTransaction` | RedisTransaction.`renamenx(String key, String newkey, Handler<AsyncResult<String>> handler)` Rename a key, only if the new key does not exist
    `RedisTransaction` | RedisTransaction.`restore(String key, long millis, String serialized, Handler<AsyncResult<String>> handler)` Create a key using the provided serialized value, previously obtained using DUMP.
    `RedisClient` | RedisClient.`restore(String key, long millis, String serialized, Handler<AsyncResult<String>> handler)` Create a key using the provided serialized value, previously obtained using DUMP.
    `RedisClient` | RedisClient.`role(Handler<AsyncResult<JsonArray>> handler)` Return the role of the instance in the context of replication
    `RedisTransaction` | RedisTransaction.`role(Handler<AsyncResult<String>> handler)` Return the role of the instance in the context of replication
    `RedisTransaction` | RedisTransaction.`rpop(String key, Handler<AsyncResult<String>> handler)` Remove and get the last element in a list
    `RedisClient` | RedisClient.`rpop(String key, Handler<AsyncResult<String>> handler)` Remove and get the last element in a list
    `RedisTransaction` | RedisTransaction.`rpoplpush(String key, String destkey, Handler<AsyncResult<String>> handler)` Remove the last element in a list, append it to another list and return it
    `RedisClient` | RedisClient.`rpoplpush(String key, String destkey, Handler<AsyncResult<String>> handler)` Remove the last element in a list, append it to another list and return it
    `RedisClient` | RedisClient.`rpush(String key, String value, Handler<AsyncResult<Long>> handler)` Append one or multiple values to a list
    `RedisTransaction` | RedisTransaction.`rpush(String key, String value, Handler<AsyncResult<String>> handler)` Append one or multiple values to a list
    `RedisClient` | RedisClient.`rpushMany(String key, List<String> values, Handler<AsyncResult<Long>> handler)` Append one or multiple values to a list
    `RedisTransaction` | RedisTransaction.`rpushMany(String key, List<String> values, Handler<AsyncResult<String>> handler)` Append one or multiple values to a list
    `RedisClient` | RedisClient.`rpushx(String key, String value, Handler<AsyncResult<Long>> handler)` Append a value to a list, only if the list exists
    `RedisTransaction` | RedisTransaction.`rpushx(String key, String value, Handler<AsyncResult<String>> handler)` Append a value to a list, only if the list exists
    `RedisClient` | RedisClient.`sadd(String key, String member, Handler<AsyncResult<Long>> handler)` Add a member to a set
    `RedisTransaction` | RedisTransaction.`sadd(String key, String member, Handler<AsyncResult<String>> handler)` Add a member to a set
    `RedisClient` | RedisClient.`saddMany(String key, List<String> members, Handler<AsyncResult<Long>> handler)` Add one or more members to a set
    `RedisTransaction` | RedisTransaction.`saddMany(String key, List<String> members, Handler<AsyncResult<String>> handler)` Add one or more members to a set
    `RedisTransaction` | RedisTransaction.`save(Handler<AsyncResult<String>> handler)` Synchronously save the dataset to disk
    `RedisClient` | RedisClient.`save(Handler<AsyncResult<String>> handler)` Synchronously save the dataset to disk
    `RedisClient` | RedisClient.`scan(String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate the keys space
    `RedisTransaction` | RedisTransaction.`scan(String cursor, ScanOptions options, Handler<AsyncResult<String>> handler)` Incrementally iterate the keys space
    `RedisClient` | RedisClient.`scard(String key, Handler<AsyncResult<Long>> handler)` Get the number of members in a set
    `RedisTransaction` | RedisTransaction.`scard(String key, Handler<AsyncResult<String>> handler)` Get the number of members in a set
    `RedisClient` | RedisClient.`scriptDebug(ScriptDebugOptions scriptDebugOptions, Handler<AsyncResult<String>> handler)` Set the debug mode for executed scripts.
    `RedisClient` | RedisClient.`scriptExists(String script, Handler<AsyncResult<JsonArray>> handler)` Check existence of script in the script cache.
    `RedisTransaction` | RedisTransaction.`scriptExists(String script, Handler<AsyncResult<String>> handler)` Check existence of script in the script cache.
    `RedisClient` | RedisClient.`scriptExistsMany(List<String> scripts, Handler<AsyncResult<JsonArray>> handler)` Check existence of scripts in the script cache.
    `RedisTransaction` | RedisTransaction.`scriptExistsMany(List<String> scripts, Handler<AsyncResult<String>> handler)` Check existence of scripts in the script cache.
    `RedisTransaction` | RedisTransaction.`scriptFlush(Handler<AsyncResult<String>> handler)` Remove all the scripts from the script cache.
    `RedisClient` | RedisClient.`scriptFlush(Handler<AsyncResult<String>> handler)` Remove all the scripts from the script cache.
    `RedisTransaction` | RedisTransaction.`scriptKill(Handler<AsyncResult<String>> handler)` Kill the script currently in execution.
    `RedisClient` | RedisClient.`scriptKill(Handler<AsyncResult<String>> handler)` Kill the script currently in execution.
    `RedisTransaction` | RedisTransaction.`scriptLoad(String script, Handler<AsyncResult<String>> handler)` Load the specified Lua script into the script cache.
    `RedisClient` | RedisClient.`scriptLoad(String script, Handler<AsyncResult<String>> handler)` Load the specified Lua script into the script cache.
    `RedisClient` | RedisClient.`sdiff(String key, List<String> cmpkeys, Handler<AsyncResult<JsonArray>> handler)` Subtract multiple sets
    `RedisTransaction` | RedisTransaction.`sdiff(String key, List<String> cmpkeys, Handler<AsyncResult<String>> handler)` Subtract multiple sets
    `RedisClient` | RedisClient.`sdiffstore(String destkey, String key, List<String> cmpkeys, Handler<AsyncResult<Long>> handler)` Subtract multiple sets and store the resulting set in a key
    `RedisTransaction` | RedisTransaction.`sdiffstore(String destkey, String key, List<String> cmpkeys, Handler<AsyncResult<String>> handler)` Subtract multiple sets and store the resulting set in a key
    `RedisTransaction` | RedisTransaction.`select(int dbindex, Handler<AsyncResult<String>> handler)` Change the selected database for the current connection
    `RedisClient` | RedisClient.`select(int dbindex, Handler<AsyncResult<String>> handler)` Change the selected database for the current connection
    `RedisTransaction` | RedisTransaction.`set(String key, String value, Handler<AsyncResult<String>> handler)` Set the string value of a key
    `RedisClient` | RedisClient.`set(String key, String value, Handler<AsyncResult<Void>> handler)` Set the string value of a key
    `RedisTransaction` | RedisTransaction.`setBinary(String key, Buffer value, Handler<AsyncResult<String>> handler)` Set the binary string value of a key - without encoding as utf-8
    `RedisClient` | RedisClient.`setBinary(String key, Buffer value, Handler<AsyncResult<Void>> handler)` Set the binary string value of a key - without encoding as utf-8
    `RedisTransaction` | RedisTransaction.`setBinaryWithOptions(String key, Buffer value, SetOptions options, Handler<AsyncResult<String>> handler)` Set the string value of a key
    `RedisClient` | RedisClient.`setBinaryWithOptions(String key, Buffer value, SetOptions options, Handler<AsyncResult<Void>> handler)` Set the string value of a key
    `RedisClient` | RedisClient.`setbit(String key, long offset, int bit, Handler<AsyncResult<Long>> handler)` Sets or clears the bit at offset in the string value stored at key
    `RedisTransaction` | RedisTransaction.`setbit(String key, long offset, int bit, Handler<AsyncResult<String>> handler)` Sets or clears the bit at offset in the string value stored at key
    `RedisTransaction` | RedisTransaction.`setex(String key, long seconds, String value, Handler<AsyncResult<String>> handler)` Set the value and expiration of a key
    `RedisClient` | RedisClient.`setex(String key, long seconds, String value, Handler<AsyncResult<String>> handler)` Set the value and expiration of a key
    `RedisClient` | RedisClient.`setnx(String key, String value, Handler<AsyncResult<Long>> handler)` Set the value of a key, only if the key does not exist
    `RedisTransaction` | RedisTransaction.`setnx(String key, String value, Handler<AsyncResult<String>> handler)` Set the value of a key, only if the key does not exist
    `RedisClient` | RedisClient.`setrange(String key, int offset, String value, Handler<AsyncResult<Long>> handler)` Overwrite part of a string at key starting at the specified offset
    `RedisTransaction` | RedisTransaction.`setrange(String key, int offset, String value, Handler<AsyncResult<String>> handler)` Overwrite part of a string at key starting at the specified offset
    `RedisTransaction` | RedisTransaction.`setWithOptions(String key, String value, SetOptions options, Handler<AsyncResult<String>> handler)` Set the string value of a key
    `RedisClient` | RedisClient.`setWithOptions(String key, String value, SetOptions options, Handler<AsyncResult<String>> handler)` Set the string value of a key
    `RedisClient` | RedisClient.`sinter(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Intersect multiple sets
    `RedisTransaction` | RedisTransaction.`sinter(List<String> keys, Handler<AsyncResult<String>> handler)` Intersect multiple sets
    `RedisClient` | RedisClient.`sinterstore(String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Intersect multiple sets and store the resulting set in a key
    `RedisTransaction` | RedisTransaction.`sinterstore(String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Intersect multiple sets and store the resulting set in a key
    `RedisClient` | RedisClient.`sismember(String key, String member, Handler<AsyncResult<Long>> handler)` Determine if a given value is a member of a set
    `RedisTransaction` | RedisTransaction.`sismember(String key, String member, Handler<AsyncResult<String>> handler)` Determine if a given value is a member of a set
    `RedisTransaction` | RedisTransaction.`slaveof(String host, int port, Handler<AsyncResult<String>> handler)` Make the server a slave of another instance
    `RedisClient` | RedisClient.`slaveof(String host, int port, Handler<AsyncResult<String>> handler)` Make the server a slave of another instance
    `RedisTransaction` | RedisTransaction.`slaveofNoone(Handler<AsyncResult<String>> handler)` Make this server a master
    `RedisClient` | RedisClient.`slaveofNoone(Handler<AsyncResult<String>> handler)` Make this server a master
    `RedisClient` | RedisClient.`slowlogGet(int limit, Handler<AsyncResult<JsonArray>> handler)` Read the Redis slow queries log
    `RedisTransaction` | RedisTransaction.`slowlogGet(int limit, Handler<AsyncResult<String>> handler)` Read the Redis slow queries log
    `RedisClient` | RedisClient.`slowlogLen(Handler<AsyncResult<Long>> handler)` Get the length of the Redis slow queries log
    `RedisTransaction` | RedisTransaction.`slowlogLen(Handler<AsyncResult<String>> handler)` Get the length of the Redis slow queries log
    `RedisTransaction` | RedisTransaction.`slowlogReset(Handler<AsyncResult<String>> handler)` Reset the Redis slow queries log
    `RedisClient` | RedisClient.`slowlogReset(Handler<AsyncResult<Void>> handler)` Reset the Redis slow queries log
    `RedisTransaction` | RedisTransaction.`smembers(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the members in a set
    `RedisClient` | RedisClient.`smembers(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the members in a set
    `RedisClient` | RedisClient.`smove(String key, String destkey, String member, Handler<AsyncResult<Long>> handler)` Move a member from one set to another
    `RedisTransaction` | RedisTransaction.`smove(String key, String destkey, String member, Handler<AsyncResult<String>> handler)` Move a member from one set to another
    `RedisClient` | RedisClient.`sort(String key, SortOptions options, Handler<AsyncResult<JsonArray>> handler)` Sort the elements in a list, set or sorted set
    `RedisTransaction` | RedisTransaction.`sort(String key, SortOptions options, Handler<AsyncResult<String>> handler)` Sort the elements in a list, set or sorted set
    `RedisTransaction` | RedisTransaction.`spop(String key, Handler<AsyncResult<String>> handler)` Remove and return a random member from a set
    `RedisClient` | RedisClient.`spop(String key, Handler<AsyncResult<String>> handler)` Remove and return a random member from a set
    `RedisClient` | RedisClient.`spopMany(String key, int count, Handler<AsyncResult<JsonArray>> handler)` Remove and return random members from a set
    `RedisTransaction` | RedisTransaction.`spopMany(String key, int count, Handler<AsyncResult<String>> handler)` Remove and return random members from a set
    `RedisTransaction` | RedisTransaction.`srandmember(String key, Handler<AsyncResult<String>> handler)` Get one or multiple random members from a set
    `RedisClient` | RedisClient.`srandmember(String key, Handler<AsyncResult<String>> handler)` Get one or multiple random members from a set
    `RedisClient` | RedisClient.`srandmemberCount(String key, int count, Handler<AsyncResult<JsonArray>> handler)` Get one or multiple random members from a set
    `RedisTransaction` | RedisTransaction.`srandmemberCount(String key, int count, Handler<AsyncResult<String>> handler)` Get one or multiple random members from a set
    `RedisClient` | RedisClient.`srem(String key, String member, Handler<AsyncResult<Long>> handler)` Remove one member from a set
    `RedisTransaction` | RedisTransaction.`srem(String key, String member, Handler<AsyncResult<String>> handler)` Remove one member from a set
    `RedisClient` | RedisClient.`sremMany(String key, List<String> members, Handler<AsyncResult<Long>> handler)` Remove one or more members from a set
    `RedisTransaction` | RedisTransaction.`sremMany(String key, List<String> members, Handler<AsyncResult<String>> handler)` Remove one or more members from a set
    `RedisClient` | RedisClient.`sscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate Set elements
    `RedisTransaction` | RedisTransaction.`sscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<String>> handler)` Incrementally iterate Set elements
    `RedisClient` | RedisClient.`strlen(String key, Handler<AsyncResult<Long>> handler)` Get the length of the value stored in a key
    `RedisTransaction` | RedisTransaction.`strlen(String key, Handler<AsyncResult<String>> handler)` Get the length of the value stored in a key
    `RedisClient` | RedisClient.`subscribe(String channel, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to the given channels
    `RedisTransaction` | RedisTransaction.`subscribe(String channel, Handler<AsyncResult<String>> handler)` Listen for messages published to the given channels
    `RedisClient` | RedisClient.`subscribeMany(List<String> channels, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to the given channels
    `RedisTransaction` | RedisTransaction.`subscribeMany(List<String> channels, Handler<AsyncResult<String>> handler)` Listen for messages published to the given channels
    `RedisClient` | RedisClient.`sunion(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Add multiple sets
    `RedisTransaction` | RedisTransaction.`sunion(List<String> keys, Handler<AsyncResult<String>> handler)` Add multiple sets
    `RedisClient` | RedisClient.`sunionstore(String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Add multiple sets and store the resulting set in a key
    `RedisTransaction` | RedisTransaction.`sunionstore(String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Add multiple sets and store the resulting set in a key
    `RedisTransaction` | RedisTransaction.`swapdb(int index1, int index2, Handler<AsyncResult<String>> handler)` Swaps two Redis databases
    `RedisClient` | RedisClient.`swapdb(int index1, int index2, Handler<AsyncResult<String>> handler)` Swaps two Redis databases
    `RedisTransaction` | RedisTransaction.`sync(Handler<AsyncResult<String>> handler)` Internal command used for replication
    `RedisClient` | RedisClient.`sync(Handler<AsyncResult<Void>> handler)` Internal command used for replication
    `RedisClient` | RedisClient.`time(Handler<AsyncResult<JsonArray>> handler)` Return the current server time
    `RedisTransaction` | RedisTransaction.`time(Handler<AsyncResult<String>> handler)` Return the current server time
    `RedisClient` | RedisClient.`touch(String key, Handler<AsyncResult<Long>> handler)` Alters the last access time of a key(s).
    `RedisClient` | RedisClient.`touchMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Alters the last access time of a key(s).
    `RedisClient` | RedisClient.`ttl(String key, Handler<AsyncResult<Long>> handler)` Get the time to live for a key
    `RedisTransaction` | RedisTransaction.`ttl(String key, Handler<AsyncResult<String>> handler)` Get the time to live for a key
    `RedisTransaction` | RedisTransaction.`type(String key, Handler<AsyncResult<String>> handler)` Determine the type stored at key
    `RedisClient` | RedisClient.`type(String key, Handler<AsyncResult<String>> handler)` Determine the type stored at key
    `RedisClient` | RedisClient.`unlink(String key, Handler<AsyncResult<Long>> handler)` Delete a key asynchronously in another thread.
    `RedisTransaction` | RedisTransaction.`unlink(String key, Handler<AsyncResult<String>> handler)` Delete a key asynchronously in another thread.
    `RedisClient` | RedisClient.`unlinkMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Delete multiple keys asynchronously in another thread.
    `RedisTransaction` | RedisTransaction.`unlinkMany(List<String> keys, Handler<AsyncResult<String>> handler)` Delete multiple keys asynchronously in another thread.
    `RedisTransaction` | RedisTransaction.`unsubscribe(List<String> channels, Handler<AsyncResult<String>> handler)` Stop listening for messages posted to the given channels
    `RedisClient` | RedisClient.`unsubscribe(List<String> channels, Handler<AsyncResult<Void>> handler)` Stop listening for messages posted to the given channels
    `RedisTransaction` | RedisTransaction.`unwatch(Handler<AsyncResult<String>> handler)` Forget about all watched keys
    `RedisTransaction` | RedisTransaction.`wait(long numSlaves, long timeout, Handler<AsyncResult<String>> handler)` Wait for the synchronous replication of all the write commands sent in the context of the current connection.
    `RedisClient` | RedisClient.`wait(long numSlaves, long timeout, Handler<AsyncResult<String>> handler)` Wait for the synchronous replication of all the write commands sent in the context of the current connection.
    `RedisTransaction` | RedisTransaction.`watch(String key, Handler<AsyncResult<String>> handler)` Watch the given keys to determine execution of the MULTI/EXEC block
    `RedisTransaction` | RedisTransaction.`watchMany(List<String> keys, Handler<AsyncResult<String>> handler)` Watch the given keys to determine execution of the MULTI/EXEC block
    `RedisClient` | RedisClient.`zadd(String key, double score, String member, Handler<AsyncResult<Long>> handler)` Add one or more members to a sorted set, or update its score if it already exists
    `RedisTransaction` | RedisTransaction.`zadd(String key, double score, String member, Handler<AsyncResult<String>> handler)` Add one or more members to a sorted set, or update its score if it already exists
    `RedisClient` | RedisClient.`zaddMany(String key, Map<String,Double> members, Handler<AsyncResult<Long>> handler)` Add one or more members to a sorted set, or update its score if it already exists
    `RedisTransaction` | RedisTransaction.`zaddMany(String key, Map<String,Double> members, Handler<AsyncResult<String>> handler)` Add one or more members to a sorted set, or update its score if it already exists
    `RedisClient` | RedisClient.`zcard(String key, Handler<AsyncResult<Long>> handler)` Get the number of members in a sorted set
    `RedisTransaction` | RedisTransaction.`zcard(String key, Handler<AsyncResult<String>> handler)` Get the number of members in a sorted set
    `RedisClient` | RedisClient.`zcount(String key, double min, double max, Handler<AsyncResult<Long>> handler)` Count the members in a sorted set with scores within the given values
    `RedisTransaction` | RedisTransaction.`zcount(String key, double min, double max, Handler<AsyncResult<String>> handler)` Count the members in a sorted set with scores within the given values
    `RedisTransaction` | RedisTransaction.`zincrby(String key, double increment, String member, Handler<AsyncResult<String>> handler)` Increment the score of a member in a sorted set
    `RedisClient` | RedisClient.`zincrby(String key, double increment, String member, Handler<AsyncResult<String>> handler)` Increment the score of a member in a sorted set
    `RedisClient` | RedisClient.`zinterstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key
    `RedisTransaction` | RedisTransaction.`zinterstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<String>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key
    `RedisClient` | RedisClient.`zinterstoreWeighed(String destkey, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
    `RedisTransaction` | RedisTransaction.`zinterstoreWeighed(String destkey, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<String>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
    `RedisClient` | RedisClient.`zlexcount(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Count the number of members in a sorted set between a given lexicographical range
    `RedisTransaction` | RedisTransaction.`zlexcount(String key, String min, String max, Handler<AsyncResult<String>> handler)` Count the number of members in a sorted set between a given lexicographical range
    `RedisClient` | RedisClient.`zrange(String key, long start, long stop, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index
    `RedisTransaction` | RedisTransaction.`zrange(String key, long start, long stop, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by index
    `RedisClient` | RedisClient.`zrangebylex(String key, String min, String max, LimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by lexicographical range
    `RedisTransaction` | RedisTransaction.`zrangebylex(String key, String min, String max, LimitOptions options, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by lexicographical range
    `RedisClient` | RedisClient.`zrangebyscore(String key, String min, String max, RangeLimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score
    `RedisTransaction` | RedisTransaction.`zrangebyscore(String key, String min, String max, RangeLimitOptions options, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by score
    `RedisClient` | RedisClient.`zrangeWithOptions(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index
    `RedisTransaction` | RedisTransaction.`zrangeWithOptions(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by index
    `RedisClient` | RedisClient.`zrank(String key, String member, Handler<AsyncResult<Long>> handler)` Determine the index of a member in a sorted set
    `RedisTransaction` | RedisTransaction.`zrank(String key, String member, Handler<AsyncResult<String>> handler)` Determine the index of a member in a sorted set
    `RedisClient` | RedisClient.`zrem(String key, String member, Handler<AsyncResult<Long>> handler)` Remove one member from a sorted set
    `RedisTransaction` | RedisTransaction.`zrem(String key, String member, Handler<AsyncResult<String>> handler)` Remove one member from a sorted set
    `RedisClient` | RedisClient.`zremMany(String key, List<String> members, Handler<AsyncResult<Long>> handler)` Remove one or more members from a sorted set
    `RedisTransaction` | RedisTransaction.`zremMany(String key, List<String> members, Handler<AsyncResult<String>> handler)` Remove one or more members from a sorted set
    `RedisClient` | RedisClient.`zremrangebylex(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Remove all members in a sorted set between the given lexicographical range
    `RedisTransaction` | RedisTransaction.`zremrangebylex(String key, String min, String max, Handler<AsyncResult<String>> handler)` Remove all members in a sorted set between the given lexicographical range
    `RedisClient` | RedisClient.`zremrangebyrank(String key, long start, long stop, Handler<AsyncResult<Long>> handler)` Remove all members in a sorted set within the given indexes
    `RedisTransaction` | RedisTransaction.`zremrangebyrank(String key, long start, long stop, Handler<AsyncResult<String>> handler)` Remove all members in a sorted set within the given indexes
    `RedisClient` | RedisClient.`zremrangebyscore(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Remove all members in a sorted set within the given scores
    `RedisTransaction` | RedisTransaction.`zremrangebyscore(String key, String min, String max, Handler<AsyncResult<String>> handler)` Remove all members in a sorted set within the given scores
    `RedisClient` | RedisClient.`zrevrange(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index, with scores ordered from high to low
    `RedisTransaction` | RedisTransaction.`zrevrange(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by index, with scores ordered from high to low
    `RedisClient` | RedisClient.`zrevrangebylex(String key, String max, String min, LimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
    `RedisTransaction` | RedisTransaction.`zrevrangebylex(String key, String max, String min, LimitOptions options, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
    `RedisClient` | RedisClient.`zrevrangebyscore(String key, String max, String min, RangeLimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score, with scores ordered from high to low
    `RedisTransaction` | RedisTransaction.`zrevrangebyscore(String key, String max, String min, RangeLimitOptions options, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by score, with scores ordered from high to low
    `RedisClient` | RedisClient.`zrevrank(String key, String member, Handler<AsyncResult<Long>> handler)` Determine the index of a member in a sorted set, with scores ordered from high to low
    `RedisTransaction` | RedisTransaction.`zrevrank(String key, String member, Handler<AsyncResult<String>> handler)` Determine the index of a member in a sorted set, with scores ordered from high to low
    `RedisClient` | RedisClient.`zscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate sorted sets elements and associated scores
    `RedisTransaction` | RedisTransaction.`zscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<String>> handler)` Incrementally iterate sorted sets elements and associated scores
    `RedisTransaction` | RedisTransaction.`zscore(String key, String member, Handler<AsyncResult<String>> handler)` Get the score associated with the given member in a sorted set
    `RedisClient` | RedisClient.`zscore(String key, String member, Handler<AsyncResult<String>> handler)` Get the score associated with the given member in a sorted set
    `RedisClient` | RedisClient.`zunionstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Add multiple sorted sets and store the resulting sorted set in a new key
    `RedisTransaction` | RedisTransaction.`zunionstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<String>> handler)` Add multiple sorted sets and store the resulting sorted set in a new key
    `RedisClient` | RedisClient.`zunionstoreWeighed(String key, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Add multiple sorted sets using weights, and store the resulting sorted set in a new key
    `RedisTransaction` | RedisTransaction.`zunionstoreWeighed(String key, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<String>> handler)` Add multiple sorted sets using weights, and store the resulting sorted set in a new key

  - ### Uses of Handler in io.vertx.rxjava.redis.client

    Methods in io.vertx.rxjava.redis.client with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `RedisAPI` | RedisAPI.`append(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command append.
    `RedisAPI` | RedisAPI.`asking(Handler<AsyncResult<Response>> handler)` Redis command asking.
    `RedisAPI` | RedisAPI.`auth(String arg0, Handler<AsyncResult<Response>> handler)` Redis command auth.
    `Redis` | Redis.`batch(List<Request> commands, Handler<AsyncResult<List<Response>>> onSend)` Sends a list of commands in a single IO operation, this prevents any inter twinning to happen from other client users.
    `RedisConnection` | RedisConnection.`batch(List<Request> commands, Handler<AsyncResult<List<Response>>> onSend)` Sends a list of commands in a single IO operation, this prevents any inter twinning to happen from other client users.
    `RedisAPI` | RedisAPI.`bgrewriteaof(Handler<AsyncResult<Response>> handler)` Redis command bgrewriteaof.
    `RedisAPI` | RedisAPI.`bgsave(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bgsave.
    `RedisAPI` | RedisAPI.`bitcount(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bitcount.
    `RedisAPI` | RedisAPI.`bitfield(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bitfield.
    `RedisAPI` | RedisAPI.`bitop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bitop.
    `RedisAPI` | RedisAPI.`bitpos(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bitpos.
    `RedisAPI` | RedisAPI.`blpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command blpop.
    `RedisAPI` | RedisAPI.`brpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command brpop.
    `RedisAPI` | RedisAPI.`brpoplpush(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command brpoplpush.
    `RedisAPI` | RedisAPI.`bzpopmax(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bzpopmax.
    `RedisAPI` | RedisAPI.`bzpopmin(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bzpopmin.
    `RedisAPI` | RedisAPI.`client(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command client.
    `RedisAPI` | RedisAPI.`cluster(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command cluster.
    `RedisAPI` | RedisAPI.`command(Handler<AsyncResult<Response>> handler)` Redis command command.
    `RedisAPI` | RedisAPI.`config(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command config.
    `Redis` | Redis.`connect(Handler<AsyncResult<RedisConnection>> handler)` Connects to the redis server.
    `RedisAPI` | RedisAPI.`dbsize(Handler<AsyncResult<Response>> handler)` Redis command dbsize.
    `RedisAPI` | RedisAPI.`debug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command debug.
    `RedisAPI` | RedisAPI.`decr(String arg0, Handler<AsyncResult<Response>> handler)` Redis command decr.
    `RedisAPI` | RedisAPI.`decrby(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command decrby.
    `RedisAPI` | RedisAPI.`del(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command del.
    `RedisAPI` | RedisAPI.`discard(Handler<AsyncResult<Response>> handler)` Redis command discard.
    `RedisAPI` | RedisAPI.`dump(String arg0, Handler<AsyncResult<Response>> handler)` Redis command dump.
    `RedisAPI` | RedisAPI.`echo(String arg0, Handler<AsyncResult<Response>> handler)` Redis command echo.
    `RedisConnection` | RedisConnection.`endHandler(Handler<Void> endHandler)`
    `RedisAPI` | RedisAPI.`eval(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command eval.
    `RedisAPI` | RedisAPI.`evalsha(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command evalsha.
    `RedisConnection` | RedisConnection.`exceptionHandler(Handler<Throwable> handler)`
    `RedisAPI` | RedisAPI.`exec(Handler<AsyncResult<Response>> handler)` Redis command exec.
    `RedisAPI` | RedisAPI.`exists(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command exists.
    `RedisAPI` | RedisAPI.`expire(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command expire.
    `RedisAPI` | RedisAPI.`expireat(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command expireat.
    `RedisAPI` | RedisAPI.`flushall(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command flushall.
    `RedisAPI` | RedisAPI.`flushdb(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command flushdb.
    `RedisAPI` | RedisAPI.`geoadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command geoadd.
    `RedisAPI` | RedisAPI.`geodist(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command geodist.
    `RedisAPI` | RedisAPI.`geohash(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command geohash.
    `RedisAPI` | RedisAPI.`geopos(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command geopos.
    `RedisAPI` | RedisAPI.`georadius(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command georadius.
    `RedisAPI` | RedisAPI.`georadiusbymember(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command georadiusbymember.
    `RedisAPI` | RedisAPI.`georadiusbymemberRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command georadiusbymemberRo.
    `RedisAPI` | RedisAPI.`georadiusRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command georadiusRo.
    `RedisAPI` | RedisAPI.`get(String arg0, Handler<AsyncResult<Response>> handler)` Redis command get.
    `RedisAPI` | RedisAPI.`getbit(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command getbit.
    `RedisAPI` | RedisAPI.`getrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command getrange.
    `RedisAPI` | RedisAPI.`getset(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command getset.
    `RedisConnection` | RedisConnection.`handler(Handler<Response> handler)`
    `RedisAPI` | RedisAPI.`hdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command hdel.
    `RedisAPI` | RedisAPI.`hexists(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command hexists.
    `RedisAPI` | RedisAPI.`hget(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command hget.
    `RedisAPI` | RedisAPI.`hgetall(String arg0, Handler<AsyncResult<Response>> handler)` Redis command hgetall.
    `RedisAPI` | RedisAPI.`hincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command hincrby.
    `RedisAPI` | RedisAPI.`hincrbyfloat(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command hincrbyfloat.
    `RedisAPI` | RedisAPI.`hkeys(String arg0, Handler<AsyncResult<Response>> handler)` Redis command hkeys.
    `RedisAPI` | RedisAPI.`hlen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command hlen.
    `RedisAPI` | RedisAPI.`hmget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command hmget.
    `RedisAPI` | RedisAPI.`hmset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command hmset.
    `RedisAPI` | RedisAPI.`host(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command host.
    `RedisAPI` | RedisAPI.`hscan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command hscan.
    `RedisAPI` | RedisAPI.`hset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command hset.
    `RedisAPI` | RedisAPI.`hsetnx(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command hsetnx.
    `RedisAPI` | RedisAPI.`hstrlen(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command hstrlen.
    `RedisAPI` | RedisAPI.`hvals(String arg0, Handler<AsyncResult<Response>> handler)` Redis command hvals.
    `RedisAPI` | RedisAPI.`incr(String arg0, Handler<AsyncResult<Response>> handler)` Redis command incr.
    `RedisAPI` | RedisAPI.`incrby(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command incrby.
    `RedisAPI` | RedisAPI.`incrbyfloat(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command incrbyfloat.
    `RedisAPI` | RedisAPI.`info(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command info.
    `RedisAPI` | RedisAPI.`keys(String arg0, Handler<AsyncResult<Response>> handler)` Redis command keys.
    `RedisAPI` | RedisAPI.`lastsave(Handler<AsyncResult<Response>> handler)` Redis command lastsave.
    `RedisAPI` | RedisAPI.`latency(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command latency.
    `RedisAPI` | RedisAPI.`lindex(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command lindex.
    `RedisAPI` | RedisAPI.`linsert(String arg0, String arg1, String arg2, String arg3, Handler<AsyncResult<Response>> handler)` Redis command linsert.
    `RedisAPI` | RedisAPI.`llen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command llen.
    `RedisAPI` | RedisAPI.`lolwut(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command lolwut.
    `RedisAPI` | RedisAPI.`lpop(String arg0, Handler<AsyncResult<Response>> handler)` Redis command lpop.
    `RedisAPI` | RedisAPI.`lpush(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command lpush.
    `RedisAPI` | RedisAPI.`lpushx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command lpushx.
    `RedisAPI` | RedisAPI.`lrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command lrange.
    `RedisAPI` | RedisAPI.`lrem(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command lrem.
    `RedisAPI` | RedisAPI.`lset(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command lset.
    `RedisAPI` | RedisAPI.`ltrim(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ltrim.
    `RedisAPI` | RedisAPI.`memory(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command memory.
    `RedisAPI` | RedisAPI.`mget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command mget.
    `RedisAPI` | RedisAPI.`migrate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command migrate.
    `RedisAPI` | RedisAPI.`module(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command module.
    `RedisAPI` | RedisAPI.`monitor(Handler<AsyncResult<Response>> handler)` Redis command monitor.
    `RedisAPI` | RedisAPI.`move(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command move.
    `RedisAPI` | RedisAPI.`mset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command mset.
    `RedisAPI` | RedisAPI.`msetnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command msetnx.
    `RedisAPI` | RedisAPI.`multi(Handler<AsyncResult<Response>> handler)` Redis command multi.
    `RedisAPI` | RedisAPI.`object(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command object.
    `RedisAPI` | RedisAPI.`persist(String arg0, Handler<AsyncResult<Response>> handler)` Redis command persist.
    `RedisAPI` | RedisAPI.`pexpire(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command pexpire.
    `RedisAPI` | RedisAPI.`pexpireat(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command pexpireat.
    `RedisAPI` | RedisAPI.`pfadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command pfadd.
    `RedisAPI` | RedisAPI.`pfcount(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command pfcount.
    `RedisAPI` | RedisAPI.`pfdebug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command pfdebug.
    `RedisAPI` | RedisAPI.`pfmerge(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command pfmerge.
    `RedisAPI` | RedisAPI.`pfselftest(Handler<AsyncResult<Response>> handler)` Redis command pfselftest.
    `RedisAPI` | RedisAPI.`ping(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ping.
    `void` | RedisConnection.`pipeTo(WriteStream<Response> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `RedisAPI` | RedisAPI.`post(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command post.
    `RedisAPI` | RedisAPI.`psetex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command psetex.
    `RedisAPI` | RedisAPI.`psubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command psubscribe.
    `RedisAPI` | RedisAPI.`psync(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command psync.
    `RedisAPI` | RedisAPI.`pttl(String arg0, Handler<AsyncResult<Response>> handler)` Redis command pttl.
    `RedisAPI` | RedisAPI.`publish(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command publish.
    `RedisAPI` | RedisAPI.`pubsub(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command pubsub.
    `RedisAPI` | RedisAPI.`punsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command punsubscribe.
    `RedisAPI` | RedisAPI.`randomkey(Handler<AsyncResult<Response>> handler)` Redis command randomkey.
    `RedisAPI` | RedisAPI.`readonly(Handler<AsyncResult<Response>> handler)` Redis command readonly.
    `RedisAPI` | RedisAPI.`readwrite(Handler<AsyncResult<Response>> handler)` Redis command readwrite.
    `RedisAPI` | RedisAPI.`rename(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command rename.
    `RedisAPI` | RedisAPI.`renamenx(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command renamenx.
    `RedisAPI` | RedisAPI.`replconf(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command replconf.
    `RedisAPI` | RedisAPI.`replicaof(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command replicaof.
    `RedisAPI` | RedisAPI.`restore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command restore.
    `RedisAPI` | RedisAPI.`restoreAsking(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command restoreAsking.
    `RedisAPI` | RedisAPI.`role(Handler<AsyncResult<Response>> handler)` Redis command role.
    `RedisAPI` | RedisAPI.`rpop(String arg0, Handler<AsyncResult<Response>> handler)` Redis command rpop.
    `RedisAPI` | RedisAPI.`rpoplpush(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command rpoplpush.
    `RedisAPI` | RedisAPI.`rpush(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command rpush.
    `RedisAPI` | RedisAPI.`rpushx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command rpushx.
    `RedisAPI` | RedisAPI.`sadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sadd.
    `RedisAPI` | RedisAPI.`save(Handler<AsyncResult<Response>> handler)` Redis command save.
    `RedisAPI` | RedisAPI.`scan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command scan.
    `RedisAPI` | RedisAPI.`scard(String arg0, Handler<AsyncResult<Response>> handler)` Redis command scard.
    `RedisAPI` | RedisAPI.`script(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command script.
    `RedisAPI` | RedisAPI.`sdiff(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sdiff.
    `RedisAPI` | RedisAPI.`sdiffstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sdiffstore.
    `RedisAPI` | RedisAPI.`select(String arg0, Handler<AsyncResult<Response>> handler)` Redis command select.
    `Redis` | Redis.`send(Request command, Handler<AsyncResult<Response>> onSend)` Send the given command to the redis server or cluster.
    `RedisConnection` | RedisConnection.`send(Request command, Handler<AsyncResult<Response>> onSend)` Send the given command to the redis server or cluster.
    `RedisAPI` | RedisAPI.`set(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command set.
    `RedisAPI` | RedisAPI.`setbit(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command setbit.
    `RedisAPI` | RedisAPI.`setex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command setex.
    `RedisAPI` | RedisAPI.`setnx(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command setnx.
    `RedisAPI` | RedisAPI.`setrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command setrange.
    `RedisAPI` | RedisAPI.`shutdown(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command shutdown.
    `RedisAPI` | RedisAPI.`sinter(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sinter.
    `RedisAPI` | RedisAPI.`sinterstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sinterstore.
    `RedisAPI` | RedisAPI.`sismember(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command sismember.
    `RedisAPI` | RedisAPI.`slaveof(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command slaveof.
    `RedisAPI` | RedisAPI.`slowlog(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command slowlog.
    `RedisAPI` | RedisAPI.`smembers(String arg0, Handler<AsyncResult<Response>> handler)` Redis command smembers.
    `RedisAPI` | RedisAPI.`smove(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command smove.
    `RedisAPI` | RedisAPI.`sort(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sort.
    `RedisAPI` | RedisAPI.`spop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command spop.
    `RedisAPI` | RedisAPI.`srandmember(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command srandmember.
    `RedisAPI` | RedisAPI.`srem(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command srem.
    `RedisAPI` | RedisAPI.`sscan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sscan.
    `RedisAPI` | RedisAPI.`strlen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command strlen.
    `RedisAPI` | RedisAPI.`subscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command subscribe.
    `RedisAPI` | RedisAPI.`substr(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command substr.
    `RedisAPI` | RedisAPI.`sunion(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sunion.
    `RedisAPI` | RedisAPI.`sunionstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sunionstore.
    `RedisAPI` | RedisAPI.`swapdb(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command swapdb.
    `RedisAPI` | RedisAPI.`sync(Handler<AsyncResult<Response>> handler)` Redis command sync.
    `RedisAPI` | RedisAPI.`time(Handler<AsyncResult<Response>> handler)` Redis command time.
    `RedisAPI` | RedisAPI.`touch(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command touch.
    `RedisAPI` | RedisAPI.`ttl(String arg0, Handler<AsyncResult<Response>> handler)` Redis command ttl.
    `RedisAPI` | RedisAPI.`type(String arg0, Handler<AsyncResult<Response>> handler)` Redis command type.
    `RedisAPI` | RedisAPI.`unlink(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command unlink.
    `RedisAPI` | RedisAPI.`unsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command unsubscribe.
    `RedisAPI` | RedisAPI.`unwatch(Handler<AsyncResult<Response>> handler)` Redis command unwatch.
    `RedisAPI` | RedisAPI.`wait(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command wait.
    `RedisAPI` | RedisAPI.`watch(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command watch.
    `RedisAPI` | RedisAPI.`xack(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xack.
    `RedisAPI` | RedisAPI.`xadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xadd.
    `RedisAPI` | RedisAPI.`xclaim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xclaim.
    `RedisAPI` | RedisAPI.`xdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xdel.
    `RedisAPI` | RedisAPI.`xgroup(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xgroup.
    `RedisAPI` | RedisAPI.`xinfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xinfo.
    `RedisAPI` | RedisAPI.`xlen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command xlen.
    `RedisAPI` | RedisAPI.`xpending(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xpending.
    `RedisAPI` | RedisAPI.`xrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xrange.
    `RedisAPI` | RedisAPI.`xread(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xread.
    `RedisAPI` | RedisAPI.`xreadgroup(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xreadgroup.
    `RedisAPI` | RedisAPI.`xrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xrevrange.
    `RedisAPI` | RedisAPI.`xsetid(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command xsetid.
    `RedisAPI` | RedisAPI.`xtrim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xtrim.
    `RedisAPI` | RedisAPI.`zadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zadd.
    `RedisAPI` | RedisAPI.`zcard(String arg0, Handler<AsyncResult<Response>> handler)` Redis command zcard.
    `RedisAPI` | RedisAPI.`zcount(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command zcount.
    `RedisAPI` | RedisAPI.`zincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command zincrby.
    `RedisAPI` | RedisAPI.`zinterstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zinterstore.
    `RedisAPI` | RedisAPI.`zlexcount(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command zlexcount.
    `RedisAPI` | RedisAPI.`zpopmax(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zpopmax.
    `RedisAPI` | RedisAPI.`zpopmin(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zpopmin.
    `RedisAPI` | RedisAPI.`zrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrange.
    `RedisAPI` | RedisAPI.`zrangebylex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrangebylex.
    `RedisAPI` | RedisAPI.`zrangebyscore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrangebyscore.
    `RedisAPI` | RedisAPI.`zrank(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command zrank.
    `RedisAPI` | RedisAPI.`zrem(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrem.
    `RedisAPI` | RedisAPI.`zremrangebylex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command zremrangebylex.
    `RedisAPI` | RedisAPI.`zremrangebyrank(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command zremrangebyrank.
    `RedisAPI` | RedisAPI.`zremrangebyscore(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command zremrangebyscore.
    `RedisAPI` | RedisAPI.`zrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrevrange.
    `RedisAPI` | RedisAPI.`zrevrangebylex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrevrangebylex.
    `RedisAPI` | RedisAPI.`zrevrangebyscore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrevrangebyscore.
    `RedisAPI` | RedisAPI.`zrevrank(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command zrevrank.
    `RedisAPI` | RedisAPI.`zscan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zscan.
    `RedisAPI` | RedisAPI.`zscore(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command zscore.
    `RedisAPI` | RedisAPI.`zunionstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zunionstore.

  - ### Uses of Handler in io.vertx.rxjava.redis.sentinel

    Methods in io.vertx.rxjava.redis.sentinel with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `RedisSentinel` | RedisSentinel.`ckquorum(String name, Handler<AsyncResult<String>> handler)` Check if the current Sentinel configuration is able to reach the quorum needed to failover a master, and the majority needed to authorize the failover.
    `void` | RedisSentinel.`close(Handler<AsyncResult<Void>> handler)` Close the client - when it is fully closed the handler will be called.
    `RedisSentinel` | RedisSentinel.`failover(String name, Handler<AsyncResult<String>> handler)` Force a failover as if the master was not reachable, and without asking for agreement to other Sentinels (however a new version of the configuration will be published so that the other Sentinels will update their configurations)
    `RedisSentinel` | RedisSentinel.`flushConfig(Handler<AsyncResult<Void>> handler)` Force Sentinel to rewrite its configuration on disk, including the current Sentinel state.
    `RedisSentinel` | RedisSentinel.`getMasterAddrByName(String name, Handler<AsyncResult<JsonArray>> handler)` Return the ip and port number of the master with that name.
    `RedisSentinel` | RedisSentinel.`master(String name, Handler<AsyncResult<JsonArray>> handler)` Show the state and info of the specified master
    `RedisSentinel` | RedisSentinel.`masters(Handler<AsyncResult<JsonArray>> handler)` Show a list of monitored masters and their state
    `RedisSentinel` | RedisSentinel.`reset(String pattern, Handler<AsyncResult<Void>> handler)` Reset all the masters with matching name.
    `RedisSentinel` | RedisSentinel.`sentinels(String name, Handler<AsyncResult<JsonArray>> handler)` Show a list of sentinel instances for this master, and their state
    `RedisSentinel` | RedisSentinel.`slaves(String name, Handler<AsyncResult<JsonArray>> handler)` Show a list of slaves for this master, and their state

  - ### Uses of Handler in io.vertx.rxjava.servicediscovery

    Methods in io.vertx.rxjava.servicediscovery with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static ServiceDiscovery` | ServiceDiscovery.`create(Vertx vertx, Handler<ServiceDiscovery> completionHandler)` Deprecated.
    `static ServiceDiscovery` | ServiceDiscovery.`create(Vertx vertx, ServiceDiscoveryOptions options, Handler<ServiceDiscovery> completionHandler)` Deprecated.
    `void` | ServiceDiscovery.`getRecord(java.util.function.Function<Record,Boolean> filter, boolean includeOutOfService, Handler<AsyncResult<Record>> resultHandler)` Lookups for a single record.
    `void` | ServiceDiscovery.`getRecord(java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<Record>> resultHandler)` Lookups for a single record.
    `void` | ServiceDiscovery.`getRecord(JsonObject filter, Handler<AsyncResult<Record>> resultHandler)` Lookups for a single record.
    `void` | ServiceDiscovery.`getRecords(java.util.function.Function<Record,Boolean> filter, boolean includeOutOfService, Handler<AsyncResult<List<Record>>> resultHandler)` Lookups for a set of records.
    `void` | ServiceDiscovery.`getRecords(java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<List<Record>>> resultHandler)` Lookups for a set of records.
    `void` | ServiceDiscovery.`getRecords(JsonObject filter, Handler<AsyncResult<List<Record>>> resultHandler)` Lookups for a set of records.
    `void` | ServiceDiscovery.`publish(Record record, Handler<AsyncResult<Record>> resultHandler)` Publishes a record.
    `ServiceDiscovery` | ServiceDiscovery.`registerServiceExporter(ServiceExporter exporter, JsonObject configuration, Handler<AsyncResult<Void>> completionHandler)` Registers a discovery bridge.
    `ServiceDiscovery` | ServiceDiscovery.`registerServiceImporter(ServiceImporter importer, JsonObject configuration, Handler<AsyncResult<Void>> completionHandler)` Registers a discovery service importer.
    `void` | ServiceDiscovery.`unpublish(String id, Handler<AsyncResult<Void>> resultHandler)` Un-publishes a record.
    `void` | ServiceDiscovery.`update(Record record, Handler<AsyncResult<Record>> resultHandler)` Updates the given record.

  - ### Uses of Handler in io.vertx.rxjava.servicediscovery.spi

    Methods in io.vertx.rxjava.servicediscovery.spi with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ServiceExporter.`close(Handler<Void> closeHandler)` Close the exporter
    `void` | ServiceImporter.`close(Handler<Void> closeHandler)` Closes the importer
    `void` | ServicePublisher.`publish(Record record, Handler<AsyncResult<Record>> resultHandler)` Publishes a record.
    `void` | ServicePublisher.`unpublish(String id, Handler<AsyncResult<Void>> resultHandler)` Un-publishes a record.
    `void` | ServicePublisher.`update(Record record, Handler<AsyncResult<Record>> resultHandler)` Updates an existing record.

  - ### Uses of Handler in io.vertx.rxjava.servicediscovery.types

    Methods in io.vertx.rxjava.servicediscovery.types with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static void` | HttpEndpoint.`getClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<HttpClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static void` | HttpEndpoint.`getClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, JsonObject conf, Handler<AsyncResult<HttpClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static void` | HttpEndpoint.`getClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<HttpClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static void` | HttpEndpoint.`getClient(ServiceDiscovery discovery, JsonObject filter, JsonObject conf, Handler<AsyncResult<HttpClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static <T> void` | MessageSource.`getConsumer(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<MessageConsumer<T>>> resultHandler)` Convenient method that looks for a message source and provides the configured .
    `static <T> void` | MessageSource.`getConsumer(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<MessageConsumer<T>>> resultHandler)` Convenient method that looks for a message source and provides the configured .
    `static void` | JDBCDataSource.`getJDBCClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<JDBCClient>> resultHandler)` Convenient method that looks for a JDBC datasource source and provides the configured `JDBCClient`.
    `static void` | JDBCDataSource.`getJDBCClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, JsonObject consumerConfiguration, Handler<AsyncResult<JDBCClient>> resultHandler)` Convenient method that looks for a JDBC datasource source and provides the configured `JDBCClient`.
    `static void` | JDBCDataSource.`getJDBCClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<JDBCClient>> resultHandler)` Convenient method that looks for a JDBC datasource source and provides the configured `JDBCClient`.
    `static void` | JDBCDataSource.`getJDBCClient(ServiceDiscovery discovery, JsonObject filter, JsonObject consumerConfiguration, Handler<AsyncResult<JDBCClient>> resultHandler)` Convenient method that looks for a JDBC datasource source and provides the configured `JDBCClient`.
    `static void` | MongoDataSource.`getMongoClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<MongoClient>> resultHandler)` Convenient method that looks for a Mongo datasource source and provides the configured `MongoClient`.
    `static void` | MongoDataSource.`getMongoClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<MongoClient>> resultHandler)` Convenient method that looks for a Mongo datasource source and provides the configured `MongoClient`.
    `static void` | MongoDataSource.`getMongoClient(ServiceDiscovery discovery, JsonObject filter, JsonObject consumerConfiguration, Handler<AsyncResult<MongoClient>> resultHandler)` Convenient method that looks for a Mongo datasource source and provides the configured `MongoClient`.
    `static void` | RedisDataSource.`getRedisClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<RedisClient>> resultHandler)` Convenient method that looks for a Redis data source and provides the configured `RedisClient`.
    `static void` | RedisDataSource.`getRedisClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, JsonObject consumerConfiguration, Handler<AsyncResult<RedisClient>> resultHandler)` Convenient method that looks for a Redis data source and provides the configured `RedisClient`.
    `static void` | RedisDataSource.`getRedisClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<RedisClient>> resultHandler)` Convenient method that looks for a Redis data source and provides the configured `RedisClient`.
    `static void` | RedisDataSource.`getRedisClient(ServiceDiscovery discovery, JsonObject filter, JsonObject consumerConfiguration, Handler<AsyncResult<RedisClient>> resultHandler)` Convenient method that looks for a Redis data source and provides the configured `RedisClient`.
    `static <T> T` | EventBusService.`getServiceProxy(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Class<T> clientClass, Handler<AsyncResult<T>> resultHandler)` Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
    `static <T> T` | EventBusService.`getServiceProxy(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Class<T> clientClass, JsonObject conf, Handler<AsyncResult<T>> resultHandler)` Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
    `static <T> T` | EventBusService.`getServiceProxyWithJsonFilter(ServiceDiscovery discovery, JsonObject filter, Class<T> clientClass, Handler<AsyncResult<T>> resultHandler)` Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
    `static <T> T` | EventBusService.`getServiceProxyWithJsonFilter(ServiceDiscovery discovery, JsonObject filter, Class<T> clientClass, JsonObject conf, Handler<AsyncResult<T>> resultHandler)` Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
    `static void` | HttpEndpoint.`getWebClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<WebClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static void` | HttpEndpoint.`getWebClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, JsonObject conf, Handler<AsyncResult<WebClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static void` | HttpEndpoint.`getWebClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<WebClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static void` | HttpEndpoint.`getWebClient(ServiceDiscovery discovery, JsonObject filter, JsonObject conf, Handler<AsyncResult<WebClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .

  - ### Uses of Handler in io.vertx.rxjava.sqlclient

    Methods in io.vertx.rxjava.sqlclient with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `Transaction` | Transaction.`abortHandler(Handler<Void> handler)` Set an handler to be called when the transaction is aborted.
    `void` | Pool.`begin(Handler<AsyncResult<Transaction>> handler)` Borrow a connection from the pool and begin a transaction, the underlying connection will be returned to the pool when the transaction ends.
    `void` | PreparedStatement.`close(Handler<AsyncResult<Void>> completionHandler)` Like `PreparedStatement.close()` but notifies the `completionHandler` when it's closed.
    `void` | RowStream.`close(Handler<AsyncResult<Void>> completionHandler)` Close the stream and release the resources.
    `void` | Cursor.`close(Handler<AsyncResult<Void>> completionHandler)` Like `Cursor.close()` but with a `completionHandler` called when the cursor has been released.
    `SqlConnection` | SqlConnection.`closeHandler(Handler<Void> handler)` Set an handler called when the connection is closed.
    `void` | Transaction.`commit(Handler<AsyncResult<Void>> handler)` Like `Transaction.commit()` with an handler to be notified when the transaction commit has completed
    `RowStream<T>` | RowStream.`endHandler(Handler<Void> endHandler)`
    `SqlConnection` | SqlConnection.`exceptionHandler(Handler<Throwable> handler)` Set an handler called with connection errors.
    `RowStream<T>` | RowStream.`exceptionHandler(Handler<Throwable> handler)`
    `void` | PreparedQuery.`execute(Handler<AsyncResult<T>> handler)` Execute the query.
    `void` | Query.`execute(Handler<AsyncResult<T>> handler)` Execute the query.
    `void` | PreparedQuery.`execute(Tuple tuple, Handler<AsyncResult<T>> handler)` Execute the query.
    `void` | PreparedQuery.`executeBatch(List<Tuple> batch, Handler<AsyncResult<T>> handler)` Execute the query with a batch of tuples.
    `void` | Pool.`getConnection(Handler<AsyncResult<SqlConnection>> handler)` Get a connection from the pool.
    `RowStream<T>` | RowStream.`handler(Handler<T> handler)`
    `void` | RowStream.`pipeTo(WriteStream<T> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `SqlConnection` | SqlConnection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)` Create a prepared query.
    `Transaction` | Transaction.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)` Create a prepared query.
    `void` | Cursor.`read(int count, Handler<AsyncResult<RowSet<Row>>> handler)` Read rows from the cursor, the result is provided asynchronously to the `handler`.
    `void` | Transaction.`rollback(Handler<AsyncResult<Void>> handler)` Like `Transaction.rollback()` with an handler to be notified when the transaction rollback has completed

  - ### Uses of Handler in io.vertx.servicediscovery

    Methods in io.vertx.servicediscovery with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static ServiceDiscovery` | ServiceDiscovery.`create(Vertx vertx, Handler<ServiceDiscovery> completionHandler)` Deprecated. this will be removed in Vert.x 4, instead use `ServiceDiscovery.create(Vertx)`
    `static ServiceDiscovery` | ServiceDiscovery.`create(Vertx vertx, ServiceDiscoveryOptions options, Handler<ServiceDiscovery> completionHandler)` Deprecated. this will be removed in Vert.x 4, instead use `ServiceDiscovery.create(Vertx, ServiceDiscoveryOptions)`
    `void` | ServiceDiscovery.`getRecord(java.util.function.Function<Record,Boolean> filter, boolean includeOutOfService, Handler<AsyncResult<Record>> resultHandler)` Lookups for a single record.
    `void` | ServiceDiscovery.`getRecord(java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<Record>> resultHandler)` Lookups for a single record.
    `void` | ServiceDiscovery.`getRecord(JsonObject filter, Handler<AsyncResult<Record>> resultHandler)` Lookups for a single record.
    `void` | ServiceDiscovery.`getRecords(java.util.function.Function<Record,Boolean> filter, boolean includeOutOfService, Handler<AsyncResult<List<Record>>> resultHandler)` Lookups for a set of records.
    `void` | ServiceDiscovery.`getRecords(java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<List<Record>>> resultHandler)` Lookups for a set of records.
    `void` | ServiceDiscovery.`getRecords(JsonObject filter, Handler<AsyncResult<List<Record>>> resultHandler)` Lookups for a set of records.
    `void` | ServiceDiscovery.`publish(Record record, Handler<AsyncResult<Record>> resultHandler)` Publishes a record.
    `ServiceDiscovery` | ServiceDiscovery.`registerServiceExporter(ServiceExporter exporter, JsonObject configuration, Handler<AsyncResult<Void>> completionHandler)` Registers a discovery bridge.
    `ServiceDiscovery` | ServiceDiscovery.`registerServiceImporter(ServiceImporter importer, JsonObject configuration, Handler<AsyncResult<Void>> completionHandler)` Registers a discovery service importer.
    `void` | ServiceDiscovery.`unpublish(String id, Handler<AsyncResult<Void>> resultHandler)` Un-publishes a record.
    `void` | ServiceDiscovery.`update(Record record, Handler<AsyncResult<Record>> resultHandler)` Updates the given record.

  - ### Uses of Handler in io.vertx.servicediscovery.backend.redis

    Methods in io.vertx.servicediscovery.backend.redis with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | RedisBackendService.`getRecord(String uuid, Handler<AsyncResult<Record>> resultHandler)`
    `void` | RedisBackendService.`getRecords(Handler<AsyncResult<List<Record>>> resultHandler)`
    `void` | RedisBackendService.`remove(Record record, Handler<AsyncResult<Record>> resultHandler)`
    `void` | RedisBackendService.`remove(String uuid, Handler<AsyncResult<Record>> resultHandler)`
    `void` | RedisBackendService.`store(Record record, Handler<AsyncResult<Record>> resultHandler)`
    `void` | RedisBackendService.`update(Record record, Handler<AsyncResult<Void>> resultHandler)`

  - ### Uses of Handler in io.vertx.servicediscovery.consul

    Methods in io.vertx.servicediscovery.consul with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ConsulServiceImporter.`close(Handler<Void> completionHandler)`

  - ### Uses of Handler in io.vertx.servicediscovery.docker

    Methods in io.vertx.servicediscovery.docker with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | DockerLinksServiceImporter.`close(Handler<Void> completionHandler)`

  - ### Uses of Handler in io.vertx.servicediscovery.kubernetes

    Methods in io.vertx.servicediscovery.kubernetes with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | KubernetesServiceImporter.`close(Handler<Void> completionHandler)`

  - ### Uses of Handler in io.vertx.servicediscovery.spi

    Methods in io.vertx.servicediscovery.spi with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ServiceExporter.`close(Handler<Void> closeHandler)` Close the exporter
    `default void` | ServiceImporter.`close(Handler<Void> closeHandler)` Closes the importer
    `void` | ServiceDiscoveryBackend.`getRecord(String uuid, Handler<AsyncResult<Record>> resultHandler)` Get the record with the given uuid.
    `void` | ServiceDiscoveryBackend.`getRecords(Handler<AsyncResult<List<Record>>> resultHandler)` Gets all the records
    `void` | ServicePublisher.`publish(Record record, Handler<AsyncResult<Record>> resultHandler)` Publishes a record.
    `void` | ServiceDiscoveryBackend.`remove(Record record, Handler<AsyncResult<Record>> resultHandler)` Removes a record.
    `void` | ServiceDiscoveryBackend.`remove(String uuid, Handler<AsyncResult<Record>> resultHandler)` Removes a records based on its UUID.
    `void` | ServiceDiscoveryBackend.`store(Record record, Handler<AsyncResult<Record>> resultHandler)` Stores a record.
    `void` | ServicePublisher.`unpublish(String id, Handler<AsyncResult<Void>> resultHandler)` Un-publishes a record.
    `void` | ServicePublisher.`update(Record record, Handler<AsyncResult<Record>> resultHandler)` Updates an existing record.
    `void` | ServiceDiscoveryBackend.`update(Record record, Handler<AsyncResult<Void>> resultHandler)` Updates a record

  - ### Uses of Handler in io.vertx.servicediscovery.types

    Methods in io.vertx.servicediscovery.types with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static void` | HttpEndpoint.`getClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<HttpClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured `HttpClient`.
    `static void` | HttpEndpoint.`getClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, JsonObject conf, Handler<AsyncResult<HttpClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured `HttpClient`.
    `static void` | HttpEndpoint.`getClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<HttpClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured `HttpClient`.
    `static void` | HttpEndpoint.`getClient(ServiceDiscovery discovery, JsonObject filter, JsonObject conf, Handler<AsyncResult<HttpClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured `HttpClient`.
    `static <T> void` | MessageSource.`getConsumer(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<MessageConsumer<T>>> resultHandler)` Convenient method that looks for a message source and provides the configured `MessageConsumer`.
    `static <T> void` | MessageSource.`getConsumer(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<MessageConsumer<T>>> resultHandler)` Convenient method that looks for a message source and provides the configured `MessageConsumer`.
    `static void` | JDBCDataSource.`getJDBCClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<JDBCClient>> resultHandler)` Convenient method that looks for a JDBC datasource source and provides the configured `JDBCClient`.
    `static void` | JDBCDataSource.`getJDBCClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, JsonObject consumerConfiguration, Handler<AsyncResult<JDBCClient>> resultHandler)` Convenient method that looks for a JDBC datasource source and provides the configured `JDBCClient`.
    `static void` | JDBCDataSource.`getJDBCClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<JDBCClient>> resultHandler)` Convenient method that looks for a JDBC datasource source and provides the configured `JDBCClient`.
    `static void` | JDBCDataSource.`getJDBCClient(ServiceDiscovery discovery, JsonObject filter, JsonObject consumerConfiguration, Handler<AsyncResult<JDBCClient>> resultHandler)` Convenient method that looks for a JDBC datasource source and provides the configured `JDBCClient`.
    `static void` | MongoDataSource.`getMongoClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<MongoClient>> resultHandler)` Convenient method that looks for a Mongo datasource source and provides the configured `MongoClient`.
    `static void` | MongoDataSource.`getMongoClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<MongoClient>> resultHandler)` Convenient method that looks for a Mongo datasource source and provides the configured `MongoClient`.
    `static void` | MongoDataSource.`getMongoClient(ServiceDiscovery discovery, JsonObject filter, JsonObject consumerConfiguration, Handler<AsyncResult<MongoClient>> resultHandler)` Convenient method that looks for a Mongo datasource source and provides the configured `MongoClient`.
    `static <T> T` | EventBusService.`getProxy(ServiceDiscovery discovery, Class<T> itf, Handler<AsyncResult<T>> resultHandler)` Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
    `static <T> T` | EventBusService.`getProxy(ServiceDiscovery discovery, Class<T> itf, JsonObject conf, Handler<AsyncResult<T>> resultHandler)` Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
    `static void` | RedisDataSource.`getRedisClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<RedisClient>> resultHandler)` Convenient method that looks for a Redis data source and provides the configured `RedisClient`.
    `static void` | RedisDataSource.`getRedisClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, JsonObject consumerConfiguration, Handler<AsyncResult<RedisClient>> resultHandler)` Convenient method that looks for a Redis data source and provides the configured `RedisClient`.
    `static void` | RedisDataSource.`getRedisClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<RedisClient>> resultHandler)` Convenient method that looks for a Redis data source and provides the configured `RedisClient`.
    `static void` | RedisDataSource.`getRedisClient(ServiceDiscovery discovery, JsonObject filter, JsonObject consumerConfiguration, Handler<AsyncResult<RedisClient>> resultHandler)` Convenient method that looks for a Redis data source and provides the configured `RedisClient`.
    `static <T> T` | EventBusService.`getServiceProxy(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Class<T> clientClass, Handler<AsyncResult<T>> resultHandler)` Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
    `static <T> T` | EventBusService.`getServiceProxy(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Class<T> clientClass, JsonObject conf, Handler<AsyncResult<T>> resultHandler)` Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
    `static <T> T` | EventBusService.`getServiceProxyWithJsonFilter(ServiceDiscovery discovery, JsonObject filter, Class<T> clientClass, Handler<AsyncResult<T>> resultHandler)` Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
    `static <T> T` | EventBusService.`getServiceProxyWithJsonFilter(ServiceDiscovery discovery, JsonObject filter, Class<T> clientClass, JsonObject conf, Handler<AsyncResult<T>> resultHandler)` Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
    `static void` | HttpEndpoint.`getWebClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, Handler<AsyncResult<WebClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured `WebClient`.
    `static void` | HttpEndpoint.`getWebClient(ServiceDiscovery discovery, java.util.function.Function<Record,Boolean> filter, JsonObject conf, Handler<AsyncResult<WebClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured `WebClient`.
    `static void` | HttpEndpoint.`getWebClient(ServiceDiscovery discovery, JsonObject filter, Handler<AsyncResult<WebClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured .
    `static void` | HttpEndpoint.`getWebClient(ServiceDiscovery discovery, JsonObject filter, JsonObject conf, Handler<AsyncResult<WebClient>> resultHandler)` Convenient method that looks for a HTTP endpoint and provides the configured `WebClient`.

  - ### Uses of Handler in io.vertx.serviceproxy

    Classes in io.vertx.serviceproxy that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ProxyHandler`

    Methods in io.vertx.serviceproxy that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `static <T> Handler<AsyncResult<T>>` | HelperUtils.`createHandler(Message msg)`
    `static Handler<AsyncResult<List<Character>>>` | HelperUtils.`createListCharHandler(Message msg)`
    `static <T> Handler<AsyncResult<List<T>>>` | HelperUtils.`createListHandler(Message msg)`
    `static Handler<AsyncResult<Set<Character>>>` | HelperUtils.`createSetCharHandler(Message msg)`
    `static <T> Handler<AsyncResult<Set<T>>>` | HelperUtils.`createSetHandler(Message msg)`

  - ### Uses of Handler in io.vertx.spi.cluster.hazelcast

    Methods in io.vertx.spi.cluster.hazelcast that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `static Handler<Promise<Status>>` | ClusterHealthCheck.`createProcedure(Vertx vertx)` Creates a ready-to-use Vert.x cluster `HealthChecks` procedure.

    Methods in io.vertx.spi.cluster.hazelcast with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `<K,V> void` | HazelcastClusterManager.`getAsyncMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)`
    `<K,V> void` | HazelcastClusterManager.`getAsyncMultiMap(String name, Handler<AsyncResult<AsyncMultiMap<K,V>>> resultHandler)` Every eventbus handler has an ID.
    `void` | HazelcastClusterManager.`getCounter(String name, Handler<AsyncResult<Counter>> resultHandler)`
    `void` | HazelcastClusterManager.`getLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler)`
    `void` | HazelcastClusterManager.`join(Handler<AsyncResult<Void>> resultHandler)`
    `void` | HazelcastClusterManager.`leave(Handler<AsyncResult<Void>> resultHandler)`

  - ### Uses of Handler in io.vertx.spi.cluster.ignite

    Methods in io.vertx.spi.cluster.ignite with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `<K,V> void` | IgniteClusterManager.`getAsyncMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> handler)`
    `<K,V> void` | IgniteClusterManager.`getAsyncMultiMap(String name, Handler<AsyncResult<AsyncMultiMap<K,V>>> handler)`
    `void` | IgniteClusterManager.`getCounter(String name, Handler<AsyncResult<Counter>> handler)`
    `void` | IgniteClusterManager.`getLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> handler)`
    `void` | IgniteClusterManager.`join(Handler<AsyncResult<Void>> handler)`
    `void` | IgniteClusterManager.`leave(Handler<AsyncResult<Void>> handler)`

  - ### Uses of Handler in io.vertx.spi.cluster.zookeeper

    Methods in io.vertx.spi.cluster.zookeeper with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `<K,V> void` | ZookeeperClusterManager.`getAsyncMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> handler)`
    `<K,V> void` | ZookeeperClusterManager.`getAsyncMultiMap(String name, Handler<AsyncResult<AsyncMultiMap<K,V>>> handler)` Every eventbus handler has an ID.
    `void` | ZookeeperClusterManager.`getCounter(String name, Handler<AsyncResult<Counter>> resultHandler)`
    `void` | ZookeeperClusterManager.`getLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler)`
    `void` | ZookeeperClusterManager.`join(Handler<AsyncResult<Void>> resultHandler)`
    `void` | ZookeeperClusterManager.`leave(Handler<AsyncResult<Void>> resultHandler)`

  - ### Uses of Handler in io.vertx.sqlclient

    Methods in io.vertx.sqlclient with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `Transaction` | Transaction.`abortHandler(Handler<Void> handler)` Set an handler to be called when the transaction is aborted.
    `void` | Pool.`begin(Handler<AsyncResult<Transaction>> handler)` Borrow a connection from the pool and begin a transaction, the underlying connection will be returned to the pool when the transaction ends.
    `void` | PreparedStatement.`close(Handler<AsyncResult<Void>> completionHandler)` Like `PreparedStatement.close()` but notifies the `completionHandler` when it's closed.
    `void` | RowStream.`close(Handler<AsyncResult<Void>> completionHandler)` Close the stream and release the resources.
    `void` | Cursor.`close(Handler<AsyncResult<Void>> completionHandler)` Like `Cursor.close()` but with a `completionHandler` called when the cursor has been released.
    `SqlConnection` | SqlConnection.`closeHandler(Handler<Void> handler)` Set an handler called when the connection is closed.
    `void` | Transaction.`commit(Handler<AsyncResult<Void>> handler)` Like `Transaction.commit()` with an handler to be notified when the transaction commit has completed
    `RowStream<T>` | RowStream.`endHandler(Handler<Void> endHandler)`
    `SqlConnection` | SqlConnection.`exceptionHandler(Handler<Throwable> handler)` Set an handler called with connection errors.
    `RowStream<T>` | RowStream.`exceptionHandler(Handler<Throwable> handler)`
    `void` | Query.`execute(Handler<AsyncResult<T>> handler)` Execute the query.
    `void` | PreparedQuery.`execute(Tuple tuple, Handler<AsyncResult<T>> handler)` Execute the query.
    `void` | PreparedQuery.`executeBatch(List<Tuple> batch, Handler<AsyncResult<T>> handler)` Execute the query with a batch of tuples.
    `void` | Pool.`getConnection(Handler<AsyncResult<SqlConnection>> handler)` Get a connection from the pool.
    `RowStream<T>` | RowStream.`handler(Handler<T> handler)`
    `SqlConnection` | SqlConnection.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)` Create a prepared query.
    `Transaction` | Transaction.`prepare(String sql, Handler<AsyncResult<PreparedStatement>> handler)` Create a prepared query.
    `void` | Cursor.`read(int count, Handler<AsyncResult<RowSet<Row>>> handler)` Read rows from the cursor, the result is provided asynchronously to the `handler`.
    `void` | Transaction.`rollback(Handler<AsyncResult<Void>> handler)` Like `Transaction.rollback()` with an handler to be notified when the transaction rollback has completed

Copyright © 2020 Eclipse. All rights reserved.