Package io.vertx.mutiny.core.http

Class HttpClient

java.lang.Object
io.vertx.mutiny.core.http.HttpClient
All Implemented Interfaces:
MutinyDelegate, Measured
public class HttpClient extends Object implements MutinyDelegate, Measured
An asynchronous HTTP client.

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

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 is designed to be reused between requests.

NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.

  • Field Details

  • Constructor Details

    • HttpClient

      public HttpClient(io.vertx.core.http.HttpClient delegate)

    • HttpClient

      public HttpClient(Object delegate)

  • Method Details

    • getDelegate

      public io.vertx.core.http.HttpClient getDelegate()
      Specified by:
      getDelegate in interface Measured
      Specified by:
      getDelegate in interface MutinyDelegate
      Returns:
      the delegate used by this Mutiny object of generated type

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • equals

      public boolean equals(Object o)
      Overrides:
      equals in class Object

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • isMetricsEnabled

      public boolean isMetricsEnabled()
      Specified by:
      isMetricsEnabled in interface Measured
      Returns:
      true if metrics are enabled

    • request

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpClientRequest> request(io.vertx.core.http.RequestOptions options)
      Create an HTTP request to send to the server. The handler is called when the request is ready to be sent.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      options - the request options
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • requestAndAwait

      public HttpClientRequest requestAndAwait(io.vertx.core.http.RequestOptions options)
      Blocking variant of request(RequestOptions).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      options - the request options
      Returns:
      the HttpClientRequest instance produced by the operation.

    • requestAndForget

      public void requestAndForget(io.vertx.core.http.RequestOptions options)
      Variant of request(RequestOptions) that ignores the result of the operation.

      This method subscribes on the result of request(RequestOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from request(RequestOptions) but you don't need to compose it with other operations.

      Parameters:
      options - the request options

    • request

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpClientRequest> request(io.vertx.core.http.HttpMethod method, int port, String host, String requestURI)
      Create an HTTP request to send to the server at the host and port. The handler is called when the request is ready to be sent.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      method - the HTTP method
      port - the port
      host - the host
      requestURI - the relative URI
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • requestAndAwait

      public HttpClientRequest requestAndAwait(io.vertx.core.http.HttpMethod method, int port, String host, String requestURI)
      Blocking variant of request(HttpMethod,int,String,String).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      method - the HTTP method
      port - the port
      host - the host
      requestURI - the relative URI
      Returns:
      the HttpClientRequest instance produced by the operation.

    • requestAndForget

      public void requestAndForget(io.vertx.core.http.HttpMethod method, int port, String host, String requestURI)
      Variant of request(HttpMethod,int,String,String) that ignores the result of the operation.

      This method subscribes on the result of request(HttpMethod,int,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from request(HttpMethod,int,String,String) but you don't need to compose it with other operations.

      Parameters:
      method - the HTTP method
      port - the port
      host - the host
      requestURI - the relative URI

    • request

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpClientRequest> request(io.vertx.core.http.HttpMethod method, String host, String requestURI)
      Create an HTTP request to send to the server at the host and default port. The handler is called when the request is ready to be sent.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      method - the HTTP method
      host - the host
      requestURI - the relative URI
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • requestAndAwait

      public HttpClientRequest requestAndAwait(io.vertx.core.http.HttpMethod method, String host, String requestURI)
      Blocking variant of request(HttpMethod,String,String).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      method - the HTTP method
      host - the host
      requestURI - the relative URI
      Returns:
      the HttpClientRequest instance produced by the operation.

    • requestAndForget

      public void requestAndForget(io.vertx.core.http.HttpMethod method, String host, String requestURI)
      Variant of request(HttpMethod,String,String) that ignores the result of the operation.

      This method subscribes on the result of request(HttpMethod,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from request(HttpMethod,String,String) but you don't need to compose it with other operations.

      Parameters:
      method - the HTTP method
      host - the host
      requestURI - the relative URI

    • request

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpClientRequest> request(io.vertx.core.http.HttpMethod method, String requestURI)
      Create an HTTP request to send to the server at the default host and port. The handler is called when the request is ready to be sent.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      method - the HTTP method
      requestURI - the relative URI
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • requestAndAwait

      public HttpClientRequest requestAndAwait(io.vertx.core.http.HttpMethod method, String requestURI)
      Blocking variant of request(HttpMethod,String).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      method - the HTTP method
      requestURI - the relative URI
      Returns:
      the HttpClientRequest instance produced by the operation.

    • requestAndForget

      public void requestAndForget(io.vertx.core.http.HttpMethod method, String requestURI)
      Variant of request(HttpMethod,String) that ignores the result of the operation.

      This method subscribes on the result of request(HttpMethod,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from request(HttpMethod,String) but you don't need to compose it with other operations.

      Parameters:
      method - the HTTP method
      requestURI - the relative URI

    • webSocket

      @CheckReturnValue @Deprecated public io.smallrye.mutiny.Uni<WebSocket> webSocket(int port, String host, String requestURI)
      Deprecated.
      instead use WebSocketClient#connect(int, String, String, Handler)
      Connect a WebSocket to the specified port, host and relative request URI

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      port - the port
      host - the host
      requestURI - the relative URI
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • webSocketAndAwait

      @Deprecated public WebSocket webSocketAndAwait(int port, String host, String requestURI)
      Deprecated.
      instead use WebSocketClient#connect(int, String, String, Handler)
      Blocking variant of webSocket(int,String,String).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      port - the port
      host - the host
      requestURI - the relative URI
      Returns:
      the WebSocket instance produced by the operation.

    • webSocketAndForget

      @Deprecated public void webSocketAndForget(int port, String host, String requestURI)
      Deprecated.
      instead use WebSocketClient#connect(int, String, String, Handler)
      Variant of webSocket(int,String,String) that ignores the result of the operation.

      This method subscribes on the result of webSocket(int,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from webSocket(int,String,String) but you don't need to compose it with other operations.

      Parameters:
      port - the port
      host - the host
      requestURI - the relative URI

    • webSocket

      @CheckReturnValue @Deprecated public io.smallrye.mutiny.Uni<WebSocket> webSocket(String host, String requestURI)
      Deprecated.
      instead use WebSocketClient#connect(int, String, String, Handler)
      Connect a WebSocket to the host and relative request URI and default port

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      host - the host
      requestURI - the relative URI
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • webSocketAndAwait

      @Deprecated public WebSocket webSocketAndAwait(String host, String requestURI)
      Deprecated.
      instead use WebSocketClient#connect(int, String, String, Handler)
      Blocking variant of webSocket(String,String).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      host - the host
      requestURI - the relative URI
      Returns:
      the WebSocket instance produced by the operation.

    • webSocketAndForget

      @Deprecated public void webSocketAndForget(String host, String requestURI)
      Deprecated.
      instead use WebSocketClient#connect(int, String, String, Handler)
      Variant of webSocket(String,String) that ignores the result of the operation.

      This method subscribes on the result of webSocket(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from webSocket(String,String) but you don't need to compose it with other operations.

      Parameters:
      host - the host
      requestURI - the relative URI

    • webSocket

      @CheckReturnValue @Deprecated public io.smallrye.mutiny.Uni<WebSocket> webSocket(String requestURI)
      Deprecated.
      instead use WebSocketClient#connect(int, String, String, Handler)
      Connect a WebSocket at the relative request URI using the default host and port

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      requestURI - the relative URI
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • webSocketAndAwait

      @Deprecated public WebSocket webSocketAndAwait(String requestURI)
      Deprecated.
      instead use WebSocketClient#connect(int, String, String, Handler)
      Blocking variant of webSocket(String).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      requestURI - the relative URI
      Returns:
      the WebSocket instance produced by the operation.

    • webSocketAndForget

      @Deprecated public void webSocketAndForget(String requestURI)
      Deprecated.
      instead use WebSocketClient#connect(int, String, String, Handler)
      Variant of webSocket(String) that ignores the result of the operation.

      This method subscribes on the result of webSocket(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from webSocket(String) but you don't need to compose it with other operations.

      Parameters:
      requestURI - the relative URI

    • webSocket

      @CheckReturnValue @Deprecated public io.smallrye.mutiny.Uni<WebSocket> webSocket(io.vertx.core.http.WebSocketConnectOptions options)
      Deprecated.
      instead use WebSocketClient#connect(WebSocketConnectOptions, Handler)
      Connect a WebSocket with the specified options.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      options - the request options
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • webSocketAndAwait

      @Deprecated public WebSocket webSocketAndAwait(io.vertx.core.http.WebSocketConnectOptions options)
      Deprecated.
      instead use WebSocketClient#connect(WebSocketConnectOptions, Handler)
      Blocking variant of webSocket(WebSocketConnectOptions).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      options - the request options
      Returns:
      the WebSocket instance produced by the operation.

    • webSocketAndForget

      @Deprecated public void webSocketAndForget(io.vertx.core.http.WebSocketConnectOptions options)
      Deprecated.
      instead use WebSocketClient#connect(WebSocketConnectOptions, Handler)
      Variant of webSocket(WebSocketConnectOptions) that ignores the result of the operation.

      This method subscribes on the result of webSocket(WebSocketConnectOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from webSocket(WebSocketConnectOptions) but you don't need to compose it with other operations.

      Parameters:
      options - the request options

    • webSocketAbs

      @CheckReturnValue @Deprecated public io.smallrye.mutiny.Uni<WebSocket> webSocketAbs(String url, MultiMap headers, io.vertx.core.http.WebsocketVersion version, List<String> subProtocols)
      Deprecated.
      instead use WebSocketClient#connect(WebSocketConnectOptions, 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.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      url - the absolute url
      headers - the headers
      version - the WebSocket version
      subProtocols - the subprotocols to use
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • webSocketAbsAndAwait

      @Deprecated public WebSocket webSocketAbsAndAwait(String url, MultiMap headers, io.vertx.core.http.WebsocketVersion version, List<String> subProtocols)
      Deprecated.
      instead use WebSocketClient#connect(WebSocketConnectOptions, Handler)
      Blocking variant of webSocketAbs(String,io.vertx.mutiny.core.MultiMap,WebsocketVersion,List).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      url - the absolute url
      headers - the headers
      version - the WebSocket version
      subProtocols - the subprotocols to use
      Returns:
      the WebSocket instance produced by the operation.

    • webSocketAbsAndForget

      @Deprecated public void webSocketAbsAndForget(String url, MultiMap headers, io.vertx.core.http.WebsocketVersion version, List<String> subProtocols)
      Deprecated.
      instead use WebSocketClient#connect(WebSocketConnectOptions, Handler)
      Variant of webSocketAbs(String,io.vertx.mutiny.core.MultiMap,WebsocketVersion,List) that ignores the result of the operation.

      This method subscribes on the result of webSocketAbs(String,io.vertx.mutiny.core.MultiMap,WebsocketVersion,List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from webSocketAbs(String,io.vertx.mutiny.core.MultiMap,WebsocketVersion,List) but you don't need to compose it with other operations.

      Parameters:
      url - the absolute url
      headers - the headers
      version - the WebSocket version
      subProtocols - the subprotocols to use

    • updateSSLOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<Boolean> updateSSLOptions(io.vertx.core.net.SSLOptions options)
      Like updateSSLOptions(io.vertx.core.net.SSLOptions) but supplying a handler that will be called when the update happened (or has failed).

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      options - the new SSL options
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • updateSSLOptionsAndAwait

      public Boolean updateSSLOptionsAndAwait(io.vertx.core.net.SSLOptions options)
      Blocking variant of updateSSLOptions(SSLOptions).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      options - the new SSL options
      Returns:
      the Boolean instance produced by the operation.

    • updateSSLOptionsAndForget

      public void updateSSLOptionsAndForget(io.vertx.core.net.SSLOptions options)
      Variant of updateSSLOptions(SSLOptions) that ignores the result of the operation.

      This method subscribes on the result of updateSSLOptions(SSLOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from updateSSLOptions(SSLOptions) but you don't need to compose it with other operations.

      Parameters:
      options - the new SSL options

    • updateSSLOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<Boolean> updateSSLOptions(io.vertx.core.net.SSLOptions options, boolean force)
      Like updateSSLOptions(io.vertx.core.net.SSLOptions) but supplying a handler that will be called when the update happened (or has failed).

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      options - the new SSL options
      force - force the update when options are equals
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • updateSSLOptionsAndAwait

      public Boolean updateSSLOptionsAndAwait(io.vertx.core.net.SSLOptions options, boolean force)
      Blocking variant of updateSSLOptions(SSLOptions,boolean).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      options - the new SSL options
      force - force the update when options are equals
      Returns:
      the Boolean instance produced by the operation.

    • updateSSLOptionsAndForget

      public void updateSSLOptionsAndForget(io.vertx.core.net.SSLOptions options, boolean force)
      Variant of updateSSLOptions(SSLOptions,boolean) that ignores the result of the operation.

      This method subscribes on the result of updateSSLOptions(SSLOptions,boolean), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from updateSSLOptions(SSLOptions,boolean) but you don't need to compose it with other operations.

      Parameters:
      options - the new SSL options
      force - force the update when options are equals

    • connectionHandler

      @Deprecated public HttpClient connectionHandler(Consumer<HttpConnection> handler)
      Deprecated.
      instead use HttpClientBuilder#withConnectHandler(Handler)
      Parameters:
      handler -
      Returns:

    • redirectHandler

      @Deprecated public HttpClient redirectHandler(Function<HttpClientResponse,io.smallrye.mutiny.Uni<io.vertx.core.http.RequestOptions>> handler)
      Deprecated.
      instead use HttpClientBuilder.withRedirectHandler(Function)
      Parameters:
      handler - the new redirect handler
      Returns:
      a reference to this, so the API can be used fluently

    • close

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> close()
      Close the client. Closing will close down any pooled connections. Clients should always be closed after use.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • closeAndAwait

      public Void closeAndAwait()
      Blocking variant of close().

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Returns:
      the Void instance produced by the operation.

    • closeAndForget

      public void closeAndForget()
      Variant of close() that ignores the result of the operation.

      This method subscribes on the result of close(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from close() but you don't need to compose it with other operations.

    • newInstance

      public static HttpClient newInstance(io.vertx.core.http.HttpClient arg)