io.vertx.core.http

## Interface HttpClient

- All Superinterfaces:
    Measured

      public interface HttpClient
      extends Measured

  An asynchronous HTTP client.

  It allows you to make requests to HTTP servers, and a single client can make requests to any server.

  It also allows you to open WebSockets to servers.

  The client can also pool HTTP connections.

  For pooling to occur, keep-alive must be true on the `HttpClientOptions` (default is true). In this case connections will be pooled and re-used if there are pending HTTP requests waiting to get a connection, otherwise they will be closed.

  This gives the benefits of keep alive when the client is loaded but means we don't keep connections hanging around unnecessarily when there would be no benefits anyway.

  The client also supports pipe-lining of requests. Pipe-lining means another request is sent on the same connection before the response from the preceding one has returned. Pipe-lining is not appropriate for all requests.

  To enable pipe-lining, it must be enabled on the `HttpClientOptions` (default is false).

  When pipe-lining is enabled the connection will be automatically closed when all in-flight responses have returned and there are no outstanding pending requests to write.

  The client is designed to be reused between requests.

  Author:
    Tim Fox

- - ### Method Summary

    All Methods Instance Methods Abstract Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `close()` Close the client.
    `HttpClient` | `connectionHandler(Handler<HttpConnection> handler)` Set a connection handler for the client.
    `HttpClientRequest` | `delete(int port, String host, String requestURI)` Create an HTTP DELETE request to send to the server at the specified host and port.
    `HttpClientRequest` | `delete(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `delete(RequestOptions options)` Create an HTTP DELETE request to send to the server with the specified options.
    `HttpClientRequest` | `delete(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `delete(String requestURI)` Create an HTTP DELETE request to send to the server at the default host and port.
    `HttpClientRequest` | `delete(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `delete(String host, String requestURI)` Create an HTTP DELETE request to send to the server at the specified host and default port.
    `HttpClientRequest` | `delete(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `deleteAbs(String absoluteURI)` Create an HTTP DELETE request to send to the server using an absolute URI
    `HttpClientRequest` | `deleteAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `get(int port, String host, String requestURI)` Create an HTTP GET request to send to the server at the specified host and port.
    `HttpClientRequest` | `get(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `get(RequestOptions options)` Create an HTTP GET request to send to the server with the specified options.
    `HttpClientRequest` | `get(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `get(String requestURI)` Create an HTTP GET request to send to the server at the default host and port.
    `HttpClientRequest` | `get(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `get(String host, String requestURI)` Create an HTTP GET request to send to the server at the specified host and default port.
    `HttpClientRequest` | `get(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `getAbs(String absoluteURI)` Create an HTTP GET request to send to the server using an absolute URI
    `HttpClientRequest` | `getAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClient` | `getNow(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClient` | `getNow(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClient` | `getNow(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClient` | `getNow(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `head(int port, String host, String requestURI)` Create an HTTP HEAD request to send to the server at the specified host and port.
    `HttpClientRequest` | `head(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `head(RequestOptions options)` Create an HTTP HEAD request to send to the server with the specified options.
    `HttpClientRequest` | `head(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `head(String requestURI)` Create an HTTP HEAD request to send to the server at the default host and port.
    `HttpClientRequest` | `head(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `head(String host, String requestURI)` Create an HTTP HEAD request to send to the server at the specified host and default port.
    `HttpClientRequest` | `head(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `headAbs(String absoluteURI)` Create an HTTP HEAD request to send to the server using an absolute URI
    `HttpClientRequest` | `headAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClient` | `headNow(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClient` | `headNow(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClient` | `headNow(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClient` | `headNow(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `options(int port, String host, String requestURI)` Create an HTTP OPTIONS request to send to the server at the specified host and port.
    `HttpClientRequest` | `options(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `options(RequestOptions options)` Create an HTTP OPTIONS request to send to the server with the specified options.
    `HttpClientRequest` | `options(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `options(String requestURI)` Create an HTTP OPTIONS request to send to the server at the default host and port.
    `HttpClientRequest` | `options(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `options(String host, String requestURI)` Create an HTTP OPTIONS request to send to the server at the specified host and default port.
    `HttpClientRequest` | `options(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `optionsAbs(String absoluteURI)` Create an HTTP OPTIONS request to send to the server using an absolute URI
    `HttpClientRequest` | `optionsAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClient` | `optionsNow(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClient` | `optionsNow(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClient` | `optionsNow(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClient` | `optionsNow(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `post(int port, String host, String requestURI)` Create an HTTP POST request to send to the server at the specified host and port.
    `HttpClientRequest` | `post(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `post(RequestOptions options)` Create an HTTP POST request to send to the server with the specified options.
    `HttpClientRequest` | `post(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `post(String requestURI)` Create an HTTP POST request to send to the server at the default host and port.
    `HttpClientRequest` | `post(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `post(String host, String requestURI)` Create an HTTP POST request to send to the server at the specified host and default port.
    `HttpClientRequest` | `post(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `postAbs(String absoluteURI)` Create an HTTP POST request to send to the server using an absolute URI
    `HttpClientRequest` | `postAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `put(int port, String host, String requestURI)` Create an HTTP PUT request to send to the server at the specified host and port.
    `HttpClientRequest` | `put(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `put(RequestOptions options)` Create an HTTP PUT request to send to the server with the specified options.
    `HttpClientRequest` | `put(RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `put(String requestURI)` Create an HTTP PUT request to send to the server at the default host and port.
    `HttpClientRequest` | `put(String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `put(String host, String requestURI)` Create an HTTP PUT request to send to the server at the specified host and default port.
    `HttpClientRequest` | `put(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `putAbs(String absoluteURI)` Create an HTTP PUT request to send to the server using an absolute URI
    `HttpClientRequest` | `putAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `java.util.function.Function<HttpClientResponse,Future<HttpClientRequest>>` | `redirectHandler()`
    `HttpClient` | `redirectHandler(java.util.function.Function<HttpClientResponse,Future<HttpClientRequest>> handler)` Set a redirect handler for the http client.
    `HttpClientRequest` | `request(HttpMethod method, int port, String host, String requestURI)` Create an HTTP request to send to the server at the specified host and port.
    `HttpClientRequest` | `request(HttpMethod method, int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `request(HttpMethod method, RequestOptions options)` Create an HTTP request to send to the server with the specified options.
    `HttpClientRequest` | `request(HttpMethod method, RequestOptions options, Handler<HttpClientResponse> responseHandler)` Deprecated. this method will break in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`
    `HttpClientRequest` | `request(HttpMethod method, SocketAddress serverAddress, int port, String host, String requestURI)` Like `request(HttpMethod, int, String, String)` using the `serverAddress` parameter to connect to the server instead of the `absoluteURI` parameter.
    `HttpClientRequest` | `request(HttpMethod method, SocketAddress serverAddress, int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Like `request(HttpMethod, int, String, String, Handler)` using the `serverAddress` parameter to connect to the server instead of the `absoluteURI` parameter.
    `HttpClientRequest` | `request(HttpMethod method, SocketAddress serverAddress, RequestOptions options)` Like `request(HttpMethod, RequestOptions)` using the `serverAddress` parameter to connect to the server instead of the `absoluteURI` parameter.
    `HttpClientRequest` | `request(HttpMethod method, SocketAddress serverAddress, RequestOptions options, Handler<HttpClientResponse> responseHandler)` Like `request(HttpMethod, RequestOptions, Handler)` using the `serverAddress` parameter to connect to the server instead of the `absoluteURI` parameter.
    `HttpClientRequest` | `request(HttpMethod method, String requestURI)` Create an HTTP request to send to the server at the default host and port.
    `HttpClientRequest` | `request(HttpMethod method, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `request(HttpMethod method, String host, String requestURI)` Create an HTTP request to send to the server at the specified host and default port.
    `HttpClientRequest` | `request(HttpMethod method, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `HttpClientRequest` | `requestAbs(HttpMethod method, SocketAddress serverAddress, String absoluteURI)` Like `requestAbs(HttpMethod, String)` using the `serverAddress` parameter to connect to the server instead of the `absoluteURI` parameter.
    `HttpClientRequest` | `requestAbs(HttpMethod method, SocketAddress serverAddress, String absoluteURI, Handler<HttpClientResponse> responseHandler)` Like `requestAbs(HttpMethod, String, Handler)` using the `serverAddress` parameter to connect to the server instead of the `absoluteURI` parameter.
    `HttpClientRequest` | `requestAbs(HttpMethod method, String absoluteURI)` Create an HTTP request to send to the server using an absolute URI
    `HttpClientRequest` | `requestAbs(HttpMethod method, String absoluteURI, Handler<HttpClientResponse> responseHandler)` Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
    `void` | `webSocket(int port, String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket to the specified port, host and relative request URI
    `HttpClient` | `websocket(int port, String host, String requestURI, Handler<WebSocket> wsConnect)` Deprecated. use `webSocket(int, String, String, Handler)` instead
    `HttpClient` | `websocket(int port, String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `webSocket(int, String, String, Handler)` instead
    `HttpClient` | `websocket(int port, String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | `websocket(int port, String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | `websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | `websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | `websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | `websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | `websocket(RequestOptions options, Handler<WebSocket> wsConnect)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | `websocket(RequestOptions options, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | `websocket(RequestOptions options, MultiMap headers, Handler<WebSocket> wsConnect)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | `websocket(RequestOptions options, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | `websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | `websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | `websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | `websocket(RequestOptions options, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `void` | `webSocket(String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket at the relative request URI using the default host and port
    `HttpClient` | `websocket(String requestURI, Handler<WebSocket> wsConnect)` Deprecated. use `webSocket(String, Handler)` instead
    `HttpClient` | `websocket(String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `webSocket(String, Handler)` instead
    `HttpClient` | `websocket(String requestURI, MultiMap headers, Handler<WebSocket> wsConnect)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | `websocket(String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | `websocket(String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | `websocket(String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | `websocket(String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | `websocket(String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `void` | `webSocket(String host, String requestURI, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket to the host and relative request URI and default port
    `HttpClient` | `websocket(String host, String requestURI, Handler<WebSocket> wsConnect)` Deprecated. use `webSocket(String, String, Handler)` instead
    `HttpClient` | `websocket(String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `webSocket(String, String, Handler)` instead
    `HttpClient` | `websocket(String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | `websocket(String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | `websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | `websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | `websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `HttpClient` | `websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `void` | `webSocket(WebSocketConnectOptions options, Handler<AsyncResult<WebSocket>> handler)` Connect a WebSocket with the specified options.
    `void` | `webSocketAbs(String url, MultiMap headers, WebsocketVersion version, List<String> subProtocols, Handler<AsyncResult<WebSocket>> handler)` 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` | `websocketAbs(String url, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `ReadStream<WebSocket>` | `websocketStream(int port, String host, String requestURI)` Deprecated. use `webSocket(int, String, String, Handler)` instead
    `ReadStream<WebSocket>` | `websocketStream(int port, String host, String requestURI, MultiMap headers)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `ReadStream<WebSocket>` | `websocketStream(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `ReadStream<WebSocket>` | `websocketStream(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `ReadStream<WebSocket>` | `websocketStream(RequestOptions options)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `ReadStream<WebSocket>` | `websocketStream(RequestOptions options, MultiMap headers)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `ReadStream<WebSocket>` | `websocketStream(RequestOptions options, MultiMap headers, WebsocketVersion version)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `ReadStream<WebSocket>` | `websocketStream(RequestOptions options, MultiMap headers, WebsocketVersion version, String subProtocols)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `ReadStream<WebSocket>` | `websocketStream(String requestURI)` Deprecated. use `webSocket(String, Handler)` instead
    `ReadStream<WebSocket>` | `websocketStream(String requestURI, MultiMap headers)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `ReadStream<WebSocket>` | `websocketStream(String requestURI, MultiMap headers, WebsocketVersion version)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `ReadStream<WebSocket>` | `websocketStream(String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `ReadStream<WebSocket>` | `websocketStream(String host, String requestURI)` Deprecated. use `webSocket(String, String, Handler)` instead
    `ReadStream<WebSocket>` | `websocketStream(String host, String requestURI, MultiMap headers)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `ReadStream<WebSocket>` | `websocketStream(String host, String requestURI, MultiMap headers, WebsocketVersion version)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `ReadStream<WebSocket>` | `websocketStream(String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
    `ReadStream<WebSocket>` | `websocketStreamAbs(String url, MultiMap headers, WebsocketVersion version, String subProtocols)` Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead

    - ### Methods inherited from interface io.vertx.core.metrics.Measured

      `isMetricsEnabled`

- - ### Method Detail

    - #### request

          HttpClientRequest request(HttpMethod method,
                                    SocketAddress serverAddress,
                                    RequestOptions options)

      Like `request(HttpMethod, RequestOptions)` using the `serverAddress` parameter to connect to the server instead of the `absoluteURI` parameter.

      The request host header will still be created from the `options` parameter.

      Use `SocketAddress.domainSocketAddress(String)` to connect to a unix domain socket server.

    - #### request

          HttpClientRequest request(HttpMethod method,
                                    RequestOptions options)

      Create an HTTP request to send to the server with the specified options.
      Parameters:
        `method` - the HTTP method
        `options` - the request options
      Returns:
        an HTTP client request object

    - #### request

          HttpClientRequest request(HttpMethod method,
                                    int port,
                                    String host,
                                    String requestURI)

      Create an HTTP request to send to the server at the specified host and port.
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
      Returns:
        an HTTP client request object

    - #### request

          HttpClientRequest request(HttpMethod method,
                                    SocketAddress serverAddress,
                                    int port,
                                    String host,
                                    String requestURI)

      Like `request(HttpMethod, int, String, String)` using the `serverAddress` parameter to connect to the server instead of the `absoluteURI` parameter.

      The request host header will still be created from the `host` and `port` parameters.

      Use `SocketAddress.domainSocketAddress(String)` to connect to a unix domain socket server.

    - #### request

          HttpClientRequest request(HttpMethod method,
                                    String host,
                                    String requestURI)

      Create an HTTP request to send to the server at the specified host and default port.
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
      Returns:
        an HTTP client request object

    - #### request

          @Deprecated
          HttpClientRequest request(HttpMethod method,
                                                RequestOptions options,
                                                Handler<HttpClientResponse> responseHandler)

      Deprecated. this method will break in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`
      Create an HTTP request to send to the server with the specified options, specifying a response handler to receive
      Parameters:
        `method` - the HTTP method
        `options` - the request options
      Returns:
        an HTTP client request object

    - #### request

          HttpClientRequest request(HttpMethod method,
                                    SocketAddress serverAddress,
                                    RequestOptions options,
                                    Handler<HttpClientResponse> responseHandler)

      Like `request(HttpMethod, RequestOptions, Handler)` using the `serverAddress` parameter to connect to the server instead of the `absoluteURI` parameter.

      The request host header will still be created from the `options` parameter.

      Use `SocketAddress.domainSocketAddress(String)` to connect to a unix domain socket server.

    - #### request

          @Deprecated
          HttpClientRequest request(HttpMethod method,
                                                int port,
                                                String host,
                                                String requestURI,
                                                Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### request

          HttpClientRequest request(HttpMethod method,
                                    SocketAddress serverAddress,
                                    int port,
                                    String host,
                                    String requestURI,
                                    Handler<HttpClientResponse> responseHandler)

      Like `request(HttpMethod, int, String, String, Handler)` using the `serverAddress` parameter to connect to the server instead of the `absoluteURI` parameter.

      The request host header will still be created from the `host` and `port` parameters.

      Use `SocketAddress.domainSocketAddress(String)` to connect to a unix domain socket server.

    - #### request

          @Deprecated
          HttpClientRequest request(HttpMethod method,
                                                String host,
                                                String requestURI,
                                                Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### request

          HttpClientRequest request(HttpMethod method,
                                    String requestURI)

      Create an HTTP request to send to the server at the default host and port.
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
      Returns:
        an HTTP client request object

    - #### request

          @Deprecated
          HttpClientRequest request(HttpMethod method,
                                                String requestURI,
                                                Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### requestAbs

          HttpClientRequest requestAbs(HttpMethod method,
                                       String absoluteURI)

      Create an HTTP request to send to the server using an absolute URI
      Parameters:
        `method` - the HTTP method
        `absoluteURI` - the absolute URI
      Returns:
        an HTTP client request object

    - #### requestAbs

          HttpClientRequest requestAbs(HttpMethod method,
                                       SocketAddress serverAddress,
                                       String absoluteURI)

      Like `requestAbs(HttpMethod, String)` using the `serverAddress` parameter to connect to the server instead of the `absoluteURI` parameter.

      The request host header will still be created from the `absoluteURI` parameter.

      Use `SocketAddress.domainSocketAddress(String)` to connect to a unix domain socket server.

    - #### requestAbs

          @Deprecated
          HttpClientRequest requestAbs(HttpMethod method,
                                                   String absoluteURI,
                                                   Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP request to send to the server using an absolute URI, specifying a response handler to receive the response
      Parameters:
        `method` - the HTTP method
        `absoluteURI` - the absolute URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### requestAbs

          HttpClientRequest requestAbs(HttpMethod method,
                                       SocketAddress serverAddress,
                                       String absoluteURI,
                                       Handler<HttpClientResponse> responseHandler)

      Like `requestAbs(HttpMethod, String, Handler)` using the `serverAddress` parameter to connect to the server instead of the `absoluteURI` parameter.

      The request host header will still be created from the `absoluteURI` parameter.

      Use `SocketAddress.domainSocketAddress(String)` to connect to a unix domain socket server.

    - #### get

          HttpClientRequest get(RequestOptions options)

      Create an HTTP GET request to send to the server with the specified options.
      Parameters:
        `options` - the request options
      Returns:
        an HTTP client request object

    - #### get

          HttpClientRequest get(int port,
                                String host,
                                String requestURI)

      Create an HTTP GET request to send to the server at the specified host and port.
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
      Returns:
        an HTTP client request object

    - #### get

          HttpClientRequest get(String host,
                                String requestURI)

      Create an HTTP GET request to send to the server at the specified host and default port.
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
      Returns:
        an HTTP client request object

    - #### get

          @Deprecated
          HttpClientRequest get(RequestOptions options,
                                            Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP GET request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### get

          @Deprecated
          HttpClientRequest get(int port,
                                            String host,
                                            String requestURI,
                                            Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP GET request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### get

          @Deprecated
          HttpClientRequest get(String host,
                                            String requestURI,
                                            Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      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
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### get

          HttpClientRequest get(String requestURI)

      Create an HTTP GET request to send to the server at the default host and port.
      Parameters:
        `requestURI` - the relative URI
      Returns:
        an HTTP client request object

    - #### get

          @Deprecated
          HttpClientRequest get(String requestURI,
                                            Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP GET request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### getAbs

          HttpClientRequest getAbs(String absoluteURI)

      Create an HTTP GET request to send to the server using an absolute URI
      Parameters:
        `absoluteURI` - the absolute URI
      Returns:
        an HTTP client request object

    - #### getAbs

          @Deprecated
          HttpClientRequest getAbs(String absoluteURI,
                                               Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP GET request to send to the server using an absolute URI, specifying a response handler to receive the response
      Parameters:
        `absoluteURI` - the absolute URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### getNow

          @Deprecated
          HttpClient getNow(RequestOptions options,
                                        Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Sends an HTTP GET request to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `responseHandler` - the response handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### getNow

          @Deprecated
          HttpClient getNow(int port,
                                        String host,
                                        String requestURI,
                                        Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Sends an HTTP GET request to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### getNow

          @Deprecated
          HttpClient getNow(String host,
                                        String requestURI,
                                        Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Sends an HTTP GET request to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### getNow

          @Deprecated
          HttpClient getNow(String requestURI,
                                        Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Sends an HTTP GET request to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### post

          HttpClientRequest post(RequestOptions options)

      Create an HTTP POST request to send to the server with the specified options.
      Parameters:
        `options` - the request options
      Returns:
        an HTTP client request object

    - #### post

          HttpClientRequest post(int port,
                                 String host,
                                 String requestURI)

      Create an HTTP POST request to send to the server at the specified host and port.
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
      Returns:
        an HTTP client request object

    - #### post

          HttpClientRequest post(String host,
                                 String requestURI)

      Create an HTTP POST request to send to the server at the specified host and default port.
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
      Returns:
        an HTTP client request object

    - #### post

          @Deprecated
          HttpClientRequest post(RequestOptions options,
                                             Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### post

          @Deprecated
          HttpClientRequest post(int port,
                                             String host,
                                             String requestURI,
                                             Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### post

          @Deprecated
          HttpClientRequest post(String host,
                                             String requestURI,
                                             Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      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
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### post

          HttpClientRequest post(String requestURI)

      Create an HTTP POST request to send to the server at the default host and port.
      Parameters:
        `requestURI` - the relative URI
      Returns:
        an HTTP client request object

    - #### post

          @Deprecated
          HttpClientRequest post(String requestURI,
                                             Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### postAbs

          HttpClientRequest postAbs(String absoluteURI)

      Create an HTTP POST request to send to the server using an absolute URI
      Parameters:
        `absoluteURI` - the absolute URI
      Returns:
        an HTTP client request object

    - #### postAbs

          @Deprecated
          HttpClientRequest postAbs(String absoluteURI,
                                                Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP POST request to send to the server using an absolute URI, specifying a response handler to receive the response
      Parameters:
        `absoluteURI` - the absolute URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### head

          HttpClientRequest head(RequestOptions options)

      Create an HTTP HEAD request to send to the server with the specified options.
      Parameters:
        `options` - the request options
      Returns:
        an HTTP client request object

    - #### head

          HttpClientRequest head(int port,
                                 String host,
                                 String requestURI)

      Create an HTTP HEAD request to send to the server at the specified host and port.
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
      Returns:
        an HTTP client request object

    - #### head

          HttpClientRequest head(String host,
                                 String requestURI)

      Create an HTTP HEAD request to send to the server at the specified host and default port.
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
      Returns:
        an HTTP client request object

    - #### head

          @Deprecated
          HttpClientRequest head(RequestOptions options,
                                             Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP HEAD request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### head

          @Deprecated
          HttpClientRequest head(int port,
                                             String host,
                                             String requestURI,
                                             Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP HEAD request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### head

          @Deprecated
          HttpClientRequest head(String host,
                                             String requestURI,
                                             Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      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
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### head

          HttpClientRequest head(String requestURI)

      Create an HTTP HEAD request to send to the server at the default host and port.
      Parameters:
        `requestURI` - the relative URI
      Returns:
        an HTTP client request object

    - #### head

          @Deprecated
          HttpClientRequest head(String requestURI,
                                             Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP HEAD request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### headAbs

          HttpClientRequest headAbs(String absoluteURI)

      Create an HTTP HEAD request to send to the server using an absolute URI
      Parameters:
        `absoluteURI` - the absolute URI
      Returns:
        an HTTP client request object

    - #### headAbs

          @Deprecated
          HttpClientRequest headAbs(String absoluteURI,
                                                Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP HEAD request to send to the server using an absolute URI, specifying a response handler to receive the response
      Parameters:
        `absoluteURI` - the absolute URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### headNow

          @Deprecated
          HttpClient headNow(RequestOptions options,
                                         Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Sends an HTTP HEAD request to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `responseHandler` - the response handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### headNow

          @Deprecated
          HttpClient headNow(int port,
                                         String host,
                                         String requestURI,
                                         Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Sends an HTTP HEAD request to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### headNow

          @Deprecated
          HttpClient headNow(String host,
                                         String requestURI,
                                         Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Sends an HTTP HEAD request to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### headNow

          @Deprecated
          HttpClient headNow(String requestURI,
                                         Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Sends an HTTP HEAD request to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### options

          HttpClientRequest options(RequestOptions options)

      Create an HTTP OPTIONS request to send to the server with the specified options.
      Parameters:
        `options` - the request options
      Returns:
        an HTTP client request object

    - #### options

          HttpClientRequest options(int port,
                                    String host,
                                    String requestURI)

      Create an HTTP OPTIONS request to send to the server at the specified host and port.
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
      Returns:
        an HTTP client request object

    - #### options

          HttpClientRequest options(String host,
                                    String requestURI)

      Create an HTTP OPTIONS request to send to the server at the specified host and default port.
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
      Returns:
        an HTTP client request object

    - #### options

          @Deprecated
          HttpClientRequest options(RequestOptions options,
                                                Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP OPTIONS request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### options

          @Deprecated
          HttpClientRequest options(int port,
                                                String host,
                                                String requestURI,
                                                Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP OPTIONS request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### options

          @Deprecated
          HttpClientRequest options(String host,
                                                String requestURI,
                                                Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      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
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### options

          HttpClientRequest options(String requestURI)

      Create an HTTP OPTIONS request to send to the server at the default host and port.
      Parameters:
        `requestURI` - the relative URI
      Returns:
        an HTTP client request object

    - #### options

          @Deprecated
          HttpClientRequest options(String requestURI,
                                                Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP OPTIONS request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### optionsAbs

          HttpClientRequest optionsAbs(String absoluteURI)

      Create an HTTP OPTIONS request to send to the server using an absolute URI
      Parameters:
        `absoluteURI` - the absolute URI
      Returns:
        an HTTP client request object

    - #### optionsAbs

          @Deprecated
          HttpClientRequest optionsAbs(String absoluteURI,
                                                   Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP OPTIONS request to send to the server using an absolute URI, specifying a response handler to receive the response
      Parameters:
        `absoluteURI` - the absolute URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### optionsNow

          @Deprecated
          HttpClient optionsNow(RequestOptions options,
                                            Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Sends an HTTP OPTIONS request to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `responseHandler` - the response handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### optionsNow

          @Deprecated
          HttpClient optionsNow(int port,
                                            String host,
                                            String requestURI,
                                            Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Sends an HTTP OPTIONS request to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### optionsNow

          @Deprecated
          HttpClient optionsNow(String host,
                                            String requestURI,
                                            Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Sends an HTTP OPTIONS request to the server at the specified host and default port, specifying a response handler to receive the response
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### optionsNow

          @Deprecated
          HttpClient optionsNow(String requestURI,
                                            Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Sends an HTTP OPTIONS request to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### put

          HttpClientRequest put(RequestOptions options)

      Create an HTTP PUT request to send to the server with the specified options.
      Parameters:
        `options` - the request options
      Returns:
        an HTTP client request object

    - #### put

          HttpClientRequest put(int port,
                                String host,
                                String requestURI)

      Create an HTTP PUT request to send to the server at the specified host and port.
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
      Returns:
        an HTTP client request object

    - #### put

          HttpClientRequest put(String host,
                                String requestURI)

      Create an HTTP PUT request to send to the server at the specified host and default port.
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
      Returns:
        an HTTP client request object

    - #### put

          @Deprecated
          HttpClientRequest put(RequestOptions options,
                                            Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### put

          @Deprecated
          HttpClientRequest put(int port,
                                            String host,
                                            String requestURI,
                                            Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### put

          @Deprecated
          HttpClientRequest put(String host,
                                            String requestURI,
                                            Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      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
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### put

          HttpClientRequest put(String requestURI)

      Create an HTTP PUT request to send to the server at the default host and port.
      Parameters:
        `requestURI` - the relative URI
      Returns:
        an HTTP client request object

    - #### put

          @Deprecated
          HttpClientRequest put(String requestURI,
                                            Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### putAbs

          HttpClientRequest putAbs(String absoluteURI)

      Create an HTTP PUT request to send to the server using an absolute URI
      Parameters:
        `absoluteURI` - the absolute URI
      Returns:
        an HTTP client request object

    - #### putAbs

          @Deprecated
          HttpClientRequest putAbs(String absoluteURI,
                                               Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP PUT request to send to the server using an absolute URI, specifying a response handler to receive the response
      Parameters:
        `absoluteURI` - the absolute URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### delete

          HttpClientRequest delete(RequestOptions options)

      Create an HTTP DELETE request to send to the server with the specified options.
      Parameters:
        `options` - the request options
      Returns:
        an HTTP client request object

    - #### delete

          HttpClientRequest delete(int port,
                                   String host,
                                   String requestURI)

      Create an HTTP DELETE request to send to the server at the specified host and port.
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
      Returns:
        an HTTP client request object

    - #### delete

          HttpClientRequest delete(String host,
                                   String requestURI)

      Create an HTTP DELETE request to send to the server at the specified host and default port.
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
      Returns:
        an HTTP client request object

    - #### delete

          @Deprecated
          HttpClientRequest delete(RequestOptions options,
                                               Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP DELETE request to send to the server with the specified options, specifying a response handler to receive the response
      Parameters:
        `options` - the request options
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### delete

          @Deprecated
          HttpClientRequest delete(int port,
                                               String host,
                                               String requestURI,
                                               Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP DELETE request to send to the server at the specified host and port, specifying a response handler to receive the response
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### delete

          @Deprecated
          HttpClientRequest delete(String host,
                                               String requestURI,
                                               Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      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
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### delete

          HttpClientRequest delete(String requestURI)

      Create an HTTP DELETE request to send to the server at the default host and port.
      Parameters:
        `requestURI` - the relative URI
      Returns:
        an HTTP client request object

    - #### delete

          @Deprecated
          HttpClientRequest delete(String requestURI,
                                               Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP DELETE request to send to the server at the default host and port, specifying a response handler to receive the response
      Parameters:
        `requestURI` - the relative URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### deleteAbs

          HttpClientRequest deleteAbs(String absoluteURI)

      Create an HTTP DELETE request to send to the server using an absolute URI
      Parameters:
        `absoluteURI` - the absolute URI
      Returns:
        an HTTP client request object

    - #### deleteAbs

          @Deprecated
          HttpClientRequest deleteAbs(String absoluteURI,
                                                  Handler<HttpClientResponse> responseHandler)

      Deprecated. this method signature will change in Vert.x 4, the handler will use an `Handler<AsyncResult<HttpClientResponse>>`, you can use instead the WebClient
      Create an HTTP DELETE request to send to the server using an absolute URI, specifying a response handler to receive the response
      Parameters:
        `absoluteURI` - the absolute URI
        `responseHandler` - the response handler
      Returns:
        an HTTP client request object

    - #### websocket

          @Deprecated
          HttpClient websocket(RequestOptions options,
                                           Handler<WebSocket> wsConnect)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Connect a WebSocket with the specified options
      Parameters:
        `options` - the request options
        `wsConnect` - handler that will be called with the WebSocket when connected
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(int port,
                                           String host,
                                           String requestURI,
                                           Handler<WebSocket> wsConnect)

      Deprecated. use `webSocket(int, String, String, Handler)` instead
      Connect a WebSocket to the specified port, host and relative request URI
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `wsConnect` - handler that will be called with the WebSocket when connected
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(RequestOptions options,
                                           Handler<WebSocket> wsConnect,
                                           Handler<Throwable> failureHandler)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Connect a WebSocket with the specified options
      Parameters:
        `options` - the request options
        `wsConnect` - handler that will be called with the WebSocket when connected
        `failureHandler` - handler that will be called if WebSocket connection fails
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(int port,
                                           String host,
                                           String requestURI,
                                           Handler<WebSocket> wsConnect,
                                           Handler<Throwable> failureHandler)

      Deprecated. use `webSocket(int, String, String, Handler)` instead
      Connect a WebSocket to the specified port, host and relative request URI
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `wsConnect` - handler that will be called with the WebSocket when connected
        `failureHandler` - handler that will be called if WebSocket connection fails
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(String host,
                                           String requestURI,
                                           Handler<WebSocket> wsConnect)

      Deprecated. use `webSocket(String, String, Handler)` instead
      Connect a WebSocket to the host and relative request URI and default port
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `wsConnect` - handler that will be called with the WebSocket when connected
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(String host,
                                           String requestURI,
                                           Handler<WebSocket> wsConnect,
                                           Handler<Throwable> failureHandler)

      Deprecated. use `webSocket(String, String, Handler)` instead
      Connect a WebSocket to the host and relative request URI and default port
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `wsConnect` - handler that will be called with the WebSocket when connected
        `failureHandler` - handler that will be called if WebSocket connection fails
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(RequestOptions options,
                                           MultiMap headers,
                                           Handler<WebSocket> wsConnect)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Connect a WebSocket with the specified options, and with the specified headers
      Parameters:
        `options` - the request options
        `headers` - the headers
        `wsConnect` - handler that will be called with the WebSocket when connected
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(int port,
                                           String host,
                                           String requestURI,
                                           MultiMap headers,
                                           Handler<WebSocket> wsConnect)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Connect a WebSocket to the specified port, host and relative request URI, and with the specified headers
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `wsConnect` - handler that will be called with the WebSocket when connected
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(RequestOptions options,
                                           MultiMap headers,
                                           Handler<WebSocket> wsConnect,
                                           Handler<Throwable> failureHandler)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Connect a WebSocket with the specified options, and with the specified headers
      Parameters:
        `options` - the request options
        `headers` - the headers
        `wsConnect` - handler that will be called with the WebSocket when connected
        `failureHandler` - handler that will be called if WebSocket connection fails
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(int port,
                                           String host,
                                           String requestURI,
                                           MultiMap headers,
                                           Handler<WebSocket> wsConnect,
                                           Handler<Throwable> failureHandler)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Connect a WebSocket to the specified port, host and relative request URI, and with the specified headers
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `wsConnect` - handler that will be called with the WebSocket when connected
        `failureHandler` - handler that will be called if WebSocket connection fails
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(String host,
                                           String requestURI,
                                           MultiMap headers,
                                           Handler<WebSocket> wsConnect)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Connect a WebSocket to the specified host,relative request UR, and default port and with the specified headers
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `wsConnect` - handler that will be called with the WebSocket when connected
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(String host,
                                           String requestURI,
                                           MultiMap headers,
                                           Handler<WebSocket> wsConnect,
                                           Handler<Throwable> failureHandler)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Connect a WebSocket to the specified host,relative request UR, and default port and with the specified headers
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `wsConnect` - handler that will be called with the WebSocket when connected
        `failureHandler` - handler that will be called if WebSocket connection fails
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(RequestOptions options,
                                           MultiMap headers,
                                           WebsocketVersion version,
                                           Handler<WebSocket> wsConnect)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Connect a WebSocket with the specified optionsI, with the specified headers and using the specified version of WebSockets
      Parameters:
        `options` - the request options
        `headers` - the headers
        `version` - the WebSocket version
        `wsConnect` - handler that will be called with the WebSocket when connected
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(int port,
                                           String host,
                                           String requestURI,
                                           MultiMap headers,
                                           WebsocketVersion version,
                                           Handler<WebSocket> wsConnect)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Connect a WebSocket to the specified port, host and relative request URI, with the specified headers and using the specified version of WebSockets
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `version` - the WebSocket version
        `wsConnect` - handler that will be called with the WebSocket when connected
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(RequestOptions options,
                                           MultiMap headers,
                                           WebsocketVersion version,
                                           Handler<WebSocket> wsConnect,
                                           Handler<Throwable> failureHandler)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Connect a WebSocket with the specified options, with the specified headers and using the specified version of WebSockets
      Parameters:
        `options` - the request options
        `headers` - the headers
        `version` - the WebSocket version
        `wsConnect` - handler that will be called with the WebSocket when connected
        `failureHandler` - handler that will be called if WebSocket connection fails
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(int port,
                                           String host,
                                           String requestURI,
                                           MultiMap headers,
                                           WebsocketVersion version,
                                           Handler<WebSocket> wsConnect,
                                           Handler<Throwable> failureHandler)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Connect a WebSocket to the specified port, host and relative request URI, with the specified headers and using the specified version of WebSockets
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `version` - the WebSocket version
        `wsConnect` - handler that will be called with the WebSocket when connected
        `failureHandler` - handler that will be called if WebSocket connection fails
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(String host,
                                           String requestURI,
                                           MultiMap headers,
                                           WebsocketVersion version,
                                           Handler<WebSocket> wsConnect)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Connect a WebSocket to the specified host, relative request URI and default port with the specified headers and using the specified version of WebSockets
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `version` - the WebSocket version
        `wsConnect` - handler that will be called with the WebSocket when connected
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(String host,
                                           String requestURI,
                                           MultiMap headers,
                                           WebsocketVersion version,
                                           Handler<WebSocket> wsConnect,
                                           Handler<Throwable> failureHandler)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Connect a WebSocket to the specified host, relative request URI and default port with the specified headers and using the specified version of WebSockets
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `version` - the WebSocket version
        `wsConnect` - handler that will be called with the WebSocket when connected
        `failureHandler` - handler that will be called if WebSocket connection fails
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(RequestOptions options,
                                           MultiMap headers,
                                           WebsocketVersion version,
                                           String subProtocols,
                                           Handler<WebSocket> wsConnect)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Connect a WebSocket with the specified options, with the specified headers, using the specified version of WebSockets, and the specified WebSocket sub protocols
      Parameters:
        `options` - the request options
        `headers` - the headers
        `version` - the WebSocket version
        `subProtocols` - the subprotocols to use
        `wsConnect` - handler that will be called with the WebSocket when connected
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(int port,
                                           String host,
                                           String requestURI,
                                           MultiMap headers,
                                           WebsocketVersion version,
                                           String subProtocols,
                                           Handler<WebSocket> wsConnect)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      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
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `version` - the WebSocket version
        `subProtocols` - the subprotocols to use
        `wsConnect` - handler that will be called with the WebSocket when connected
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocketAbs

          @Deprecated
          HttpClient websocketAbs(String url,
                                              MultiMap headers,
                                              WebsocketVersion version,
                                              String subProtocols,
                                              Handler<WebSocket> wsConnect,
                                              Handler<Throwable> failureHandler)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Connect a WebSocket with the specified absolute url, with the specified headers, using the specified version of WebSockets, and the specified WebSocket sub protocols.
      Parameters:
        `url` - the absolute url
        `headers` - the headers
        `version` - the WebSocket version
        `subProtocols` - the subprotocols to use
        `wsConnect` - handler that will be called with the WebSocket when connected
        `failureHandler` - handler that will be called if WebSocket connection fails
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(RequestOptions options,
                                           MultiMap headers,
                                           WebsocketVersion version,
                                           String subProtocols,
                                           Handler<WebSocket> wsConnect,
                                           Handler<Throwable> failureHandler)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Connect a WebSocket with the specified options, with the specified headers, using the specified version of WebSockets, and the specified WebSocket sub protocols
      Parameters:
        `options` - the request options
        `headers` - the headers
        `version` - the WebSocket version
        `subProtocols` - the subprotocols to use
        `wsConnect` - handler that will be called with the WebSocket when connected
        `failureHandler` - handler that will be called if WebSocket connection fails
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(int port,
                                           String host,
                                           String requestURI,
                                           MultiMap headers,
                                           WebsocketVersion version,
                                           String subProtocols,
                                           Handler<WebSocket> wsConnect,
                                           Handler<Throwable> failureHandler)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      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
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `version` - the WebSocket version
        `subProtocols` - the subprotocols to use
        `wsConnect` - handler that will be called with the WebSocket when connected
        `failureHandler` - handler that will be called if WebSocket connection fails
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(String host,
                                           String requestURI,
                                           MultiMap headers,
                                           WebsocketVersion version,
                                           String subProtocols,
                                           Handler<WebSocket> wsConnect)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      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
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `version` - the WebSocket version
        `subProtocols` - the subprotocols to use
        `wsConnect` - handler that will be called with the WebSocket when connected
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(String host,
                                           String requestURI,
                                           MultiMap headers,
                                           WebsocketVersion version,
                                           String subProtocols,
                                           Handler<WebSocket> wsConnect,
                                           Handler<Throwable> failureHandler)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      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
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `version` - the WebSocket version
        `subProtocols` - the subprotocols to use
        `wsConnect` - handler that will be called with the WebSocket when connected
        `failureHandler` - handler that will be called if WebSocket connection fails
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(String requestURI,
                                           Handler<WebSocket> wsConnect)

      Deprecated. use `webSocket(String, Handler)` instead
      Connect a WebSocket at the relative request URI using the default host and port
      Parameters:
        `requestURI` - the relative URI
        `wsConnect` - handler that will be called with the WebSocket when connected
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(String requestURI,
                                           Handler<WebSocket> wsConnect,
                                           Handler<Throwable> failureHandler)

      Deprecated. use `webSocket(String, Handler)` instead
      Connect a WebSocket at the relative request URI using the default host and port
      Parameters:
        `requestURI` - the relative URI
        `wsConnect` - handler that will be called with the WebSocket when connected
        `failureHandler` - handler that will be called if WebSocket connection fails
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(String requestURI,
                                           MultiMap headers,
                                           Handler<WebSocket> wsConnect)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Connect a WebSocket at the relative request URI using the default host and port and the specified headers
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `wsConnect` - handler that will be called with the WebSocket when connected
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(String requestURI,
                                           MultiMap headers,
                                           Handler<WebSocket> wsConnect,
                                           Handler<Throwable> failureHandler)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Connect a WebSocket at the relative request URI using the default host and port and the specified headers
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `wsConnect` - handler that will be called with the WebSocket when connected
        `failureHandler` - handler that will be called if WebSocket connection fails
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(String requestURI,
                                           MultiMap headers,
                                           WebsocketVersion version,
                                           Handler<WebSocket> wsConnect)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Connect a WebSocket at the relative request URI using the default host and port, the specified headers and the specified version of WebSockets
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `version` - the WebSocket version
        `wsConnect` - handler that will be called with the WebSocket when connected
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(String requestURI,
                                           MultiMap headers,
                                           WebsocketVersion version,
                                           Handler<WebSocket> wsConnect,
                                           Handler<Throwable> failureHandler)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Connect a WebSocket at the relative request URI using the default host and port, the specified headers and the specified version of WebSockets
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `version` - the WebSocket version
        `wsConnect` - handler that will be called with the WebSocket when connected
        `failureHandler` - handler that will be called if WebSocket connection fails
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(String requestURI,
                                           MultiMap headers,
                                           WebsocketVersion version,
                                           String subProtocols,
                                           Handler<WebSocket> wsConnect)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      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
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `version` - the WebSocket version
        `subProtocols` - the subprotocols
        `wsConnect` - handler that will be called with the WebSocket when connected
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocket

          @Deprecated
          HttpClient websocket(String requestURI,
                                           MultiMap headers,
                                           WebsocketVersion version,
                                           String subProtocols,
                                           Handler<WebSocket> wsConnect,
                                           Handler<Throwable> failureHandler)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      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
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `version` - the WebSocket version
        `subProtocols` - the subprotocols
        `wsConnect` - handler that will be called with the WebSocket when connected
        `failureHandler` - handler that will be called if WebSocket connection fails
      Returns:
        a reference to this, so the API can be used fluently

    - #### webSocket

          void webSocket(int port,
                         String host,
                         String requestURI,
                         Handler<AsyncResult<WebSocket>> handler)

      Connect a WebSocket to the specified port, host and relative request URI
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `handler` - handler that will be called with the WebSocket when connected

    - #### webSocket

          void webSocket(String host,
                         String requestURI,
                         Handler<AsyncResult<WebSocket>> handler)

      Connect a WebSocket to the host and relative request URI and default port
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `handler` - handler that will be called with the WebSocket when connected

    - #### webSocket

          void webSocket(String requestURI,
                         Handler<AsyncResult<WebSocket>> handler)

      Connect a WebSocket at the relative request URI using the default host and port
      Parameters:
        `requestURI` - the relative URI
        `handler` - handler that will be called with the WebSocket when connected

    - #### webSocket

          void webSocket(WebSocketConnectOptions options,
                         Handler<AsyncResult<WebSocket>> handler)

      Connect a WebSocket with the specified options.
      Parameters:
        `options` - the request options

    - #### webSocketAbs

          void webSocketAbs(String url,
                            MultiMap headers,
                            WebsocketVersion version,
                            List<String> subProtocols,
                            Handler<AsyncResult<WebSocket>> handler)

      Connect a WebSocket with the specified absolute url, with the specified headers, using the specified version of WebSockets, and the specified WebSocket sub protocols.
      Parameters:
        `url` - the absolute url
        `headers` - the headers
        `version` - the WebSocket version
        `subProtocols` - the subprotocols to use
        `handler` - handler that will be called if WebSocket connection fails

    - #### websocketStream

          @Deprecated
          ReadStream<WebSocket> websocketStream(RequestOptions options)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Create a WebSocket stream with the specified options
      Parameters:
        `options` - the request options
      Returns:
        a stream emitting a WebSocket event when the client connection has been upgraded to a WebSocket

    - #### websocketStream

          @Deprecated
          ReadStream<WebSocket> websocketStream(int port,
                                                            String host,
                                                            String requestURI)

      Deprecated. use `webSocket(int, String, String, Handler)` instead
      Create a WebSocket stream to the specified port, host and relative request URI
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
      Returns:
        a stream emitting a WebSocket event when the client connection has been upgraded to a WebSocket

    - #### websocketStream

          @Deprecated
          ReadStream<WebSocket> websocketStream(String host,
                                                            String requestURI)

      Deprecated. use `webSocket(String, String, Handler)` instead
      Create a WebSocket stream to the specified host, relative request URI and default port
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
      Returns:
        a stream emitting a WebSocket event when the client connection has been upgraded to a WebSocket

    - #### websocketStream

          @Deprecated
          ReadStream<WebSocket> websocketStream(RequestOptions options,
                                                            MultiMap headers)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Create a WebSocket stream with the specified options, and with the specified headers
      Parameters:
        `options` - the request options
        `headers` - the headers
      Returns:
        a stream emitting a WebSocket event when the client connection has been upgraded to a WebSocket

    - #### websocketStream

          @Deprecated
          ReadStream<WebSocket> websocketStream(int port,
                                                            String host,
                                                            String requestURI,
                                                            MultiMap headers)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Create a WebSocket stream to the specified port, host and relative request URI, and with the specified headers
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
      Returns:
        a stream emitting a WebSocket event when the client connection has been upgraded to a WebSocket

    - #### websocketStream

          @Deprecated
          ReadStream<WebSocket> websocketStream(String host,
                                                            String requestURI,
                                                            MultiMap headers)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Create a WebSocket stream to the specified host, relative request URI and default port and with the specified headers
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
      Returns:
        a stream emitting a WebSocket event when the client connection has been upgraded to a WebSocket

    - #### websocketStream

          @Deprecated
          ReadStream<WebSocket> websocketStream(RequestOptions options,
                                                            MultiMap headers,
                                                            WebsocketVersion version)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Create a WebSocket stream with the specified options, with the specified headers and using the specified version of WebSockets
      Parameters:
        `options` - the request options
        `headers` - the headers
        `version` - the WebSocket version
      Returns:
        a stream emitting a WebSocket event when the client connection has been upgraded to a WebSocket

    - #### websocketStream

          @Deprecated
          ReadStream<WebSocket> websocketStream(int port,
                                                            String host,
                                                            String requestURI,
                                                            MultiMap headers,
                                                            WebsocketVersion version)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Create a WebSocket stream to the specified port, host and relative request URI, with the specified headers and using the specified version of WebSockets
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `version` - the WebSocket version
      Returns:
        a stream emitting a WebSocket event when the client connection has been upgraded to a WebSocket

    - #### websocketStream

          @Deprecated
          ReadStream<WebSocket> websocketStream(String host,
                                                            String requestURI,
                                                            MultiMap headers,
                                                            WebsocketVersion version)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Create a WebSocket stream with the specified options and with the specified headers and using the specified version of WebSockets
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `version` - the WebSocket version
      Returns:
        a stream emitting a WebSocket event when the client connection has been upgraded to a WebSocket

    - #### websocketStreamAbs

          @Deprecated
          ReadStream<WebSocket> websocketStreamAbs(String url,
                                                               MultiMap headers,
                                                               WebsocketVersion version,
                                                               String subProtocols)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Create a WebSocket stream with the specified absolute url, the specified headers, using the specified version of WebSockets, and the specified WebSocket sub protocols.
      Parameters:
        `url` - the absolute url
        `headers` - the headers
        `version` - the WebSocket version
        `subProtocols` - the subprotocols to use
      Returns:
        a stream emitting a WebSocket event when the client connection has been upgraded to a WebSocket

    - #### websocketStream

          @Deprecated
          ReadStream<WebSocket> websocketStream(RequestOptions options,
                                                            MultiMap headers,
                                                            WebsocketVersion version,
                                                            String subProtocols)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Create a WebSocket stream 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
      Parameters:
        `options` - the request options
        `headers` - the headers
        `version` - the WebSocket version
        `subProtocols` - the subprotocols to use
      Returns:
        a stream emitting a WebSocket event when the client connection has been upgraded to a WebSocket

    - #### websocketStream

          @Deprecated
          ReadStream<WebSocket> websocketStream(int port,
                                                            String host,
                                                            String requestURI,
                                                            MultiMap headers,
                                                            WebsocketVersion version,
                                                            String subProtocols)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Create a WebSocket stream 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
      Parameters:
        `port` - the port
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `version` - the WebSocket version
        `subProtocols` - the subprotocols to use
      Returns:
        a stream emitting a WebSocket event when the client connection has been upgraded to a WebSocket

    - #### websocketStream

          @Deprecated
          ReadStream<WebSocket> websocketStream(String host,
                                                            String requestURI,
                                                            MultiMap headers,
                                                            WebsocketVersion version,
                                                            String subProtocols)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Create a WebSocket stream 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
      Parameters:
        `host` - the host
        `requestURI` - the relative URI
        `headers` - the headers
        `version` - the WebSocket version
        `subProtocols` - the subprotocols to use
      Returns:
        a stream emitting a WebSocket event when the client connection has been upgraded to a WebSocket

    - #### websocketStream

          @Deprecated
          ReadStream<WebSocket> websocketStream(String requestURI)

      Deprecated. use `webSocket(String, Handler)` instead
      Create a WebSocket stream at the relative request URI using the default host and port and the specified headers
      Parameters:
        `requestURI` - the relative URI
      Returns:
        a stream emitting a WebSocket event when the client connection has been upgraded to a WebSocket

    - #### websocketStream

          @Deprecated
          ReadStream<WebSocket> websocketStream(String requestURI,
                                                            MultiMap headers)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Create a WebSocket stream at the relative request URI using the default host and port and the specified headers
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
      Returns:
        a stream emitting a WebSocket event when the client connection has been upgraded to a WebSocket

    - #### websocketStream

          @Deprecated
          ReadStream<WebSocket> websocketStream(String requestURI,
                                                            MultiMap headers,
                                                            WebsocketVersion version)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Create a WebSocket stream at the relative request URI using the default host and port, the specified headers and the specified version of WebSockets
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `version` - the WebSocket version
      Returns:
        a stream emitting a WebSocket event when the client connection has been upgraded to a WebSocket

    - #### websocketStream

          @Deprecated
          ReadStream<WebSocket> websocketStream(String requestURI,
                                                            MultiMap headers,
                                                            WebsocketVersion version,
                                                            String subProtocols)

      Deprecated. use `webSocket(WebSocketConnectOptions, Handler)` instead
      Create a WebSocket stream at the relative request URI using the default host and port, the specified headers, the specified version of WebSockets and the specified sub protocols
      Parameters:
        `requestURI` - the relative URI
        `headers` - the headers
        `version` - the WebSocket version
        `subProtocols` - the subprotocols
      Returns:
        a stream emitting a WebSocket event when the client connection has been upgraded to a WebSocket

    - #### connectionHandler

          HttpClient connectionHandler(Handler<HttpConnection> handler)

      Set a connection handler for the client. This handler is called when a new connection is established.
      Returns:
        a reference to this, so the API can be used fluently

    - #### redirectHandler

          HttpClient redirectHandler(java.util.function.Function<HttpClientResponse,Future<HttpClientRequest>> handler)

      Set a redirect handler for the http client.

      The redirect handler is called when a `3xx` response is received and the request is configured to follow redirects with `HttpClientRequest.setFollowRedirects(boolean)`.

      The redirect handler is passed the `HttpClientResponse`, it can return an `HttpClientRequest` or `null`.

      - when null is returned, the original response is processed by the original request response handler
      - when a new `Future<HttpClientRequest>` is returned, the client will send this new request
      The new request will get a copy of the previous request headers unless headers are set. In this case, the client assumes that the redirect handler exclusively managers the headers of the new request.

      The handler must return a `Future<HttpClientRequest>` unsent so the client can further configure it and send it.

      Parameters:
        `handler` - the new redirect handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### redirectHandler

          java.util.function.Function<HttpClientResponse,Future<HttpClientRequest>> redirectHandler()

      Returns:
        the current redirect handler.

    - #### close

          void close()

      Close the client. Closing will close down any pooled connections. Clients should always be closed after use.

Copyright © 2020 Eclipse. All rights reserved.