io.vertx.reactivex.ext.web.client

## Class HttpRequest<T>

- java.lang.Object
- - io.vertx.reactivex.ext.web.client.HttpRequest<T>

-     public class HttpRequest<T>
      extends Object

  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

  - `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)`
  - `sendStream(io.vertx.reactivex.core.streams.ReadStream<io.vertx.reactivex.core.buffer.Buffer>, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)`
  - `sendJson(java.lang.Object, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` ()}
  - `sendForm(io.vertx.reactivex.core.MultiMap, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)`
  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 is used such as .

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

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static io.vertx.lang.rx.TypeArg<HttpRequest>` | `__TYPE_ARG`
    `io.vertx.lang.rx.TypeArg<T>` | `__typeArg_0`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `HttpRequest(HttpRequest delegate)`
    `HttpRequest(Object delegate, io.vertx.lang.rx.TypeArg<T> typeArg_0)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `HttpRequest<T>` | `addQueryParam(String paramName, String paramValue)` Add a query parameter to the request.
    `<U> HttpRequest<U>` | `as(BodyCodec<U> responseCodec)` Configure the request to decode the response with the `responseCodec`.
    `HttpRequest<T>` | `authentication(Credentials credentials)` Configure the request to perform HTTP Authentication.
    `HttpRequest<T>` | `basicAuthentication(Buffer id, Buffer password)` Configure the request to perform basic access authentication.
    `HttpRequest<T>` | `basicAuthentication(String id, String password)` Configure the request to perform basic access authentication.
    `HttpRequest<T>` | `bearerTokenAuthentication(String bearerToken)` Configure the request to perform bearer token authentication.
    `BodyCodec<T>` | `bodyCodec()`
    `long` | `connectTimeout()`
    `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`.
    `HttpRequest<T>` | `copy()` Copy this request
    `boolean` | `equals(Object o)`
    `HttpRequest<T>` | `expect(java.util.function.Function<HttpResponse<Void>,ResponsePredicateResult> predicate)` Add an expectation that the response is valid according to the provided `predicate`.
    `HttpRequest<T>` | `expect(ResponsePredicate predicate)` Add an expectation that the response is valid according to the provided `predicate`.
    `List<ResponsePredicate>` | `expectations()`
    `boolean` | `followRedirects()`
    `HttpRequest<T>` | `followRedirects(boolean value)` Set whether to follow request redirections
    `HttpRequest` | `getDelegate()`
    `int` | `hashCode()`
    `MultiMap` | `headers()`
    `String` | `host()`
    `HttpRequest<T>` | `host(String value)` Configure the request to use a new host `value`.
    `long` | `idleTimeout()`
    `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`.
    `HttpMethod` | `method()`
    `HttpRequest<T>` | `method(HttpMethod value)` Configure the request to use a new method `value`.
    `boolean` | `multipartMixed()`
    `HttpRequest<T>` | `multipartMixed(boolean allow)` Allow or disallow multipart mixed encoding when sending having files sharing the same file name.
    `static <T> HttpRequest<T>` | `newInstance(HttpRequest arg)`
    `static <T> HttpRequest<T>` | `newInstance(HttpRequest arg, io.vertx.lang.rx.TypeArg<T> __typeArg_T)`
    `int` | `port()`
    `HttpRequest<T>` | `port(int value)` Configure the request to use a new port `value`.
    `ProxyOptions` | `proxy()`
    `HttpRequest<T>` | `proxy(ProxyOptions proxyOptions)` Configure the request to set a proxy for this request.
    `HttpRequest<T>` | `putHeader(String name, Iterable<String> value)` Configure the request to set a new HTTP header with multiple values.
    `HttpRequest<T>` | `putHeader(String name, String value)` Configure the request to set a new HTTP header.
    `HttpRequest<T>` | `putHeaders(MultiMap headers)` Configure the request to add multiple HTTP headers .
    `MultiMap` | `queryParams()` Return the current query parameters.
    `Single<HttpResponse<T>>` | `rxSend()` Send a request, the `handler` will receive the response as an `HttpResponse`.
    `Single<HttpResponse<T>>` | `rxSendBuffer(Buffer body)` Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` buffer.
    `Single<HttpResponse<T>>` | `rxSendForm(MultiMap body)` Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` multimap encoded as form and the content type set to `application/x-www-form-urlencoded`.
    `Single<HttpResponse<T>>` | `rxSendForm(MultiMap body, String charset)` Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` multimap encoded as form and the content type set to `application/x-www-form-urlencoded`.
    `Single<HttpResponse<T>>` | `rxSendJson(Object body)` Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
    `Single<HttpResponse<T>>` | `rxSendJsonObject(JsonObject body)` Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
    `Single<HttpResponse<T>>` | `rxSendMultipartForm(MultipartForm body)` Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` multimap encoded as form and the content type set to `multipart/form-data`.
    `Single<HttpResponse<T>>` | `rxSendStream(Flowable<Buffer> body)` Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
    `Single<HttpResponse<T>>` | `rxSendStream(ReadStream<Buffer> body)` Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
    `void` | `send()` Send a request, the `handler` will receive the response as an `HttpResponse`.
    `void` | `send(Handler<AsyncResult<HttpResponse<T>>> handler)` Send a request, the `handler` will receive the response as an `HttpResponse`.
    `void` | `sendBuffer(Buffer body)` Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` buffer.
    `void` | `sendBuffer(Buffer body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` buffer.
    `void` | `sendForm(MultiMap body)` Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` multimap encoded as form and the content type set to `application/x-www-form-urlencoded`.
    `void` | `sendForm(MultiMap body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` multimap encoded as form and the content type set to `application/x-www-form-urlencoded`.
    `void` | `sendForm(MultiMap body, String charset)` Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` multimap encoded as form and the content type set to `application/x-www-form-urlencoded`.
    `void` | `sendForm(MultiMap body, String charset, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` multimap encoded as form and the content type set to `application/x-www-form-urlencoded`.
    `void` | `sendJson(Object body)` Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
    `void` | `sendJson(Object body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
    `void` | `sendJsonObject(JsonObject body)` Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
    `void` | `sendJsonObject(JsonObject body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
    `void` | `sendMultipartForm(MultipartForm body)` Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` multimap encoded as form and the content type set to `multipart/form-data`.
    `void` | `sendMultipartForm(MultipartForm body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` multimap encoded as form and the content type set to `multipart/form-data`.
    `void` | `sendStream(Flowable<Buffer> body)` Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
    `void` | `sendStream(Flowable<Buffer> body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
    `void` | `sendStream(ReadStream<Buffer> body)` Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
    `void` | `sendStream(ReadStream<Buffer> body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
    `HttpRequest<T>` | `setQueryParam(String paramName, String paramValue)` Set a query parameter to the request.
    `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 .
    `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 .
    `HttpRequest<T>` | `setTemplateParam(String paramName, String paramValue)` Set a request URI template string parameter to the request, expanded when the request URI is a .
    `Boolean` | `ssl()`
    `HttpRequest<T>` | `ssl(Boolean value)` Configure the request whether to use SSL.
    `Variables` | `templateParams()` Return the current request URI template parameters.
    `long` | `timeout()`
    `HttpRequest<T>` | `timeout(long value)` Sets both connect and idle timeouts for the request connect timeout: if the request is not obtained from the client within the timeout period, the `Future` obtained from the client is failed with a `TimeoutException`. idle timeout: 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`, e.g.
    `String` | `toString()`
    `String` | `traceOperation()`
    `HttpRequest<T>` | `traceOperation(String traceOperation)` Trace operation name override.
    `String` | `uri()`
    `HttpRequest<T>` | `uri(String value)` Configure the request to use a new request URI `value`.
    `String` | `virtualHost()`
    `HttpRequest<T>` | `virtualHost(String value)` Configure the request to use a virtual host `value`.

    - ### Methods inherited from class java.lang.Object

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

- - ### Field Detail

    - #### __TYPE_ARG

          public static final io.vertx.lang.rx.TypeArg<HttpRequest> __TYPE_ARG

    - #### __typeArg_0

          public final io.vertx.lang.rx.TypeArg<T> __typeArg_0

  - ### Constructor Detail

    - #### HttpRequest

          public HttpRequest(HttpRequest delegate)

    - #### HttpRequest

          public HttpRequest(Object delegate,
                             io.vertx.lang.rx.TypeArg<T> typeArg_0)

  - ### Method Detail

    - #### 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`

    - #### getDelegate

          public HttpRequest getDelegate()

    - #### method

          public HttpRequest<T> method(HttpMethod value)

      Configure the request to use a new method `value`.
      Parameters:
        `value` -
      Returns:
        a reference to this, so the API can be used fluently

    - #### method

          public 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

      Parameters:
        `value` -
      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

      Parameters:
        `value` -
      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.
      Parameters:
        `value` -
      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

      Parameters:
        `value` -
      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

    - #### putHeaders

          public HttpRequest<T> putHeaders(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

    - #### headers

          public MultiMap headers()

      Returns:
        The HTTP headers

    - #### 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 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(Buffer id,
                                                    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 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 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

      Parameters:
        `value` -
      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)

      Sets both connect and idle timeouts for the request
      - connect timeout: if the request is not obtained from the client within the timeout period, the `Future` obtained from the client is failed with a `TimeoutException`.
      - idle timeout: 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`, e.g. `Future` or `Future` response body.
      The connect and idle timeouts can be set separately using `connectTimeout(long)` and `idleTimeout(long)`
      Parameters:
        `value` -
      Returns:

    - #### 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 in milliseconds

    - #### 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 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 in milliseconds

    - #### 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 .
      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 .
      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 .
      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

    - #### proxy

          public HttpRequest<T> proxy(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 ProxyOptions proxy()

      Returns:
        the proxy for this request

    - #### expect

          public HttpRequest<T> expect(java.util.function.Function<HttpResponse<Void>,ResponsePredicateResult> predicate)

      Add an expectation that the response is valid according to the provided `predicate`.

      Multiple predicates can be added.

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

    - #### expect

          public HttpRequest<T> expect(ResponsePredicate predicate)

      Add an expectation that the response is valid according to the provided `predicate`.

      Multiple predicates can be added.

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

    - #### expectations

          public List<ResponsePredicate> expectations()

      Returns:
        a read-only list of the response predicate expectations

    - #### queryParams

          public 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 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

    - #### sendStream

          public void sendStream(ReadStream<Buffer> body,
                                 Handler<AsyncResult<HttpResponse<T>>> handler)

      Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
      Parameters:
        `body` - the body
        `handler` -

    - #### sendStream

          public void sendStream(ReadStream<Buffer> body)

      Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
      Parameters:
        `body` - the body

    - #### rxSendStream

          public Single<HttpResponse<T>> rxSendStream(ReadStream<Buffer> body)

      Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
      Parameters:
        `body` - the body
      Returns:

    - #### sendStream

          public void sendStream(Flowable<Buffer> body,
                                 Handler<AsyncResult<HttpResponse<T>>> handler)

      Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
      Parameters:
        `body` - the body
        `handler` -

    - #### sendStream

          public void sendStream(Flowable<Buffer> body)

      Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
      Parameters:
        `body` - the body

    - #### rxSendStream

          public Single<HttpResponse<T>> rxSendStream(Flowable<Buffer> body)

      Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
      Parameters:
        `body` - the body
      Returns:

    - #### sendBuffer

          public void sendBuffer(Buffer body,
                                 Handler<AsyncResult<HttpResponse<T>>> handler)

      Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` buffer.
      Parameters:
        `body` - the body
        `handler` -

    - #### sendBuffer

          public void sendBuffer(Buffer body)

      Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` buffer.
      Parameters:
        `body` - the body

    - #### rxSendBuffer

          public Single<HttpResponse<T>> rxSendBuffer(Buffer body)

      Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` buffer.
      Parameters:
        `body` - the body
      Returns:

    - #### sendJsonObject

          public void sendJsonObject(JsonObject body,
                                     Handler<AsyncResult<HttpResponse<T>>> handler)

      Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
      Parameters:
        `body` - the body
        `handler` -

    - #### sendJsonObject

          public void sendJsonObject(JsonObject body)

      Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
      Parameters:
        `body` - the body

    - #### rxSendJsonObject

          public Single<HttpResponse<T>> rxSendJsonObject(JsonObject body)

      Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
      Parameters:
        `body` - the body
      Returns:

    - #### sendJson

          public void sendJson(Object body,
                               Handler<AsyncResult<HttpResponse<T>>> handler)

      Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
      Parameters:
        `body` - the body
        `handler` -

    - #### sendJson

          public void sendJson(Object body)

      Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
      Parameters:
        `body` - the body

    - #### rxSendJson

          public Single<HttpResponse<T>> rxSendJson(Object body)

      Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
      Parameters:
        `body` - the body
      Returns:

    - #### sendForm

          public void sendForm(MultiMap body,
                               Handler<AsyncResult<HttpResponse<T>>> handler)

      Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` 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.

      Parameters:
        `body` - the body
        `handler` -

    - #### sendForm

          public void sendForm(MultiMap body)

      Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` 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.

      Parameters:
        `body` - the body

    - #### rxSendForm

          public Single<HttpResponse<T>> rxSendForm(MultiMap body)

      Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` 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.

      Parameters:
        `body` - the body
      Returns:

    - #### sendForm

          public void sendForm(MultiMap body,
                               String charset,
                               Handler<AsyncResult<HttpResponse<T>>> handler)

      Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` 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.

      Parameters:
        `body` - the body
        `charset` -
        `handler` -

    - #### sendForm

          public void sendForm(MultiMap body,
                               String charset)

      Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` 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.

      Parameters:
        `body` - the body
        `charset` -

    - #### rxSendForm

          public Single<HttpResponse<T>> rxSendForm(MultiMap body,
                                                    String charset)

      Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` 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.

      Parameters:
        `body` - the body
        `charset` -
      Returns:

    - #### sendMultipartForm

          public void sendMultipartForm(MultipartForm body,
                                        Handler<AsyncResult<HttpResponse<T>>> handler)

      Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` 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.
      Parameters:
        `body` - the body
        `handler` -

    - #### sendMultipartForm

          public void sendMultipartForm(MultipartForm body)

      Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` 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.
      Parameters:
        `body` - the body

    - #### rxSendMultipartForm

          public Single<HttpResponse<T>> rxSendMultipartForm(MultipartForm body)

      Like `send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` 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.
      Parameters:
        `body` - the body
      Returns:

    - #### send

          public void send(Handler<AsyncResult<HttpResponse<T>>> handler)

      Send a request, the `handler` will receive the response as an `HttpResponse`.
      Parameters:
        `handler` -

    - #### send

          public void send()

      Send a request, the `handler` will receive the response as an `HttpResponse`.

    - #### rxSend

          public Single<HttpResponse<T>> rxSend()

      Send a request, the `handler` will receive the response as an `HttpResponse`.
      Returns:

    - #### 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

    - #### authentication

          public HttpRequest<T> 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 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

    - #### newInstance

          public static <T> HttpRequest<T> newInstance(HttpRequest arg)

    - #### newInstance

          public static <T> HttpRequest<T> newInstance(HttpRequest arg,
                                                       io.vertx.lang.rx.TypeArg<T> __typeArg_T)

Copyright © 2024 Eclipse. All rights reserved.