Uses of Interface
io.vertx.core.Handler

Packages that use Handler

Package	Description
io.vertx.core
io.vertx.core.datagram
io.vertx.core.dns
io.vertx.core.eventbus
io.vertx.core.file
io.vertx.core.http
io.vertx.core.net
io.vertx.core.parsetools
io.vertx.core.shareddata
io.vertx.core.spi
io.vertx.core.spi.cluster
io.vertx.core.spi.resolver
io.vertx.core.streams

Uses of Handler in io.vertx.core

Subinterfaces of Handler in io.vertx.core

Modifier and Type	Interface and Description
interface	CompositeFuture The composite future wraps a list of futures, it is useful when several futures needs to be coordinated.
interface	Future<T> Represents the result of an action that may, or may not, have occurred yet.

Methods in io.vertx.core that return Handler

Modifier and Type	Method and Description
default Handler<AsyncResult<T>>	Future.completer()
Handler<Throwable>	Vertx.exceptionHandler()
Handler<Throwable>	Context.exceptionHandler()

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
void	Closeable.close(Handler<AsyncResult<Void>> completionHandler) Close this resource, the completionHandler must be notified when the operation has completed.
static void	Vertx.clusteredVertx(VertxOptions options, Handler<AsyncResult<Vertx>> resultHandler) Creates a clustered instance using the specified options.
default <U> Future<U>	Future.compose(Handler<T> handler, Future<U> next) Compose this future with a provided next future.
void	Vertx.deployVerticle(Class<? extends Verticle> verticleClass, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler) Like Vertx.deployVerticle(Verticle, DeploymentOptions, Handler) but Verticle instance is created by invoking the default constructor of verticleClass.
void	Vertx.deployVerticle(String name, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler) Like Vertx.deployVerticle(String, Handler) but DeploymentOptions are provided to configure the deployment.
void	Vertx.deployVerticle(String name, Handler<AsyncResult<String>> completionHandler) Like Vertx.deployVerticle(String) but the completionHandler will be notified when the deployment is complete.
void	Vertx.deployVerticle(Supplier<Verticle> verticleSupplier, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler) Like Vertx.deployVerticle(Verticle, DeploymentOptions, Handler) but Verticle instance is created by invoking the verticleSupplier.
void	Vertx.deployVerticle(Verticle verticle, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler) Like Vertx.deployVerticle(Verticle, Handler) but DeploymentOptions are provided to configure the deployment.
void	Vertx.deployVerticle(Verticle verticle, Handler<AsyncResult<String>> completionHandler) Like Vertx.deployVerticle(Verticle) but the completionHandler will be notified when the deployment is complete.
TimeoutStream	TimeoutStream.endHandler(Handler<Void> endHandler)
Vertx	Vertx.exceptionHandler(Handler<Throwable> handler) Set a default exception handler for Context, set on Context.exceptionHandler(Handler) at creation.
TimeoutStream	TimeoutStream.exceptionHandler(Handler<Throwable> handler)
Context	Context.exceptionHandler(Handler<Throwable> handler) Set an exception handler called when the context runs an action throwing an uncaught throwable. When this handler is called, Vertx.currentContext() will return this context.
<T> void	WorkerExecutor.executeBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler) Safely execute some blocking code.
<T> void	WorkerExecutor.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	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.
default <T> void	WorkerExecutor.executeBlocking(Handler<Future<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler) Like WorkerExecutor.executeBlocking(Handler, boolean, Handler) called with ordered = true.
default <T> void	WorkerExecutor.executeBlocking(Handler<Future<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler) Like WorkerExecutor.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	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.
static <T> Future<T>	Future.future(Handler<Future<T>> handler) Create a future that hasn't completed yet and that is passed to the handler before it is returned.
TimeoutStream	TimeoutStream.handler(Handler<Long> handler)
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.
CompositeFuture	CompositeFuture.setHandler(Handler<AsyncResult<CompositeFuture>> handler)
Future<T>	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.
DatagramSocket	DatagramSocket.endHandler(Handler<Void> endHandler)
DatagramSocket	DatagramSocket.exceptionHandler(Handler<Throwable> handler)
DatagramSocket	DatagramSocket.handler(Handler<DatagramPacket> handler)
DatagramSocket	DatagramSocket.listen(int port, String host, Handler<AsyncResult<DatagramSocket>> handler) Start listening on the given port and host.
DatagramSocket	DatagramSocket.listenMulticastGroup(String multicastAddress, Handler<AsyncResult<DatagramSocket>> handler) Joins a multicast group and listens for packets send to it.
DatagramSocket	DatagramSocket.listenMulticastGroup(String multicastAddress, String networkInterface, String source, Handler<AsyncResult<DatagramSocket>> handler) Joins a multicast group and listens for packets send to it on the given network interface.
DatagramSocket	DatagramSocket.send(Buffer packet, int port, String host, Handler<AsyncResult<DatagramSocket>> handler) Write the given Buffer to the SocketAddress.
DatagramSocket	DatagramSocket.send(String str, int port, String host, Handler<AsyncResult<DatagramSocket>> handler) Write the given String to the SocketAddress using UTF8 encoding.
DatagramSocket	DatagramSocket.send(String str, String enc, int port, String host, Handler<AsyncResult<DatagramSocket>> handler) Write the given String to the SocketAddress using the given encoding.
DatagramSocket	DatagramSocket.unlistenMulticastGroup(String multicastAddress, Handler<AsyncResult<DatagramSocket>> handler) Leaves a multicast group and stops listening for packets send to it.
DatagramSocket	DatagramSocket.unlistenMulticastGroup(String multicastAddress, String networkInterface, String source, Handler<AsyncResult<DatagramSocket>> handler) Leaves a multicast group and stops listening for packets send to it on the given network interface.

Uses of Handler in io.vertx.core.dns

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

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

Uses of Handler in io.vertx.core.eventbus

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

Modifier and Type	Method and Description
<T> EventBus	EventBus.addInboundInterceptor(Handler<DeliveryContext<T>> interceptor) Add an interceptor that will be called whenever a message is received by Vert.x
<T> EventBus	EventBus.addOutboundInterceptor(Handler<DeliveryContext<T>> interceptor) Add an interceptor that will be called whenever a message is sent from Vert.x
void	EventBus.close(Handler<AsyncResult<Void>> completionHandler) Close the event bus and release any resources held.
void	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.
<T> EventBus	EventBus.removeInboundInterceptor(Handler<DeliveryContext<T>> interceptor) Remove an interceptor that was added by EventBus.addInboundInterceptor(Handler)
<T> EventBus	EventBus.removeOutboundInterceptor(Handler<DeliveryContext<T>> interceptor) Remove an interceptor that was added by EventBus.addOutboundInterceptor(Handler)
<R> void	Message.reply(Object message, DeliveryOptions options, Handler<AsyncResult<Message<R>>> replyHandler) 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.
<R> MessageProducer<T>	MessageProducer.send(T message, Handler<AsyncResult<Message<R>>> replyHandler) Like MessageProducer.send(Object) but specifying a replyHandler that will be called if the recipient subsequently replies to the message.
void	EventBus.start(Handler<AsyncResult<Void>> completionHandler) Start the event bus.
void	MessageConsumer.unregister(Handler<AsyncResult<Void>> completionHandler) Unregisters the handler which created this registration

Uses of Handler in io.vertx.core.file

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

Modifier and Type	Method and Description
FileSystem	FileSystem.chmod(String path, String perms, Handler<AsyncResult<Void>> handler) Change the permissions on the file represented by path to perms, asynchronously.
FileSystem	FileSystem.chmodRecursive(String path, String perms, String dirPerms, Handler<AsyncResult<Void>> handler) Change the permissions on the file represented by path to perms, asynchronously.
FileSystem	FileSystem.chown(String path, String user, String group, Handler<AsyncResult<Void>> handler) Change the ownership on the file represented by path to user and {code group}, asynchronously.
void	AsyncFile.close(Handler<AsyncResult<Void>> handler) Close the file.
FileSystem	FileSystem.copy(String from, String to, CopyOptions options, Handler<AsyncResult<Void>> handler) Copy a file from the path from to path to, asynchronously.
FileSystem	FileSystem.copy(String from, String to, Handler<AsyncResult<Void>> handler) Copy a file from the path from to path to, asynchronously.
FileSystem	FileSystem.copyRecursive(String from, String to, boolean recursive, Handler<AsyncResult<Void>> handler) Copy a file from the path from to path to, asynchronously.
FileSystem	FileSystem.createFile(String path, Handler<AsyncResult<Void>> handler) Creates an empty file with the specified path, asynchronously.
FileSystem	FileSystem.createFile(String path, String perms, Handler<AsyncResult<Void>> handler) Creates an empty file with the specified path and permissions perms, asynchronously.
FileSystem	FileSystem.createTempDirectory(String prefix, Handler<AsyncResult<String>> handler) Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
FileSystem	FileSystem.createTempDirectory(String prefix, String perms, Handler<AsyncResult<String>> handler) Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
FileSystem	FileSystem.createTempDirectory(String dir, String prefix, String perms, Handler<AsyncResult<String>> handler) Creates a new directory in the directory provided by the path path, using the given prefix to generate its name, asynchronously.
FileSystem	FileSystem.createTempFile(String prefix, String suffix, Handler<AsyncResult<String>> handler) Creates a new file in the default temporary-file directory, using the given prefix and suffix to generate its name, asynchronously.
FileSystem	FileSystem.createTempFile(String prefix, String suffix, String perms, Handler<AsyncResult<String>> handler) Creates a new file in the directory provided by the path dir, using the given prefix and suffix to generate its name, asynchronously.
FileSystem	FileSystem.createTempFile(String dir, String prefix, String suffix, String perms, Handler<AsyncResult<String>> handler) Creates a new file in the directory provided by the path dir, using the given prefix and suffix to generate its name, asynchronously.
FileSystem	FileSystem.delete(String path, Handler<AsyncResult<Void>> handler) Deletes the file represented by the specified path, asynchronously.
FileSystem	FileSystem.deleteRecursive(String path, boolean recursive, Handler<AsyncResult<Void>> handler) Deletes the file represented by the specified path, asynchronously.
AsyncFile	AsyncFile.drainHandler(Handler<Void> handler)
AsyncFile	AsyncFile.endHandler(Handler<Void> endHandler)
AsyncFile	AsyncFile.exceptionHandler(Handler<Throwable> handler)
FileSystem	FileSystem.exists(String path, Handler<AsyncResult<Boolean>> handler) Determines whether the file as specified by the path path exists, asynchronously.
AsyncFile	AsyncFile.flush(Handler<AsyncResult<Void>> handler) Same as AsyncFile.flush() but the handler will be called when the flush is complete or if an error occurs
FileSystem	FileSystem.fsProps(String path, Handler<AsyncResult<FileSystemProps>> handler) Returns properties of the file-system being used by the specified path, asynchronously.
AsyncFile	AsyncFile.handler(Handler<Buffer> handler)
FileSystem	FileSystem.link(String link, String existing, Handler<AsyncResult<Void>> handler) Create a hard link on the file system from link to existing, asynchronously.
FileSystem	FileSystem.lprops(String path, Handler<AsyncResult<FileProps>> handler) Obtain properties for the link represented by path, asynchronously.
FileSystem	FileSystem.mkdir(String path, Handler<AsyncResult<Void>> handler) Create the directory represented by path, asynchronously.
FileSystem	FileSystem.mkdir(String path, String perms, Handler<AsyncResult<Void>> handler) Create the directory represented by path, asynchronously.
FileSystem	FileSystem.mkdirs(String path, Handler<AsyncResult<Void>> handler) Create the directory represented by path and any non existent parents, asynchronously.
FileSystem	FileSystem.mkdirs(String path, String perms, Handler<AsyncResult<Void>> handler) Create the directory represented by path and any non existent parents, asynchronously.
FileSystem	FileSystem.move(String from, String to, CopyOptions options, Handler<AsyncResult<Void>> handler) Move a file from the path from to path to, asynchronously.
FileSystem	FileSystem.move(String from, String to, Handler<AsyncResult<Void>> handler) Move a file from the path from to path to, asynchronously.
FileSystem	FileSystem.open(String path, OpenOptions options, Handler<AsyncResult<AsyncFile>> handler) Open the file represented by path, asynchronously.
FileSystem	FileSystem.props(String path, Handler<AsyncResult<FileProps>> handler) Obtain properties for the file represented by path, asynchronously.
AsyncFile	AsyncFile.read(Buffer buffer, int offset, long position, int length, Handler<AsyncResult<Buffer>> handler) Reads length bytes of data from the file at position position in the file, asynchronously.
FileSystem	FileSystem.readDir(String path, Handler<AsyncResult<List<String>>> handler) Read the contents of the directory specified by path, asynchronously.
FileSystem	FileSystem.readDir(String path, String filter, Handler<AsyncResult<List<String>>> handler) Read the contents of the directory specified by path, asynchronously.
FileSystem	FileSystem.readFile(String path, Handler<AsyncResult<Buffer>> handler) Reads the entire file as represented by the path path as a Buffer, asynchronously.
FileSystem	FileSystem.readSymlink(String link, Handler<AsyncResult<String>> handler) Returns the path representing the file that the symbolic link specified by link points to, asynchronously.
FileSystem	FileSystem.symlink(String link, String existing, Handler<AsyncResult<Void>> handler) Create a symbolic link on the file system from link to existing, asynchronously.
FileSystem	FileSystem.truncate(String path, long len, Handler<AsyncResult<Void>> handler) Truncate the file represented by path to length len in bytes, asynchronously.
FileSystem	FileSystem.unlink(String link, Handler<AsyncResult<Void>> handler) Unlinks the link on the file system represented by the path link, asynchronously.
AsyncFile	AsyncFile.write(Buffer 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
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 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.
HttpConnection	HttpConnection.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, this is called when the underlying connection is closed and the response was still using the connection.
HttpClient	HttpClient.connectionHandler(Handler<HttpConnection> handler) Set a connection handler for the client.
HttpClientRequest	HttpClientRequest.connectionHandler(Handler<HttpConnection> handler) Set a connection handler called when an HTTP connection has been established.
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.
HttpServerRequest	HttpServerRequest.customFrameHandler(Handler<HttpFrame> handler) Set a custom frame handler.
HttpClientResponse	HttpClientResponse.customFrameHandler(Handler<HttpFrame> handler) Set an custom frame handler.
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(RequestOptions options, Handler<HttpClientResponse> responseHandler) Create an HTTP DELETE request to send to the server with the specified options, 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)
HttpClientRequest	HttpClientRequest.drainHandler(Handler<Void> handler)
ServerWebSocket	ServerWebSocket.drainHandler(Handler<Void> handler)
HttpServerResponse	HttpServerResponse.drainHandler(Handler<Void> handler)
WebSocketBase	WebSocketBase.endHandler(Handler<Void> endHandler)
HttpServerRequest	HttpServerRequest.endHandler(Handler<Void> endHandler)
HttpServerFileUpload	HttpServerFileUpload.endHandler(Handler<Void> endHandler)
WebSocket	WebSocket.endHandler(Handler<Void> endHandler)
HttpClientRequest	HttpClientRequest.endHandler(Handler<Void> endHandler)
ServerWebSocket	ServerWebSocket.endHandler(Handler<Void> endHandler)
HttpServerResponse	HttpServerResponse.endHandler(Handler<Void> handler) Set an end handler for the response.
HttpClientResponse	HttpClientResponse.endHandler(Handler<Void> endHandler)
WebSocketBase	WebSocketBase.exceptionHandler(Handler<Throwable> handler)
HttpServerRequest	HttpServerRequest.exceptionHandler(Handler<Throwable> handler)
HttpServerFileUpload	HttpServerFileUpload.exceptionHandler(Handler<Throwable> handler)
HttpConnection	HttpConnection.exceptionHandler(Handler<Throwable> handler) Set an handler called when a connection error happens
WebSocket	WebSocket.exceptionHandler(Handler<Throwable> handler)
HttpClientRequest	HttpClientRequest.exceptionHandler(Handler<Throwable> handler)
HttpServer	HttpServer.exceptionHandler(Handler<Throwable> handler) Set an exception handler called for socket errors happening before the HTTP connection is established, e.g during the TLS handshake.
ServerWebSocket	ServerWebSocket.exceptionHandler(Handler<Throwable> handler)
HttpServerResponse	HttpServerResponse.exceptionHandler(Handler<Throwable> handler)
HttpClientResponse	HttpClientResponse.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(RequestOptions options, Handler<HttpClientResponse> responseHandler) Create an HTTP GET request to send to the server with the specified options, 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(RequestOptions options, Handler<HttpClientResponse> responseHandler) Sends an HTTP GET request to the server with the specified options, 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
HttpConnection	HttpConnection.goAwayHandler(Handler<GoAway> handler) Set an handler called when a GOAWAY frame is received.
WebSocketBase	WebSocketBase.handler(Handler<Buffer> handler)
HttpServerRequest	HttpServerRequest.handler(Handler<Buffer> handler)
HttpServerFileUpload	HttpServerFileUpload.handler(Handler<Buffer> handler)
WebSocket	WebSocket.handler(Handler<Buffer> handler)
ServerWebSocket	ServerWebSocket.handler(Handler<Buffer> handler)
HttpClientResponse	HttpClientResponse.handler(Handler<Buffer> handler)
HttpClientRequest	HttpClientRequest.handler(Handler<HttpClientResponse> 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(RequestOptions options, Handler<HttpClientResponse> responseHandler) Create an HTTP HEAD request to send to the server with the specified options, 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(RequestOptions options, Handler<HttpClientResponse> responseHandler) Sends an HTTP HEAD request to the server with the specified options, 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).
HttpServer	HttpServer.listen(SocketAddress address, Handler<AsyncResult<HttpServer>> listenHandler) Tell the server to start listening on the given address supplying a handler that will be called when the server is actually listening (or has failed).
HttpClientRequest	HttpClient.options(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler) 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(RequestOptions options, Handler<HttpClientResponse> responseHandler) Create an HTTP OPTIONS request to send to the server with the specified options, 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(RequestOptions options, Handler<HttpClientResponse> responseHandler) Sends an HTTP OPTIONS request to the server with the specified options, 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
HttpConnection	HttpConnection.ping(Buffer data, Handler<AsyncResult<Buffer>> pongHandler) Send a PING frame to the remote endpoint.
HttpConnection	HttpConnection.pingHandler(Handler<Buffer> handler) Set an handler notified when a PING frame is received from the remote endpoint.
WebSocketBase	WebSocketBase.pongHandler(Handler<Buffer> handler) Set a pong message handler on the connection.
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(RequestOptions options, Handler<HttpClientResponse> responseHandler) Create an HTTP POST request to send to the server with the specified options, 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
HttpServerResponse	HttpServerResponse.push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler) Like HttpServerResponse.push(HttpMethod, String, String, MultiMap, Handler) with the host copied from the current request.
HttpServerResponse	HttpServerResponse.push(HttpMethod method, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler) Like HttpServerResponse.push(HttpMethod, String, String, MultiMap, Handler) with the host copied from the current request.
HttpServerResponse	HttpServerResponse.push(HttpMethod method, String host, String path, Handler<AsyncResult<HttpServerResponse>> handler) Like HttpServerResponse.push(HttpMethod, String, String, MultiMap, Handler) with no headers.
HttpServerResponse	HttpServerResponse.push(HttpMethod method, String host, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler) Push a response to the client. The handler will be notified with a success when the push can be sent and with a failure when the client has disabled push or reset the push before it has been sent. The handler may be queued if the client has reduced the maximum number of streams the server can push concurrently. Push can be sent only for peer initiated streams and if the response is not ended.
HttpClientRequest	HttpClientRequest.pushHandler(Handler<HttpClientRequest> handler) Set a push handler for this request. The handler is called when the client receives a push promise from the server.
HttpClientRequest	HttpClient.put(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler) 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(RequestOptions options, Handler<HttpClientResponse> responseHandler) Create an HTTP PUT request to send to the server with the specified options, 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
HttpConnection	HttpConnection.remoteSettingsHandler(Handler<Http2Settings> handler) Set an handler that is called when remote endpoint Http2Settings are updated.
HttpClientRequest	HttpClient.request(HttpMethod method, int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler) 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, RequestOptions options, Handler<HttpClientResponse> responseHandler) Create an HTTP request to send to the server with the specified options, specifying a response handler to receive
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.
HttpClientRequest	HttpClientRequest.sendHead(Handler<HttpVersion> completionHandler) Like HttpClientRequest.sendHead() but with an handler after headers have been sent.
HttpConnection	HttpConnection.shutdownHandler(Handler<Void> handler) Set an handler called when a GOAWAY frame has been sent or received and all connections are closed.
HttpServerRequest	HttpServerRequest.streamPriorityHandler(Handler<StreamPriority> handler) Set an handler for stream priority changes
HttpClientResponse	HttpClientResponse.streamPriorityHandler(Handler<StreamPriority> handler) Set an handler for stream priority changes.
WebSocketBase	WebSocketBase.textMessageHandler(Handler<String> handler) Set a text message handler on the connection.
HttpConnection	HttpConnection.updateSettings(Http2Settings settings, Handler<AsyncResult<Void>> completionHandler) Send to the remote endpoint an update of this endpoint settings The completionHandler will be notified when the remote endpoint has acknowledged the settings.
HttpServerRequest	HttpServerRequest.uploadHandler(Handler<HttpServerFileUpload> uploadHandler) Set an upload handler.
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(RequestOptions options, Handler<WebSocket> wsConnect) Connect a WebSocket with the specified options
HttpClient	HttpClient.websocket(RequestOptions options, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket with the specified options
HttpClient	HttpClient.websocket(RequestOptions options, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket with the specified options
HttpClient	HttpClient.websocket(RequestOptions options, MultiMap headers, Handler<WebSocket> wsConnect) Connect a WebSocket with the specified options, and with the specified headers
HttpClient	HttpClient.websocket(RequestOptions options, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket with the specified options, and with the specified headers
HttpClient	HttpClient.websocket(RequestOptions options, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket with the specified options, and with the specified headers
HttpClient	HttpClient.websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect) Connect a WebSocket with the specified optionsI, with the specified headers and using the specified version of WebSockets
HttpClient	HttpClient.websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket with the specified options, with the specified headers and using the specified version of WebSockets
HttpClient	HttpClient.websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket with the specified options, with the specified headers and using the specified version of WebSockets
HttpClient	HttpClient.websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect) Connect a WebSocket with the specified options, with the specified headers, using the specified version of WebSockets, and the specified websocket sub protocols
HttpClient	HttpClient.websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket with the specified options, with the specified headers, using the specified version of WebSockets, and the specified websocket sub protocols
HttpClient	HttpClient.websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket with the specified options, 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
HttpClient	HttpClient.websocketAbs(String url, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket with the specified absolute url, with the specified headers, using the specified version of WebSockets, and the specified websocket sub protocols.
HttpClient	HttpClient.websocketAbs(String url, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler) Connect a WebSocket with the specified absolute url, 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.
NetClient	NetClient.connect(int port, String host, String serverName, Handler<AsyncResult<NetSocket>> connectHandler) Open a connection to a server at the specific port and host.
NetClient	NetClient.connect(SocketAddress remoteAddress, Handler<AsyncResult<NetSocket>> connectHandler) Open a connection to a server at the specific remoteAddress.
NetClient	NetClient.connect(SocketAddress remoteAddress, String serverName, Handler<AsyncResult<NetSocket>> connectHandler) Open a connection to a server at the specific remoteAddress.
NetServer	NetServer.connectHandler(Handler<NetSocket> handler) Supply a connect handler for this server.
NetSocket	NetSocket.drainHandler(Handler<Void> handler)
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)
NetServer	NetServer.listen(Handler<AsyncResult<NetServer>> listenHandler) Like NetServer.listen() but providing a handler that will be notified when the server is listening, or fails.
NetServer	NetServer.listen(int port, Handler<AsyncResult<NetServer>> listenHandler) Like NetServer.listen(int) but providing a handler that will be notified when the server is listening, or fails.
NetServer	NetServer.listen(int port, String host, Handler<AsyncResult<NetServer>> listenHandler) Like NetServer.listen(int, String) but providing a handler that will be notified when the server is listening, or fails.
NetServer	NetServer.listen(SocketAddress localAddress, Handler<AsyncResult<NetServer>> listenHandler) Like NetServer.listen(SocketAddress) but providing a handler that will be notified when the server is listening, or fails.
default NetSocket	NetSocket.sendFile(String filename, Handler<AsyncResult<Void>> resultHandler) Same as NetSocket.sendFile(String) but also takes a handler that will be called when the send has completed or a failure has occurred
default NetSocket	NetSocket.sendFile(String filename, long offset, Handler<AsyncResult<Void>> resultHandler) Same as NetSocket.sendFile(String, long) but also takes a handler that will be called when the send has completed or a failure has occurred
NetSocket	NetSocket.sendFile(String filename, long offset, long length, Handler<AsyncResult<Void>> resultHandler) Same as NetSocket.sendFile(String, long, long) but also takes a handler that will be called when the send has completed or a failure has occurred
NetSocket	NetSocket.upgradeToSsl(Handler<Void> handler) Upgrade channel to use SSL/TLS.
NetSocket	NetSocket.upgradeToSsl(String serverName, Handler<Void> handler) Upgrade channel to use SSL/TLS.
NetSocket	NetSocket.write(Buffer message, Handler<AsyncResult<Void>> handler) Like WriteStream.write(Object) but with an handler called when the message has been written or failed to be written.

Uses of Handler in io.vertx.core.parsetools

Subinterfaces of Handler in io.vertx.core.parsetools

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

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

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

Uses of Handler in io.vertx.core.shareddata

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

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

Uses of Handler in io.vertx.core.spi

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

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

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

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

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

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

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

Modifier and Type	Method and Description
void	ResolverProvider.close(Handler<Void> doneHandler)

Uses of Handler in io.vertx.core.streams

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

Modifier and Type	Method and Description
WriteStream<T>	WriteStream.drainHandler(Handler<Void> handler) Set a drain handler on the stream.
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.