Package io.vertx.mutiny.ext.web.client

Class HttpRequest<T>

java.lang.Object
io.vertx.mutiny.ext.web.client.HttpRequest<T>
Type Parameters:
T - the type of response body
All Implemented Interfaces:
MutinyDelegate
public class HttpRequest<T> extends Object implements MutinyDelegate
A client-side HTTP request.

Instances are created by an WebClient instance, via one of the methods corresponding to the specific HTTP methods such as WebClient.get(java.lang.String), etc...

The request shall be configured prior sending, the request is immutable and when a mutator method is called, a new request is returned allowing to expose the request in a public API and apply further customization.

After the request has been configured, the methods

can be called. The sendXXX methods perform the actual request, they can be called multiple times to perform the same HTTP request at different points in time.

The handler is called back with

  • an HttpResponse instance when the HTTP response has been received
  • a failure when the HTTP request failed (like a connection error) or when the HTTP response could not be obtained (like connection or unmarshalling errors)

Most of the time, this client will buffer the HTTP response fully unless a specific BodyCodec is used such as BodyCodec#create(Handler).

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

Author:
Julien Viet
See Also:
  • HttpRequest

  • Field Details

  • Constructor Details

    • HttpRequest

      public HttpRequest(io.vertx.ext.web.client.HttpRequest<T> delegate)
      Create a new instance of HttpRequest delegating to the given (non-null) instance of HttpRequest.

    • HttpRequest

      public HttpRequest(io.vertx.ext.web.client.HttpRequest<T> delegate, TypeArg<T> typeArg_0)

    • HttpRequest

      public HttpRequest(Object delegate, TypeArg<T> typeArg_0)

  • Method Details

    • getDelegate

      public io.vertx.ext.web.client.HttpRequest<T> getDelegate()
      Get the delegate instance.

      This method returns the instance on which this shim is delegating the calls. And so, give you access to the bare API.

      Specified by:
      getDelegate in interface MutinyDelegate
      Returns:
      the delegate instance

    • sendStream

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpResponse<T>> sendStream(ReadStream<io.vertx.core.buffer.Buffer> body)
      Like send() but with an HTTP request body stream.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      body - the body
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • sendStreamAndAwait

      public HttpResponse<T> sendStreamAndAwait(ReadStream<io.vertx.core.buffer.Buffer> body)
      Like send() but with an HTTP request body stream.

      Unlike the bare Vert.x variant, this method returns a HttpResponse<T>. This method awaits indefinitely 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:
      body - the body
      Returns:
      The operation result
      See Also:

    • sendStreamAndForget

      public HttpRequest<T> sendStreamAndForget(ReadStream<io.vertx.core.buffer.Buffer> body)
      Like send() but with an HTTP request body stream.

      Unlike the bare Vert.x variant, this method ignores the HttpResponse<T> result or any failure.

      Parameters:
      body - the body
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • sendStream

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpResponse<T>> sendStream(Flow.Publisher<io.vertx.core.buffer.Buffer> body)
      Like send() but with an HTTP request body stream.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      body - the body
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • sendStreamAndAwait

      public HttpResponse<T> sendStreamAndAwait(Flow.Publisher<io.vertx.core.buffer.Buffer> body)
      Like send() but with an HTTP request body stream.

      Unlike the bare Vert.x variant, this method returns a HttpResponse<T>. This method awaits indefinitely 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:
      body - the body
      Returns:
      The operation result
      See Also:

    • sendStreamAndForget

      public HttpRequest<T> sendStreamAndForget(Flow.Publisher<io.vertx.core.buffer.Buffer> body)
      Like send() but with an HTTP request body stream.

      Unlike the bare Vert.x variant, this method ignores the HttpResponse<T> result or any failure.

      Parameters:
      body - the body
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • sendBuffer

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpResponse<T>> sendBuffer(io.vertx.core.buffer.Buffer body)
      Like send() but with an HTTP request body buffer.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      body - the body
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • sendBufferAndAwait

      public HttpResponse<T> sendBufferAndAwait(io.vertx.core.buffer.Buffer body)
      Like send() but with an HTTP request body buffer.

      Unlike the bare Vert.x variant, this method returns a HttpResponse<T>. This method awaits indefinitely 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:
      body - the body
      Returns:
      The operation result
      See Also:

    • sendBufferAndForget

      public HttpRequest<T> sendBufferAndForget(io.vertx.core.buffer.Buffer body)
      Like send() but with an HTTP request body buffer.

      Unlike the bare Vert.x variant, this method ignores the HttpResponse<T> result or any failure.

      Parameters:
      body - the body
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • sendJsonObject

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpResponse<T>> sendJsonObject(io.vertx.core.json.JsonObject body)
      Like send() but with an HTTP request body object encoded as json and the content type set to application/json.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      body - the body
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • sendJsonObjectAndAwait

      public HttpResponse<T> sendJsonObjectAndAwait(io.vertx.core.json.JsonObject body)
      Like send() but with an HTTP request body object encoded as json and the content type set to application/json.

      Unlike the bare Vert.x variant, this method returns a HttpResponse<T>. This method awaits indefinitely 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:
      body - the body
      Returns:
      The operation result
      See Also:

    • sendJsonObjectAndForget

      public HttpRequest<T> sendJsonObjectAndForget(io.vertx.core.json.JsonObject body)
      Like send() but with an HTTP request body object encoded as json and the content type set to application/json.

      Unlike the bare Vert.x variant, this method ignores the HttpResponse<T> result or any failure.

      Parameters:
      body - the body
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • sendJson

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpResponse<T>> sendJson(Object body)
      Like send() but with an HTTP request body object encoded as json and the content type set to application/json.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      body - the body. Can be null.
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • sendJsonAndAwait

      public HttpResponse<T> sendJsonAndAwait(Object body)
      Like send() but with an HTTP request body object encoded as json and the content type set to application/json.

      Unlike the bare Vert.x variant, this method returns a HttpResponse<T>. This method awaits indefinitely 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:
      body - the body
      Returns:
      The operation result
      See Also:

    • sendJsonAndForget

      public HttpRequest<T> sendJsonAndForget(Object body)
      Like send() but with an HTTP request body object encoded as json and the content type set to application/json.

      Unlike the bare Vert.x variant, this method ignores the HttpResponse<T> result or any failure.

      Parameters:
      body - the body
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • sendForm

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpResponse<T>> sendForm(io.vertx.core.MultiMap body)
      Like send() but with an HTTP request body multimap encoded as form and the content type set to application/x-www-form-urlencoded.

      When the content type header is previously set to multipart/form-data it will be used instead.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      body - the body
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • sendFormAndAwait

      public HttpResponse<T> sendFormAndAwait(io.vertx.core.MultiMap body)
      Like send() but with an HTTP request body multimap encoded as form and the content type set to application/x-www-form-urlencoded.

      When the content type header is previously set to multipart/form-data it will be used instead.

      Unlike the bare Vert.x variant, this method returns a HttpResponse<T>. This method awaits indefinitely 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:
      body - the body
      Returns:
      The operation result
      See Also:

    • sendFormAndForget

      public HttpRequest<T> sendFormAndForget(io.vertx.core.MultiMap body)
      Like send() but with an HTTP request body multimap encoded as form and the content type set to application/x-www-form-urlencoded.

      When the content type header is previously set to multipart/form-data it will be used instead.

      Unlike the bare Vert.x variant, this method ignores the HttpResponse<T> result or any failure.

      Parameters:
      body - the body
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • sendForm

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpResponse<T>> sendForm(io.vertx.core.MultiMap body, String charset)
      Like send() but with an HTTP request body multimap encoded as form and the content type set to application/x-www-form-urlencoded.

      When the content type header is previously set to multipart/form-data it will be used instead. NOTE: the use of this method is strongly discouraged to use when the form is a application/x-www-form-urlencoded encoded form since the charset to use must be UTF-8.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      body - the body
      charset - the charset
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • sendFormAndAwait

      public HttpResponse<T> sendFormAndAwait(io.vertx.core.MultiMap body, String charset)
      Like send() but with an HTTP request body multimap encoded as form and the content type set to application/x-www-form-urlencoded.

      When the content type header is previously set to multipart/form-data it will be used instead. NOTE: the use of this method is strongly discouraged to use when the form is a application/x-www-form-urlencoded encoded form since the charset to use must be UTF-8.

      Unlike the bare Vert.x variant, this method returns a HttpResponse<T>. This method awaits indefinitely 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:
      body - the body
      charset - the charset
      Returns:
      The operation result
      See Also:

    • sendFormAndForget

      public HttpRequest<T> sendFormAndForget(io.vertx.core.MultiMap body, String charset)
      Like send() but with an HTTP request body multimap encoded as form and the content type set to application/x-www-form-urlencoded.

      When the content type header is previously set to multipart/form-data it will be used instead. NOTE: the use of this method is strongly discouraged to use when the form is a application/x-www-form-urlencoded encoded form since the charset to use must be UTF-8.

      Unlike the bare Vert.x variant, this method ignores the HttpResponse<T> result or any failure.

      Parameters:
      body - the body
      charset - the charset
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • sendMultipartForm

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpResponse<T>> sendMultipartForm(MultipartForm body)
      Like send() but with an HTTP request body multimap encoded as form and the content type set to multipart/form-data. You may use this method to send attributes and upload files.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      body - the body
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • sendMultipartFormAndAwait

      public HttpResponse<T> sendMultipartFormAndAwait(MultipartForm body)
      Like send() but with an HTTP request body multimap encoded as form and the content type set to multipart/form-data. You may use this method to send attributes and upload files.

      Unlike the bare Vert.x variant, this method returns a HttpResponse<T>. This method awaits indefinitely 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:
      body - the body
      Returns:
      The operation result
      See Also:

    • sendMultipartFormAndForget

      public HttpRequest<T> sendMultipartFormAndForget(MultipartForm body)
      Like send() but with an HTTP request body multimap encoded as form and the content type set to multipart/form-data. You may use this method to send attributes and upload files.

      Unlike the bare Vert.x variant, this method ignores the HttpResponse<T> result or any failure.

      Parameters:
      body - the body
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • send

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpResponse<T>> send()
      Send a request, the handler will receive the response as an HttpResponse.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • sendAndAwait

      public HttpResponse<T> sendAndAwait()
      Send a request, the handler will receive the response as an HttpResponse.

      Unlike the bare Vert.x variant, this method returns a HttpResponse<T>. This method awaits indefinitely 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 operation result
      See Also:

    • sendAndForget

      public HttpRequest<T> sendAndForget()
      Send a request, the handler will receive the response as an HttpResponse.

      Unlike the bare Vert.x variant, this method ignores the HttpResponse<T> result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:

    • method

      public HttpRequest<T> method(io.vertx.core.http.HttpMethod value)
      Configure the request to use a new method value.
      Returns:
      a reference to this, so the API can be used fluently

    • method

      public io.vertx.core.http.HttpMethod method()
      Returns:
      the request method

    • port

      public HttpRequest<T> port(int value)
      Configure the request to use a new port value.

      This overrides the port set by absolute URI requests

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

    • port

      public int port()
      Returns:
      the request port or 0 when none is set for absolute URI templates

    • as

      public <U> HttpRequest<U> as(BodyCodec<U> responseCodec)
      Configure the request to decode the response with the responseCodec.
      Parameters:
      responseCodec - the response codec
      Returns:
      a reference to this, so the API can be used fluently

    • bodyCodec

      public BodyCodec<T> bodyCodec()
      Returns:
      the request body codec

    • host

      public HttpRequest<T> host(String value)
      Configure the request to use a new host value.

      This overrides the host set by absolute URI requests

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

    • host

      public String host()
      Returns:
      the request host or null when none is set for absolute URI templates

    • virtualHost

      public HttpRequest<T> virtualHost(String value)
      Configure the request to use a virtual host value.

      Usually the header host (:authority pseudo header for HTTP/2) is set from the request host value since this host value resolves to the server IP address.

      Sometimes you need to set a host header for an address that does not resolve to the server IP address. The virtual host value overrides the value of the actual host header (:authority pseudo header for HTTP/2).

      The virtual host is also be used for SNI.

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

    • virtualHost

      public String virtualHost()
      Returns:
      the request virtual host if any or null

    • uri

      public HttpRequest<T> uri(String value)
      Configure the request to use a new request URI value.

      This overrides the port set by absolute URI requests

      When the uri has query parameters, they are set in the queryParams(), overwriting any parameters previously set

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

    • uri

      public String uri()
      Returns:
      the request uri or null when none is set for absolute URI templates, when the request uri is a template, the template is extrapolated tolerating missing variables.

    • putHeaders

      public HttpRequest<T> putHeaders(io.vertx.core.MultiMap headers)
      Configure the request to add multiple HTTP headers .
      Parameters:
      headers - The HTTP headers
      Returns:
      a reference to this, so the API can be used fluently

    • putHeader

      public HttpRequest<T> putHeader(String name, String value)
      Configure the request to set a new HTTP header.
      Parameters:
      name - the header name
      value - the header value
      Returns:
      a reference to this, so the API can be used fluently

    • putHeader

      public HttpRequest<T> putHeader(CharSequence name, CharSequence value)
      Configure the request to set a new HTTP header using CharSequence.

      This is an overload of putHeader(String, String) that accepts CharSequence parameters.

      Parameters:
      name - the header name
      value - the header value
      Returns:
      a reference to this, so the API can be used fluently

    • putHeader

      public HttpRequest<T> putHeader(String name, Iterable<String> value)
      Configure the request to set a new HTTP header with multiple values.
      Parameters:
      name - the header name
      value - the header value
      Returns:
      a reference to this, so the API can be used fluently

    • putHeader

      public HttpRequest<T> putHeader(CharSequence name, Iterable<CharSequence> values)
      Configure the request to set a new HTTP header with multiple values using CharSequence.

      This is an overload of putHeader(String, Iterable) that accepts CharSequence parameters.

      Parameters:
      name - the header name
      values - the header values
      Returns:
      a reference to this, so the API can be used fluently

    • headers

      public io.vertx.core.MultiMap headers()
      Returns:
      The HTTP headers

    • authentication

      public HttpRequest<T> authentication(io.vertx.ext.auth.authentication.Credentials credentials)
      Configure the request to perform HTTP Authentication.

      Performs a generic authentication using the credentials provided by the user. For the sake of validation safety it is recommended that Credentials.applyHttpChallenge(String) is called to ensure that the credentials are applicable to the HTTP Challenged received on a previous request that returned a 401 response code.

      Parameters:
      credentials - the credentials to use.
      Returns:
      a reference to this, so the API can be used fluently

    • basicAuthentication

      public HttpRequest<T> basicAuthentication(String id, String password)
      Configure the request to perform basic access authentication.

      In basic HTTP authentication, a request contains a header field of the form 'Authorization: Basic <credentials>', where credentials is the base64 encoding of id and password joined by a colon.

      In practical terms the arguments are converted to a UsernamePasswordCredentials object.
      Parameters:
      id - the id
      password - the password
      Returns:
      a reference to this, so the API can be used fluently

    • basicAuthentication

      public HttpRequest<T> basicAuthentication(io.vertx.core.buffer.Buffer id, io.vertx.core.buffer.Buffer password)
      Configure the request to perform basic access authentication.

      In basic HTTP authentication, a request contains a header field of the form 'Authorization: Basic <credentials>', where credentials is the base64 encoding of id and password joined by a colon.

      In practical terms the arguments are converted to a UsernamePasswordCredentials object.
      Parameters:
      id - the id
      password - the password
      Returns:
      a reference to this, so the API can be used fluently

    • bearerTokenAuthentication

      public HttpRequest<T> bearerTokenAuthentication(String bearerToken)
      Configure the request to perform bearer token authentication.

      In OAuth 2.0, a request contains a header field of the form 'Authorization: Bearer <bearerToken>', where bearerToken is the bearer token issued by an authorization server to access protected resources.

      In practical terms the arguments are converted to a TokenCredentials object.
      Parameters:
      bearerToken - the bearer token
      Returns:
      a reference to this, so the API can be used fluently

    • ssl

      public HttpRequest<T> ssl(Boolean value)
      Configure the request whether to use SSL.

      This overrides the SSL value set by absolute URI requests

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

    • ssl

      public Boolean ssl()
      Returns:
      whether the request uses SSL or null when none is set for absolute URI templates

    • timeout

      public HttpRequest<T> timeout(long value)
      Configures the amount of time in milliseconds after which if the request does not return any data within the timeout period an TimeoutException fails the request.

      Setting zero or a negative value disables the timeout.

      Parameters:
      value - The quantity of time in milliseconds.
      Returns:
      a reference to this, so the API can be used fluently

    • timeout

      public long timeout()
      Returns:
      the current timeout in milliseconds

    • idleTimeout

      public HttpRequest<T> idleTimeout(long timeout)
      Sets the amount of time after which, if the request does not return any data within the timeout period, the request/response is closed and the related futures are failed with a TimeoutException.

      The timeout starts after a connection is obtained from the client.

      Parameters:
      timeout - the amount of time in milliseconds.
      Returns:
      a reference to this, so the API can be used fluently

    • idleTimeout

      public long idleTimeout()
      Returns:
      the idle timeout

    • connectTimeout

      public HttpRequest<T> connectTimeout(long timeout)
      Sets the amount of time after which, if the request is not obtained from the client within the timeout period, the response is failed with a TimeoutException. Note this is not related to the TCP HttpClientOptions#setConnectTimeout(int) option, when a request is made against a pooled HTTP client, the timeout applies to the duration to obtain a connection from the pool to serve the request, the timeout might fire because the server does not respond in time or the pool is too busy to serve a request.
      Parameters:
      timeout - the amount of time in milliseconds.
      Returns:
      a reference to this, so the API can be used fluently

    • connectTimeout

      public long connectTimeout()
      Returns:
      the connect timeout

    • addQueryParam

      public HttpRequest<T> addQueryParam(String paramName, String paramValue)
      Add a query parameter to the request.
      Parameters:
      paramName - the param name
      paramValue - the param value
      Returns:
      a reference to this, so the API can be used fluently

    • setQueryParam

      public HttpRequest<T> setQueryParam(String paramName, String paramValue)
      Set a query parameter to the request.
      Parameters:
      paramName - the param name
      paramValue - the param value
      Returns:
      a reference to this, so the API can be used fluently

    • setTemplateParam

      public HttpRequest<T> setTemplateParam(String paramName, String paramValue)
      Set a request URI template string parameter to the request, expanded when the request URI is a UriTemplate.
      Parameters:
      paramName - the param name
      paramValue - the param value
      Returns:
      a reference to this, so the API can be used fluently

    • setTemplateParam

      public HttpRequest<T> setTemplateParam(String paramName, List<String> paramValue)
      Set a request URI template list parameter to the request, expanded when the request URI is a UriTemplate.
      Parameters:
      paramName - the param name
      paramValue - the param value
      Returns:
      a reference to this, so the API can be used fluently

    • setTemplateParam

      public HttpRequest<T> setTemplateParam(String paramName, Map<String,String> paramValue)
      Set a request URI template map parameter to the request, expanded when the request URI is a UriTemplate.
      Parameters:
      paramName - the param name
      paramValue - the param value
      Returns:
      a reference to this, so the API can be used fluently

    • followRedirects

      public HttpRequest<T> followRedirects(boolean value)
      Set whether to follow request redirections
      Parameters:
      value - true if redirections should be followed
      Returns:
      a reference to this, so the API can be used fluently

    • followRedirects

      public boolean followRedirects()
      Returns:
      whether to follow request redirections

    • routingKey

      public HttpRequest<T> routingKey(String key)
      Set the routing key, the routing key can be used by a Vert.x client side sticky load balancer to pin the request to a remote HTTP server.
      Parameters:
      key - the routing key
      Returns:
      a reference to this, so the API can be used fluently

    • routingKey

      public String routingKey()
      Return the routing key, the routing key can be used by a Vert.x client side sticky load balancer to pin the request to a remote HTTP server.
      Returns:
      the routing key

    • proxy

      public HttpRequest<T> proxy(io.vertx.core.net.ProxyOptions proxyOptions)
      Configure the request to set a proxy for this request. Setting proxy here supersedes the proxy set on the client itself
      Parameters:
      proxyOptions - The proxy options
      Returns:
      a reference to this, so the API can be used fluently

    • proxy

      public io.vertx.core.net.ProxyOptions proxy()
      Returns:
      the proxy for this request

    • queryParams

      public io.vertx.core.MultiMap queryParams()
      Return the current query parameters.
      Returns:
      the current query parameters

    • templateParams

      public Variables templateParams()
      Return the current request URI template parameters.
      Returns:
      the current request URI template parameters

    • copy

      public HttpRequest<T> copy()
      Copy this request
      Returns:
      a copy of this request

    • multipartMixed

      public HttpRequest<T> multipartMixed(boolean allow)
      Allow or disallow multipart mixed encoding when sending MultipartForm having files sharing the same file name.
      The default value is true.
      Set to false if you want to achieve the behavior for HTML5.
      Parameters:
      allow - true allows use of multipart mixed encoding
      Returns:
      a reference to this, so the API can be used fluently

    • multipartMixed

      public boolean multipartMixed()
      Returns:
      whether multipart mixed encoding is allowed

    • traceOperation

      public HttpRequest<T> traceOperation(String traceOperation)
      Trace operation name override.
      Parameters:
      traceOperation - Name of operation to use in traces
      Returns:
      a reference to this, so the API can be used fluently

    • traceOperation

      public String traceOperation()
      Returns:
      the trace operation name override

    • newInstance

      public static <T> HttpRequest<T> newInstance(io.vertx.ext.web.client.HttpRequest<T> delegate)
      Creates a new instance of the HttpRequest.

    • newInstance

      public static <T> HttpRequest<T> newInstance(io.vertx.ext.web.client.HttpRequest<T> delegate, TypeArg<T> typeArg_0)
      Creates a new instance of the HttpRequest.

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • equals

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

    • toString

      public String toString()
      Overrides:
      toString in class Object