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.eventbus.bridge.grpc
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
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.mysqlclient
io.vertx.mysqlclient.spi
io.vertx.oracleclient
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.eventbus.bridge.grpc
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.codec
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.eventbus.bridge.grpc
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.codec
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.
default 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 final 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<HttpSettings> handler)	Set an handler that is called when remote endpoint HttpSettings 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.
HttpServerBuilder	HttpServerBuilder.withConnectHandler(Handler<HttpConnection> handler)	Set a connection handler for the server.

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
QuicConnection	QuicConnection.closeHandler(Handler<Void> handler)	Set a handler called when the connection is closed.
QuicStream	QuicStream.closeHandler(Handler<Void> handler)	Set a handler called when the stream is closed.
StreamChannel	StreamChannel.closeHandler(Handler<Void> handler)	Set a handler notified when the channel is closed
NetServer	NetServer.connectHandler(Handler<NetSocket> handler)	Supply a connect handler for this server.
QuicServer	QuicServer.connectHandler(Handler<QuicConnection> handler)	Set the handler processing QuicConnection, the handler must be set before the server is bound.
QuicConnection	QuicConnection.datagramHandler(Handler<Buffer> handler)	Set a handler called with the datagram addressed to this connection.
NetSocket	NetSocket.drainHandler(Handler<Void> handler)
QuicStream	QuicStream.drainHandler(Handler<Void> handler)
StreamChannel	StreamChannel.drainHandler(Handler<Void> handler)
NetSocket	NetSocket.endHandler(Handler<Void> endHandler)	Set an end handler.
QuicStream	QuicStream.endHandler(Handler<Void> endHandler)
StreamChannel	StreamChannel.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(Handler), e.g during the TLS handshake.
NetSocket	NetSocket.exceptionHandler(Handler<Throwable> handler)
QuicServer	QuicServer.exceptionHandler(Handler<Throwable> handler)	Set an exception handler called for socket errors happening before the QUIC connection is established, e.g. during the TLS handshake.
QuicStream	QuicStream.exceptionHandler(Handler<Throwable> handler)	Set an exception handling, catching stream exceptions.
StreamChannel	StreamChannel.exceptionHandler(Handler<Throwable> handler)
NetSocket	NetSocket.handler(Handler<Buffer> handler)
QuicStream	QuicStream.handler(Handler<Buffer> handler)	Set the handler signaled with the data events the remote peer has sent.
StreamChannel	StreamChannel.handler(Handler<Buffer> handler)
QuicStream	QuicStream.resetHandler(Handler<Long> handler)	Set a handler called upon stream reset: when a stream receives a reset frame from its peer, this handler is called.
NetSocket	NetSocket.shutdownHandler(Handler<Duration> handler)	Set a handler notified when the socket is shutdown: the client or server will close the connection within a certain amount of time.
QuicConnection	QuicConnection.shutdownHandler(Handler<Duration> handler)	Set a handler notified when the connection is shutdown: the client or server will close the connection within a certain amount of time.
QuicStream	QuicStream.shutdownHandler(Handler<Duration> handler)	Set a handler called when the stream is shutdown or closed
StreamChannel	StreamChannel.shutdownHandler(Handler<Duration> handler)	Set a handler notified when the channel is shutdown: the client or server will close the connection within a certain amount of time.
QuicConnection	QuicConnection.streamHandler(Handler<QuicStream> handler)	Set a handler processing incoming Quic streams.
default QuicServer	QuicServer.streamHandler(Handler<QuicStream> handler)	Set a handler processing incoming Quic streams, this is a short-cut of server.connectHandler(connection -> connection.streamHandler(stream)).

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
protected Pool	DB2Driver.newPool(io.vertx.core.internal.VertxInternal vertx, Handler<SqlConnection> connectHandler, Supplier<Future<DB2ConnectOptions>> databases, PoolOptions poolOptions, NetClientOptions transportOptions, io.vertx.core.internal.CloseFuture closeFuture)

Uses of Handler in io.vertx.eventbus.bridge.grpc

Methods in io.vertx.eventbus.bridge.grpc with parameters of type Handler

Modifier and Type	Method	Description
GrpcEventBusBridgeBuilder	GrpcEventBusBridgeBuilder.withEventHandler(Handler<BridgeEvent> eventHandler)	Set a handler for bridge events that can be used to implement custom security logic.

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.
Router	Router.uncaughtErrorHandler(Handler<RoutingContext> errorHandler)	Specify an handler to handle an error for any status code that doesn't have a specific handler assigned.

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

Methods in io.vertx.ext.web.codec with parameters of type Handler

Modifier and Type	Method	Description
static BodyCodec<Void>	BodyCodec.sseStream(Handler<ReadStream<SseEvent>> handler)	A body codec that parse the response as a Server-SentEvent stream.

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<Buffer> 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)	Deprecated, for removal: This API element is subject to removal in a future version.
VertxServerBuilder	VertxServerBuilder.useSsl(Handler<HttpServerOptions> handler)	Deprecated, for removal: This API element is subject to removal in a future version.

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)	Deprecated.
WriteStream<T>	GrpcWriteStream.exceptionHandler(Handler<Throwable> hndlr)	Deprecated.
static <I,O> ReadStream<O>	ClientCalls.manyToMany(io.vertx.core.internal.ContextInternal ctx, Handler<WriteStream<I>> requestHandler, Function<StreamObserver<O>, StreamObserver<I>> delegate)	Deprecated.
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)	Deprecated.
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)	Deprecated.
static <I,O> Future<O>	ClientCalls.manyToOne(io.vertx.core.internal.ContextInternal ctx, Handler<WriteStream<I>> requestHandler, Function<StreamObserver<O>, StreamObserver<I>> delegate)	Deprecated.
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)	Deprecated.

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.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
protected Pool	MySQLDriver.newPool(io.vertx.core.internal.VertxInternal vertx, Handler<SqlConnection> connectHandler, Supplier<Future<MySQLConnectOptions>> databases, PoolOptions poolOptions, NetClientOptions transportOptions, 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.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)	Inherited from ReadStream.exceptionHandler(Handler) but this one is a no-op.
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
protected Pool	PgDriver.newPool(io.vertx.core.internal.VertxInternal vertx, Handler<SqlConnection> connectHandler, Supplier<Future<PgConnectOptions>> databases, PoolOptions poolOptions, NetClientOptions transportOptions, 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(Handler, Function) but using the circuit breaker .
<T> CircuitBreaker	CircuitBreaker.executeAndReport(Promise<T> resultPromise, Handler<Promise<T>> command)	Same as CircuitBreaker.executeAndReportWithFallback(Promise, Handler, Function) 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(Handler, Function) 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(Handler) 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(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(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.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<HttpSettings> handler)	Set an handler that is called when remote endpoint HttpSettings 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.
HttpServerBuilder	HttpServerBuilder.withConnectHandler(Handler<HttpConnection> handler)	Set a connection handler for the server.

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
QuicConnection	QuicConnection.closeHandler(Handler<Void> handler)	Set a handler called when the connection is closed.
QuicStream	QuicStream.closeHandler(Handler<Void> handler)	Set a handler called when the stream is closed.
StreamChannel	StreamChannel.closeHandler(Handler<Void> handler)	Set a handler notified when the channel is closed
NetServer	NetServer.connectHandler(Handler<NetSocket> handler)	Supply a connect handler for this server.
QuicServer	QuicServer.connectHandler(Handler<QuicConnection> handler)	Set the handler processing QuicConnection, the handler must be set before the server is bound.
QuicConnection	QuicConnection.datagramHandler(Handler<Buffer> handler)	Set a handler called with the datagram addressed to this connection.
NetSocket	NetSocket.drainHandler(Handler<Void> handler)
QuicStream	QuicStream.drainHandler(Handler<Void> handler)
StreamChannel	StreamChannel.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.
QuicStream	QuicStream.endHandler(Handler<Void> endHandler)
StreamChannel	StreamChannel.endHandler(Handler<Void> endHandler)	This handler might be called after the close handler when the channel is paused and there are still buffers to deliver.
NetSocket	NetSocket.exceptionHandler(Handler<Throwable> handler)
QuicServer	QuicServer.exceptionHandler(Handler<Throwable> handler)	Set an exception handler called for socket errors happening before the QUIC connection is established, e.g. during the TLS handshake.
QuicStream	QuicStream.exceptionHandler(Handler<Throwable> handler)	Set an exception handling, catching stream exceptions.
StreamChannel	StreamChannel.exceptionHandler(Handler<Throwable> handler)
NetSocket	NetSocket.handler(Handler<Buffer> handler)
QuicStream	QuicStream.handler(Handler<Buffer> handler)	Set the handler signaled with the data events the remote peer has sent.
StreamChannel	StreamChannel.handler(Handler<Buffer> handler)
QuicStream	QuicStream.resetHandler(Handler<Long> handler)	Set a handler called upon stream reset: when a stream receives a reset frame from its peer, this handler is called.
NetSocket	NetSocket.shutdownHandler(Handler<Duration> handler)	Set a handler notified when the socket is shutdown: the client or server will close the connection within a certain amount of time.
QuicConnection	QuicConnection.shutdownHandler(Handler<Duration> handler)	Set a handler notified when the connection is shutdown: the client or server will close the connection within a certain amount of time.
QuicStream	QuicStream.shutdownHandler(Handler<Duration> handler)	Set a handler called when the stream is shutdown or closed
QuicConnection	QuicConnection.streamHandler(Handler<QuicStream> handler)	Set a handler processing incoming Quic streams.
QuicServer	QuicServer.streamHandler(Handler<QuicStream> handler)	Set a handler processing incoming Quic streams, this is a short-cut of server.connectHandler(connection -> connection.streamHandler(stream)).

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(String, Handler) 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, Handler) 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.eventbus.bridge.grpc

Methods in io.vertx.reactivex.eventbus.bridge.grpc with parameters of type Handler

Modifier and Type	Method	Description
GrpcEventBusBridgeBuilder	GrpcEventBusBridgeBuilder.withEventHandler(Handler<BridgeEvent> eventHandler)	Set a handler for bridge events that can be used to implement custom security logic.

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(Handler) 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.
Router	Router.uncaughtErrorHandler(Handler<RoutingContext> errorHandler)	Specify an handler to handle an error for any status code that doesn't have a specific handler assigned.

Uses of Handler in io.vertx.reactivex.ext.web.codec

Methods in io.vertx.reactivex.ext.web.codec with parameters of type Handler

Modifier and Type	Method	Description
static BodyCodec<Void>	BodyCodec.sseStream(Handler<ReadStream<SseEvent>> handler)	A body codec that parse the response as a Server-SentEvent stream.

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