io.vertx.rxjava3.ext.web.client

## Class HttpRequest<T>

- java.lang.Object
- - io.vertx.rxjava3.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()`
  - `sendStream(io.reactivex.rxjava3.core.Flowable<io.vertx.rxjava3.core.buffer.Buffer>)`
  - ()}
  - `sendForm(io.vertx.rxjava3.core.MultiMap)`
  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.
    `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`.
    `HttpRequest<T>` | `followRedirects(boolean value)` Set wether or not to follow the directs for the request.
    `HttpRequest` | `getDelegate()`
    `int` | `hashCode()`
    `MultiMap` | `headers()`
    `HttpRequest<T>` | `host(String value)` Configure the request to use a new host `value`.
    `HttpRequest<T>` | `method(HttpMethod value)` Configure the request to use a new method `value`.
    `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)`
    `HttpRequest<T>` | `port(int value)` Configure the request to use a new port `value`.
    `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()` but with an HTTP request `body` buffer.
    `Single<HttpResponse<T>>` | `rxSendForm(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`.
    `Single<HttpResponse<T>>` | `rxSendForm(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`.
    `Single<HttpResponse<T>>` | `rxSendJson(Object body)` Like `send()` 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()` 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()` 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()` but with an HTTP request `body` stream.
    `Single<HttpResponse<T>>` | `send()` Send a request, the `handler` will receive the response as an `HttpResponse`.
    `Single<HttpResponse<T>>` | `sendBuffer(Buffer body)` Like `send()` but with an HTTP request `body` buffer.
    `Single<HttpResponse<T>>` | `sendForm(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`.
    `Single<HttpResponse<T>>` | `sendForm(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`.
    `Single<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`.
    `Single<HttpResponse<T>>` | `sendJsonObject(JsonObject body)` Like `send()` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
    `Single<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`.
    `Single<HttpResponse<T>>` | `sendStream(Flowable<Buffer> body)` Like `send()` but with an HTTP request `body` stream.
    `HttpRequest<T>` | `setQueryParam(String paramName, String paramValue)` Set a query parameter to the request.
    `HttpRequest<T>` | `ssl(Boolean value)`
    `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.
    `String` | `toString()`
    `HttpRequest<T>` | `uri(String value)` Configure the request to use a new request URI `value`.
    `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

    - #### port

          public HttpRequest<T> port(int value)

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

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

    - #### host

          public HttpRequest<T> host(String value)

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

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

    - #### uri

          public HttpRequest<T> uri(String value)

      Configure the request to use a new request URI `value`.

      When the uri has query parameters, they are set in the `queryParams()` multimap, overwritting any parameters previously set.

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

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

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

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

    - #### followRedirects

          public HttpRequest<T> followRedirects(boolean value)

      Set wether or not to follow the directs for the request.
      Parameters:
        `value` - true if redirections should be followed
      Returns:
        a reference to this, so the API can be used fluently

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

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

    - #### queryParams

          public MultiMap queryParams()

      Return the current query parameters.
      Returns:
        the current query 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

    - #### sendStream

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

      Like `send()` but with an HTTP request `body` stream.
      Parameters:
        `body` - the body
      Returns:

    - #### rxSendStream

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

      Like `send()` but with an HTTP request `body` stream.
      Parameters:
        `body` - the body
      Returns:

    - #### sendBuffer

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

      Like `send()` but with an HTTP request `body` buffer.
      Parameters:
        `body` - the body
      Returns:

    - #### rxSendBuffer

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

      Like `send()` but with an HTTP request `body` buffer.
      Parameters:
        `body` - the body
      Returns:

    - #### sendJsonObject

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

      Like `send()` but with an HTTP request `body` object encoded as json and the content type set to `application/json`.
      Parameters:
        `body` - the body
      Returns:

    - #### rxSendJsonObject

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

      Like `send()` 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 Single<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`.
      Parameters:
        `body` - the body
      Returns:

    - #### rxSendJson

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

      Like `send()` 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 Single<HttpResponse<T>> sendForm(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.

      Parameters:
        `body` - the body
      Returns:

    - #### rxSendForm

          public Single<HttpResponse<T>> rxSendForm(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.

      Parameters:
        `body` - the body
      Returns:

    - #### sendForm

          public Single<HttpResponse<T>> sendForm(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.

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

    - #### rxSendForm

          public Single<HttpResponse<T>> rxSendForm(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.

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

    - #### sendMultipartForm

          public Single<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.
      Parameters:
        `body` - the body
      Returns:

    - #### rxSendMultipartForm

          public Single<HttpResponse<T>> rxSendMultipartForm(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.
      Parameters:
        `body` - the body
      Returns:

    - #### send

          public Single<HttpResponse<T>> send()

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

    - #### 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 © 2022 Eclipse. All rights reserved.