Uses of Interface
io.vertx.core.Handler

Packages that use Handler

Package	Description
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

Uses of Handler in io.vertx.core

Methods in io.vertx.core that return Handler

Modifier and Type	Method	Description
Handler<Throwable>	Context.exceptionHandler()
Handler<Throwable>	Vertx.exceptionHandler()

Methods in io.vertx.core with parameters of type Handler

Modifier and Type	Method	Description
default Future<T>	Future.andThen(Handler<AsyncResult<T>> handler)	Invokes the given handler upon completion.
Context	Context.exceptionHandler(Handler<Throwable> handler)	Set an exception handler called when the context runs an action throwing an uncaught throwable.
Vertx	Vertx.exceptionHandler(Handler<Throwable> handler)	Set a default exception handler for Context, set on Context.exceptionHandler(Handler) at creation.
static <T> Future<T>	Future.future(Handler<Promise<T>> handler)	Create a promise and pass it to the handler, and then returns this future's promise.
CompositeFuture	CompositeFuture.onComplete(Handler<AsyncResult<CompositeFuture>> handler)
default Future<T>	Future.onComplete(Handler<? super T> successHandler, Handler<? super Throwable> failureHandler)	Add handlers to be notified on succeeded result and failed result.
Future<T>	Future.onComplete(Handler<AsyncResult<T>> handler)	Add a handler to be notified of the result.
default CompositeFuture	CompositeFuture.onFailure(Handler<? super Throwable> handler)
default Future<T>	Future.onFailure(Handler<? super Throwable> handler)	Add a handler to be notified of the failed result.
default CompositeFuture	CompositeFuture.onSuccess(Handler<? super CompositeFuture> handler)
default Future<T>	Future.onSuccess(Handler<? super T> handler)	Add a handler to be notified of the succeeded result.
void	Context.runOnContext(Handler<Void> action)	Run the specified action asynchronously on the same context, some time after the current execution has completed.
void	Vertx.runOnContext(Handler<Void> action)	Puts the handler on the event queue for the current context so it will be run asynchronously ASAP after all preceeding events have been handled.
long	Vertx.setPeriodic(long initialDelay, long delay, Handler<Long> handler)	Set a periodic timer to fire every delay milliseconds with initial delay, at which point handler will be called with the id of the timer.
default long	Vertx.setPeriodic(long delay, Handler<Long> handler)	Set a periodic timer to fire every delay milliseconds, at which point handler will be called with the id of the timer.
long	Vertx.setTimer(long delay, Handler<Long> handler)	Set a one-shot timer to fire after delay milliseconds, at which point handler will be called with the id of the timer.

Uses of Handler in io.vertx.core.datagram

Methods in io.vertx.core.datagram with parameters of type Handler

Modifier and Type	Method	Description
DatagramSocket	DatagramSocket.exceptionHandler(Handler<Throwable> handler)
DatagramSocket	DatagramSocket.handler(Handler<DatagramPacket> handler)

Uses of Handler in io.vertx.core.eventbus

Methods in io.vertx.core.eventbus with parameters of type Handler

Modifier and Type	Method	Description
<T> EventBus	EventBus.addInboundInterceptor(Handler<DeliveryContext<T>> interceptor)	Add an interceptor that will be called whenever a message is received by Vert.x
<T> EventBus	EventBus.addOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)	Add an interceptor that will be called whenever a message is sent from Vert.x
<T> MessageConsumer<T>	EventBus.consumer(MessageConsumerOptions options, Handler<Message<T>> handler)	Create a consumer and register it against the specified options address.
<T> MessageConsumer<T>	EventBus.consumer(String address, Handler<Message<T>> handler)	Create a consumer and register it against the specified address.
MessageConsumer<T>	MessageConsumer.endHandler(Handler<Void> endHandler)
MessageConsumer<T>	MessageConsumer.exceptionHandler(Handler<Throwable> handler)
MessageConsumer<T>	MessageConsumer.handler(Handler<Message<T>> handler)
<T> MessageConsumer<T>	EventBus.localConsumer(String address, Handler<Message<T>> handler)	Like EventBus.consumer(String, Handler) but the address won't be propagated across the cluster.
<T> EventBus	EventBus.removeInboundInterceptor(Handler<DeliveryContext<T>> interceptor)	Remove an interceptor that was added by EventBus.addInboundInterceptor(Handler)
<T> EventBus	EventBus.removeOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)	Remove an interceptor that was added by EventBus.addOutboundInterceptor(Handler)

Uses of Handler in io.vertx.core.file

Methods in io.vertx.core.file with parameters of type Handler

Modifier and Type	Method	Description
AsyncFile	AsyncFile.drainHandler(Handler<Void> handler)
AsyncFile	AsyncFile.endHandler(Handler<Void> endHandler)
AsyncFile	AsyncFile.exceptionHandler(Handler<Throwable> handler)	Set an exception handler on the read stream and on the write stream.
AsyncFile	AsyncFile.handler(Handler<Buffer> handler)

Uses of Handler in io.vertx.core.http

Fields in io.vertx.core.http declared as Handler

Modifier and Type	Field	Description
static Handler<HttpServerRequest>	HttpServerRequest.DEFAULT_INVALID_REQUEST_HANDLER	The default invalid request handler, it uses the HttpServerRequest.decoderResult() cause and the request information to determine the status code of the response to be sent.

Methods in io.vertx.core.http that return Handler

Modifier and Type	Method	Description
Handler<HttpServerRequest>	HttpServer.requestHandler()
Handler<ServerWebSocket>	HttpServer.webSocketHandler()

Methods in io.vertx.core.http with parameters of type Handler

Modifier and Type	Method	Description
ClientWebSocket	ClientWebSocket.binaryMessageHandler(Handler<Buffer> handler)
WebSocket	WebSocket.binaryMessageHandler(Handler<Buffer> handler)
WebSocketBase	WebSocketBase.binaryMessageHandler(Handler<Buffer> handler)	Set a binary message handler on the connection.
HttpServerResponse	HttpServerResponse.bodyEndHandler(Handler<Void> handler)	Provides a handler that will be called after the last part of the body is written to the wire.
default HttpClientResponse	HttpClientResponse.bodyHandler(Handler<Buffer> bodyHandler)	Convenience method for receiving the entire request body in one piece.
default HttpServerRequest	HttpServerRequest.bodyHandler(Handler<Buffer> bodyHandler)	Convenience method for receiving the entire request body in one piece.
ClientWebSocket	ClientWebSocket.closeHandler(Handler<Void> handler)
HttpConnection	HttpConnection.closeHandler(Handler<Void> handler)	Set a close handler.
HttpServerResponse	HttpServerResponse.closeHandler(Handler<Void> handler)	Set a close handler for the response, this is called when the underlying connection is closed and the response was still using the connection.
ServerWebSocket	ServerWebSocket.closeHandler(Handler<Void> handler)
WebSocket	WebSocket.closeHandler(Handler<Void> handler)
WebSocketBase	WebSocketBase.closeHandler(Handler<Void> handler)	Set a close handler.
HttpServer	HttpServer.connectionHandler(Handler<HttpConnection> handler)	Set a connection handler for the server.
HttpClientRequest	HttpClientRequest.continueHandler(Handler<Void> handler)	If you send an HTTP request with the header Expect set to the value 100-continue and the server responds with an interim HTTP response with a status code of 100 and a Continue handler has been set using this method, then the handler will be called.
HttpClientResponse	HttpClientResponse.customFrameHandler(Handler<HttpFrame> handler)	Set an custom frame handler.
HttpServerRequest	HttpServerRequest.customFrameHandler(Handler<HttpFrame> handler)	Set a custom frame handler.
ClientWebSocket	ClientWebSocket.drainHandler(Handler<Void> handler)
HttpClientRequest	HttpClientRequest.drainHandler(Handler<Void> handler)
HttpServerResponse	HttpServerResponse.drainHandler(Handler<Void> handler)
ServerWebSocket	ServerWebSocket.drainHandler(Handler<Void> handler)
WebSocket	WebSocket.drainHandler(Handler<Void> handler)
WebSocketBase	WebSocketBase.drainHandler(Handler<Void> handler)
HttpClientRequest	HttpClientRequest.earlyHintsHandler(Handler<MultiMap> handler)	If the server responds with an interim HTTP response with a status code of 103 and a Early Hints handler has been set using this method, then the handler will be called.
ClientWebSocket	ClientWebSocket.endHandler(Handler<Void> endHandler)
HttpClientResponse	HttpClientResponse.endHandler(Handler<Void> endHandler)
HttpServerFileUpload	HttpServerFileUpload.endHandler(Handler<Void> endHandler)
HttpServerRequest	HttpServerRequest.endHandler(Handler<Void> endHandler)
HttpServerResponse	HttpServerResponse.endHandler(Handler<Void> handler)	Set an end handler for the response.
ServerWebSocket	ServerWebSocket.endHandler(Handler<Void> endHandler)
WebSocket	WebSocket.endHandler(Handler<Void> endHandler)
WebSocketBase	WebSocketBase.endHandler(Handler<Void> endHandler)
ClientWebSocket	ClientWebSocket.exceptionHandler(Handler<Throwable> handler)
HttpClientRequest	HttpClientRequest.exceptionHandler(Handler<Throwable> handler)
HttpClientResponse	HttpClientResponse.exceptionHandler(Handler<Throwable> handler)
HttpConnection	HttpConnection.exceptionHandler(Handler<Throwable> handler)	Set an handler called when a connection error happens
HttpServer	HttpServer.exceptionHandler(Handler<Throwable> handler)	Set an exception handler called for socket errors happening before the HTTP connection is established, e.g during the TLS handshake.
HttpServerFileUpload	HttpServerFileUpload.exceptionHandler(Handler<Throwable> handler)
HttpServerRequest	HttpServerRequest.exceptionHandler(Handler<Throwable> handler)
HttpServerResponse	HttpServerResponse.exceptionHandler(Handler<Throwable> handler)
ServerWebSocket	ServerWebSocket.exceptionHandler(Handler<Throwable> handler)
WebSocket	WebSocket.exceptionHandler(Handler<Throwable> handler)
WebSocketBase	WebSocketBase.exceptionHandler(Handler<Throwable> handler)
ClientWebSocket	ClientWebSocket.frameHandler(Handler<WebSocketFrame> handler)
ServerWebSocket	ServerWebSocket.frameHandler(Handler<WebSocketFrame> handler)
WebSocket	WebSocket.frameHandler(Handler<WebSocketFrame> handler)
WebSocketBase	WebSocketBase.frameHandler(Handler<WebSocketFrame> handler)	Set a frame handler on the connection.
HttpConnection	HttpConnection.goAwayHandler(Handler<GoAway> handler)	Set an handler called when a GOAWAY frame is received.
ClientWebSocket	ClientWebSocket.handler(Handler<Buffer> handler)
HttpClientResponse	HttpClientResponse.handler(Handler<Buffer> handler)
HttpServerFileUpload	HttpServerFileUpload.handler(Handler<Buffer> handler)
HttpServerRequest	HttpServerRequest.handler(Handler<Buffer> handler)
ServerWebSocket	ServerWebSocket.handler(Handler<Buffer> handler)
WebSocket	WebSocket.handler(Handler<Buffer> handler)
WebSocketBase	WebSocketBase.handler(Handler<Buffer> handler)
HttpServerResponse	HttpServerResponse.headersEndHandler(Handler<Void> handler)	Provide a handler that will be called just before the headers are written to the wire.
HttpServer	HttpServer.invalidRequestHandler(Handler<HttpServerRequest> handler)	Set a handler for handling invalid requests.
HttpConnection	HttpConnection.pingHandler(Handler<Buffer> handler)	Set an handler notified when a PING frame is received from the remote endpoint.
ClientWebSocket	ClientWebSocket.pongHandler(Handler<Buffer> handler)
WebSocket	WebSocket.pongHandler(Handler<Buffer> handler)
WebSocketBase	WebSocketBase.pongHandler(Handler<Buffer> handler)	Set a pong frame handler on the connection.
HttpClientRequest	HttpClientRequest.pushHandler(Handler<HttpClientRequest> handler)	Set a push handler for this request.
HttpConnection	HttpConnection.remoteSettingsHandler(Handler<Http2Settings> handler)	Set an handler that is called when remote endpoint Http2Settings are updated.
HttpServer	HttpServer.requestHandler(Handler<HttpServerRequest> handler)	Set the request handler for the server to requestHandler.
HttpConnection	HttpConnection.shutdownHandler(Handler<Void> handler)	Set a handler notified when the HTTP connection is shutdown: the client or server will close the connection within a certain amount of time.
WebSocket	WebSocket.shutdownHandler(Handler<Void> handler)
WebSocketBase	WebSocketBase.shutdownHandler(Handler<Void> handler)	Set a handler notified when the WebSocket is shutdown: the client or server will close the connection within a certain amount of time.
HttpClientResponse	HttpClientResponse.streamPriorityHandler(Handler<StreamPriority> handler)	Set an handler for stream priority changes.
HttpServerRequest	HttpServerRequest.streamPriorityHandler(Handler<StreamPriority> handler)	Set an handler for stream priority changes
ClientWebSocket	ClientWebSocket.textMessageHandler(Handler<String> handler)
WebSocket	WebSocket.textMessageHandler(Handler<String> handler)
WebSocketBase	WebSocketBase.textMessageHandler(Handler<String> handler)	Set a text message handler on the connection.
HttpServerRequest	HttpServerRequest.uploadHandler(Handler<HttpServerFileUpload> uploadHandler)	Set an upload handler.
HttpServer	HttpServer.webSocketHandler(Handler<ServerWebSocket> handler)	Set the WebSocket handler for the server to wsHandler.
HttpServer	HttpServer.webSocketHandshakeHandler(Handler<ServerWebSocketHandshake> handler)	Set a handler for WebSocket handshake.
HttpClientBuilder	HttpClientBuilder.withConnectHandler(Handler<HttpConnection> handler)	Set a connection handler for the client.

Uses of Handler in io.vertx.core.net

Methods in io.vertx.core.net that return Handler

Modifier and Type	Method	Description
Handler<NetSocket>	NetServer.connectHandler()

Methods in io.vertx.core.net with parameters of type Handler

Modifier and Type	Method	Description
NetSocket	NetSocket.closeHandler(Handler<Void> handler)	Set a handler notified when the socket is closed
NetServer	NetServer.connectHandler(Handler<NetSocket> handler)	Supply a connect handler for this server.
NetSocket	NetSocket.drainHandler(Handler<Void> handler)
NetSocket	NetSocket.endHandler(Handler<Void> endHandler)	Set an end handler.
NetServer	NetServer.exceptionHandler(Handler<Throwable> handler)	Set an exception handler called for socket errors happening before the connection is passed to the NetServer.connectHandler(io.vertx.core.Handler<io.vertx.core.net.NetSocket>), e.g during the TLS handshake.
NetSocket	NetSocket.exceptionHandler(Handler<Throwable> handler)
NetSocket	NetSocket.handler(Handler<Buffer> handler)
NetSocket	NetSocket.shutdownHandler(Handler<Void> handler)	Set a handler notified when the socket is shutdown: the client or server will close the connection within a certain amount of time.

Uses of Handler in io.vertx.core.parsetools

Subinterfaces of Handler in io.vertx.core.parsetools

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

Methods in io.vertx.core.parsetools with parameters of type Handler

Modifier and Type	Method	Description
JsonParser	JsonParser.endHandler(Handler<Void> endHandler)
RecordParser	RecordParser.endHandler(Handler<Void> endHandler)
JsonParser	JsonParser.exceptionHandler(Handler<Throwable> handler)
RecordParser	RecordParser.exceptionHandler(Handler<Throwable> handler)
JsonParser	JsonParser.handler(Handler<JsonEvent> handler)
RecordParser	RecordParser.handler(Handler<Buffer> handler)
static RecordParser	RecordParser.newDelimited(Buffer delim, Handler<Buffer> output)	Like RecordParser.newDelimited(Buffer) but set the output that will receive whole records which have been parsed.
static RecordParser	RecordParser.newDelimited(String delim, Handler<Buffer> output)	Like RecordParser.newDelimited(String) but set the output that will receive whole records which have been parsed.
static RecordParser	RecordParser.newFixed(int size, Handler<Buffer> output)	Like RecordParser.newFixed(int) but set the output that will receive whole records which have been parsed.
void	RecordParser.setOutput(Handler<Buffer> output)

Uses of Handler in io.vertx.core.streams

Methods in io.vertx.core.streams with parameters of type Handler

Modifier and Type	Method	Description
WriteStream<T>	WriteStream.drainHandler(Handler<Void> handler)	Set a drain handler on the stream.
ReadStream<T>	ReadStream.endHandler(Handler<Void> endHandler)	Set an end handler.
ReadStream<T>	ReadStream.exceptionHandler(Handler<Throwable> handler)	Set an exception handler on the read stream.
StreamBase	StreamBase.exceptionHandler(Handler<Throwable> handler)	Set an exception handler.
WriteStream<T>	WriteStream.exceptionHandler(Handler<Throwable> handler)	Set an exception handler on the write stream.
ReadStream<T>	ReadStream.handler(Handler<T> handler)	Set a data handler.