Uses of Interface
io.vertx.core.Handler

Packages that use Handler

Package	Description
io.vertx.core	= Vert.x Core Manual :toc: left At the heart of Vert.x is a set of Java APIs that we call *Vert.x Core* https://github.com/eclipse/vert.x[Repository].
io.vertx.core.datagram	== Datagram sockets (UDP) Using User Datagram Protocol (UDP) with Vert.x is a piece of cake.
io.vertx.core.dns	== DNS client Often you will find yourself in situations where you need to obtain DNS informations in an asynchronous fashion.
io.vertx.core.eventbus	== The Event Bus :toc: left The event bus is the *nervous system* of Vert.x.
io.vertx.core.file	== Using the file system with Vert.x The Vert.x FileSystem object provides many operations for manipulating the file system.
io.vertx.core.http	== Writing HTTP servers and clients Vert.x allows you to easily write non blocking HTTP clients and servers.
io.vertx.core.net	== Writing TCP servers and clients Vert.x allows you to easily write non blocking TCP clients and servers.
io.vertx.core.parsetools	== Record Parser The record parser allows you to easily parse protocols which are delimited by a sequence of bytes, or fixed size records.
io.vertx.core.shareddata	== Using Shared Data with Vert.x Shared data contains functionality that allows you to safely share data between different parts of your application, or different applications in the same Vert.x instance or across a cluster of Vert.x instances.
io.vertx.core.spi
io.vertx.core.spi.cluster
io.vertx.core.streams	== Streams There are several objects in Vert.x that allow items to be read from and written.

Uses of Handler in io.vertx.core

Subinterfaces of Handler in io.vertx.core

Modifier and Type	Interface and Description
interface	AsyncResultHandler<T> Handler for AsyncResult

Classes in io.vertx.core that implement Handler

Modifier and Type	Class and Description
class	VoidHandler This class can be used for simple handlers which don't receive any value.

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

Modifier and Type	Method and Description
void	Vertx.close(Handler<AsyncResult<Void>> completionHandler) Like Vertx.close() but the completionHandler will be called when the close is complete
static void	Vertx.clusteredVertx(VertxOptions options, Handler<AsyncResult<Vertx>> resultHandler) Creates a clustered instance using the specified options.
void	Vertx.deployVerticle(String name, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler) Like Vertx.deployVerticle(String, Handler) but DeploymentOptions are provided to configure the deployment.
void	Vertx.deployVerticle(String name, Handler<AsyncResult<String>> completionHandler) Like Vertx.deployVerticle(String) but the completionHandler will be notified when the deployment is complete.
void	Vertx.deployVerticle(Verticle verticle, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler) Like Vertx.deployVerticle(Verticle, Handler) but DeploymentOptions are provided to configure the deployment.
void	Vertx.deployVerticle(Verticle verticle, Handler<AsyncResult<String>> completionHandler) Like Vertx.deployVerticle(Verticle) but the completionHandler will be notified when the deployment is complete.
TimeoutStream	TimeoutStream.endHandler(Handler<Void> endHandler)
TimeoutStream	TimeoutStream.exceptionHandler(Handler<Throwable> handler)
<T> void	Vertx.executeBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler) Safely execute some blocking code.
<T> void	Vertx.executeBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler) Safely execute some blocking code.
<T> void	Context.executeBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler) Safely execute some blocking code.
<T> void	Context.executeBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler) Safely execute some blocking code.
<T> void	Vertx.executeBlocking(Handler<Future<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler) Like Vertx.executeBlocking(Handler, boolean, Handler) called with ordered = true.
<T> void	Vertx.executeBlocking(Handler<Future<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler) Like Vertx.executeBlocking(Handler, boolean, Handler) called with ordered = true.
<T> void	Context.executeBlocking(Handler<Future<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler) Invoke Context.executeBlocking(Handler, boolean, Handler) with order = true.
<T> void	Context.executeBlocking(Handler<Future<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler) Invoke Context.executeBlocking(Handler, boolean, Handler) with order = true.
TimeoutStream	TimeoutStream.handler(Handler<Long> handler)
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.
void	Context.runOnContext(Handler<Void> action) Run the specified action asynchronously on the same context, some time after the current execution has completed.
void	Future.setHandler(Handler<AsyncResult<T>> handler) Set a handler for the result.
long	Vertx.setPeriodic(long delay, Handler<Long> handler) Set a periodic timer to fire every delay milliseconds, at which point handler will be called with the id of the timer.
long	Vertx.setTimer(long delay, Handler<Long> handler) Set a one-shot timer to fire after delay milliseconds, at which point handler will be called with the id of the timer.
void	Vertx.undeploy(String deploymentID, Handler<AsyncResult<Void>> completionHandler) Like Vertx.undeploy(String) but the completionHandler will be notified when the undeployment is complete.

Uses of Handler in io.vertx.core.datagram

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

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

Uses of Handler in io.vertx.core.dns

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

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

Uses of Handler in io.vertx.core.eventbus

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

Modifier and Type	Method and Description
void	EventBus.close(Handler<AsyncResult<Void>> completionHandler) Close the event bus and release any resources held
void	MessageConsumer.completionHandler(Handler<AsyncResult<Void>> completionHandler) Optional method which can be called to indicate when the registration has been propagated across the cluster.
<T> MessageConsumer<T>	EventBus.consumer(String address, Handler<Message<T>> handler) Create a consumer and register it against the specified address.
MessageProducer<T>	MessageProducer.drainHandler(Handler<Void> handler)
MessageConsumer<T>	MessageConsumer.endHandler(Handler<Void> endHandler)
MessageProducer<T>	MessageProducer.exceptionHandler(Handler<Throwable> handler)
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.
<R> void	Message.reply(Object message, DeliveryOptions options, Handler<AsyncResult<Message<R>>> replyHandler) The same as reply(R message, DeliveryOptions) but you can specify handler for the reply - i.e.
<R> void	Message.reply(Object message, Handler<AsyncResult<Message<R>>> replyHandler) The same as reply(R message) but you can specify handler for the reply - i.e.
<T> EventBus	EventBus.send(String address, Object message, DeliveryOptions options, Handler<AsyncResult<Message<T>>> replyHandler) Like EventBus.send(String, Object, DeliveryOptions) but specifying a replyHandler that will be called if the recipient subsequently replies to the message.
<T> EventBus	EventBus.send(String address, Object message, Handler<AsyncResult<Message<T>>> replyHandler) Like EventBus.send(String, Object) but specifying a replyHandler that will be called if the recipient subsequently replies to the message.
void	MessageConsumer.unregister(Handler<AsyncResult<Void>> completionHandler) Unregisters the handler which created this registration

Uses of Handler in io.vertx.core.file

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

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

Uses of Handler in io.vertx.core.http

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

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

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

Modifier and Type	Method and Description
HttpServerResponse	HttpServerResponse.bodyEndHandler(Handler<Void> handler) Provide a handler that will be called just before the last part of the body is written to the wire and the response is ended.
HttpServerRequest	HttpServerRequest.bodyHandler(Handler<Buffer> bodyHandler) Convenience method for receiving the entire request body in one piece.
HttpClientResponse	HttpClientResponse.bodyHandler(Handler<Buffer> bodyHandler) Convenience method for receiving the entire request body in one piece.
void	HttpServer.close(Handler<AsyncResult<Void>> completionHandler) Like HttpServer.close() but supplying a handler that will be called when the server is actually closed (or has failed).
WebSocketBase	WebSocketBase.closeHandler(Handler<Void> handler) Set a close handler.
WebSocket	WebSocket.closeHandler(Handler<Void> handler)
ServerWebSocket	ServerWebSocket.closeHandler(Handler<Void> handler)
HttpServerResponse	HttpServerResponse.closeHandler(Handler<Void> handler) Set a close handler for the response.
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.
HttpClientRequest	HttpClient.delete(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler) Create an HTTP DELETE request to send to the server at the specified host and port, specifying a response handler to receive the response
HttpClientRequest	HttpClient.delete(String requestURI, Handler<HttpClientResponse> responseHandler) Create an HTTP DELETE request to send to the server at the default host and port, specifying a response handler to receive the response
HttpClientRequest	HttpClient.delete(String host, String requestURI, Handler<HttpClientResponse> responseHandler) Create an HTTP DELETE request to send to the server at the specified host and default port, specifying a response handler to receive the response
HttpClientRequest	HttpClient.deleteAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler) Create an HTTP DELETE request to send to the server using an absolute URI, specifying a response handler to receive the response
WebSocketBase	WebSocketBase.drainHandler(Handler<Void> handler)
WebSocket	WebSocket.drainHandler(Handler<Void> handler)
ServerWebSocket	ServerWebSocket.drainHandler(Handler<Void> handler)
HttpServerResponse	HttpServerResponse.drainHandler(Handler<Void> handler)
HttpClientRequest	HttpClientRequest.drainHandler(Handler<Void> handler)
WebSocketStream	WebSocketStream.endHandler(Handler<Void> endHandler)
WebSocketBase	WebSocketBase.endHandler(Handler<Void> endHandler)
WebSocket	WebSocket.endHandler(Handler<Void> endHandler)
ServerWebSocketStream	ServerWebSocketStream.endHandler(Handler<Void> endHandler)
ServerWebSocket	ServerWebSocket.endHandler(Handler<Void> endHandler)
HttpServerRequestStream	HttpServerRequestStream.endHandler(Handler<Void> endHandler)
HttpServerRequest	HttpServerRequest.endHandler(Handler<Void> endHandler)
HttpServerFileUpload	HttpServerFileUpload.endHandler(Handler<Void> endHandler)
HttpClientResponse	HttpClientResponse.endHandler(Handler<Void> endHandler)
HttpClientRequest	HttpClientRequest.endHandler(Handler<Void> endHandler)
WebSocketStream	WebSocketStream.exceptionHandler(Handler<Throwable> handler)
WebSocketBase	WebSocketBase.exceptionHandler(Handler<Throwable> handler)
WebSocket	WebSocket.exceptionHandler(Handler<Throwable> handler)
ServerWebSocketStream	ServerWebSocketStream.exceptionHandler(Handler<Throwable> handler)
ServerWebSocket	ServerWebSocket.exceptionHandler(Handler<Throwable> handler)
HttpServerResponse	HttpServerResponse.exceptionHandler(Handler<Throwable> handler)
HttpServerRequestStream	HttpServerRequestStream.exceptionHandler(Handler<Throwable> handler)
HttpServerRequest	HttpServerRequest.exceptionHandler(Handler<Throwable> handler)
HttpServerFileUpload	HttpServerFileUpload.exceptionHandler(Handler<Throwable> handler)
HttpClientResponse	HttpClientResponse.exceptionHandler(Handler<Throwable> handler)
HttpClientRequest	HttpClientRequest.exceptionHandler(Handler<Throwable> handler)
WebSocketBase	WebSocketBase.frameHandler(Handler<WebSocketFrame> handler) Set a frame handler on the connection.
WebSocket	WebSocket.frameHandler(Handler<WebSocketFrame> handler)
ServerWebSocket	ServerWebSocket.frameHandler(Handler<WebSocketFrame> handler)
HttpClientRequest	HttpClient.get(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler) Create an HTTP GET request to send to the server at the specified host and port, specifying a response handler to receive the response
HttpClientRequest	HttpClient.get(String requestURI, Handler<HttpClientResponse> responseHandler) Create an HTTP GET request to send to the server at the default host and port, specifying a response handler to receive the response
HttpClientRequest	HttpClient.get(String host, String requestURI, Handler<HttpClientResponse> responseHandler) Create an HTTP GET request to send to the server at the specified host and default port, specifying a response handler to receive the response
HttpClientRequest	HttpClient.getAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler) Create an HTTP GET request to send to the server using an absolute URI, specifying a response handler to receive the response
HttpClient	HttpClient.getNow(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler) Sends an HTTP GET request to the server at the specified host and port, specifying a response handler to receive the response
HttpClient	HttpClient.getNow(String requestURI, Handler<HttpClientResponse> responseHandler) Sends an HTTP GET request to the server at the default host and port, specifying a response handler to receive the response
HttpClient	HttpClient.getNow(String host, String requestURI, Handler<HttpClientResponse> responseHandler) Sends an HTTP GET request to the server at the specified host and default port, specifying a response handler to receive the response
WebSocketBase	WebSocketBase.handler(Handler<Buffer> handler)
WebSocket	WebSocket.handler(Handler<Buffer> handler)
ServerWebSocket	ServerWebSocket.handler(Handler<Buffer> handler)
HttpServerRequest	HttpServerRequest.handler(Handler<Buffer> handler)
HttpServerFileUpload	HttpServerFileUpload.handler(Handler<Buffer> handler)
HttpClientResponse	HttpClientResponse.handler(Handler<Buffer> handler)
HttpClientRequest	HttpClientRequest.handler(Handler<HttpClientResponse> handler)
HttpServerRequestStream	HttpServerRequestStream.handler(Handler<HttpServerRequest> handler)
ServerWebSocketStream	ServerWebSocketStream.handler(Handler<ServerWebSocket> handler)
WebSocketStream	WebSocketStream.handler(Handler<WebSocket> handler)
HttpClientRequest	HttpClient.head(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler) Create an HTTP HEAD request to send to the server at the specified host and port, specifying a response handler to receive the response
HttpClientRequest	HttpClient.head(String requestURI, Handler<HttpClientResponse> responseHandler) Create an HTTP HEAD request to send to the server at the default host and port, specifying a response handler to receive the response
HttpClientRequest	HttpClient.head(String host, String requestURI, Handler<HttpClientResponse> responseHandler) Create an HTTP HEAD request to send to the server at the specified host and default port, specifying a response handler to receive the response
HttpClientRequest	HttpClient.headAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler) Create an HTTP HEAD request to send to the server using an absolute URI, specifying a response handler to receive the response
HttpServerResponse	HttpServerResponse.headersEndHandler(Handler<Void> handler) Provide a handler that will be called just before the headers are written to the wire.
HttpClient	HttpClient.headNow(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler) Sends an HTTP HEAD request to the server at the specified host and port, specifying a response handler to receive the response
HttpClient	HttpClient.headNow(String requestURI, Handler<HttpClientResponse> responseHandler) Sends an HTTP HEAD request to the server at the default host and port, specifying a response handler to receive the response
HttpClient	HttpClient.headNow(String host, String requestURI, Handler<HttpClientResponse> responseHandler) Sends an HTTP HEAD request to the server at the specified host and default port, specifying a response handler to receive the response
HttpServer	HttpServer.listen(Handler<AsyncResult<HttpServer>> listenHandler) Like HttpServer.listen() but supplying a handler that will be called when the server is actually listening (or has failed).
HttpServer	HttpServer.listen(int port, Handler<AsyncResult<HttpServer>> listenHandler) Like HttpServer.listen(int) but supplying a handler that will be called when the server is actually listening (or has failed).
HttpServer	HttpServer.listen(int port, String host, Handler<AsyncResult<HttpServer>> listenHandler) Like HttpServer.listen(int, String) but supplying a handler that will be called when the server is actually listening (or has failed).
HttpClientRequest	HttpClient.options(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler) Create an HTTP OPTIONS request to send to the server at the specified host and port, specifying a response handler to receive the response
HttpClientRequest	HttpClient.options(String requestURI, Handler<HttpClientResponse> responseHandler) Create an HTTP OPTIONS request to send to the server at the default host and port, specifying a response handler to receive the response
HttpClientRequest	HttpClient.options(String host, String requestURI, Handler<HttpClientResponse> responseHandler) Create an HTTP OPTIONS request to send to the server at the specified host and default port, specifying a response handler to receive the response
HttpClientRequest	HttpClient.optionsAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler) Create an HTTP OPTIONS request to send to the server using an absolute URI, specifying a response handler to receive the response
HttpClient	HttpClient.optionsNow(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler) Sends an HTTP OPTIONS request to the server at the specified host and port, specifying a response handler to receive the response
HttpClient	HttpClient.optionsNow(String requestURI, Handler<HttpClientResponse> responseHandler) Sends an HTTP OPTIONS request to the server at the default host and port, specifying a response handler to receive the response
HttpClient	HttpClient.optionsNow(String host, String requestURI, Handler<HttpClientResponse> responseHandler) Sends an HTTP OPTIONS request to the server at the specified host and default port, specifying a response handler to receive the response
HttpClientRequest	HttpClient.post(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler) Create an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
HttpClientRequest	HttpClient.post(String requestURI, Handler<HttpClientResponse> responseHandler) Create an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
HttpClientRequest	HttpClient.post(String host, String requestURI, Handler<HttpClientResponse> responseHandler) Create an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
HttpClientRequest	HttpClient.postAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler) Create an HTTP POST request to send to the server using an absolute URI, specifying a response handler to receive the response
HttpClientRequest	HttpClient.put(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler) Create an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
HttpClientRequest	HttpClient.put(String requestURI, Handler<HttpClientResponse> responseHandler) Create an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
HttpClientRequest	HttpClient.put(String host, String requestURI, Handler<HttpClientResponse> responseHandler) Create an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
HttpClientRequest	HttpClient.putAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler) Create an HTTP PUT request to send to the server using an absolute URI, specifying a response handler to receive the response
HttpClientRequest	HttpClient.request(HttpMethod method, int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler) Create an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
HttpClientRequest	HttpClient.request(HttpMethod method, String requestURI, Handler<HttpClientResponse> responseHandler) Create an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
HttpClientRequest	HttpClient.request(HttpMethod method, String host, String requestURI, Handler<HttpClientResponse> responseHandler) Create an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
HttpClientRequest	HttpClient.requestAbs(HttpMethod method, String absoluteURI, Handler<HttpClientResponse> responseHandler) Create an HTTP request to send to the server using an absolute URI, specifying a response handler to receive the response
HttpServer	HttpServer.requestHandler(Handler<HttpServerRequest> handler) Set the request handler for the server to requestHandler.
default HttpServerResponse	HttpServerResponse.sendFile(String filename, Handler<AsyncResult<Void>> resultHandler) Like HttpServerResponse.sendFile(String) but providing a handler which will be notified once the file has been completely written to the wire.
default HttpServerResponse	HttpServerResponse.sendFile(String filename, long offset, Handler<AsyncResult<Void>> resultHandler) Like HttpServerResponse.sendFile(String, long) but providing a handler which will be notified once the file has been completely written to the wire.
HttpServerResponse	HttpServerResponse.sendFile(String filename, long offset, long length, Handler<AsyncResult<Void>> resultHandler) Like HttpServerResponse.sendFile(String, long, long) but providing a handler which will be notified once the file has been completely written to the wire.
HttpServerRequest	HttpServerRequest.uploadHandler(Handler<HttpServerFileUpload> uploadHandler) Set an upload handler.
HttpClient	HttpClient.websocket(int port, String host, String requestURI, Handler<WebSocket> wsConnect) Connect a WebSocket to the specified port, host and relative request URI
HttpClient	HttpClient.websocket(int port, String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket to the specified port, host and relative request URI
HttpClient	HttpClient.websocket(int port, String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket to the specified port, host and relative request URI
HttpClient	HttpClient.websocket(int port, String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect) Connect a WebSocket to the specified port, host and relative request URI, and with the specified headers
HttpClient	HttpClient.websocket(int port, String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket to the specified port, host and relative request URI, and with the specified headers
HttpClient	HttpClient.websocket(int port, String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket to the specified port, host and relative request URI, and with the specified headers
HttpClient	HttpClient.websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect) Connect a WebSocket to the specified port, host and relative request URI, with the specified headers and using the specified version of WebSockets
HttpClient	HttpClient.websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket to the specified port, host and relative request URI, with the specified headers and using the specified version of WebSockets
HttpClient	HttpClient.websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket to the specified port, host and relative request URI, with the specified headers and using the specified version of WebSockets
HttpClient	HttpClient.websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect) Connect a WebSocket to the specified port, host and relative request URI, with the specified headers, using the specified version of WebSockets, and the specified websocket sub protocols
HttpClient	HttpClient.websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket to the specified port, host and relative request URI, with the specified headers, using the specified version of WebSockets, and the specified websocket sub protocols
HttpClient	HttpClient.websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket to the specified port, host and relative request URI, with the specified headers, using the specified version of WebSockets, and the specified websocket sub protocols
HttpClient	HttpClient.websocket(String requestURI, Handler<WebSocket> wsConnect) Connect a WebSocket at the relative request URI using the default host and port
HttpClient	HttpClient.websocket(String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket at the relative request URI using the default host and port
HttpClient	HttpClient.websocket(String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket at the relative request URI using the default host and port
HttpClient	HttpClient.websocket(String requestURI, MultiMap headers, Handler<WebSocket> wsConnect) Connect a WebSocket at the relative request URI using the default host and port and the specified headers
HttpClient	HttpClient.websocket(String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket at the relative request URI using the default host and port and the specified headers
HttpClient	HttpClient.websocket(String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket at the relative request URI using the default host and port and the specified headers
HttpClient	HttpClient.websocket(String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect) Connect a WebSocket at the relative request URI using the default host and port, the specified headers and the specified version of WebSockets
HttpClient	HttpClient.websocket(String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket at the relative request URI using the default host and port, the specified headers and the specified version of WebSockets
HttpClient	HttpClient.websocket(String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket at the relative request URI using the default host and port, the specified headers and the specified version of WebSockets
HttpClient	HttpClient.websocket(String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect) Connect a WebSocket at the relative request URI using the default host and port, the specified headers, the specified version of WebSockets and the specified sub protocols
HttpClient	HttpClient.websocket(String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket at the relative request URI using the default host and port, the specified headers, the specified version of WebSockets and the specified sub protocols
HttpClient	HttpClient.websocket(String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket at the relative request URI using the default host and port, the specified headers, the specified version of WebSockets and the specified sub protocols
HttpClient	HttpClient.websocket(String host, String requestURI, Handler<WebSocket> wsConnect) Connect a WebSocket to the host and relative request URI and default port
HttpClient	HttpClient.websocket(String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket to the host and relative request URI and default port
HttpClient	HttpClient.websocket(String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket to the host and relative request URI and default port
HttpClient	HttpClient.websocket(String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect) Connect a WebSocket to the specified host,relative request UR, and default port and with the specified headers
HttpClient	HttpClient.websocket(String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket to the specified host,relative request UR, and default port and with the specified headers
HttpClient	HttpClient.websocket(String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket to the specified host,relative request UR, and default port and with the specified headers
HttpClient	HttpClient.websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect) Connect a WebSocket to the specified host, relative request URI and default port with the specified headers and using the specified version of WebSockets
HttpClient	HttpClient.websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket to the specified host, relative request URI and default port with the specified headers and using the specified version of WebSockets
HttpClient	HttpClient.websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket to the specified host, relative request URI and default port with the specified headers and using the specified version of WebSockets
HttpClient	HttpClient.websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect) Connect a WebSocket to the specified host, relative request URI and default port, with the specified headers, using the specified version of WebSockets, and the specified websocket sub protocols
HttpClient	HttpClient.websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket to the specified host, relative request URI and default port, with the specified headers, using the specified version of WebSockets, and the specified websocket sub protocols
HttpClient	HttpClient.websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket to the specified host, relative request URI and default port, with the specified headers, using the specified version of WebSockets, and the specified websocket sub protocols
HttpServer	HttpServer.websocketHandler(Handler<ServerWebSocket> handler) Set the websocket handler for the server to wsHandler.

Uses of Handler in io.vertx.core.net

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

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

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

Modifier and Type	Method and Description
void	NetServer.close(Handler<AsyncResult<Void>> completionHandler) Like NetServer.close() but supplying a handler that will be notified when close is complete.
NetSocket	NetSocket.closeHandler(Handler<Void> handler) Set a handler that will be called when the NetSocket is closed
NetClient	NetClient.connect(int port, String host, Handler<AsyncResult<NetSocket>> connectHandler) Open a connection to a server at the specific port and host.
NetServer	NetServer.connectHandler(Handler<NetSocket> handler) Supply a connect handler for this server.
NetSocket	NetSocket.drainHandler(Handler<Void> handler)
NetSocketStream	NetSocketStream.endHandler(Handler<Void> endHandler)
NetSocket	NetSocket.endHandler(Handler<Void> endHandler)
NetSocketStream	NetSocketStream.exceptionHandler(Handler<Throwable> handler)
NetSocket	NetSocket.exceptionHandler(Handler<Throwable> handler)
NetSocket	NetSocket.handler(Handler<Buffer> handler)
NetSocketStream	NetSocketStream.handler(Handler<NetSocket> handler)
NetServer	NetServer.listen(Handler<AsyncResult<NetServer>> listenHandler) Like NetServer.listen() but providing a handler that will be notified when the server is listening, or fails.
NetServer	NetServer.listen(int port, Handler<AsyncResult<NetServer>> listenHandler) Like NetServer.listen(int) but providing a handler that will be notified when the server is listening, or fails.
NetServer	NetServer.listen(int port, String host, Handler<AsyncResult<NetServer>> listenHandler) Like NetServer.listen(int, String) but providing a handler that will be notified when the server is listening, or fails.
default NetSocket	NetSocket.sendFile(String filename, Handler<AsyncResult<Void>> resultHandler) Same as NetSocket.sendFile(String) but also takes a handler that will be called when the send has completed or a failure has occurred
default NetSocket	NetSocket.sendFile(String filename, long offset, Handler<AsyncResult<Void>> resultHandler) Same as NetSocket.sendFile(String, long) but also takes a handler that will be called when the send has completed or a failure has occurred
NetSocket	NetSocket.sendFile(String filename, long offset, long length, Handler<AsyncResult<Void>> resultHandler) Same as NetSocket.sendFile(String, long, long) but also takes a handler that will be called when the send has completed or a failure has occurred
NetSocket	NetSocket.upgradeToSsl(Handler<Void> handler) Upgrade channel to use SSL/TLS.

Uses of Handler in io.vertx.core.parsetools

Subinterfaces of Handler in io.vertx.core.parsetools

Modifier and Type	Interface and Description
interface	RecordParser A helper class which allows you to easily parse protocols which are delimited by a sequence of bytes, or fixed size records.

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

Modifier and Type	Method and Description
static RecordParser	RecordParser.newDelimited(Buffer delim, Handler<Buffer> output) Create a new RecordParser instance, initially in delimited mode, and where the delimiter can be represented by the Buffer delim.
static RecordParser	RecordParser.newDelimited(String delim, Handler<Buffer> output) Create a new RecordParser instance, initially in delimited mode, and where the delimiter can be represented by the String delim endcoded in latin-1 .
static RecordParser	RecordParser.newFixed(int size, Handler<Buffer> output) Create a new RecordParser instance, initially in fixed size mode, and where the record size is specified by the size parameter.
void	RecordParser.setOutput(Handler<Buffer> output)

Uses of Handler in io.vertx.core.shareddata

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

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

Uses of Handler in io.vertx.core.spi

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

Modifier and Type	Method and Description
void	VertxFactory.clusteredVertx(VertxOptions options, Handler<AsyncResult<Vertx>> resultHandler)

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

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

Modifier and Type	Method and Description
void	AsyncMultiMap.add(K k, V v, Handler<AsyncResult<Void>> completionHandler) Add a value to the list of values for that key in the map
void	AsyncMultiMap.get(K k, Handler<AsyncResult<ChoosableIterable<V>>> resultHandler) Get a list of values from the map for the key
<K,V> void	ClusterManager.getAsyncMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler) Return an async map for the given name
<K,V> void	ClusterManager.getAsyncMultiMap(String name, Handler<AsyncResult<AsyncMultiMap<K,V>>> resultHandler) Return an async multi-map for the given name
void	ClusterManager.getCounter(String name, Handler<AsyncResult<Counter>> resultHandler)
void	ClusterManager.getLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler)
void	ClusterManager.join(Handler<AsyncResult<Void>> resultHandler) Join the cluster
void	ClusterManager.leave(Handler<AsyncResult<Void>> resultHandler) Leave the cluster
void	AsyncMultiMap.remove(K k, V v, Handler<AsyncResult<Boolean>> completionHandler) Remove a value from the list of values for that key in the map.
void	AsyncMultiMap.removeAllForValue(V v, Handler<AsyncResult<Void>> completionHandler) Remove all the specified values from all keys in the map

Uses of Handler in io.vertx.core.streams

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

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