Package io.vertx.mutiny.core.http

Class HttpClient

java.lang.Object

io.vertx.mutiny.core.http.HttpClient

All Implemented Interfaces:

Measured

public class HttpClient
extends Object
implements 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.

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

Field Summary

Fields

Modifier and Type	Field	Description
static TypeArg<HttpClient>	__TYPE_ARG

Constructor Summary

Constructors

Constructor	Description
HttpClient(io.vertx.core.http.HttpClient delegate)
HttpClient(Object delegate)

Method Summary

Modifier and Type	Method	Description
io.smallrye.mutiny.Uni<Void>	close()	Close the client.
Void	closeAndAwait()	Blocking variant of close().
void	closeAndForget()	Variant of close() that ignores the result of the operation.
HttpClient	connectionHandler(Consumer<HttpConnection> handler)
boolean	equals(Object o)
io.vertx.core.http.HttpClient	getDelegate()
int	hashCode()
boolean	isMetricsEnabled()
static HttpClient	newInstance(io.vertx.core.http.HttpClient arg)
HttpClient	redirectHandler(Function<HttpClientResponse,io.smallrye.mutiny.Uni<io.vertx.core.http.RequestOptions>> handler)
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.
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.
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.
io.smallrye.mutiny.Uni<HttpClientRequest>	request(io.vertx.core.http.RequestOptions options)	Create an HTTP request to send to the server.
HttpClientRequest	requestAndAwait(io.vertx.core.http.HttpMethod method, int port, String host, String requestURI)	Blocking variant of request(HttpMethod,int,String,String).
HttpClientRequest	requestAndAwait(io.vertx.core.http.HttpMethod method, String requestURI)	Blocking variant of request(HttpMethod,String).
HttpClientRequest	requestAndAwait(io.vertx.core.http.HttpMethod method, String host, String requestURI)	Blocking variant of request(HttpMethod,String,String).
HttpClientRequest	requestAndAwait(io.vertx.core.http.RequestOptions options)	Blocking variant of request(RequestOptions).
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.
void	requestAndForget(io.vertx.core.http.HttpMethod method, String requestURI)	Variant of request(HttpMethod,String) that ignores the result of the operation.
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.
void	requestAndForget(io.vertx.core.http.RequestOptions options)	Variant of request(RequestOptions) that ignores the result of the operation.
String	toString()
io.smallrye.mutiny.Uni<WebSocket>	webSocket(int port, String host, String requestURI)	Connect a WebSocket to the specified port, host and relative request URI
io.smallrye.mutiny.Uni<WebSocket>	webSocket(io.vertx.core.http.WebSocketConnectOptions options)	Connect a WebSocket with the specified options.
io.smallrye.mutiny.Uni<WebSocket>	webSocket(String requestURI)	Connect a WebSocket at the relative request URI using the default host and port
io.smallrye.mutiny.Uni<WebSocket>	webSocket(String host, String requestURI)	Connect a WebSocket to the host and relative request URI and default port
io.smallrye.mutiny.Uni<WebSocket>	webSocketAbs(String url, MultiMap headers, io.vertx.core.http.WebsocketVersion version, List<String> subProtocols)	Connect a WebSocket with the specified absolute url, with the specified headers, using the specified version of WebSockets, and the specified WebSocket sub protocols.
WebSocket	webSocketAbsAndAwait(String url, MultiMap headers, io.vertx.core.http.WebsocketVersion version, List<String> subProtocols)	Blocking variant of io.vertx.mutiny.core.http.HttpClient#webSocketAbs(String,io.vertx.mutiny.core.MultiMap,WebsocketVersion,List).
void	webSocketAbsAndForget(String url, MultiMap headers, io.vertx.core.http.WebsocketVersion version, List<String> subProtocols)	Variant of io.vertx.mutiny.core.http.HttpClient#webSocketAbs(String,io.vertx.mutiny.core.MultiMap,WebsocketVersion,List) that ignores the result of the operation.
WebSocket	webSocketAndAwait(int port, String host, String requestURI)	Blocking variant of webSocket(int,String,String).
WebSocket	webSocketAndAwait(io.vertx.core.http.WebSocketConnectOptions options)	Blocking variant of webSocket(WebSocketConnectOptions).
WebSocket	webSocketAndAwait(String requestURI)	Blocking variant of webSocket(String).
WebSocket	webSocketAndAwait(String host, String requestURI)	Blocking variant of webSocket(String,String).
void	webSocketAndForget(int port, String host, String requestURI)	Variant of webSocket(int,String,String) that ignores the result of the operation.
void	webSocketAndForget(io.vertx.core.http.WebSocketConnectOptions options)	Variant of webSocket(WebSocketConnectOptions) that ignores the result of the operation.
void	webSocketAndForget(String requestURI)	Variant of webSocket(String) that ignores the result of the operation.
void	webSocketAndForget(String host, String requestURI)	Variant of webSocket(String,String) that ignores the result of the operation.

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

__TYPE_ARG

public static final TypeArg<HttpClient> __TYPE_ARG

Constructor Detail

HttpClient

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

HttpClient

public HttpClient(Object delegate)

Method Detail

getDelegate

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

Specified by:

getDelegate in interface Measured

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

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

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

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

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

public io.smallrye.mutiny.Uni<WebSocket> webSocket(int port,
                                                   String host,
                                                   String requestURI)

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

public WebSocket webSocketAndAwait(int port,
                                   String host,
                                   String requestURI)

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

public void webSocketAndForget(int port,
                               String host,
                               String requestURI)

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

public io.smallrye.mutiny.Uni<WebSocket> webSocket(String host,
                                                   String requestURI)

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

public WebSocket webSocketAndAwait(String host,
                                   String requestURI)

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

public void webSocketAndForget(String host,
                               String requestURI)

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

public io.smallrye.mutiny.Uni<WebSocket> webSocket(String requestURI)

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

public WebSocket webSocketAndAwait(String requestURI)

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

public void webSocketAndForget(String requestURI)

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

public io.smallrye.mutiny.Uni<WebSocket> webSocket(io.vertx.core.http.WebSocketConnectOptions options)

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

public WebSocket webSocketAndAwait(io.vertx.core.http.WebSocketConnectOptions options)

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

public void webSocketAndForget(io.vertx.core.http.WebSocketConnectOptions options)

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

public io.smallrye.mutiny.Uni<WebSocket> webSocketAbs(String url,
                                                      MultiMap headers,
                                                      io.vertx.core.http.WebsocketVersion version,
                                                      List<String> subProtocols)

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

public WebSocket webSocketAbsAndAwait(String url,
                                      MultiMap headers,
                                      io.vertx.core.http.WebsocketVersion version,
                                      List<String> subProtocols)

Blocking variant of io.vertx.mutiny.core.http.HttpClient#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

public void webSocketAbsAndForget(String url,
                                  MultiMap headers,
                                  io.vertx.core.http.WebsocketVersion version,
                                  List<String> subProtocols)

Variant of io.vertx.mutiny.core.http.HttpClient#webSocketAbs(String,io.vertx.mutiny.core.MultiMap,WebsocketVersion,List) that ignores the result of the operation.

This method subscribes on the result of io.vertx.mutiny.core.http.HttpClient#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 io.vertx.mutiny.core.http.HttpClient#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

connectionHandler

public HttpClient connectionHandler(Consumer<HttpConnection> handler)

Parameters:

handler -

Returns:

redirectHandler

public HttpClient redirectHandler(Function<HttpClientResponse,io.smallrye.mutiny.Uni<io.vertx.core.http.RequestOptions>> handler)

Parameters:

handler - the new redirect handler

Returns:

a reference to this, so the API can be used fluently

close

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)