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

- Packages that use Handler
  Package | Description
  --- | ---
  io.vertx.amqp |
  io.vertx.cassandra |
  io.vertx.circuitbreaker |
  io.vertx.config |
  io.vertx.config.spi.utils |
  io.vertx.core |
  io.vertx.core.datagram |
  io.vertx.core.eventbus |
  io.vertx.core.file |
  io.vertx.core.http |
  io.vertx.core.net |
  io.vertx.core.parsetools |
  io.vertx.core.streams |
  io.vertx.db2client |
  io.vertx.db2client.spi |
  io.vertx.ext.auth.audit |
  io.vertx.ext.auth.oauth2 |
  io.vertx.ext.cluster.infinispan |
  io.vertx.ext.consul |
  io.vertx.ext.eventbus.bridge.tcp |
  io.vertx.ext.healthchecks |
  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.stomp |
  io.vertx.ext.unit |
  io.vertx.ext.unit.collect |
  io.vertx.ext.unit.report |
  io.vertx.ext.web |
  io.vertx.ext.web.api.service |
  io.vertx.ext.web.client |
  io.vertx.ext.web.client.spi |
  io.vertx.ext.web.codec.spi |
  io.vertx.ext.web.handler |
  io.vertx.ext.web.handler.graphql |
  io.vertx.ext.web.handler.graphql.ws |
  io.vertx.ext.web.handler.sockjs |
  io.vertx.ext.web.healthchecks |
  io.vertx.ext.web.openapi.router |
  io.vertx.ext.web.proxy.handler |
  io.vertx.ext.web.validation |
  io.vertx.grpc |
  io.vertx.grpc.client |
  io.vertx.grpc.common |
  io.vertx.grpc.server |
  io.vertx.grpc.stub |
  io.vertx.grpcio.client |
  io.vertx.grpcio.server |
  io.vertx.httpproxy |
  io.vertx.junit5 |
  io.vertx.kafka.client.consumer |
  io.vertx.kafka.client.producer |
  io.vertx.lang.reactivex |
  io.vertx.lang.rxjava3 |
  io.vertx.micrometer |
  io.vertx.mqtt |
  io.vertx.mssqlclient |
  io.vertx.mssqlclient.spi |
  io.vertx.mysqlclient |
  io.vertx.mysqlclient.spi |
  io.vertx.oracleclient |
  io.vertx.oracleclient.spi |
  io.vertx.pgclient |
  io.vertx.pgclient.pubsub |
  io.vertx.pgclient.spi |
  io.vertx.rabbitmq |
  io.vertx.reactivex |
  io.vertx.reactivex.amqp |
  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.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.streams |
  io.vertx.reactivex.db2client |
  io.vertx.reactivex.ext.auth.audit |
  io.vertx.reactivex.ext.auth.oauth2 |
  io.vertx.reactivex.ext.consul |
  io.vertx.reactivex.ext.eventbus.bridge.tcp |
  io.vertx.reactivex.ext.healthchecks |
  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.handler |
  io.vertx.reactivex.ext.web.handler.graphql |
  io.vertx.reactivex.ext.web.handler.graphql.ws |
  io.vertx.reactivex.ext.web.handler.sockjs |
  io.vertx.reactivex.ext.web.healthchecks |
  io.vertx.reactivex.ext.web.openapi.router |
  io.vertx.reactivex.ext.web.validation |
  io.vertx.reactivex.grpc.client |
  io.vertx.reactivex.grpc.common |
  io.vertx.reactivex.grpc.server |
  io.vertx.reactivex.kafka.client.consumer |
  io.vertx.reactivex.kafka.client.producer |
  io.vertx.reactivex.micrometer |
  io.vertx.reactivex.mqtt |
  io.vertx.reactivex.mssqlclient |
  io.vertx.reactivex.mysqlclient |
  io.vertx.reactivex.oracleclient |
  io.vertx.reactivex.pgclient |
  io.vertx.reactivex.pgclient.pubsub |
  io.vertx.reactivex.rabbitmq |
  io.vertx.reactivex.redis.client |
  io.vertx.reactivex.servicediscovery.spi |
  io.vertx.reactivex.sqlclient |
  io.vertx.redis.client |
  io.vertx.rxjava3 |
  io.vertx.rxjava3.amqp |
  io.vertx.rxjava3.cassandra |
  io.vertx.rxjava3.circuitbreaker |
  io.vertx.rxjava3.config |
  io.vertx.rxjava3.core |
  io.vertx.rxjava3.core.datagram |
  io.vertx.rxjava3.core.eventbus |
  io.vertx.rxjava3.core.file |
  io.vertx.rxjava3.core.http |
  io.vertx.rxjava3.core.net |
  io.vertx.rxjava3.core.parsetools |
  io.vertx.rxjava3.core.streams |
  io.vertx.rxjava3.db2client |
  io.vertx.rxjava3.ext.auth.audit |
  io.vertx.rxjava3.ext.auth.oauth2 |
  io.vertx.rxjava3.ext.consul |
  io.vertx.rxjava3.ext.eventbus.bridge.tcp |
  io.vertx.rxjava3.ext.healthchecks |
  io.vertx.rxjava3.ext.stomp |
  io.vertx.rxjava3.ext.unit |
  io.vertx.rxjava3.ext.unit.collect |
  io.vertx.rxjava3.ext.unit.report |
  io.vertx.rxjava3.ext.web |
  io.vertx.rxjava3.ext.web.handler |
  io.vertx.rxjava3.ext.web.handler.graphql |
  io.vertx.rxjava3.ext.web.handler.graphql.ws |
  io.vertx.rxjava3.ext.web.handler.sockjs |
  io.vertx.rxjava3.ext.web.healthchecks |
  io.vertx.rxjava3.ext.web.openapi.router |
  io.vertx.rxjava3.ext.web.proxy.handler |
  io.vertx.rxjava3.ext.web.validation |
  io.vertx.rxjava3.grpc.client |
  io.vertx.rxjava3.grpc.common |
  io.vertx.rxjava3.grpc.server |
  io.vertx.rxjava3.httpproxy |
  io.vertx.rxjava3.kafka.client.consumer |
  io.vertx.rxjava3.kafka.client.producer |
  io.vertx.rxjava3.micrometer |
  io.vertx.rxjava3.mqtt |
  io.vertx.rxjava3.mssqlclient |
  io.vertx.rxjava3.mysqlclient |
  io.vertx.rxjava3.oracleclient |
  io.vertx.rxjava3.pgclient |
  io.vertx.rxjava3.pgclient.pubsub |
  io.vertx.rxjava3.rabbitmq |
  io.vertx.rxjava3.redis.client |
  io.vertx.rxjava3.servicediscovery.spi |
  io.vertx.rxjava3.sqlclient |
  io.vertx.servicediscovery.backend.redis |
  io.vertx.servicediscovery.consul |
  io.vertx.servicediscovery.docker |
  io.vertx.servicediscovery.kubernetes |
  io.vertx.servicediscovery.spi |
  io.vertx.servicediscovery.zookeeper |
  io.vertx.serviceproxy |
  io.vertx.spi.cluster.hazelcast |
  io.vertx.sqlclient |
  io.vertx.sqlclient.spi |

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

    Methods in io.vertx.amqp with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `AmqpReceiver` | AmqpReceiver.`endHandler​(Handler<Void> endHandler)` |
    `AmqpConnection` | AmqpConnection.`exceptionHandler​(Handler<Throwable> handler)` | Registers a handler called on disconnection.
    `AmqpReceiver` | AmqpReceiver.`exceptionHandler​(Handler<Throwable> handler)` |
    `AmqpSender` | AmqpSender.`exceptionHandler​(Handler<Throwable> handler)` |
    `AmqpReceiver` | AmqpReceiver.`handler​(Handler<AmqpMessage> handler)` |

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

    Methods in io.vertx.cassandra with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `CassandraRowStream` | CassandraRowStream.`endHandler​(Handler<Void> handler)` |
    `CassandraRowStream` | CassandraRowStream.`exceptionHandler​(Handler<Throwable> handler)` |
    `CassandraRowStream` | CassandraRowStream.`handler​(Handler<com.datastax.oss.driver.api.core.cql.Row> handler)` |

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

    Methods in io.vertx.circuitbreaker with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `CircuitBreaker` | CircuitBreaker.`closeHandler​(Handler<Void> handler)` | Sets a `Handler` to be invoked when the circuit breaker state switches to closed.
    `<T> Future<T>` | CircuitBreaker.`execute​(Handler<Promise<T>> command)` | Same as `CircuitBreaker.executeWithFallback(Handler, Function)` but using the circuit breaker default fallback.
    `<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.
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReportWithFallback​(Promise<T> resultPromise, Handler<Promise<T>> command, Function<Throwable,​T> fallback)` | Executes the given operation with the circuit breaker control.
    `<T> Future<T>` | CircuitBreaker.`executeWithFallback​(Handler<Promise<T>> command, Function<Throwable,​T> fallback)` | Executes the given operation with the circuit breaker control.
    `CircuitBreaker` | CircuitBreaker.`halfOpenHandler​(Handler<Void> handler)` | Sets a `Handler` to be invoked when the circuit breaker state switches to half-open.
    `CircuitBreaker` | CircuitBreaker.`openHandler​(Handler<Void> handler)` | Sets a `Handler` to be 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 | Description
    --- | --- | ---
    `void` | ConfigRetriever.`listen​(Handler<ConfigChange> listener)` | Registers a listener receiving configuration changes.
    `ConfigRetriever` | ConfigRetriever.`setBeforeScanHandler​(Handler<Void> handler)` | Registers a handler called before every scan.

  - ### 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 | 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.core

    Methods in io.vertx.core that return Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `Handler<Throwable>` | Context.`exceptionHandler()` |
    `Handler<Throwable>` | Vertx.`exceptionHandler()` |

    Methods in io.vertx.core with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `default Future<T>` | Future.`andThen​(Handler<AsyncResult<T>> handler)` | Invokes the given `handler` upon completion.
    `Context` | Context.`exceptionHandler​(Handler<Throwable> handler)` | Set an exception handler called when the context runs an action throwing an uncaught throwable.
    `Vertx` | Vertx.`exceptionHandler​(Handler<Throwable> handler)` | Set a default exception handler for `Context`, set on `Context.exceptionHandler(Handler)` at creation.
    `static <T> Future<T>` | Future.`future​(Handler<Promise<T>> handler)` | Create a promise and pass it to the `handler`, and then returns this future's promise.
    `CompositeFuture` | CompositeFuture.`onComplete​(Handler<AsyncResult<CompositeFuture>> handler)` |
    `default Future<T>` | Future.`onComplete​(Handler<? super T> successHandler, Handler<? super Throwable> failureHandler)` | Add handlers to be notified on succeeded result and failed result.
    `Future<T>` | Future.`onComplete​(Handler<AsyncResult<T>> handler)` | Add a handler to be notified of the result.
    `default CompositeFuture` | CompositeFuture.`onFailure​(Handler<? super Throwable> handler)` |
    `default Future<T>` | Future.`onFailure​(Handler<? super Throwable> handler)` | Add a handler to be notified of the failed result.
    `default CompositeFuture` | CompositeFuture.`onSuccess​(Handler<? super CompositeFuture> handler)` |
    `default Future<T>` | Future.`onSuccess​(Handler<? super 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.
    `long` | Vertx.`setPeriodic​(long initialDelay, long delay, Handler<Long> handler)` | Set a periodic timer to fire every `delay` milliseconds with initial delay, at which point `handler` will be called with the id of the timer.
    `default 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.

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

    Methods in io.vertx.core.datagram with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `DatagramSocket` | DatagramSocket.`exceptionHandler​(Handler<Throwable> handler)` |
    `DatagramSocket` | DatagramSocket.`handler​(Handler<DatagramPacket> handler)` |

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

    Methods in io.vertx.core.eventbus with parameters of type Handler
    Modifier and Type | Method | 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
    `<T> MessageConsumer<T>` | EventBus.`consumer​(MessageConsumerOptions options, Handler<Message<T>> handler)` | Create a consumer and register it against the specified options address.
    `<T> MessageConsumer<T>` | EventBus.`consumer​(String address, Handler<Message<T>> handler)` | Create a consumer and register it against the specified address.
    `MessageConsumer<T>` | MessageConsumer.`endHandler​(Handler<Void> endHandler)` |
    `MessageConsumer<T>` | MessageConsumer.`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)`

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

    Methods in io.vertx.core.file with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `AsyncFile` | AsyncFile.`drainHandler​(Handler<Void> handler)` |
    `AsyncFile` | AsyncFile.`endHandler​(Handler<Void> endHandler)` |
    `AsyncFile` | AsyncFile.`exceptionHandler​(Handler<Throwable> handler)` | Set an exception handler on the read stream and on the write stream.
    `AsyncFile` | AsyncFile.`handler​(Handler<Buffer> handler)` |

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

    Fields in io.vertx.core.http declared as Handler
    Modifier and Type | Field | Description
    --- | --- | ---
    `static Handler<HttpServerRequest>` | HttpServerRequest.`DEFAULT_INVALID_REQUEST_HANDLER` | The default invalid request handler, it uses the `HttpServerRequest.decoderResult()` cause and the request information to determine the status code of the response to be sent.

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

    Methods in io.vertx.core.http with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `ClientWebSocket` | ClientWebSocket.`binaryMessageHandler​(Handler<Buffer> handler)` |
    `WebSocket` | WebSocket.`binaryMessageHandler​(Handler<Buffer> handler)` |
    `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.
    `default 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.
    `ClientWebSocket` | ClientWebSocket.`closeHandler​(Handler<Void> handler)` |
    `HttpConnection` | HttpConnection.`closeHandler​(Handler<Void> handler)` | Set a close handler.
    `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)` |
    `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.`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.
    `ClientWebSocket` | ClientWebSocket.`drainHandler​(Handler<Void> handler)` |
    `HttpClientRequest` | HttpClientRequest.`drainHandler​(Handler<Void> handler)` |
    `HttpServerResponse` | HttpServerResponse.`drainHandler​(Handler<Void> handler)` |
    `ServerWebSocket` | ServerWebSocket.`drainHandler​(Handler<Void> handler)` |
    `WebSocket` | WebSocket.`drainHandler​(Handler<Void> handler)` |
    `WebSocketBase` | WebSocketBase.`drainHandler​(Handler<Void> handler)` |
    `HttpClientRequest` | HttpClientRequest.`earlyHintsHandler​(Handler<MultiMap> handler)` | If the server responds with an interim HTTP response with a status code of `103` and a Early Hints handler has been set using this method, then the `handler` will be called.
    `ClientWebSocket` | ClientWebSocket.`endHandler​(Handler<Void> endHandler)` |
    `HttpClientResponse` | HttpClientResponse.`endHandler​(Handler<Void> endHandler)` |
    `HttpServerFileUpload` | HttpServerFileUpload.`endHandler​(Handler<Void> endHandler)` |
    `HttpServerRequest` | HttpServerRequest.`endHandler​(Handler<Void> endHandler)` |
    `HttpServerResponse` | HttpServerResponse.`endHandler​(Handler<Void> handler)` | Set an end handler for the response.
    `ServerWebSocket` | ServerWebSocket.`endHandler​(Handler<Void> endHandler)` |
    `WebSocket` | WebSocket.`endHandler​(Handler<Void> endHandler)` |
    `WebSocketBase` | WebSocketBase.`endHandler​(Handler<Void> endHandler)` |
    `ClientWebSocket` | ClientWebSocket.`exceptionHandler​(Handler<Throwable> handler)` |
    `HttpClientRequest` | HttpClientRequest.`exceptionHandler​(Handler<Throwable> handler)` |
    `HttpClientResponse` | HttpClientResponse.`exceptionHandler​(Handler<Throwable> handler)` |
    `HttpConnection` | HttpConnection.`exceptionHandler​(Handler<Throwable> handler)` | Set an handler called when a connection error happens
    `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.
    `HttpServerFileUpload` | HttpServerFileUpload.`exceptionHandler​(Handler<Throwable> handler)` |
    `HttpServerRequest` | HttpServerRequest.`exceptionHandler​(Handler<Throwable> handler)` |
    `HttpServerResponse` | HttpServerResponse.`exceptionHandler​(Handler<Throwable> handler)` |
    `ServerWebSocket` | ServerWebSocket.`exceptionHandler​(Handler<Throwable> handler)` |
    `WebSocket` | WebSocket.`exceptionHandler​(Handler<Throwable> handler)` |
    `WebSocketBase` | WebSocketBase.`exceptionHandler​(Handler<Throwable> handler)` |
    `ClientWebSocket` | ClientWebSocket.`frameHandler​(Handler<WebSocketFrame> 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.
    `HttpConnection` | HttpConnection.`goAwayHandler​(Handler<GoAway> handler)` | Set an handler called when a GOAWAY frame is received.
    `ClientWebSocket` | ClientWebSocket.`handler​(Handler<Buffer> handler)` |
    `HttpClientResponse` | HttpClientResponse.`handler​(Handler<Buffer> handler)` |
    `HttpServerFileUpload` | HttpServerFileUpload.`handler​(Handler<Buffer> handler)` |
    `HttpServerRequest` | HttpServerRequest.`handler​(Handler<Buffer> handler)` |
    `ServerWebSocket` | ServerWebSocket.`handler​(Handler<Buffer> handler)` |
    `WebSocket` | WebSocket.`handler​(Handler<Buffer> handler)` |
    `WebSocketBase` | WebSocketBase.`handler​(Handler<Buffer> handler)` |
    `HttpServerResponse` | HttpServerResponse.`headersEndHandler​(Handler<Void> handler)` | Provide a handler that will be called just before the headers are written to the wire.
    `HttpServer` | HttpServer.`invalidRequestHandler​(Handler<HttpServerRequest> handler)` | Set a `handler` for handling invalid requests.
    `HttpConnection` | HttpConnection.`pingHandler​(Handler<Buffer> handler)` | Set an handler notified when a PING frame is received from the remote endpoint.
    `ClientWebSocket` | ClientWebSocket.`pongHandler​(Handler<Buffer> handler)` |
    `WebSocket` | WebSocket.`pongHandler​(Handler<Buffer> handler)` |
    `WebSocketBase` | WebSocketBase.`pongHandler​(Handler<Buffer> handler)` | Set a pong frame handler on the connection.
    `HttpClientRequest` | HttpClientRequest.`pushHandler​(Handler<HttpClientRequest> handler)` | Set a push handler for this request.
    `HttpConnection` | HttpConnection.`remoteSettingsHandler​(Handler<Http2Settings> handler)` | Set an handler that is called when remote endpoint `Http2Settings` are updated.
    `HttpServer` | HttpServer.`requestHandler​(Handler<HttpServerRequest> handler)` | Set the request handler for the server to `requestHandler`.
    `HttpConnection` | HttpConnection.`shutdownHandler​(Handler<Void> handler)` | Set a `handler` notified when the HTTP connection is shutdown: the client or server will close the connection within a certain amount of time.
    `WebSocket` | WebSocket.`shutdownHandler​(Handler<Void> handler)` |
    `WebSocketBase` | WebSocketBase.`shutdownHandler​(Handler<Void> handler)` | Set a `handler` notified when the WebSocket is shutdown: the client or server will close the connection within a certain amount of time.
    `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
    `ClientWebSocket` | ClientWebSocket.`textMessageHandler​(Handler<String> handler)` |
    `WebSocket` | WebSocket.`textMessageHandler​(Handler<String> handler)` |
    `WebSocketBase` | WebSocketBase.`textMessageHandler​(Handler<String> handler)` | Set a text message handler on the connection.
    `HttpServerRequest` | HttpServerRequest.`uploadHandler​(Handler<HttpServerFileUpload> uploadHandler)` | Set an upload handler.
    `HttpServer` | HttpServer.`webSocketHandler​(Handler<ServerWebSocket> handler)` | Set the WebSocket handler for the server to `wsHandler`.
    `HttpServer` | HttpServer.`webSocketHandshakeHandler​(Handler<ServerWebSocketHandshake> handler)` | Set a handler for WebSocket handshake.
    `HttpClientBuilder` | HttpClientBuilder.`withConnectHandler​(Handler<HttpConnection> handler)` | Set a connection handler for the client.

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

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

    Methods in io.vertx.core.net with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `NetSocket` | NetSocket.`closeHandler​(Handler<Void> handler)` | Set a `handler` notified when the socket is closed
    `NetServer` | NetServer.`connectHandler​(Handler<NetSocket> handler)` | Supply a connect handler for this server.
    `NetSocket` | NetSocket.`drainHandler​(Handler<Void> handler)` |
    `NetSocket` | NetSocket.`endHandler​(Handler<Void> endHandler)` | Set an end 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.`exceptionHandler​(Handler<Throwable> handler)` |
    `NetSocket` | NetSocket.`handler​(Handler<Buffer> handler)` |
    `NetSocket` | NetSocket.`shutdownHandler​(Handler<Void> handler)` | Set a `handler` notified when the socket is shutdown: the client or server will close the connection within a certain amount of time.

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

    Subinterfaces of Handler in io.vertx.core.parsetools
    Modifier and Type | Interface | 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 | Description
    --- | --- | ---
    `JsonParser` | JsonParser.`endHandler​(Handler<Void> endHandler)` |
    `RecordParser` | RecordParser.`endHandler​(Handler<Void> endHandler)` |
    `JsonParser` | JsonParser.`exceptionHandler​(Handler<Throwable> handler)` |
    `RecordParser` | RecordParser.`exceptionHandler​(Handler<Throwable> handler)` |
    `JsonParser` | JsonParser.`handler​(Handler<JsonEvent> handler)` |
    `RecordParser` | RecordParser.`handler​(Handler<Buffer> 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.streams

    Methods in io.vertx.core.streams with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `WriteStream<T>` | WriteStream.`drainHandler​(Handler<Void> handler)` | Set a drain handler on the stream.
    `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.

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

    Methods in io.vertx.db2client with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `static SqlClient` | DB2Builder.`client​(Handler<ClientBuilder<SqlClient>> handler)` | Build a client backed by a connection pool with the specified `block` argument.
    `DB2Connection` | DB2Connection.`closeHandler​(Handler<Void> handler)` |
    `DB2Connection` | DB2Connection.`exceptionHandler​(Handler<Throwable> handler)` |
    `static Pool` | DB2Builder.`pool​(Handler<ClientBuilder<Pool>> block)` | Build a pool with the specified `block` argument.

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

    Methods in io.vertx.db2client.spi with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `Pool` | DB2Driver.`newPool​(Vertx vertx, Supplier<Future<DB2ConnectOptions>> databases, PoolOptions poolOptions, NetClientOptions transportOptions, Handler<SqlConnection> connectHandler, io.vertx.core.internal.CloseFuture closeFuture)` |

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

    Methods in io.vertx.ext.auth.audit that return Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `default <T> Handler<AsyncResult<T>>` | SecurityAudit.`auditHandlerFor​(Marker marker)` |

  - ### 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 | Description
    --- | --- | ---
    `OAuth2Auth` | OAuth2Auth.`missingKeyHandler​(Handler<String> handler)` | Handled to be called when a key (mentioned on a JWT) is missing from the current config.

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

    Subinterfaces of Handler in io.vertx.ext.cluster.infinispan
    Modifier and Type | Interface | Description
    --- | --- | ---
    `interface` | `ClusterHealthCheck` | A helper to create Vert.x cluster `HealthChecks` procedures.

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

    Methods in io.vertx.ext.consul with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `Watch<T>` | Watch.`setHandler​(Handler<WatchResult<T>> handler)` | Set the result handler.

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

    Methods in io.vertx.ext.eventbus.bridge.tcp with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `static TcpEventBusBridge` | TcpEventBusBridge.`create​(Vertx vertx, BridgeOptions options, NetServerOptions netServerOptions, Handler<BridgeEvent> eventHandler)` |

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

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

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

    Methods in io.vertx.ext.reactivestreams with parameters of type Handler
    Modifier and Type | Method | 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)` |

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

    Methods in io.vertx.ext.shell with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | ShellServer.`shellHandler​(Handler<Shell> shellHandler)` | Called when a new shell is created.

  - ### 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 | 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.
    `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`.

  - ### 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 | 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 | 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 | Description
    --- | --- | ---
    `interface` | `SockJSTermHandler` |

    Methods in io.vertx.ext.shell.term with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `Term` | Term.`closeHandler​(Handler<Void> handler)` | Set a handler that will be called when the terminal is closed.
    `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.
    `Term` | Term.`resizehandler​(Handler<Void> handler)` |
    `Tty` | Tty.`resizehandler​(Handler<Void> handler)` | Set a resize handler, the handler is called when the tty size changes.
    `Term` | Term.`stdinHandler​(Handler<String> handler)` |
    `Tty` | Tty.`stdinHandler​(Handler<String> handler)` | Set a stream handler on the standard input to read the data.
    `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.stomp

    Subinterfaces of Handler in io.vertx.ext.stomp
    Modifier and Type | Interface | 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 | 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 | Description
    --- | --- | ---
    `Handler<ServerWebSocket>` | StompServer.`webSocketHandler()` | Gets the `Handler` able to manage web socket connections.
    `Handler<ServerWebSocketHandshake>` | StompServer.`webSocketHandshakeHandler()` | Gets the `Handler` able to manage web socket connection handshakes.

    Methods in io.vertx.ext.stomp with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `StompServerHandler` | StompServerHandler.`abortHandler​(Handler<ServerFrame> handler)` | Configures the action to execute when a `ABORT` frame is received.
    `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.`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.
    `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.
    `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.
    `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.
    `StompClient` | StompClient.`exceptionHandler​(Handler<Throwable> handler)` | Sets an exception handler notified for TCP-level errors.
    `StompClientConnection` | StompClientConnection.`exceptionHandler​(Handler<Throwable> exceptionHandler)` | Configures the exception handler notified upon TCP-level errors.
    `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.`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.
    `StompClient` | StompClient.`receivedFrameHandler​(Handler<Frame> handler)` | Configures a received handler that gets notified when a STOMP frame is received by the client.
    `StompClientConnection` | StompClientConnection.`receivedFrameHandler​(Handler<Frame> handler)` | Configures a received handler that get 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.
    `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.
    `Future<String>` | StompClientConnection.`subscribe​(String destination, Handler<Frame> handler)` | Subscribes to the given destination.
    `Future<String>` | StompClientConnection.`subscribe​(String destination, Map<String,​String> headers, Handler<Frame> handler)` | Subscribes to the given destination.
    `StompServerHandler` | StompServerHandler.`subscribeHandler​(Handler<ServerFrame> handler)` | Configures the action to execute when a `SUBSCRIBE` frame is received.
    `StompServerHandler` | StompServerHandler.`unsubscribeHandler​(Handler<ServerFrame> handler)` | Configures the action to execute when a `UNSUBSCRIBE` frame is received.
    `StompClient` | StompClient.`writingFrameHandler​(Handler<Frame> handler)` | Configures a writing handler that gets notified when a STOMP frame is written on the wire.
    `StompClientConnection` | StompClientConnection.`writingFrameHandler​(Handler<Frame> handler)` | Configures a handler notified when a frame is going to be 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.unit

    Methods in io.vertx.ext.unit that return Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure()` | Creates and returns a new async handler, the returned handler controls the completion of 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.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess()` | Creates and returns a new async handler, the returned handler controls the completion of 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.
    `Handler<Throwable>` | TestContext.`exceptionHandler()` |

    Methods in io.vertx.ext.unit with parameters of type Handler
    Modifier and Type | Method | 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.
    `<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.
    `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, int repeat, Handler<TestContext> testCase)` | Add a new test case to the suite.
    `TestSuite` | TestSuite.`test​(String name, 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 | Description
    --- | --- | ---
    `Handler<Message<JsonObject>>` | EventBusCollector.`asMessageHandler()` |

    Methods in io.vertx.ext.unit.collect with parameters of type Handler
    Modifier and Type | Method | 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 | 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 | 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 | 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.`addEndHandler​(Handler<AsyncResult<Void>> handler)` | Add an end handler for the request/response context.
    `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.
    `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.service

    Subinterfaces of Handler in io.vertx.ext.web.api.service
    Modifier and Type | Interface | Description
    --- | --- | ---
    `interface` | `OpenAPIRouterHandler` |
    `interface` | `RouteToEBServiceHandler` | Handler that proxy the request to an event bus endpoint, waits for the reply and then writes the HTTP response.

  - ### 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 | Description
    --- | --- | ---
    `OAuth2WebClient` | OAuth2WebClient.`addInterceptor​(Handler<io.vertx.ext.web.client.impl.HttpContext<?>> interceptor)` |
    `WebClient` | WebClient.`addInterceptor​(Handler<io.vertx.ext.web.client.impl.HttpContext<?>> interceptor)` | Add interceptor in the chain.
    `WebClientSession` | WebClientSession.`addInterceptor​(Handler<io.vertx.ext.web.client.impl.HttpContext<?>> interceptor)` |

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

    Methods in io.vertx.ext.web.client.spi with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `default void` | CacheStore.`delete​(io.vertx.ext.web.client.impl.cache.CacheKey key, Handler<AsyncResult<Void>> handler)` | Delete all variations of a key from the cache.
    `default void` | CacheStore.`flush​(Handler<AsyncResult<Void>> handler)` | Delete all entries from the cache.
    `default void` | CacheStore.`get​(io.vertx.ext.web.client.impl.cache.CacheKey key, Handler<AsyncResult<io.vertx.ext.web.client.impl.cache.CachedHttpResponse>> handler)` | Retrieve a cached response.
    `default void` | CacheStore.`set​(io.vertx.ext.web.client.impl.cache.CacheKey key, io.vertx.ext.web.client.impl.cache.CachedHttpResponse response, Handler<AsyncResult<io.vertx.ext.web.client.impl.cache.CachedHttpResponse>> handler)` | Add a response in the cache with the given key.

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

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

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

    Subinterfaces of Handler in io.vertx.ext.web.handler
    Modifier and Type | Interface | Description
    --- | --- | ---
    `interface` | `APIKeyHandler` | An authentication handler that provides API Key support.
    `interface` | `AuthenticationHandler` | Base interface for auth handlers.
    `interface` | `AuthorizationHandler` | Base interface for authorization handlers that provide authorization support.
    `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` | `CorsHandler` | A handler which implements server side http://www.w3.org/TR/cors/[CORS] support for Vert.x-Web.
    `interface` | `CSPHandler` | Content Security Policy (CSP) is an added layer of security that helps to detect and mitigate certain types of attacks, including Cross Site Scripting (XSS) and data injection attacks.
    `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` | `HSTSHandler` | HTTP Strict Transport Security (HSTS) RFC6797.
    `interface` | `InputTrustHandler` | Base input trust interface for handlers that verify the trust of the request.
    `interface` | `JWTAuthHandler` | An auth handler that provides JWT Authentication support.
    `interface` | `LoggerHandler` | A handler which logs request information to the Vert.x logger.
    `interface` | `MethodOverrideHandler` |
    `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` | `OtpAuthHandler` | An auth handler that provides One Time Password (Multi-Factor) Authentication support.
    `interface` | `PlatformHandler` | Base platform interface for handlers that provide functionality to the application platform.
    `interface` | `ProtocolUpgradeHandler` | Base interface for handlers that perform protocol upgrades.
    `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` | `SecurityAuditLoggerHandler` | A handler that logs security audit events.
    `interface` | `SecurityPolicyHandler` | Base security policy interface for handlers that provide HTTP security related headers.
    `interface` | `SessionHandler` | A handler that maintains a `Session` for each browser session.
    `interface` | `SimpleAuthenticationHandler` | A user customizable authentication handler.
    `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` | `WebAuthn4JHandler` | An auth handler that provides FIDO2 WebAuthN Relay Party support.
    `interface` | `XFrameHandler` | The X-Frame-Options HTTP response header can be used to indicate whether or not a browser should be allowed to render a page in a `<frame>`, `<iframe>`, `<embed>` or `<object>`.

    Methods in io.vertx.ext.web.handler with parameters of type Handler
    Modifier and Type | Method | 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.

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

    Subinterfaces of Handler in io.vertx.ext.web.handler.graphql
    Modifier and Type | Interface | Description
    --- | --- | ---
    `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 | Description
    --- | --- | ---
    `GraphQLHandlerBuilder` | GraphQLHandlerBuilder.`beforeExecute​(Handler<ExecutionInputBuilderWithContext<RoutingContext>> beforeExecuteHandler)` | Set a callback to invoke before executing a GraphQL query.

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

    Subinterfaces of Handler in io.vertx.ext.web.handler.graphql.ws
    Modifier and Type | Interface | Description
    --- | --- | ---
    `interface` | `GraphQLWSHandler` | A handler for the GraphQL over WebSocket Protocol.

    Methods in io.vertx.ext.web.handler.graphql.ws with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `GraphQLWSHandlerBuilder` | GraphQLWSHandlerBuilder.`beforeExecute​(Handler<ExecutionInputBuilderWithContext<Message>> beforeExecuteHandler)` | Set a callback to invoke before executing a GraphQL query.
    `GraphQLWSHandlerBuilder` | GraphQLWSHandlerBuilder.`onConnectionInit​(Handler<ConnectionInitEvent> connectionInitHandler)` | Customize the connection init `Handler`.
    `GraphQLWSHandlerBuilder` | GraphQLWSHandlerBuilder.`onMessage​(Handler<Message> messageHandler)` | Customize the message `Handler`.
    `GraphQLWSHandlerBuilder` | GraphQLWSHandlerBuilder.`onSocketEnd​(Handler<ServerWebSocket> endHandler)` | Customize the end `Handler`.

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

    Methods in io.vertx.ext.web.handler.sockjs with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `Router` | SockJSHandler.`bridge​(AuthorizationProvider authorizationProvider, SockJSBridgeOptions bridgeOptions, Handler<BridgeEvent> bridgeEventHandler)` | Like `SockJSHandler.bridge(SockJSBridgeOptions)` but specifying a handler that will receive bridge events.
    `default Router` | SockJSHandler.`bridge​(SockJSBridgeOptions bridgeOptions, Handler<BridgeEvent> bridgeEventHandler)` | Like `SockJSHandler.bridge(SockJSBridgeOptions)` but specifying a handler that will receive bridge events.
    `SockJSSocket` | SockJSSocket.`closeHandler​(Handler<Void> closeHandler)` |
    `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.

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

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

    Methods in io.vertx.ext.web.healthchecks with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `HealthCheckHandler` | HealthCheckHandler.`register​(String name, long timeout, Handler<Promise<Status>> procedure)` | Registers a health check procedure.
    `HealthCheckHandler` | HealthCheckHandler.`register​(String name, Handler<Promise<Status>> procedure)` | Registers a health check procedure.

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

    Methods in io.vertx.ext.web.openapi.router that return types with arguments of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `List<Handler<RoutingContext>>` | OpenAPIRoute.`getFailureHandlers()` |
    `List<Handler<RoutingContext>>` | OpenAPIRoute.`getHandlers()` |

    Methods in io.vertx.ext.web.openapi.router with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `OpenAPIRoute` | OpenAPIRoute.`addFailureHandler​(Handler<RoutingContext> handler)` | Adds a failure handler for this route
    `OpenAPIRoute` | OpenAPIRoute.`addHandler​(Handler<RoutingContext> handler)` | Adds a handler for this route which is executed after the security and validation handlers defined in the contract
    `RouterBuilder` | RouterBuilder.`rootHandler​(Handler<RoutingContext> rootHandler)` | Add global handler to be applied prior to `Router` being generated.

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

    Subinterfaces of Handler in io.vertx.ext.web.proxy.handler
    Modifier and Type | Interface | Description
    --- | --- | ---
    `interface` | `ProxyHandler` |

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

    Subinterfaces of Handler in io.vertx.ext.web.validation
    Modifier and Type | Interface | Description
    --- | --- | ---
    `interface` | `ValidationHandler` |

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

    Methods in io.vertx.grpc with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `VertxChannelBuilder` | VertxChannelBuilder.`useSsl​(Handler<ClientOptionsBase> handler)` |
    `VertxServerBuilder` | VertxServerBuilder.`useSsl​(Handler<HttpServerOptions> handler)` |

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

    Methods in io.vertx.grpc.client with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `GrpcClientRequest<Req,​Resp>` | GrpcClientRequest.`drainHandler​(Handler<Void> handler)` |
    `GrpcClientResponse<Req,​Resp>` | GrpcClientResponse.`endHandler​(Handler<Void> handler)` |
    `GrpcClientResponse<Req,​Resp>` | GrpcClientResponse.`errorHandler​(Handler<GrpcError> handler)` |
    `GrpcClientRequest<Req,​Resp>` | GrpcClientRequest.`exceptionHandler​(Handler<Throwable> handler)` |
    `GrpcClientResponse<Req,​Resp>` | GrpcClientResponse.`exceptionHandler​(Handler<Throwable> handler)` |
    `GrpcClientResponse<Req,​Resp>` | GrpcClientResponse.`handler​(Handler<Resp> handler)` |
    `GrpcClientResponse<Req,​Resp>` | GrpcClientResponse.`messageHandler​(Handler<GrpcMessage> handler)` |

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

    Methods in io.vertx.grpc.common with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `GrpcWriteStream<T>` | GrpcWriteStream.`drainHandler​(Handler<Void> handler)` |
    `GrpcReadStream<T>` | GrpcReadStream.`endHandler​(Handler<Void> handler)` |
    `GrpcReadStream<T>` | GrpcReadStream.`errorHandler​(Handler<GrpcError> handler)` | Set a handler to be notified with gRPC errors.
    `GrpcReadStream<T>` | GrpcReadStream.`exceptionHandler​(Handler<Throwable> handler)` |
    `GrpcWriteStream<T>` | GrpcWriteStream.`exceptionHandler​(Handler<Throwable> handler)` |
    `GrpcReadStream<T>` | GrpcReadStream.`handler​(Handler<T> handler)` |
    `GrpcReadStream<T>` | GrpcReadStream.`invalidMessageHandler​(Handler<InvalidMessageException> handler)` | Set a message handler that is reported with invalid message errors.
    `GrpcReadStream<T>` | GrpcReadStream.`messageHandler​(Handler<GrpcMessage> handler)` | Set a handler to be notified with incoming encoded messages.

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

    Subinterfaces of Handler in io.vertx.grpc.server
    Modifier and Type | Interface | Description
    --- | --- | ---
    `interface` | `GrpcServer` | A gRPC server based on Vert.x HTTP server.

    Methods in io.vertx.grpc.server with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `<Req,​Resp> ServiceBuilder` | ServiceBuilder.`bind​(ServiceMethod<Req,​Resp> serviceMethod, Handler<GrpcServerRequest<Req,​Resp>> handler)` | Bind a service method call handler that handles any call made to the server for the `fullMethodName` method.
    `GrpcServer` | GrpcServer.`callHandler​(Handler<GrpcServerRequest<Buffer,​Buffer>> handler)` | Set a call handler that handles any call made to the server.
    `<Req,​Resp> GrpcServer` | GrpcServer.`callHandler​(ServiceMethod<Req,​Resp> serviceMethod, Handler<GrpcServerRequest<Req,​Resp>> handler)` | Set a service method call handler that handles any call made to the server for the `fullMethodName` service method.
    `GrpcServerResponse<Req,​Resp>` | GrpcServerResponse.`drainHandler​(Handler<Void> handler)` |
    `GrpcServerRequest<Req,​Resp>` | GrpcServerRequest.`endHandler​(Handler<Void> endHandler)` |
    `GrpcServerRequest<Req,​Resp>` | GrpcServerRequest.`errorHandler​(Handler<GrpcError> handler)` |
    `GrpcServerRequest<Req,​Resp>` | GrpcServerRequest.`exceptionHandler​(Handler<Throwable> handler)` |
    `GrpcServerResponse<Req,​Resp>` | GrpcServerResponse.`exceptionHandler​(Handler<Throwable> handler)` |
    `GrpcServerRequest<Req,​Resp>` | GrpcServerRequest.`handler​(Handler<Req> handler)` |
    `GrpcServerRequest<Req,​Resp>` | GrpcServerRequest.`messageHandler​(Handler<GrpcMessage> handler)` |

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

    Methods in io.vertx.grpc.stub with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `WriteStream<T>` | GrpcWriteStream.`drainHandler​(Handler<Void> hndlr)` |
    `WriteStream<T>` | GrpcWriteStream.`exceptionHandler​(Handler<Throwable> hndlr)` |
    `static <I,​O> ReadStream<O>` | ClientCalls.`manyToMany​(io.vertx.core.internal.ContextInternal ctx, Handler<WriteStream<I>> requestHandler, Function<StreamObserver<O>,​StreamObserver<I>> delegate)` |
    `static <I,​O> ReadStream<O>` | ClientCalls.`manyToMany​(io.vertx.core.internal.ContextInternal ctx, Handler<WriteStream<I>> requestHandler, Function<StreamObserver<O>,​StreamObserver<I>> delegate, Handler<Throwable> exceptionHandler)` |
    `static <I,​O> ReadStream<O>` | ClientCalls.`manyToMany​(io.vertx.core.internal.ContextInternal ctx, Handler<WriteStream<I>> requestHandler, Function<StreamObserver<O>,​StreamObserver<I>> delegate, Handler<O> handler, Handler<Void> endHandler, Handler<Throwable> exceptionHandler)` |
    `static <I,​O> Future<O>` | ClientCalls.`manyToOne​(io.vertx.core.internal.ContextInternal ctx, Handler<WriteStream<I>> requestHandler, Function<StreamObserver<O>,​StreamObserver<I>> delegate)` |
    `static <I,​O> ReadStream<O>` | ClientCalls.`oneToMany​(io.vertx.core.internal.ContextInternal ctx, I request, BiConsumer<I,​StreamObserver<O>> delegate, Handler<O> handler, Handler<Void> endHandler, Handler<Throwable> exceptionHandler)` |

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

    Methods in io.vertx.grpcio.client with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `default <Req,​Resp,​T> Future<T>` | GrpcIoClient.`call​(MethodDescriptor<Req,​Resp> service, Handler<GrpcClientRequest<Req,​Resp>> requestHandler, Function<GrpcClientResponse<Req,​Resp>,​Future<T>> resultFn)` | Like `GrpcIoClient.call(Address, MethodDescriptor, Handler, Function)` with the default remote server.
    `default <Req,​Resp,​T> Future<T>` | GrpcIoClient.`call​(Address server, MethodDescriptor<Req,​Resp> service, Handler<GrpcClientRequest<Req,​Resp>> requestHandler, Function<GrpcClientResponse<Req,​Resp>,​Future<T>> resultFn)` | Call the `service` gRPC service hosted by `server`.

  - ### Uses of Handler in io.vertx.grpcio.server

    Subinterfaces of Handler in io.vertx.grpcio.server
    Modifier and Type | Interface | Description
    --- | --- | ---
    `interface` | `GrpcIoServer` | A gRPC server based on Vert.x HTTP server.

    Methods in io.vertx.grpcio.server with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `<Req,​Resp> GrpcIoServer` | GrpcIoServer.`callHandler​(MethodDescriptor<Req,​Resp> methodDesc, Handler<GrpcServerRequest<Req,​Resp>> handler)` | Set a service method call handler that handles any call made to the server for the `MethodDescriptor` service method.
    `GrpcIoServer` | GrpcIoServer.`callHandler​(Handler<GrpcServerRequest<Buffer,​Buffer>> handler)` |

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

    Subinterfaces of Handler in io.vertx.httpproxy
    Modifier and Type | Interface | Description
    --- | --- | ---
    `interface` | `HttpProxy` | Handles the HTTP reverse proxy logic between the user agent and the origin.

    Methods in io.vertx.httpproxy with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `ProxyInterceptorBuilder` | ProxyInterceptorBuilder.`transformingQueryParams​(Handler<MultiMap> updater)` | Apply modifications to the query parameters.
    `ProxyInterceptorBuilder` | ProxyInterceptorBuilder.`transformingRequestHeaders​(Handler<MultiMap> requestHeadersUpdater)` | Apply callbacks to change the request headers when the proxy receives them.
    `ProxyInterceptorBuilder` | ProxyInterceptorBuilder.`transformingResponseHeaders​(Handler<MultiMap> responseHeadersUpdater)` | Apply callbacks to change the response headers when the proxy receives them.

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

    Methods in io.vertx.junit5 that return Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `<T> Handler<AsyncResult<T>>` | VertxTestContext.`completing()` | Deprecated. Use `VertxTestContext.succeedingThenComplete()` instead.
    `<T> Handler<AsyncResult<T>>` | VertxTestContext.`failing()` | Deprecated. Use `VertxTestContext.failingThenComplete()` or `VertxTestContext.failing(Handler)`, for example `failing(e -> checkpoint.flag())`, `failing(e -> { more testing code })`, or `failing(e -> {})`.
    `<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.`failingThenComplete()` | Create an asynchronous result handler that expects a failure to then complete the test context.
    `<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.
    `<T> Handler<AsyncResult<T>>` | VertxTestContext.`succeedingThenComplete()` | Create an asynchronous result handler that expects a success to then complete the test context.

    Methods in io.vertx.junit5 with parameters of type Handler
    Modifier and Type | Method | 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.client.consumer

    Methods in io.vertx.kafka.client.consumer with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `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.
    `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.`endHandler​(Handler<Void> endHandler)` |
    `KafkaReadStream<K,​V>` | KafkaReadStream.`endHandler​(Handler<Void> endHandler)` |
    `KafkaConsumer<K,​V>` | KafkaConsumer.`exceptionHandler​(Handler<Throwable> handler)` |
    `KafkaReadStream<K,​V>` | KafkaReadStream.`exceptionHandler​(Handler<Throwable> handler)` |
    `KafkaConsumer<K,​V>` | KafkaConsumer.`handler​(Handler<KafkaConsumerRecord<K,​V>> handler)` |
    `KafkaReadStream<K,​V>` | KafkaReadStream.`handler​(Handler<org.apache.kafka.clients.consumer.ConsumerRecord<K,​V>> handler)` |
    `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.`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.`partitionsRevokedHandler​(Handler<Set<TopicPartition>> handler)` | Set the handler called when topic partitions are revoked to the consumer
    `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

  - ### 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 | Description
    --- | --- | ---
    `KafkaProducer<K,​V>` | KafkaProducer.`drainHandler​(Handler<Void> handler)` |
    `KafkaWriteStream<K,​V>` | KafkaWriteStream.`drainHandler​(Handler<Void> handler)` |
    `KafkaProducer<K,​V>` | KafkaProducer.`exceptionHandler​(Handler<Throwable> handler)` |
    `KafkaWriteStream<K,​V>` | KafkaWriteStream.`exceptionHandler​(Handler<Throwable> handler)` |

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

    Methods in io.vertx.lang.reactivex that return Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `static <CORE,​REACTIVE> Handler<CORE>` | Helper.`convertHandler​(Handler<REACTIVE> rxHandler, Function<CORE,​REACTIVE> mapper)` | Convert a handler for a generated reactive type to a handler for the corresponding core type.

    Methods in io.vertx.lang.reactivex with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `static <CORE,​REACTIVE> Handler<CORE>` | Helper.`convertHandler​(Handler<REACTIVE> rxHandler, Function<CORE,​REACTIVE> mapper)` | Convert a handler for a generated reactive type to a handler for the corresponding core type.

  - ### Uses of Handler in io.vertx.lang.rxjava3

    Methods in io.vertx.lang.rxjava3 that return Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `static <CORE,​REACTIVE> Handler<CORE>` | Helper.`convertHandler​(Handler<REACTIVE> rxHandler, Function<CORE,​REACTIVE> mapper)` | Convert a handler for a generated reactive type to a handler for the corresponding core type.

    Methods in io.vertx.lang.rxjava3 with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `static <CORE,​REACTIVE> Handler<CORE>` | Helper.`convertHandler​(Handler<REACTIVE> rxHandler, Function<CORE,​REACTIVE> mapper)` | Convert a handler for a generated reactive type to a handler for the corresponding core type.

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

    Methods in io.vertx.micrometer that return Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `static Handler<HttpServerRequest>` | PrometheusRequestHandler.`create()` | Creates a handler with a new PrometheusMeterRegistry and the default metrics endpoint ("/metrics").
    `static Handler<HttpServerRequest>` | PrometheusRequestHandler.`create​(io.micrometer.prometheusmetrics.PrometheusMeterRegistry registry)` | Creates a handler with the specified PrometheusMeterRegistry and the default metrics endpoint ("/metrics").
    `static Handler<HttpServerRequest>` | PrometheusRequestHandler.`create​(io.micrometer.prometheusmetrics.PrometheusMeterRegistry registry, String metricsEndpoint)` | Creates a handler with the specified PrometheusMeterRegistry and metrics endpoint.
    `static Handler<RoutingContext>` | PrometheusScrapingHandler.`create()` | Creates a Vert.x Web `Route` handler for Prometheus metrics scraping.
    `static Handler<RoutingContext>` | PrometheusScrapingHandler.`create​(io.micrometer.prometheusmetrics.PrometheusMeterRegistry registry)` | 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 | Description
    --- | --- | ---
    `MqttClient` | MqttClient.`authenticationExchangeHandler​(Handler<MqttAuthenticationExchangeMessage> authenticationExchangeHandler)` | Sets handler which will be called after AUTH packet receiving
    `MqttEndpoint` | MqttEndpoint.`authenticationExchangeHandler​(Handler<MqttAuthenticationExchangeMessage> handler)` | Set the auth handler on the MQTT endpoint.
    `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.
    `MqttEndpoint` | MqttEndpoint.`disconnectHandler​(Handler<Void> handler)` | Set a disconnect handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`disconnectMessageHandler​(Handler<MqttDisconnectMessage> 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
    `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
    `MqttEndpoint` | MqttEndpoint.`publishAcknowledgeHandler​(Handler<Integer> handler)` | Set the puback handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishAcknowledgeMessageHandler​(Handler<MqttPubAckMessage> handler)` | Set the puback handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`publishCompletionExpirationHandler​(Handler<Integer> publishCompletionExpirationHandler)` | Sets a handler which will be called when the client does not receive a PUBACK or PUBREC/PUBCOMP for a message published using QoS 1 or 2 respectively.
    `MqttClient` | MqttClient.`publishCompletionHandler​(Handler<Integer> publishCompletionHandler)` | Sets a handler which will be called each time the publishing of a message has been completed.
    `MqttEndpoint` | MqttEndpoint.`publishCompletionHandler​(Handler<Integer> handler)` | Set the pubcomp handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishCompletionMessageHandler​(Handler<MqttPubCompMessage> handler)` | Set the pubcomp handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`publishCompletionUnknownPacketIdHandler​(Handler<Integer> publishCompletionPhantomHandler)` | Sets a handler which will be called when the client receives a PUBACK/PUBREC/PUBCOMP with an unknown packet ID.
    `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.`publishReceivedMessageHandler​(Handler<MqttPubRecMessage> handler)` | Set the pubrec handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishReleaseHandler​(Handler<Integer> handler)` | Set the pubrel handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishReleaseMessageHandler​(Handler<MqttPubRelMessage> handler)` | Set the pubrel handler on the MQTT endpoint.
    `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.`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.mssqlclient

    Methods in io.vertx.mssqlclient with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `MSSQLConnection` | MSSQLConnection.`closeHandler​(Handler<Void> handler)` | Set an handler called when the connection is closed.
    `MSSQLConnection` | MSSQLConnection.`exceptionHandler​(Handler<Throwable> handler)` | Set an handler called with connection errors.
    `MSSQLConnection` | MSSQLConnection.`infoHandler​(Handler<MSSQLInfo> handler)` | Set a handler called when the connection receives an informational message from the server.
    `static Pool` | MSSQLBuilder.`pool​(Handler<ClientBuilder<Pool>> block)` | Build a pool with the specified `block` argument.

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

    Methods in io.vertx.mssqlclient.spi with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `Pool` | MSSQLDriver.`newPool​(Vertx vertx, Supplier<Future<MSSQLConnectOptions>> databases, PoolOptions options, NetClientOptions transportOptions, Handler<SqlConnection> connectHandler, io.vertx.core.internal.CloseFuture closeFuture)` |

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

    Methods in io.vertx.mysqlclient with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `static SqlClient` | MySQLBuilder.`client​(Handler<ClientBuilder<SqlClient>> handler)` | Build a client backed by a connection pool with the specified `block` argument.
    `MySQLConnection` | MySQLConnection.`closeHandler​(Handler<Void> handler)` | Set an handler called when the connection is closed.
    `MySQLConnection` | MySQLConnection.`exceptionHandler​(Handler<Throwable> handler)` | Set an handler called with connection errors.
    `static Pool` | MySQLBuilder.`pool​(Handler<ClientBuilder<Pool>> block)` | Build a pool with the specified `block` argument.

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

    Methods in io.vertx.mysqlclient.spi with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `Pool` | MySQLDriver.`newPool​(Vertx vertx, Supplier<Future<MySQLConnectOptions>> databases, PoolOptions options, NetClientOptions transportOptions, Handler<SqlConnection> connectHandler, io.vertx.core.internal.CloseFuture closeFuture)` |

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

    Methods in io.vertx.oracleclient with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `OracleConnection` | OracleConnection.`closeHandler​(Handler<Void> handler)` | Set an handler called when the connection is closed.
    `OracleConnection` | OracleConnection.`exceptionHandler​(Handler<Throwable> handler)` | Set an handler called with connection errors.
    `static Pool` | OracleBuilder.`pool​(Handler<ClientBuilder<Pool>> block)` | Build a pool with the specified `block` argument.

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

    Methods in io.vertx.oracleclient.spi with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `Pool` | OracleDriver.`newPool​(Vertx vertx, Supplier<Future<OracleConnectOptions>> databases, PoolOptions options, NetClientOptions transportOptions, Handler<SqlConnection> connectHandler, io.vertx.core.internal.CloseFuture closeFuture)` |

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

    Methods in io.vertx.pgclient with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `static SqlClient` | PgBuilder.`client​(Handler<ClientBuilder<SqlClient>> handler)` | Build a client backed by a connection pool with the specified `block` argument.
    `PgConnection` | PgConnection.`closeHandler​(Handler<Void> handler)` | Set an handler called when the connection is closed.
    `PgConnection` | PgConnection.`exceptionHandler​(Handler<Throwable> handler)` | Set an handler called with connection errors.
    `PgConnection` | PgConnection.`noticeHandler​(Handler<PgNotice> handler)` | Set a handler called when the connection receives a notice from the server.
    `PgConnection` | PgConnection.`notificationHandler​(Handler<PgNotification> handler)` | Set a handler called when the connection receives notification on a channel.
    `static Pool` | PgBuilder.`pool​(Handler<ClientBuilder<Pool>> block)` | Build a pool with the specified `block` argument.

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

    Methods in io.vertx.pgclient.pubsub with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `PgSubscriber` | PgSubscriber.`closeHandler​(Handler<Void> handler)` | Set an handler called when the subscriber is closed.
    `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.pgclient.spi

    Methods in io.vertx.pgclient.spi with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `Pool` | PgDriver.`newPool​(Vertx vertx, Supplier<Future<PgConnectOptions>> databases, PoolOptions poolOptions, NetClientOptions transportOptions, Handler<SqlConnection> connectHandler, io.vertx.core.internal.CloseFuture closeFuture)` |

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

    Methods in io.vertx.rabbitmq with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | RabbitMQClient.`addConnectionEstablishedCallback​(Handler<Promise<Void>> connectionEstablishedCallback)` | Set a callback to be called whenever a new connection is established.
    `Future<Void>` | RabbitMQClient.`basicPublishWithDeliveryTag​(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler)` | Publish a message.
    `RabbitMQConsumer` | RabbitMQConsumer.`endHandler​(Handler<Void> endHandler)` | Set an end handler.
    `RabbitMQConsumer` | RabbitMQConsumer.`exceptionHandler​(Handler<Throwable> exceptionHandler)` | Set an exception handler on the read stream.
    `RabbitMQConsumer` | RabbitMQConsumer.`handler​(Handler<RabbitMQMessage> messageArrived)` | Set a message handler.

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

    Methods in io.vertx.reactivex with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `static <T> CompletableObserver` | CompletableHelper.`toObserver​(Handler<AsyncResult<T>> handler)` | Adapts an Vert.x `Handler<AsyncResult<T>>` to an RxJava2 `SingleObserver`.
    `static <T> MaybeObserver<T>` | MaybeHelper.`toObserver​(Handler<AsyncResult<T>> handler)` | Adapts an Vert.x `Handler<AsyncResult<T>>` to an RxJava2 `MaybeObserver`.
    `static <T> SingleObserver<T>` | SingleHelper.`toObserver​(Handler<AsyncResult<T>> handler)` | Adapts an Vert.x `Handler<AsyncResult<T>>` to an RxJava2 `SingleObserver`.

    Method parameters in io.vertx.reactivex with type arguments of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `static Completable` | CompletableHelper.`toCompletable​(Consumer<Handler<AsyncResult<Void>>> handler)` | Returns a `Completable` that, when subscribed, uses the provided `handler` to adapt a callback-based asynchronous method.
    `static <T> Maybe<T>` | MaybeHelper.`toMaybe​(Consumer<Handler<AsyncResult<T>>> handler)` | Returns a `Maybe` that, when subscribed, uses the provided `handler` to adapt a callback-based asynchronous method.
    `static <T> Single<T>` | SingleHelper.`toSingle​(Consumer<Handler<AsyncResult<T>>> handler)` | Returns a `Single` that, when subscribed, uses the provided `handler` to adapt a callback-based asynchronous method.

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

    Methods in io.vertx.reactivex.amqp with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `WriteStream<AmqpMessage>` | AmqpSender.`drainHandler​(Handler<Void> handler)` | Set a drain handler on the stream.
    `AmqpReceiver` | AmqpReceiver.`endHandler​(Handler<Void> endHandler)` |
    `AmqpConnection` | AmqpConnection.`exceptionHandler​(Handler<Throwable> handler)` | Registers a handler called on disconnection.
    `AmqpReceiver` | AmqpReceiver.`exceptionHandler​(Handler<Throwable> handler)` |
    `AmqpSender` | AmqpSender.`exceptionHandler​(Handler<Throwable> handler)` |
    `AmqpReceiver` | AmqpReceiver.`handler​(Handler<AmqpMessage> handler)` |

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

    Methods in io.vertx.reactivex.cassandra with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `CassandraRowStream` | CassandraRowStream.`endHandler​(Handler<Void> handler)` |
    `CassandraRowStream` | CassandraRowStream.`exceptionHandler​(Handler<Throwable> handler)` |
    `CassandraRowStream` | CassandraRowStream.`handler​(Handler<com.datastax.oss.driver.api.core.cql.Row> handler)` |

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

    Methods in io.vertx.reactivex.circuitbreaker with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `CircuitBreaker` | CircuitBreaker.`closeHandler​(Handler<Void> handler)` | Sets a to be invoked when the circuit breaker state switches to closed.
    `<T> Future<T>` | CircuitBreaker.`execute​(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>)` but using the circuit breaker .
    `<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 .
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReportWithFallback​(Promise<T> resultPromise, Handler<Promise<T>> command, Function<Throwable,​T> fallback)` | Executes the given operation with the circuit breaker control.
    `<T> Future<T>` | CircuitBreaker.`executeWithFallback​(Handler<Promise<T>> command, Function<Throwable,​T> fallback)` | Executes the given operation with the circuit breaker control.
    `CircuitBreaker` | CircuitBreaker.`halfOpenHandler​(Handler<Void> handler)` | Sets a to be invoked when the circuit breaker state switches to half-open.
    `CircuitBreaker` | CircuitBreaker.`openHandler​(Handler<Void> handler)` | Sets a to be 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>)` but using the circuit breaker .
    `<T> Single<T>` | CircuitBreaker.`rxExecuteWithFallback​(Handler<Promise<T>> command, Function<Throwable,​T> fallback)` | Executes the given operation with the circuit breaker control.

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

    Methods in io.vertx.reactivex.config with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | ConfigRetriever.`listen​(Handler<ConfigChange> listener)` | Registers a listener receiving configuration changes.
    `ConfigRetriever` | ConfigRetriever.`setBeforeScanHandler​(Handler<Void> handler)` | Registers a handler called before every scan.

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

    Methods in io.vertx.reactivex.core with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `Context` | Context.`exceptionHandler​(Handler<Throwable> handler)` | Set an exception handler called when the context runs an action throwing an uncaught throwable.
    `Vertx` | Vertx.`exceptionHandler​(Handler<Throwable> handler)` | Set a default exception handler for `Context`, set on `Context.exceptionHandler(io.vertx.core.Handler<java.lang.Throwable>)` at creation.
    `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.
    `long` | Vertx.`setPeriodic​(long initialDelay, long delay, Handler<Long> handler)` | Set a periodic timer to fire every `delay` milliseconds with initial delay, at which point `handler` will be called with the id of the timer.
    `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.

  - ### 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 | Description
    --- | --- | ---
    `DatagramSocket` | DatagramSocket.`exceptionHandler​(Handler<Throwable> handler)` |
    `DatagramSocket` | DatagramSocket.`handler​(Handler<DatagramPacket> handler)` |

  - ### 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 | 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
    `<T> MessageConsumer<T>` | EventBus.`consumer​(MessageConsumerOptions options, Handler<Message<T>> handler)` | Create a consumer and register it against the specified options address.
    `<T> MessageConsumer<T>` | EventBus.`consumer​(String address, Handler<Message<T>> handler)` | Create a consumer and register it against the specified address.
    `MessageConsumer<T>` | MessageConsumer.`endHandler​(Handler<Void> endHandler)` |
    `MessageConsumer<T>` | MessageConsumer.`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(io.vertx.core.eventbus.MessageConsumerOptions)` 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(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>>)`

  - ### 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 | Description
    --- | --- | ---
    `AsyncFile` | AsyncFile.`drainHandler​(Handler<Void> handler)` |
    `AsyncFile` | AsyncFile.`endHandler​(Handler<Void> endHandler)` |
    `AsyncFile` | AsyncFile.`exceptionHandler​(Handler<Throwable> handler)` | Set an exception handler on the read stream and on the write stream.
    `AsyncFile` | AsyncFile.`handler​(Handler<Buffer> handler)` |

  - ### 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 | Description
    --- | --- | ---
    `ClientWebSocket` | ClientWebSocket.`binaryMessageHandler​(Handler<Buffer> handler)` |
    `WebSocket` | WebSocket.`binaryMessageHandler​(Handler<Buffer> handler)` |
    `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.
    `ClientWebSocket` | ClientWebSocket.`closeHandler​(Handler<Void> handler)` |
    `HttpConnection` | HttpConnection.`closeHandler​(Handler<Void> handler)` | Set a close handler.
    `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)` |
    `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.`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.
    `ClientWebSocket` | ClientWebSocket.`drainHandler​(Handler<Void> handler)` |
    `HttpClientRequest` | HttpClientRequest.`drainHandler​(Handler<Void> handler)` |
    `HttpServerResponse` | HttpServerResponse.`drainHandler​(Handler<Void> handler)` |
    `ServerWebSocket` | ServerWebSocket.`drainHandler​(Handler<Void> handler)` |
    `WebSocket` | WebSocket.`drainHandler​(Handler<Void> handler)` |
    `WebSocketBase` | WebSocketBase.`drainHandler​(Handler<Void> handler)` |
    `HttpClientRequest` | HttpClientRequest.`earlyHintsHandler​(Handler<MultiMap> handler)` | If the server responds with an interim HTTP response with a status code of `103` and a Early Hints handler has been set using this method, then the `handler` will be called.
    `ClientWebSocket` | ClientWebSocket.`endHandler​(Handler<Void> endHandler)` |
    `HttpClientResponse` | HttpClientResponse.`endHandler​(Handler<Void> endHandler)` |
    `HttpServerFileUpload` | HttpServerFileUpload.`endHandler​(Handler<Void> endHandler)` |
    `HttpServerRequest` | HttpServerRequest.`endHandler​(Handler<Void> endHandler)` |
    `HttpServerResponse` | HttpServerResponse.`endHandler​(Handler<Void> handler)` | Set an end handler for the response.
    `ServerWebSocket` | ServerWebSocket.`endHandler​(Handler<Void> endHandler)` |
    `WebSocket` | WebSocket.`endHandler​(Handler<Void> endHandler)` |
    `WebSocketBase` | WebSocketBase.`endHandler​(Handler<Void> endHandler)` |
    `ClientWebSocket` | ClientWebSocket.`exceptionHandler​(Handler<Throwable> handler)` |
    `HttpClientRequest` | HttpClientRequest.`exceptionHandler​(Handler<Throwable> handler)` |
    `HttpClientResponse` | HttpClientResponse.`exceptionHandler​(Handler<Throwable> handler)` |
    `HttpConnection` | HttpConnection.`exceptionHandler​(Handler<Throwable> handler)` | Set an handler called when a connection error happens
    `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.
    `HttpServerFileUpload` | HttpServerFileUpload.`exceptionHandler​(Handler<Throwable> handler)` |
    `HttpServerRequest` | HttpServerRequest.`exceptionHandler​(Handler<Throwable> handler)` |
    `HttpServerResponse` | HttpServerResponse.`exceptionHandler​(Handler<Throwable> handler)` |
    `ServerWebSocket` | ServerWebSocket.`exceptionHandler​(Handler<Throwable> handler)` |
    `WebSocket` | WebSocket.`exceptionHandler​(Handler<Throwable> handler)` |
    `WebSocketBase` | WebSocketBase.`exceptionHandler​(Handler<Throwable> handler)` |
    `ClientWebSocket` | ClientWebSocket.`frameHandler​(Handler<WebSocketFrame> 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.
    `HttpConnection` | HttpConnection.`goAwayHandler​(Handler<GoAway> handler)` | Set an handler called when a frame is received.
    `ClientWebSocket` | ClientWebSocket.`handler​(Handler<Buffer> handler)` |
    `HttpClientResponse` | HttpClientResponse.`handler​(Handler<Buffer> handler)` |
    `HttpServerFileUpload` | HttpServerFileUpload.`handler​(Handler<Buffer> handler)` |
    `HttpServerRequest` | HttpServerRequest.`handler​(Handler<Buffer> handler)` |
    `ServerWebSocket` | ServerWebSocket.`handler​(Handler<Buffer> handler)` |
    `WebSocket` | WebSocket.`handler​(Handler<Buffer> handler)` |
    `WebSocketBase` | WebSocketBase.`handler​(Handler<Buffer> handler)` |
    `HttpServerResponse` | HttpServerResponse.`headersEndHandler​(Handler<Void> handler)` | Provide a handler that will be called just before the headers are written to the wire.
    `HttpServer` | HttpServer.`invalidRequestHandler​(Handler<HttpServerRequest> handler)` | Set a `handler` for handling invalid requests.
    `HttpConnection` | HttpConnection.`pingHandler​(Handler<Buffer> handler)` | Set an handler notified when a frame is received from the remote endpoint.
    `ClientWebSocket` | ClientWebSocket.`pongHandler​(Handler<Buffer> handler)` |
    `WebSocket` | WebSocket.`pongHandler​(Handler<Buffer> handler)` |
    `WebSocketBase` | WebSocketBase.`pongHandler​(Handler<Buffer> handler)` | Set a pong frame handler on the connection.
    `HttpClientRequest` | HttpClientRequest.`pushHandler​(Handler<HttpClientRequest> handler)` | Set a push handler for this request.
    `HttpConnection` | HttpConnection.`remoteSettingsHandler​(Handler<Http2Settings> handler)` | Set an handler that is called when remote endpoint `Http2Settings` are updated.
    `HttpServer` | HttpServer.`requestHandler​(Handler<HttpServerRequest> handler)` | Set the request handler for the server to `requestHandler`.
    `HttpConnection` | HttpConnection.`shutdownHandler​(Handler<Void> handler)` | Set a `handler` notified when the HTTP connection is shutdown: the client or server will close the connection within a certain amount of time.
    `WebSocket` | WebSocket.`shutdownHandler​(Handler<Void> handler)` |
    `WebSocketBase` | WebSocketBase.`shutdownHandler​(Handler<Void> handler)` | Set a `handler` notified when the WebSocket is shutdown: the client or server will close the connection within a certain amount of time.
    `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
    `ClientWebSocket` | ClientWebSocket.`textMessageHandler​(Handler<String> handler)` |
    `WebSocket` | WebSocket.`textMessageHandler​(Handler<String> handler)` |
    `WebSocketBase` | WebSocketBase.`textMessageHandler​(Handler<String> handler)` | Set a text message handler on the connection.
    `HttpServerRequest` | HttpServerRequest.`uploadHandler​(Handler<HttpServerFileUpload> uploadHandler)` | Set an upload handler.
    `HttpServer` | HttpServer.`webSocketHandler​(Handler<ServerWebSocket> handler)` | Set the WebSocket handler for the server to `wsHandler`.
    `HttpServer` | HttpServer.`webSocketHandshakeHandler​(Handler<ServerWebSocketHandshake> handler)` | Set a handler for WebSocket handshake.
    `HttpClientBuilder` | HttpClientBuilder.`withConnectHandler​(Handler<HttpConnection> handler)` | Set a connection handler for the client.

  - ### 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 | Description
    --- | --- | ---
    `NetSocket` | NetSocket.`closeHandler​(Handler<Void> handler)` | Set a `handler` notified when the socket is closed
    `NetServer` | NetServer.`connectHandler​(Handler<NetSocket> handler)` | Supply a connect handler for this server.
    `NetSocket` | NetSocket.`drainHandler​(Handler<Void> handler)` |
    `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)` |
    `NetSocket` | NetSocket.`shutdownHandler​(Handler<Void> handler)` | Set a `handler` notified when the socket is shutdown: the client or server will close the connection within a certain amount of time.

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

    Classes in io.vertx.reactivex.core.parsetools that implement Handler
    Modifier and Type | Class | 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.reactivex.core.parsetools with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `JsonParser` | JsonParser.`endHandler​(Handler<Void> endHandler)` |
    `RecordParser` | RecordParser.`endHandler​(Handler<Void> endHandler)` |
    `JsonParser` | JsonParser.`exceptionHandler​(Handler<Throwable> handler)` |
    `RecordParser` | RecordParser.`exceptionHandler​(Handler<Throwable> handler)` |
    `JsonParser` | JsonParser.`handler​(Handler<JsonEvent> handler)` |
    `RecordParser` | RecordParser.`handler​(Handler<Buffer> handler)` |
    `static RecordParser` | RecordParser.`newDelimited​(Buffer delim, Handler<Buffer> output)` | Like `RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.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.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.`setOutput​(Handler<Buffer> output)` |

  - ### 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 | Description
    --- | --- | ---
    `WriteStream<T>` | WriteStream.`drainHandler​(Handler<Void> handler)` | Set a drain handler on the stream.
    `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.

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

    Methods in io.vertx.reactivex.db2client with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `static SqlClient` | DB2Builder.`client​(Handler<ClientBuilder<SqlClient>> handler)` | Build a client backed by a connection pool with the specified `block` argument.
    `DB2Connection` | DB2Connection.`closeHandler​(Handler<Void> handler)` |
    `DB2Connection` | DB2Connection.`exceptionHandler​(Handler<Throwable> handler)` |
    `static Pool` | DB2Builder.`pool​(Handler<ClientBuilder<Pool>> block)` | Build a pool with the specified `block` argument.

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

    Methods in io.vertx.reactivex.ext.auth.audit that return Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `<T> Handler<AsyncResult<T>>` | SecurityAudit.`auditHandlerFor​(Marker marker)` |

  - ### 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 | Description
    --- | --- | ---
    `OAuth2Auth` | OAuth2Auth.`missingKeyHandler​(Handler<String> handler)` | Handled to be called when a key (mentioned on a JWT) is missing from the current config.

  - ### 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 | Description
    --- | --- | ---
    `Watch<T>` | Watch.`setHandler​(Handler<WatchResult<T>> handler)` | Set the result handler.

  - ### 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 | Description
    --- | --- | ---
    `static TcpEventBusBridge` | TcpEventBusBridge.`create​(Vertx vertx, BridgeOptions options, NetServerOptions netServerOptions, Handler<BridgeEvent> eventHandler)` |

  - ### 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 | Description
    --- | --- | ---
    `HealthChecks` | HealthChecks.`invoke​(Handler<JsonObject> resultHandler)` | Invokes the registered procedures and computes the outcome.
    `HealthChecks` | HealthChecks.`register​(String name, long timeout, Handler<Promise<Status>> procedure)` | Registers a health check procedure.
    `HealthChecks` | HealthChecks.`register​(String name, Handler<Promise<Status>> procedure)` | Registers a health check procedure.

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

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

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

    Methods in io.vertx.reactivex.ext.stomp with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `StompServerHandler` | StompServerHandler.`abortHandler​(Handler<ServerFrame> handler)` | Configures the action to execute when a `ABORT` frame is received.
    `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.`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.
    `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.
    `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.
    `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.
    `StompClient` | StompClient.`exceptionHandler​(Handler<Throwable> handler)` | Sets an exception handler notified for TCP-level errors.
    `StompClientConnection` | StompClientConnection.`exceptionHandler​(Handler<Throwable> exceptionHandler)` | Configures the exception handler notified upon TCP-level errors.
    `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.`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.
    `StompClient` | StompClient.`receivedFrameHandler​(Handler<Frame> handler)` | Configures a received handler that gets notified when a STOMP frame is received by the client.
    `StompClientConnection` | StompClientConnection.`receivedFrameHandler​(Handler<Frame> handler)` | Configures a received handler that get 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.
    `Single<String>` | StompClientConnection.`rxSubscribe​(String destination, Handler<Frame> handler)` | Subscribes to the given destination.
    `Single<String>` | StompClientConnection.`rxSubscribe​(String destination, Map<String,​String> headers, Handler<Frame> handler)` | Subscribes 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.
    `Future<String>` | StompClientConnection.`subscribe​(String destination, Handler<Frame> handler)` | Subscribes to the given destination.
    `Future<String>` | StompClientConnection.`subscribe​(String destination, Map<String,​String> headers, Handler<Frame> handler)` | Subscribes to the given destination.
    `StompServerHandler` | StompServerHandler.`subscribeHandler​(Handler<ServerFrame> handler)` | Configures the action to execute when a `SUBSCRIBE` frame is received.
    `StompServerHandler` | StompServerHandler.`unsubscribeHandler​(Handler<ServerFrame> handler)` | Configures the action to execute when a `UNSUBSCRIBE` frame is received.
    `StompClient` | StompClient.`writingFrameHandler​(Handler<Frame> handler)` | Configures a writing handler that gets notified when a STOMP frame is written on the wire.
    `StompClientConnection` | StompClientConnection.`writingFrameHandler​(Handler<Frame> handler)` | Configures a handler notified when a frame is going to be 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 | Description
    --- | --- | ---
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure()` | Creates and returns a new async handler, the returned handler controls the completion of 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.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess()` | Creates and returns a new async handler, the returned handler controls the completion of 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.
    `Handler<Throwable>` | TestContext.`exceptionHandler()` |

    Methods in io.vertx.reactivex.ext.unit with parameters of type Handler
    Modifier and Type | Method | 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.
    `<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.
    `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` | Async.`handler​(Handler<AsyncResult<Void>> completionHandler)` | Completion handler to receive a completion signal when this completions completes.
    `void` | Completion.`handler​(Handler<AsyncResult<T>> 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, int repeat, Handler<TestContext> testCase)` | Add a new test case to the suite.
    `TestSuite` | TestSuite.`test​(String name, 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 | 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 | 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.reactivex.ext.web

    Classes in io.vertx.reactivex.ext.web that implement Handler
    Modifier and Type | Class | 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.reactivex.ext.web with parameters of type Handler
    Modifier and Type | Method | 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.`addEndHandler​(Handler<AsyncResult<Void>> handler)` | Add an end handler for the request/response context.
    `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.
    `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.handler

    Subinterfaces of Handler in io.vertx.reactivex.ext.web.handler
    Modifier and Type | Interface | Description
    --- | --- | ---
    `interface` | `AuthenticationHandler` | Base interface for auth handlers.
    `interface` | `InputTrustHandler` | Base input trust interface for handlers that verify the trust of the request.
    `interface` | `PlatformHandler` | Base platform interface for handlers that provide functionality to the application platform.
    `interface` | `ProtocolUpgradeHandler` | Base interface for handlers that perform protocol upgrades.
    `interface` | `SecurityPolicyHandler` | Base security policy interface for handlers that provide HTTP security related headers.

    Classes in io.vertx.reactivex.ext.web.handler that implement Handler
    Modifier and Type | Class | Description
    --- | --- | ---
    `class` | `APIKeyHandler` | An authentication handler that provides API Key support.
    `class` | `AuthorizationHandler` | Base interface for authorization handlers that provide authorization support.
    `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` | `CorsHandler` | A handler which implements server side http://www.w3.org/TR/cors/[CORS] support for Vert.x-Web.
    `class` | `CSPHandler` | Content Security Policy (CSP) is an added layer of security that helps to detect and mitigate certain types of attacks, including Cross Site Scripting (XSS) and data injection attacks.
    `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` | `HSTSHandler` | HTTP Strict Transport Security (HSTS) RFC6797.
    `class` | `JWTAuthHandler` | An auth handler that provides JWT Authentication support.
    `class` | `LoggerHandler` | A handler which logs request information to the Vert.x logger.
    `class` | `MethodOverrideHandler` | NOTE: This class has been automatically generated from the `original` non RX-ified interface using Vert.x codegen.
    `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` | `OtpAuthHandler` | An auth handler that provides One Time Password (Multi-Factor) 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` | `SecurityAuditLoggerHandler` | A handler that logs security audit events.
    `class` | `SessionHandler` | A handler that maintains a `Session` for each browser session.
    `class` | `SimpleAuthenticationHandler` | A user customizable authentication handler.
    `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` | `WebAuthn4JHandler` | An auth handler that provides FIDO2 WebAuthN Relay Party support.
    `class` | `XFrameHandler` | The X-Frame-Options HTTP response header can be used to indicate whether or not a browser should be allowed to render a page in a ``, ``, `` or `` .

    Methods in io.vertx.reactivex.ext.web.handler with parameters of type Handler
    Modifier and Type | Method | 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.

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

    Classes in io.vertx.reactivex.ext.web.handler.graphql that implement Handler
    Modifier and Type | Class | Description
    --- | --- | ---
    `class` | `GraphQLHandler` | A `Route` handler for GraphQL requests.

    Methods in io.vertx.reactivex.ext.web.handler.graphql with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `GraphQLHandlerBuilder` | GraphQLHandlerBuilder.`beforeExecute​(Handler<ExecutionInputBuilderWithContext<RoutingContext>> beforeExecuteHandler)` | Set a callback to invoke before executing a GraphQL query.

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

    Classes in io.vertx.reactivex.ext.web.handler.graphql.ws that implement Handler
    Modifier and Type | Class | Description
    --- | --- | ---
    `class` | `GraphQLWSHandler` | A handler for the GraphQL over WebSocket Protocol.

    Methods in io.vertx.reactivex.ext.web.handler.graphql.ws with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `GraphQLWSHandlerBuilder` | GraphQLWSHandlerBuilder.`beforeExecute​(Handler<ExecutionInputBuilderWithContext<Message>> beforeExecuteHandler)` | Set a callback to invoke before executing a GraphQL query.
    `GraphQLWSHandlerBuilder` | GraphQLWSHandlerBuilder.`onConnectionInit​(Handler<ConnectionInitEvent> connectionInitHandler)` | Customize the connection init .
    `GraphQLWSHandlerBuilder` | GraphQLWSHandlerBuilder.`onMessage​(Handler<Message> messageHandler)` | Customize the message .
    `GraphQLWSHandlerBuilder` | GraphQLWSHandlerBuilder.`onSocketEnd​(Handler<ServerWebSocket> endHandler)` | Customize the end .

  - ### 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 | Description
    --- | --- | ---
    `Router` | SockJSHandler.`bridge​(SockJSBridgeOptions bridgeOptions, Handler<BridgeEvent> bridgeEventHandler)` | Like `SockJSHandler.bridge(io.vertx.ext.web.handler.sockjs.SockJSBridgeOptions)` but specifying a handler that will receive bridge events.
    `Router` | SockJSHandler.`bridge​(AuthorizationProvider authorizationProvider, SockJSBridgeOptions bridgeOptions, Handler<BridgeEvent> bridgeEventHandler)` | Like `SockJSHandler.bridge(io.vertx.ext.web.handler.sockjs.SockJSBridgeOptions)` but specifying a handler that will receive bridge events.
    `SockJSSocket` | SockJSSocket.`closeHandler​(Handler<Void> closeHandler)` |
    `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.

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

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

    Methods in io.vertx.reactivex.ext.web.healthchecks with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `HealthCheckHandler` | HealthCheckHandler.`register​(String name, long timeout, Handler<Promise<Status>> procedure)` | Registers a health check procedure.
    `HealthCheckHandler` | HealthCheckHandler.`register​(String name, Handler<Promise<Status>> procedure)` | Registers a health check procedure.

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

    Methods in io.vertx.reactivex.ext.web.openapi.router with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `OpenAPIRoute` | OpenAPIRoute.`addFailureHandler​(Handler<RoutingContext> handler)` | Adds a failure handler for this route
    `OpenAPIRoute` | OpenAPIRoute.`addHandler​(Handler<RoutingContext> handler)` | Adds a handler for this route which is executed after the security and validation handlers defined in the contract
    `RouterBuilder` | RouterBuilder.`rootHandler​(Handler<RoutingContext> rootHandler)` | Add global handler to be applied prior to being generated.

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

    Classes in io.vertx.reactivex.ext.web.validation that implement Handler
    Modifier and Type | Class | Description
    --- | --- | ---
    `class` | `ValidationHandler` |

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

    Methods in io.vertx.reactivex.grpc.client with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `GrpcClientRequest<Req,​Resp>` | GrpcClientRequest.`drainHandler​(Handler<Void> handler)` |
    `GrpcClientResponse<Req,​Resp>` | GrpcClientResponse.`endHandler​(Handler<Void> handler)` |
    `GrpcClientResponse<Req,​Resp>` | GrpcClientResponse.`errorHandler​(Handler<GrpcError> handler)` |
    `GrpcClientRequest<Req,​Resp>` | GrpcClientRequest.`exceptionHandler​(Handler<Throwable> handler)` |
    `GrpcClientResponse<Req,​Resp>` | GrpcClientResponse.`exceptionHandler​(Handler<Throwable> handler)` |
    `GrpcClientResponse<Req,​Resp>` | GrpcClientResponse.`handler​(Handler<Resp> handler)` |
    `GrpcReadStream<Resp>` | GrpcClientResponse.`invalidMessageHandler​(Handler<InvalidMessageException> handler)` | Set a message handler that is reported with invalid message errors.
    `GrpcClientResponse<Req,​Resp>` | GrpcClientResponse.`messageHandler​(Handler<GrpcMessage> handler)` |

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

    Methods in io.vertx.reactivex.grpc.common with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `GrpcWriteStream<T>` | GrpcWriteStream.`drainHandler​(Handler<Void> handler)` |
    `GrpcReadStream<T>` | GrpcReadStream.`endHandler​(Handler<Void> handler)` |
    `GrpcReadStream<T>` | GrpcReadStream.`errorHandler​(Handler<GrpcError> handler)` | Set a handler to be notified with gRPC errors.
    `GrpcReadStream<T>` | GrpcReadStream.`exceptionHandler​(Handler<Throwable> handler)` |
    `GrpcWriteStream<T>` | GrpcWriteStream.`exceptionHandler​(Handler<Throwable> handler)` |
    `GrpcReadStream<T>` | GrpcReadStream.`handler​(Handler<T> handler)` |
    `GrpcReadStream<T>` | GrpcReadStream.`invalidMessageHandler​(Handler<InvalidMessageException> handler)` | Set a message handler that is reported with invalid message errors.
    `GrpcReadStream<T>` | GrpcReadStream.`messageHandler​(Handler<GrpcMessage> handler)` | Set a handler to be notified with incoming encoded messages.

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

    Classes in io.vertx.reactivex.grpc.server that implement Handler
    Modifier and Type | Class | Description
    --- | --- | ---
    `class` | `GrpcServer` | A gRPC server based on Vert.x HTTP server.

    Methods in io.vertx.reactivex.grpc.server with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `GrpcServer` | GrpcServer.`callHandler​(Handler<GrpcServerRequest<Buffer,​Buffer>> handler)` | Set a call handler that handles any call made to the server.
    `<Req,​Resp> GrpcServer` | GrpcServer.`callHandler​(ServiceMethod<Req,​Resp> serviceMethod, Handler<GrpcServerRequest<Req,​Resp>> handler)` | Set a service method call handler that handles any call made to the server for the `fullMethodName` service method.
    `GrpcServerResponse<Req,​Resp>` | GrpcServerResponse.`drainHandler​(Handler<Void> handler)` |
    `GrpcServerRequest<Req,​Resp>` | GrpcServerRequest.`endHandler​(Handler<Void> endHandler)` |
    `GrpcServerRequest<Req,​Resp>` | GrpcServerRequest.`errorHandler​(Handler<GrpcError> handler)` |
    `GrpcServerRequest<Req,​Resp>` | GrpcServerRequest.`exceptionHandler​(Handler<Throwable> handler)` |
    `GrpcServerResponse<Req,​Resp>` | GrpcServerResponse.`exceptionHandler​(Handler<Throwable> handler)` |
    `GrpcServerRequest<Req,​Resp>` | GrpcServerRequest.`handler​(Handler<Req> handler)` |
    `GrpcReadStream<Req>` | GrpcServerRequest.`invalidMessageHandler​(Handler<InvalidMessageException> handler)` | Set a message handler that is reported with invalid message errors.
    `GrpcServerRequest<Req,​Resp>` | GrpcServerRequest.`messageHandler​(Handler<GrpcMessage> handler)` |

  - ### 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 | Description
    --- | --- | ---
    `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.
    `KafkaConsumer<K,​V>` | KafkaConsumer.`endHandler​(Handler<Void> endHandler)` |
    `KafkaConsumer<K,​V>` | KafkaConsumer.`exceptionHandler​(Handler<Throwable> handler)` |
    `KafkaConsumer<K,​V>` | KafkaConsumer.`handler​(Handler<KafkaConsumerRecord<K,​V>> handler)` |
    `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.`partitionsRevokedHandler​(Handler<Set<TopicPartition>> handler)` | Set the handler called when topic partitions are revoked to the consumer

  - ### 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 | Description
    --- | --- | ---
    `KafkaProducer<K,​V>` | KafkaProducer.`drainHandler​(Handler<Void> handler)` |
    `KafkaProducer<K,​V>` | KafkaProducer.`exceptionHandler​(Handler<Throwable> handler)` |

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

    Methods in io.vertx.reactivex.micrometer that return Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `static Handler<HttpServerRequest>` | PrometheusRequestHandler.`create()` | Creates a handler with a new PrometheusMeterRegistry and the default metrics endpoint ("/metrics").
    `static Handler<HttpServerRequest>` | PrometheusRequestHandler.`create​(io.micrometer.prometheusmetrics.PrometheusMeterRegistry registry)` | Creates a handler with the specified PrometheusMeterRegistry and the default metrics endpoint ("/metrics").
    `static Handler<HttpServerRequest>` | PrometheusRequestHandler.`create​(io.micrometer.prometheusmetrics.PrometheusMeterRegistry registry, String metricsEndpoint)` | Creates a handler with the specified PrometheusMeterRegistry and metrics endpoint.
    `static Handler<RoutingContext>` | PrometheusScrapingHandler.`create()` | Creates a Vert.x Web `Route` handler for Prometheus metrics scraping.
    `static Handler<RoutingContext>` | PrometheusScrapingHandler.`create​(io.micrometer.prometheusmetrics.PrometheusMeterRegistry registry)` | 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 | Description
    --- | --- | ---
    `MqttClient` | MqttClient.`authenticationExchangeHandler​(Handler<MqttAuthenticationExchangeMessage> authenticationExchangeHandler)` | Sets handler which will be called after AUTH packet receiving
    `MqttEndpoint` | MqttEndpoint.`authenticationExchangeHandler​(Handler<MqttAuthenticationExchangeMessage> handler)` | Set the auth handler on the MQTT endpoint.
    `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.
    `MqttEndpoint` | MqttEndpoint.`disconnectHandler​(Handler<Void> handler)` | Set a disconnect handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`disconnectMessageHandler​(Handler<MqttDisconnectMessage> 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
    `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
    `MqttEndpoint` | MqttEndpoint.`publishAcknowledgeHandler​(Handler<Integer> handler)` | Set the puback handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishAcknowledgeMessageHandler​(Handler<MqttPubAckMessage> handler)` | Set the puback handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`publishCompletionExpirationHandler​(Handler<Integer> publishCompletionExpirationHandler)` | Sets a handler which will be called when the client does not receive a PUBACK or PUBREC/PUBCOMP for a message published using QoS 1 or 2 respectively.
    `MqttClient` | MqttClient.`publishCompletionHandler​(Handler<Integer> publishCompletionHandler)` | Sets a handler which will be called each time the publishing of a message has been completed.
    `MqttEndpoint` | MqttEndpoint.`publishCompletionHandler​(Handler<Integer> handler)` | Set the pubcomp handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishCompletionMessageHandler​(Handler<MqttPubCompMessage> handler)` | Set the pubcomp handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`publishCompletionUnknownPacketIdHandler​(Handler<Integer> publishCompletionPhantomHandler)` | Sets a handler which will be called when the client receives a PUBACK/PUBREC/PUBCOMP with an unknown packet ID.
    `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.`publishReceivedMessageHandler​(Handler<MqttPubRecMessage> handler)` | Set the pubrec handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishReleaseHandler​(Handler<Integer> handler)` | Set the pubrel handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishReleaseMessageHandler​(Handler<MqttPubRelMessage> handler)` | Set the pubrel handler on the MQTT endpoint.
    `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.`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.mssqlclient

    Methods in io.vertx.reactivex.mssqlclient with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `MSSQLConnection` | MSSQLConnection.`closeHandler​(Handler<Void> handler)` |
    `MSSQLConnection` | MSSQLConnection.`exceptionHandler​(Handler<Throwable> handler)` |
    `MSSQLConnection` | MSSQLConnection.`infoHandler​(Handler<MSSQLInfo> handler)` | Set a handler called when the connection receives an informational message from the server.
    `static Pool` | MSSQLBuilder.`pool​(Handler<ClientBuilder<Pool>> block)` | Build a pool with the specified `block` argument.

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

    Methods in io.vertx.reactivex.mysqlclient with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `static SqlClient` | MySQLBuilder.`client​(Handler<ClientBuilder<SqlClient>> handler)` | Build a client backed by a connection pool with the specified `block` argument.
    `MySQLConnection` | MySQLConnection.`closeHandler​(Handler<Void> handler)` |
    `MySQLConnection` | MySQLConnection.`exceptionHandler​(Handler<Throwable> handler)` |
    `static Pool` | MySQLBuilder.`pool​(Handler<ClientBuilder<Pool>> block)` | Build a pool with the specified `block` argument.

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

    Methods in io.vertx.reactivex.oracleclient with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `OracleConnection` | OracleConnection.`closeHandler​(Handler<Void> handler)` |
    `OracleConnection` | OracleConnection.`exceptionHandler​(Handler<Throwable> handler)` |
    `static Pool` | OracleBuilder.`pool​(Handler<ClientBuilder<Pool>> block)` | Build a pool with the specified `block` argument.

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

    Methods in io.vertx.reactivex.pgclient with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `static SqlClient` | PgBuilder.`client​(Handler<ClientBuilder<SqlClient>> handler)` | Build a client backed by a connection pool with the specified `block` argument.
    `PgConnection` | PgConnection.`closeHandler​(Handler<Void> handler)` |
    `PgConnection` | PgConnection.`exceptionHandler​(Handler<Throwable> handler)` |
    `PgConnection` | PgConnection.`noticeHandler​(Handler<PgNotice> handler)` | Set a handler called when the connection receives a notice from the server.
    `PgConnection` | PgConnection.`notificationHandler​(Handler<PgNotification> handler)` | Set a handler called when the connection receives notification on a channel.
    `static Pool` | PgBuilder.`pool​(Handler<ClientBuilder<Pool>> block)` | Build a pool with the specified `block` argument.

  - ### 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 | Description
    --- | --- | ---
    `PgSubscriber` | PgSubscriber.`closeHandler​(Handler<Void> handler)` | Set an handler called when the subscriber is closed.
    `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.reactivex.rabbitmq

    Methods in io.vertx.reactivex.rabbitmq with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | RabbitMQClient.`basicPublishWithDeliveryTag​(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler)` | Publish a message.
    `RabbitMQConsumer` | RabbitMQConsumer.`endHandler​(Handler<Void> endHandler)` | Set an end handler.
    `RabbitMQConsumer` | RabbitMQConsumer.`exceptionHandler​(Handler<Throwable> exceptionHandler)` | Set an exception handler on the read stream.
    `RabbitMQConsumer` | RabbitMQConsumer.`handler​(Handler<RabbitMQMessage> messageArrived)` | Set a message handler.
    `Completable` | RabbitMQClient.`rxBasicPublishWithDeliveryTag​(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler)` | Publish a message.

  - ### 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 | Description
    --- | --- | ---
    `RedisConnection` | RedisConnection.`endHandler​(Handler<Void> endHandler)` |
    `RedisConnection` | RedisConnection.`exceptionHandler​(Handler<Throwable> handler)` |
    `RedisConnection` | RedisConnection.`handler​(Handler<Response> handler)` |

  - ### 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 | Description
    --- | --- | ---
    `void` | ServiceExporter.`close​(Handler<Void> closeHandler)` | Close the exporter
    `void` | ServiceImporter.`close​(Handler<Void> closeHandler)` | Closes the importer

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

    Methods in io.vertx.reactivex.sqlclient with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `SqlConnection` | SqlConnection.`closeHandler​(Handler<Void> handler)` | Set an handler called when the connection is closed.
    `RowStream<T>` | RowStream.`endHandler​(Handler<Void> endHandler)` |
    `RowStream<T>` | RowStream.`exceptionHandler​(Handler<Throwable> handler)` |
    `SqlConnection` | SqlConnection.`exceptionHandler​(Handler<Throwable> handler)` | Set an handler called with connection errors.
    `RowStream<T>` | RowStream.`handler​(Handler<T> handler)` |
    `ClientBuilder<C>` | ClientBuilder.`withConnectHandler​(Handler<SqlConnection> handler)` | Set a handler called when the pool has established a connection to the database.

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

    Classes in io.vertx.redis.client that implement Handler
    Modifier and Type | Class | Description
    --- | --- | ---
    `class` | `EventBusHandler` | A handler that can be installed on a Redis connection using `RedisConnection.handler(Handler)` in order to consume subscription messages and send them on the Vert.x event bus.

    Methods in io.vertx.redis.client with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `RedisConnection` | RedisConnection.`endHandler​(Handler<Void> endHandler)` | Set an end handler.
    `RedisConnection` | RedisConnection.`exceptionHandler​(Handler<Throwable> handler)` | Set an exception handler on the read stream.
    `RedisConnection` | RedisConnection.`handler​(Handler<Response> handler)` | Set a data handler.

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

    Methods in io.vertx.rxjava3 with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `static <T> CompletableObserver` | CompletableHelper.`toObserver​(Handler<AsyncResult<T>> handler)` | Adapts an Vert.x `Handler<AsyncResult<T>>` to an RxJava2 `SingleObserver`.
    `static <T> MaybeObserver<T>` | MaybeHelper.`toObserver​(Handler<AsyncResult<T>> handler)` | Adapts an Vert.x `Handler<AsyncResult<T>>` to an RxJava2 `MaybeObserver`.
    `static <T> SingleObserver<T>` | SingleHelper.`toObserver​(Handler<AsyncResult<T>> handler)` | Adapts an Vert.x `Handler<AsyncResult<T>>` to an RxJava2 `SingleObserver`.

    Method parameters in io.vertx.rxjava3 with type arguments of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `static Completable` | CompletableHelper.`toCompletable​(Consumer<Handler<AsyncResult<Void>>> handler)` | Returns a `Completable` that, when subscribed, uses the provided `handler` to adapt a callback-based asynchronous method.
    `static <T> Maybe<T>` | MaybeHelper.`toMaybe​(Consumer<Handler<AsyncResult<T>>> handler)` | Returns a `Maybe` that, when subscribed, uses the provided `handler` to adapt a callback-based asynchronous method.
    `static <T> Single<T>` | SingleHelper.`toSingle​(Consumer<Handler<AsyncResult<T>>> handler)` | Returns a `Single` that, when subscribed, uses the provided `handler` to adapt a callback-based asynchronous method.

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

    Methods in io.vertx.rxjava3.amqp with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `WriteStream<AmqpMessage>` | AmqpSender.`drainHandler​(Handler<Void> handler)` | Set a drain handler on the stream.
    `AmqpReceiver` | AmqpReceiver.`endHandler​(Handler<Void> endHandler)` |
    `AmqpConnection` | AmqpConnection.`exceptionHandler​(Handler<Throwable> handler)` | Registers a handler called on disconnection.
    `AmqpReceiver` | AmqpReceiver.`exceptionHandler​(Handler<Throwable> handler)` |
    `AmqpSender` | AmqpSender.`exceptionHandler​(Handler<Throwable> handler)` |
    `AmqpReceiver` | AmqpReceiver.`handler​(Handler<AmqpMessage> handler)` |

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

    Methods in io.vertx.rxjava3.cassandra with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `CassandraRowStream` | CassandraRowStream.`endHandler​(Handler<Void> handler)` |
    `CassandraRowStream` | CassandraRowStream.`exceptionHandler​(Handler<Throwable> handler)` |
    `CassandraRowStream` | CassandraRowStream.`handler​(Handler<com.datastax.oss.driver.api.core.cql.Row> handler)` |

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

    Methods in io.vertx.rxjava3.circuitbreaker with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `CircuitBreaker` | CircuitBreaker.`closeHandler​(Handler<Void> handler)` | Sets a to be invoked when the circuit breaker state switches to closed.
    `<T> Single<T>` | CircuitBreaker.`execute​(Handler<Promise<T>> command)` | Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava3.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker .
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReport​(Promise<T> resultPromise, Handler<Promise<T>> command)` | Same as `CircuitBreaker.executeAndReportWithFallback(io.vertx.rxjava3.core.Promise<T>, io.vertx.core.Handler<io.vertx.rxjava3.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker .
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReportWithFallback​(Promise<T> resultPromise, Handler<Promise<T>> command, Function<Throwable,​T> fallback)` | Executes the given operation with the circuit breaker control.
    `<T> Single<T>` | CircuitBreaker.`executeWithFallback​(Handler<Promise<T>> command, Function<Throwable,​T> fallback)` | Executes the given operation with the circuit breaker control.
    `CircuitBreaker` | CircuitBreaker.`halfOpenHandler​(Handler<Void> handler)` | Sets a to be invoked when the circuit breaker state switches to half-open.
    `CircuitBreaker` | CircuitBreaker.`openHandler​(Handler<Void> handler)` | Sets a to be 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.rxjava3.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker .
    `<T> Single<T>` | CircuitBreaker.`rxExecuteWithFallback​(Handler<Promise<T>> command, Function<Throwable,​T> fallback)` | Executes the given operation with the circuit breaker control.

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

    Methods in io.vertx.rxjava3.config with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | ConfigRetriever.`listen​(Handler<ConfigChange> listener)` | Registers a listener receiving configuration changes.
    `ConfigRetriever` | ConfigRetriever.`setBeforeScanHandler​(Handler<Void> handler)` | Registers a handler called before every scan.

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

    Methods in io.vertx.rxjava3.core with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `Context` | Context.`exceptionHandler​(Handler<Throwable> handler)` | Set an exception handler called when the context runs an action throwing an uncaught throwable.
    `Vertx` | Vertx.`exceptionHandler​(Handler<Throwable> handler)` | Set a default exception handler for `Context`, set on `Context.exceptionHandler(io.vertx.core.Handler<java.lang.Throwable>)` at creation.
    `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.
    `long` | Vertx.`setPeriodic​(long initialDelay, long delay, Handler<Long> handler)` | Set a periodic timer to fire every `delay` milliseconds with initial delay, at which point `handler` will be called with the id of the timer.
    `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.

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

    Methods in io.vertx.rxjava3.core.datagram with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `DatagramSocket` | DatagramSocket.`exceptionHandler​(Handler<Throwable> handler)` |
    `DatagramSocket` | DatagramSocket.`handler​(Handler<DatagramPacket> handler)` |

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

    Methods in io.vertx.rxjava3.core.eventbus with parameters of type Handler
    Modifier and Type | Method | 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
    `<T> MessageConsumer<T>` | EventBus.`consumer​(MessageConsumerOptions options, Handler<Message<T>> handler)` | Create a consumer and register it against the specified options address.
    `<T> MessageConsumer<T>` | EventBus.`consumer​(String address, Handler<Message<T>> handler)` | Create a consumer and register it against the specified address.
    `MessageConsumer<T>` | MessageConsumer.`endHandler​(Handler<Void> endHandler)` |
    `MessageConsumer<T>` | MessageConsumer.`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(io.vertx.core.eventbus.MessageConsumerOptions)` 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(io.vertx.core.Handler<io.vertx.rxjava3.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.rxjava3.core.eventbus.DeliveryContext<T>>)`

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

    Methods in io.vertx.rxjava3.core.file with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `AsyncFile` | AsyncFile.`drainHandler​(Handler<Void> handler)` |
    `AsyncFile` | AsyncFile.`endHandler​(Handler<Void> endHandler)` |
    `AsyncFile` | AsyncFile.`exceptionHandler​(Handler<Throwable> handler)` | Set an exception handler on the read stream and on the write stream.
    `AsyncFile` | AsyncFile.`handler​(Handler<Buffer> handler)` |

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

    Methods in io.vertx.rxjava3.core.http with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `ClientWebSocket` | ClientWebSocket.`binaryMessageHandler​(Handler<Buffer> handler)` |
    `WebSocket` | WebSocket.`binaryMessageHandler​(Handler<Buffer> handler)` |
    `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.
    `ClientWebSocket` | ClientWebSocket.`closeHandler​(Handler<Void> handler)` |
    `HttpConnection` | HttpConnection.`closeHandler​(Handler<Void> handler)` | Set a close handler.
    `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)` |
    `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.`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.
    `ClientWebSocket` | ClientWebSocket.`drainHandler​(Handler<Void> handler)` |
    `HttpClientRequest` | HttpClientRequest.`drainHandler​(Handler<Void> handler)` |
    `HttpServerResponse` | HttpServerResponse.`drainHandler​(Handler<Void> handler)` |
    `ServerWebSocket` | ServerWebSocket.`drainHandler​(Handler<Void> handler)` |
    `WebSocket` | WebSocket.`drainHandler​(Handler<Void> handler)` |
    `WebSocketBase` | WebSocketBase.`drainHandler​(Handler<Void> handler)` |
    `HttpClientRequest` | HttpClientRequest.`earlyHintsHandler​(Handler<MultiMap> handler)` | If the server responds with an interim HTTP response with a status code of `103` and a Early Hints handler has been set using this method, then the `handler` will be called.
    `ClientWebSocket` | ClientWebSocket.`endHandler​(Handler<Void> endHandler)` |
    `HttpClientResponse` | HttpClientResponse.`endHandler​(Handler<Void> endHandler)` |
    `HttpServerFileUpload` | HttpServerFileUpload.`endHandler​(Handler<Void> endHandler)` |
    `HttpServerRequest` | HttpServerRequest.`endHandler​(Handler<Void> endHandler)` |
    `HttpServerResponse` | HttpServerResponse.`endHandler​(Handler<Void> handler)` | Set an end handler for the response.
    `ServerWebSocket` | ServerWebSocket.`endHandler​(Handler<Void> endHandler)` |
    `WebSocket` | WebSocket.`endHandler​(Handler<Void> endHandler)` |
    `WebSocketBase` | WebSocketBase.`endHandler​(Handler<Void> endHandler)` |
    `ClientWebSocket` | ClientWebSocket.`exceptionHandler​(Handler<Throwable> handler)` |
    `HttpClientRequest` | HttpClientRequest.`exceptionHandler​(Handler<Throwable> handler)` |
    `HttpClientResponse` | HttpClientResponse.`exceptionHandler​(Handler<Throwable> handler)` |
    `HttpConnection` | HttpConnection.`exceptionHandler​(Handler<Throwable> handler)` | Set an handler called when a connection error happens
    `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.
    `HttpServerFileUpload` | HttpServerFileUpload.`exceptionHandler​(Handler<Throwable> handler)` |
    `HttpServerRequest` | HttpServerRequest.`exceptionHandler​(Handler<Throwable> handler)` |
    `HttpServerResponse` | HttpServerResponse.`exceptionHandler​(Handler<Throwable> handler)` |
    `ServerWebSocket` | ServerWebSocket.`exceptionHandler​(Handler<Throwable> handler)` |
    `WebSocket` | WebSocket.`exceptionHandler​(Handler<Throwable> handler)` |
    `WebSocketBase` | WebSocketBase.`exceptionHandler​(Handler<Throwable> handler)` |
    `ClientWebSocket` | ClientWebSocket.`frameHandler​(Handler<WebSocketFrame> 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.
    `HttpConnection` | HttpConnection.`goAwayHandler​(Handler<GoAway> handler)` | Set an handler called when a frame is received.
    `ClientWebSocket` | ClientWebSocket.`handler​(Handler<Buffer> handler)` |
    `HttpClientResponse` | HttpClientResponse.`handler​(Handler<Buffer> handler)` |
    `HttpServerFileUpload` | HttpServerFileUpload.`handler​(Handler<Buffer> handler)` |
    `HttpServerRequest` | HttpServerRequest.`handler​(Handler<Buffer> handler)` |
    `ServerWebSocket` | ServerWebSocket.`handler​(Handler<Buffer> handler)` |
    `WebSocket` | WebSocket.`handler​(Handler<Buffer> handler)` |
    `WebSocketBase` | WebSocketBase.`handler​(Handler<Buffer> handler)` |
    `HttpServerResponse` | HttpServerResponse.`headersEndHandler​(Handler<Void> handler)` | Provide a handler that will be called just before the headers are written to the wire.
    `HttpServer` | HttpServer.`invalidRequestHandler​(Handler<HttpServerRequest> handler)` | Set a `handler` for handling invalid requests.
    `HttpConnection` | HttpConnection.`pingHandler​(Handler<Buffer> handler)` | Set an handler notified when a frame is received from the remote endpoint.
    `ClientWebSocket` | ClientWebSocket.`pongHandler​(Handler<Buffer> handler)` |
    `WebSocket` | WebSocket.`pongHandler​(Handler<Buffer> handler)` |
    `WebSocketBase` | WebSocketBase.`pongHandler​(Handler<Buffer> handler)` | Set a pong frame handler on the connection.
    `HttpClientRequest` | HttpClientRequest.`pushHandler​(Handler<HttpClientRequest> handler)` | Set a push handler for this request.
    `HttpConnection` | HttpConnection.`remoteSettingsHandler​(Handler<Http2Settings> handler)` | Set an handler that is called when remote endpoint `Http2Settings` are updated.
    `HttpServer` | HttpServer.`requestHandler​(Handler<HttpServerRequest> handler)` | Set the request handler for the server to `requestHandler`.
    `HttpConnection` | HttpConnection.`shutdownHandler​(Handler<Void> handler)` | Set a `handler` notified when the HTTP connection is shutdown: the client or server will close the connection within a certain amount of time.
    `WebSocket` | WebSocket.`shutdownHandler​(Handler<Void> handler)` |
    `WebSocketBase` | WebSocketBase.`shutdownHandler​(Handler<Void> handler)` | Set a `handler` notified when the WebSocket is shutdown: the client or server will close the connection within a certain amount of time.
    `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
    `ClientWebSocket` | ClientWebSocket.`textMessageHandler​(Handler<String> handler)` |
    `WebSocket` | WebSocket.`textMessageHandler​(Handler<String> handler)` |
    `WebSocketBase` | WebSocketBase.`textMessageHandler​(Handler<String> handler)` | Set a text message handler on the connection.
    `HttpServerRequest` | HttpServerRequest.`uploadHandler​(Handler<HttpServerFileUpload> uploadHandler)` | Set an upload handler.
    `HttpServer` | HttpServer.`webSocketHandler​(Handler<ServerWebSocket> handler)` | Set the WebSocket handler for the server to `wsHandler`.
    `HttpServer` | HttpServer.`webSocketHandshakeHandler​(Handler<ServerWebSocketHandshake> handler)` | Set a handler for WebSocket handshake.
    `HttpClientBuilder` | HttpClientBuilder.`withConnectHandler​(Handler<HttpConnection> handler)` | Set a connection handler for the client.

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

    Methods in io.vertx.rxjava3.core.net with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `NetSocket` | NetSocket.`closeHandler​(Handler<Void> handler)` | Set a `handler` notified when the socket is closed
    `NetServer` | NetServer.`connectHandler​(Handler<NetSocket> handler)` | Supply a connect handler for this server.
    `NetSocket` | NetSocket.`drainHandler​(Handler<Void> handler)` |
    `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)` |
    `NetSocket` | NetSocket.`shutdownHandler​(Handler<Void> handler)` | Set a `handler` notified when the socket is shutdown: the client or server will close the connection within a certain amount of time.

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

    Classes in io.vertx.rxjava3.core.parsetools that implement Handler
    Modifier and Type | Class | 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.rxjava3.core.parsetools with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `JsonParser` | JsonParser.`endHandler​(Handler<Void> endHandler)` |
    `RecordParser` | RecordParser.`endHandler​(Handler<Void> endHandler)` |
    `JsonParser` | JsonParser.`exceptionHandler​(Handler<Throwable> handler)` |
    `RecordParser` | RecordParser.`exceptionHandler​(Handler<Throwable> handler)` |
    `JsonParser` | JsonParser.`handler​(Handler<JsonEvent> handler)` |
    `RecordParser` | RecordParser.`handler​(Handler<Buffer> handler)` |
    `static RecordParser` | RecordParser.`newDelimited​(Buffer delim, Handler<Buffer> output)` | Like `RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.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.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.`setOutput​(Handler<Buffer> output)` |

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

    Methods in io.vertx.rxjava3.core.streams with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `WriteStream<T>` | WriteStream.`drainHandler​(Handler<Void> handler)` | Set a drain handler on the stream.
    `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.

  - ### Uses of Handler in io.vertx.rxjava3.db2client

    Methods in io.vertx.rxjava3.db2client with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `static SqlClient` | DB2Builder.`client​(Handler<ClientBuilder<SqlClient>> handler)` | Build a client backed by a connection pool with the specified `block` argument.
    `DB2Connection` | DB2Connection.`closeHandler​(Handler<Void> handler)` |
    `DB2Connection` | DB2Connection.`exceptionHandler​(Handler<Throwable> handler)` |
    `static Pool` | DB2Builder.`pool​(Handler<ClientBuilder<Pool>> block)` | Build a pool with the specified `block` argument.

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

    Methods in io.vertx.rxjava3.ext.auth.audit that return Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `<T> Handler<AsyncResult<T>>` | SecurityAudit.`auditHandlerFor​(Marker marker)` |

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

    Methods in io.vertx.rxjava3.ext.auth.oauth2 with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `OAuth2Auth` | OAuth2Auth.`missingKeyHandler​(Handler<String> handler)` | Handled to be called when a key (mentioned on a JWT) is missing from the current config.

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

    Methods in io.vertx.rxjava3.ext.consul with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `Watch<T>` | Watch.`setHandler​(Handler<WatchResult<T>> handler)` | Set the result handler.

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

    Methods in io.vertx.rxjava3.ext.eventbus.bridge.tcp with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `static TcpEventBusBridge` | TcpEventBusBridge.`create​(Vertx vertx, BridgeOptions options, NetServerOptions netServerOptions, Handler<BridgeEvent> eventHandler)` |

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

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

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

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

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

    Methods in io.vertx.rxjava3.ext.stomp with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `StompServerHandler` | StompServerHandler.`abortHandler​(Handler<ServerFrame> handler)` | Configures the action to execute when a `ABORT` frame is received.
    `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.`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.
    `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.
    `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.
    `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.
    `StompClient` | StompClient.`exceptionHandler​(Handler<Throwable> handler)` | Sets an exception handler notified for TCP-level errors.
    `StompClientConnection` | StompClientConnection.`exceptionHandler​(Handler<Throwable> exceptionHandler)` | Configures the exception handler notified upon TCP-level errors.
    `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.`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.
    `StompClient` | StompClient.`receivedFrameHandler​(Handler<Frame> handler)` | Configures a received handler that gets notified when a STOMP frame is received by the client.
    `StompClientConnection` | StompClientConnection.`receivedFrameHandler​(Handler<Frame> handler)` | Configures a received handler that get 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.
    `Single<String>` | StompClientConnection.`rxSubscribe​(String destination, Handler<Frame> handler)` | Subscribes to the given destination.
    `Single<String>` | StompClientConnection.`rxSubscribe​(String destination, Map<String,​String> headers, Handler<Frame> handler)` | Subscribes 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.
    `Single<String>` | StompClientConnection.`subscribe​(String destination, Handler<Frame> handler)` | Subscribes to the given destination.
    `Single<String>` | StompClientConnection.`subscribe​(String destination, Map<String,​String> headers, Handler<Frame> handler)` | Subscribes to the given destination.
    `StompServerHandler` | StompServerHandler.`subscribeHandler​(Handler<ServerFrame> handler)` | Configures the action to execute when a `SUBSCRIBE` frame is received.
    `StompServerHandler` | StompServerHandler.`unsubscribeHandler​(Handler<ServerFrame> handler)` | Configures the action to execute when a `UNSUBSCRIBE` frame is received.
    `StompClient` | StompClient.`writingFrameHandler​(Handler<Frame> handler)` | Configures a writing handler that gets notified when a STOMP frame is written on the wire.
    `StompClientConnection` | StompClientConnection.`writingFrameHandler​(Handler<Frame> handler)` | Configures a handler notified when a frame is going to be 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.rxjava3.ext.unit

    Methods in io.vertx.rxjava3.ext.unit that return Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure()` | Creates and returns a new async handler, the returned handler controls the completion of 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.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess()` | Creates and returns a new async handler, the returned handler controls the completion of 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.
    `Handler<Throwable>` | TestContext.`exceptionHandler()` |

    Methods in io.vertx.rxjava3.ext.unit with parameters of type Handler
    Modifier and Type | Method | 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.
    `<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.
    `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` | Async.`handler​(Handler<AsyncResult<Void>> completionHandler)` | Completion handler to receive a completion signal when this completions completes.
    `void` | Completion.`handler​(Handler<AsyncResult<T>> 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, int repeat, Handler<TestContext> testCase)` | Add a new test case to the suite.
    `TestSuite` | TestSuite.`test​(String name, 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.rxjava3.ext.unit.collect

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

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

    Methods in io.vertx.rxjava3.ext.unit.report with parameters of type Handler
    Modifier and Type | Method | 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.rxjava3.ext.web

    Classes in io.vertx.rxjava3.ext.web that implement Handler
    Modifier and Type | Class | 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.rxjava3.ext.web with parameters of type Handler
    Modifier and Type | Method | 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.`addEndHandler​(Handler<AsyncResult<Void>> handler)` | Add an end handler for the request/response context.
    `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.rxjava3.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.
    `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.rxjava3.ext.web.handler

    Subinterfaces of Handler in io.vertx.rxjava3.ext.web.handler
    Modifier and Type | Interface | Description
    --- | --- | ---
    `interface` | `AuthenticationHandler` | Base interface for auth handlers.
    `interface` | `InputTrustHandler` | Base input trust interface for handlers that verify the trust of the request.
    `interface` | `PlatformHandler` | Base platform interface for handlers that provide functionality to the application platform.
    `interface` | `ProtocolUpgradeHandler` | Base interface for handlers that perform protocol upgrades.
    `interface` | `SecurityPolicyHandler` | Base security policy interface for handlers that provide HTTP security related headers.

    Classes in io.vertx.rxjava3.ext.web.handler that implement Handler
    Modifier and Type | Class | Description
    --- | --- | ---
    `class` | `APIKeyHandler` | An authentication handler that provides API Key support.
    `class` | `AuthorizationHandler` | Base interface for authorization handlers that provide authorization support.
    `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` | `CorsHandler` | A handler which implements server side http://www.w3.org/TR/cors/[CORS] support for Vert.x-Web.
    `class` | `CSPHandler` | Content Security Policy (CSP) is an added layer of security that helps to detect and mitigate certain types of attacks, including Cross Site Scripting (XSS) and data injection attacks.
    `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` | `HSTSHandler` | HTTP Strict Transport Security (HSTS) RFC6797.
    `class` | `JWTAuthHandler` | An auth handler that provides JWT Authentication support.
    `class` | `LoggerHandler` | A handler which logs request information to the Vert.x logger.
    `class` | `MethodOverrideHandler` | NOTE: This class has been automatically generated from the `original` non RX-ified interface using Vert.x codegen.
    `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` | `OtpAuthHandler` | An auth handler that provides One Time Password (Multi-Factor) 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` | `SecurityAuditLoggerHandler` | A handler that logs security audit events.
    `class` | `SessionHandler` | A handler that maintains a `Session` for each browser session.
    `class` | `SimpleAuthenticationHandler` | A user customizable authentication handler.
    `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` | `WebAuthn4JHandler` | An auth handler that provides FIDO2 WebAuthN Relay Party support.
    `class` | `XFrameHandler` | The X-Frame-Options HTTP response header can be used to indicate whether or not a browser should be allowed to render a page in a ``, ``, `` or `` .

    Methods in io.vertx.rxjava3.ext.web.handler with parameters of type Handler
    Modifier and Type | Method | 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.

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

    Classes in io.vertx.rxjava3.ext.web.handler.graphql that implement Handler
    Modifier and Type | Class | Description
    --- | --- | ---
    `class` | `GraphQLHandler` | A `Route` handler for GraphQL requests.

    Methods in io.vertx.rxjava3.ext.web.handler.graphql with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `GraphQLHandlerBuilder` | GraphQLHandlerBuilder.`beforeExecute​(Handler<ExecutionInputBuilderWithContext<RoutingContext>> beforeExecuteHandler)` | Set a callback to invoke before executing a GraphQL query.

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

    Classes in io.vertx.rxjava3.ext.web.handler.graphql.ws that implement Handler
    Modifier and Type | Class | Description
    --- | --- | ---
    `class` | `GraphQLWSHandler` | A handler for the GraphQL over WebSocket Protocol.

    Methods in io.vertx.rxjava3.ext.web.handler.graphql.ws with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `GraphQLWSHandlerBuilder` | GraphQLWSHandlerBuilder.`beforeExecute​(Handler<ExecutionInputBuilderWithContext<Message>> beforeExecuteHandler)` | Set a callback to invoke before executing a GraphQL query.
    `GraphQLWSHandlerBuilder` | GraphQLWSHandlerBuilder.`onConnectionInit​(Handler<ConnectionInitEvent> connectionInitHandler)` | Customize the connection init .
    `GraphQLWSHandlerBuilder` | GraphQLWSHandlerBuilder.`onMessage​(Handler<Message> messageHandler)` | Customize the message .
    `GraphQLWSHandlerBuilder` | GraphQLWSHandlerBuilder.`onSocketEnd​(Handler<ServerWebSocket> endHandler)` | Customize the end .

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

    Methods in io.vertx.rxjava3.ext.web.handler.sockjs with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `Router` | SockJSHandler.`bridge​(SockJSBridgeOptions bridgeOptions, Handler<BridgeEvent> bridgeEventHandler)` | Like `SockJSHandler.bridge(io.vertx.ext.web.handler.sockjs.SockJSBridgeOptions)` but specifying a handler that will receive bridge events.
    `Router` | SockJSHandler.`bridge​(AuthorizationProvider authorizationProvider, SockJSBridgeOptions bridgeOptions, Handler<BridgeEvent> bridgeEventHandler)` | Like `SockJSHandler.bridge(io.vertx.ext.web.handler.sockjs.SockJSBridgeOptions)` but specifying a handler that will receive bridge events.
    `SockJSSocket` | SockJSSocket.`closeHandler​(Handler<Void> closeHandler)` |
    `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.

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

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

    Methods in io.vertx.rxjava3.ext.web.healthchecks with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `HealthCheckHandler` | HealthCheckHandler.`register​(String name, long timeout, Handler<Promise<Status>> procedure)` | Registers a health check procedure.
    `HealthCheckHandler` | HealthCheckHandler.`register​(String name, Handler<Promise<Status>> procedure)` | Registers a health check procedure.

  - ### Uses of Handler in io.vertx.rxjava3.ext.web.openapi.router

    Methods in io.vertx.rxjava3.ext.web.openapi.router with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `OpenAPIRoute` | OpenAPIRoute.`addFailureHandler​(Handler<RoutingContext> handler)` | Adds a failure handler for this route
    `OpenAPIRoute` | OpenAPIRoute.`addHandler​(Handler<RoutingContext> handler)` | Adds a handler for this route which is executed after the security and validation handlers defined in the contract
    `RouterBuilder` | RouterBuilder.`rootHandler​(Handler<RoutingContext> rootHandler)` | Add global handler to be applied prior to being generated.

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

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

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

    Classes in io.vertx.rxjava3.ext.web.validation that implement Handler
    Modifier and Type | Class | Description
    --- | --- | ---
    `class` | `ValidationHandler` |

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

    Methods in io.vertx.rxjava3.grpc.client with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `GrpcClientRequest<Req,​Resp>` | GrpcClientRequest.`drainHandler​(Handler<Void> handler)` |
    `GrpcClientResponse<Req,​Resp>` | GrpcClientResponse.`endHandler​(Handler<Void> handler)` |
    `GrpcClientResponse<Req,​Resp>` | GrpcClientResponse.`errorHandler​(Handler<GrpcError> handler)` |
    `GrpcClientRequest<Req,​Resp>` | GrpcClientRequest.`exceptionHandler​(Handler<Throwable> handler)` |
    `GrpcClientResponse<Req,​Resp>` | GrpcClientResponse.`exceptionHandler​(Handler<Throwable> handler)` |
    `GrpcClientResponse<Req,​Resp>` | GrpcClientResponse.`handler​(Handler<Resp> handler)` |
    `GrpcReadStream<Resp>` | GrpcClientResponse.`invalidMessageHandler​(Handler<InvalidMessageException> handler)` | Set a message handler that is reported with invalid message errors.
    `GrpcClientResponse<Req,​Resp>` | GrpcClientResponse.`messageHandler​(Handler<GrpcMessage> handler)` |

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

    Methods in io.vertx.rxjava3.grpc.common with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `GrpcWriteStream<T>` | GrpcWriteStream.`drainHandler​(Handler<Void> handler)` |
    `GrpcReadStream<T>` | GrpcReadStream.`endHandler​(Handler<Void> handler)` |
    `GrpcReadStream<T>` | GrpcReadStream.`errorHandler​(Handler<GrpcError> handler)` | Set a handler to be notified with gRPC errors.
    `GrpcReadStream<T>` | GrpcReadStream.`exceptionHandler​(Handler<Throwable> handler)` |
    `GrpcWriteStream<T>` | GrpcWriteStream.`exceptionHandler​(Handler<Throwable> handler)` |
    `GrpcReadStream<T>` | GrpcReadStream.`handler​(Handler<T> handler)` |
    `GrpcReadStream<T>` | GrpcReadStream.`invalidMessageHandler​(Handler<InvalidMessageException> handler)` | Set a message handler that is reported with invalid message errors.
    `GrpcReadStream<T>` | GrpcReadStream.`messageHandler​(Handler<GrpcMessage> handler)` | Set a handler to be notified with incoming encoded messages.

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

    Classes in io.vertx.rxjava3.grpc.server that implement Handler
    Modifier and Type | Class | Description
    --- | --- | ---
    `class` | `GrpcServer` | A gRPC server based on Vert.x HTTP server.

    Methods in io.vertx.rxjava3.grpc.server with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `GrpcServer` | GrpcServer.`callHandler​(Handler<GrpcServerRequest<Buffer,​Buffer>> handler)` | Set a call handler that handles any call made to the server.
    `<Req,​Resp> GrpcServer` | GrpcServer.`callHandler​(ServiceMethod<Req,​Resp> serviceMethod, Handler<GrpcServerRequest<Req,​Resp>> handler)` | Set a service method call handler that handles any call made to the server for the `fullMethodName` service method.
    `GrpcServerResponse<Req,​Resp>` | GrpcServerResponse.`drainHandler​(Handler<Void> handler)` |
    `GrpcServerRequest<Req,​Resp>` | GrpcServerRequest.`endHandler​(Handler<Void> endHandler)` |
    `GrpcServerRequest<Req,​Resp>` | GrpcServerRequest.`errorHandler​(Handler<GrpcError> handler)` |
    `GrpcServerRequest<Req,​Resp>` | GrpcServerRequest.`exceptionHandler​(Handler<Throwable> handler)` |
    `GrpcServerResponse<Req,​Resp>` | GrpcServerResponse.`exceptionHandler​(Handler<Throwable> handler)` |
    `GrpcServerRequest<Req,​Resp>` | GrpcServerRequest.`handler​(Handler<Req> handler)` |
    `GrpcReadStream<Req>` | GrpcServerRequest.`invalidMessageHandler​(Handler<InvalidMessageException> handler)` | Set a message handler that is reported with invalid message errors.
    `GrpcServerRequest<Req,​Resp>` | GrpcServerRequest.`messageHandler​(Handler<GrpcMessage> handler)` |

  - ### Uses of Handler in io.vertx.rxjava3.httpproxy

    Classes in io.vertx.rxjava3.httpproxy that implement Handler
    Modifier and Type | Class | Description
    --- | --- | ---
    `class` | `HttpProxy` | Handles the HTTP reverse proxy logic between the user agent and the origin.

    Methods in io.vertx.rxjava3.httpproxy with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `ProxyInterceptorBuilder` | ProxyInterceptorBuilder.`transformingQueryParams​(Handler<MultiMap> updater)` | Apply modifications to the query parameters.
    `ProxyInterceptorBuilder` | ProxyInterceptorBuilder.`transformingRequestHeaders​(Handler<MultiMap> requestHeadersUpdater)` | Apply callbacks to change the request headers when the proxy receives them.
    `ProxyInterceptorBuilder` | ProxyInterceptorBuilder.`transformingResponseHeaders​(Handler<MultiMap> responseHeadersUpdater)` | Apply callbacks to change the response headers when the proxy receives them.

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

    Methods in io.vertx.rxjava3.kafka.client.consumer with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `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.
    `KafkaConsumer<K,​V>` | KafkaConsumer.`endHandler​(Handler<Void> endHandler)` |
    `KafkaConsumer<K,​V>` | KafkaConsumer.`exceptionHandler​(Handler<Throwable> handler)` |
    `KafkaConsumer<K,​V>` | KafkaConsumer.`handler​(Handler<KafkaConsumerRecord<K,​V>> handler)` |
    `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.`partitionsRevokedHandler​(Handler<Set<TopicPartition>> handler)` | Set the handler called when topic partitions are revoked to the consumer

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

    Methods in io.vertx.rxjava3.kafka.client.producer with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `KafkaProducer<K,​V>` | KafkaProducer.`drainHandler​(Handler<Void> handler)` |
    `KafkaProducer<K,​V>` | KafkaProducer.`exceptionHandler​(Handler<Throwable> handler)` |

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

    Methods in io.vertx.rxjava3.micrometer that return Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `static Handler<HttpServerRequest>` | PrometheusRequestHandler.`create()` | Creates a handler with a new PrometheusMeterRegistry and the default metrics endpoint ("/metrics").
    `static Handler<HttpServerRequest>` | PrometheusRequestHandler.`create​(io.micrometer.prometheusmetrics.PrometheusMeterRegistry registry)` | Creates a handler with the specified PrometheusMeterRegistry and the default metrics endpoint ("/metrics").
    `static Handler<HttpServerRequest>` | PrometheusRequestHandler.`create​(io.micrometer.prometheusmetrics.PrometheusMeterRegistry registry, String metricsEndpoint)` | Creates a handler with the specified PrometheusMeterRegistry and metrics endpoint.
    `static Handler<RoutingContext>` | PrometheusScrapingHandler.`create()` | Creates a Vert.x Web `Route` handler for Prometheus metrics scraping.
    `static Handler<RoutingContext>` | PrometheusScrapingHandler.`create​(io.micrometer.prometheusmetrics.PrometheusMeterRegistry registry)` | 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.rxjava3.mqtt

    Methods in io.vertx.rxjava3.mqtt with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `MqttClient` | MqttClient.`authenticationExchangeHandler​(Handler<MqttAuthenticationExchangeMessage> authenticationExchangeHandler)` | Sets handler which will be called after AUTH packet receiving
    `MqttEndpoint` | MqttEndpoint.`authenticationExchangeHandler​(Handler<MqttAuthenticationExchangeMessage> handler)` | Set the auth handler on the MQTT endpoint.
    `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.
    `MqttEndpoint` | MqttEndpoint.`disconnectHandler​(Handler<Void> handler)` | Set a disconnect handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`disconnectMessageHandler​(Handler<MqttDisconnectMessage> 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
    `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
    `MqttEndpoint` | MqttEndpoint.`publishAcknowledgeHandler​(Handler<Integer> handler)` | Set the puback handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishAcknowledgeMessageHandler​(Handler<MqttPubAckMessage> handler)` | Set the puback handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`publishCompletionExpirationHandler​(Handler<Integer> publishCompletionExpirationHandler)` | Sets a handler which will be called when the client does not receive a PUBACK or PUBREC/PUBCOMP for a message published using QoS 1 or 2 respectively.
    `MqttClient` | MqttClient.`publishCompletionHandler​(Handler<Integer> publishCompletionHandler)` | Sets a handler which will be called each time the publishing of a message has been completed.
    `MqttEndpoint` | MqttEndpoint.`publishCompletionHandler​(Handler<Integer> handler)` | Set the pubcomp handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishCompletionMessageHandler​(Handler<MqttPubCompMessage> handler)` | Set the pubcomp handler on the MQTT endpoint.
    `MqttClient` | MqttClient.`publishCompletionUnknownPacketIdHandler​(Handler<Integer> publishCompletionPhantomHandler)` | Sets a handler which will be called when the client receives a PUBACK/PUBREC/PUBCOMP with an unknown packet ID.
    `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.`publishReceivedMessageHandler​(Handler<MqttPubRecMessage> handler)` | Set the pubrec handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishReleaseHandler​(Handler<Integer> handler)` | Set the pubrel handler on the MQTT endpoint.
    `MqttEndpoint` | MqttEndpoint.`publishReleaseMessageHandler​(Handler<MqttPubRelMessage> handler)` | Set the pubrel handler on the MQTT endpoint.
    `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.`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.rxjava3.mssqlclient

    Methods in io.vertx.rxjava3.mssqlclient with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `MSSQLConnection` | MSSQLConnection.`closeHandler​(Handler<Void> handler)` |
    `MSSQLConnection` | MSSQLConnection.`exceptionHandler​(Handler<Throwable> handler)` |
    `MSSQLConnection` | MSSQLConnection.`infoHandler​(Handler<MSSQLInfo> handler)` | Set a handler called when the connection receives an informational message from the server.
    `static Pool` | MSSQLBuilder.`pool​(Handler<ClientBuilder<Pool>> block)` | Build a pool with the specified `block` argument.

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

    Methods in io.vertx.rxjava3.mysqlclient with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `static SqlClient` | MySQLBuilder.`client​(Handler<ClientBuilder<SqlClient>> handler)` | Build a client backed by a connection pool with the specified `block` argument.
    `MySQLConnection` | MySQLConnection.`closeHandler​(Handler<Void> handler)` |
    `MySQLConnection` | MySQLConnection.`exceptionHandler​(Handler<Throwable> handler)` |
    `static Pool` | MySQLBuilder.`pool​(Handler<ClientBuilder<Pool>> block)` | Build a pool with the specified `block` argument.

  - ### Uses of Handler in io.vertx.rxjava3.oracleclient

    Methods in io.vertx.rxjava3.oracleclient with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `OracleConnection` | OracleConnection.`closeHandler​(Handler<Void> handler)` |
    `OracleConnection` | OracleConnection.`exceptionHandler​(Handler<Throwable> handler)` |
    `static Pool` | OracleBuilder.`pool​(Handler<ClientBuilder<Pool>> block)` | Build a pool with the specified `block` argument.

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

    Methods in io.vertx.rxjava3.pgclient with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `static SqlClient` | PgBuilder.`client​(Handler<ClientBuilder<SqlClient>> handler)` | Build a client backed by a connection pool with the specified `block` argument.
    `PgConnection` | PgConnection.`closeHandler​(Handler<Void> handler)` |
    `PgConnection` | PgConnection.`exceptionHandler​(Handler<Throwable> handler)` |
    `PgConnection` | PgConnection.`noticeHandler​(Handler<PgNotice> handler)` | Set a handler called when the connection receives a notice from the server.
    `PgConnection` | PgConnection.`notificationHandler​(Handler<PgNotification> handler)` | Set a handler called when the connection receives notification on a channel.
    `static Pool` | PgBuilder.`pool​(Handler<ClientBuilder<Pool>> block)` | Build a pool with the specified `block` argument.

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

    Methods in io.vertx.rxjava3.pgclient.pubsub with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `PgSubscriber` | PgSubscriber.`closeHandler​(Handler<Void> handler)` | Set an handler called when the subscriber is closed.
    `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.rxjava3.rabbitmq

    Methods in io.vertx.rxjava3.rabbitmq with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `Completable` | RabbitMQClient.`basicPublishWithDeliveryTag​(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler)` | Publish a message.
    `RabbitMQConsumer` | RabbitMQConsumer.`endHandler​(Handler<Void> endHandler)` | Set an end handler.
    `RabbitMQConsumer` | RabbitMQConsumer.`exceptionHandler​(Handler<Throwable> exceptionHandler)` | Set an exception handler on the read stream.
    `RabbitMQConsumer` | RabbitMQConsumer.`handler​(Handler<RabbitMQMessage> messageArrived)` | Set a message handler.
    `Completable` | RabbitMQClient.`rxBasicPublishWithDeliveryTag​(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler)` | Publish a message.

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

    Methods in io.vertx.rxjava3.redis.client with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `RedisConnection` | RedisConnection.`endHandler​(Handler<Void> endHandler)` |
    `RedisConnection` | RedisConnection.`exceptionHandler​(Handler<Throwable> handler)` |
    `RedisConnection` | RedisConnection.`handler​(Handler<Response> handler)` |

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

    Methods in io.vertx.rxjava3.servicediscovery.spi with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | ServiceExporter.`close​(Handler<Void> closeHandler)` | Close the exporter
    `void` | ServiceImporter.`close​(Handler<Void> closeHandler)` | Closes the importer

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

    Methods in io.vertx.rxjava3.sqlclient with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `SqlConnection` | SqlConnection.`closeHandler​(Handler<Void> handler)` | Set an handler called when the connection is closed.
    `RowStream<T>` | RowStream.`endHandler​(Handler<Void> endHandler)` |
    `RowStream<T>` | RowStream.`exceptionHandler​(Handler<Throwable> handler)` |
    `SqlConnection` | SqlConnection.`exceptionHandler​(Handler<Throwable> handler)` | Set an handler called with connection errors.
    `RowStream<T>` | RowStream.`handler​(Handler<T> handler)` |
    `ClientBuilder<C>` | ClientBuilder.`withConnectHandler​(Handler<SqlConnection> handler)` | Set a handler called when the pool has established a connection to the database.

  - ### 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 | 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 | 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 | 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 | 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 | 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` | 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` | ServiceDiscoveryBackend.`update​(Record record, Handler<AsyncResult<Void>> resultHandler)` | Updates a record

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

    Methods in io.vertx.servicediscovery.zookeeper with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | ZookeeperServiceImporter.`close​(Handler<Void> closeHandler)` |

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

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

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

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

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

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

    Methods in io.vertx.sqlclient with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `SqlConnection` | SqlConnection.`closeHandler​(Handler<Void> handler)` | Set an handler called when the connection is closed.
    `RowStream<T>` | RowStream.`endHandler​(Handler<Void> endHandler)` |
    `RowStream<T>` | RowStream.`exceptionHandler​(Handler<Throwable> handler)` |
    `SqlConnection` | SqlConnection.`exceptionHandler​(Handler<Throwable> handler)` | Set an handler called with connection errors.
    `RowStream<T>` | RowStream.`handler​(Handler<T> handler)` |
    `static Pool` | ClientBuilder.`pool​(Driver<?> driver, Handler<ClientBuilder<Pool>> block)` | Build a pool with the specified `block` argument and `Driver` The `block` argument is usually a lambda that configures the provided builder
    `ClientBuilder<C>` | ClientBuilder.`withConnectHandler​(Handler<SqlConnection> handler)` | Set a handler called when the pool has established a connection to the database.

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

    Methods in io.vertx.sqlclient.spi with parameters of type Handler
    Modifier and Type | Method | Description
    --- | --- | ---
    `default Pool` | Driver.`createPool​(Vertx vertx, Supplier<Future<C>> databases, PoolOptions poolOptions, NetClientOptions transportOptions, Handler<SqlConnection> connectHandler)` | Create a connection pool to the database configured with the given `connectOptions` and `poolOptions`.
    `Pool` | Driver.`newPool​(Vertx vertx, Supplier<Future<C>> databases, PoolOptions options, NetClientOptions transportOptions, Handler<SqlConnection> connectHandler, io.vertx.core.internal.CloseFuture closeFuture)` | Create a connection pool to the database configured with the given `connectOptions` and `poolOptions`.