io.vertx.core.http

## Class HttpClientOptions

- java.lang.Object
- - io.vertx.core.net.NetworkOptions
  - - io.vertx.core.net.TCPSSLOptions
    - - io.vertx.core.net.ClientOptionsBase
      - - io.vertx.core.http.HttpClientOptions

- Direct Known Subclasses:
    OAuth2ClientOptions, WebClientOptions

      public class HttpClientOptions
      extends ClientOptionsBase

  Options describing how an `HttpClient` will make connections.
  Author:
    Tim Fox

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static List<HttpVersion>` | `DEFAULT_ALPN_VERSIONS` Default Application-Layer Protocol Negotiation versions = [] (automatic according to protocol version)
    `static int` | `DEFAULT_DECODER_INITIAL_BUFFER_SIZE` Default initial buffer size for HttpObjectDecoder = 128 bytes
    `static String` | `DEFAULT_DEFAULT_HOST` The default value for host name = "localhost"
    `static int` | `DEFAULT_DEFAULT_PORT` The default value for port = 80
    `static boolean` | `DEFAULT_FORCE_SNI`
    `static boolean` | `DEFAULT_HTTP2_CLEAR_TEXT_UPGRADE` Default using HTTP/1.1 upgrade for establishing an h2C connection = true
    `static int` | `DEFAULT_HTTP2_CONNECTION_WINDOW_SIZE` The default connection window size for HTTP/2 = -1
    `static int` | `DEFAULT_HTTP2_MAX_POOL_SIZE` The default maximum number of connections an HTTP/2 client will pool = 1
    `static int` | `DEFAULT_HTTP2_MULTIPLEXING_LIMIT` The default maximum number of concurrent streams per connection for HTTP/2 = -1
    `static boolean` | `DEFAULT_KEEP_ALIVE` Default value of whether keep-alive is enabled = true
    `static int` | `DEFAULT_MAX_CHUNK_SIZE` Default max HTTP chunk size = 8192
    `static int` | `DEFAULT_MAX_HEADER_SIZE` Default max length of all headers = 8192
    `static int` | `DEFAULT_MAX_INITIAL_LINE_LENGTH` Default max length of the initial line (e.g.
    `static int` | `DEFAULT_MAX_POOL_SIZE` The default maximum number of HTTP/1 connections a client will pool = 5
    `static int` | `DEFAULT_MAX_REDIRECTS`
    `static int` | `DEFAULT_MAX_WAIT_QUEUE_SIZE` Default max wait queue size = -1 (unbounded)
    `static int` | `DEFAULT_MAX_WEBSOCKET_FRAME_SIZE` The default value for maximum websocket frame size = 65536 bytes
    `static int` | `DEFAULT_MAX_WEBSOCKET_MESSAGE_SIZE` The default value for maximum websocket messages (could be assembled from multiple frames) is 4 full frames worth of data
    `static boolean` | `DEFAULT_PIPELINING` Default value of whether pipe-lining is enabled = false
    `static int` | `DEFAULT_PIPELINING_LIMIT` The default maximum number of requests an HTTP/1.1 pipe-lined connection can send = 10
    `static HttpVersion` | `DEFAULT_PROTOCOL_VERSION` The default protocol version = HTTP/1.1
    `static boolean` | `DEFAULT_SEND_UNMASKED_FRAMES` Default WebSocket Masked bit is true as depicted by RFC.
    `static boolean` | `DEFAULT_TRY_USE_COMPRESSION` Default value of whether the client will attempt to use compression = false
    `static boolean` | `DEFAULT_VERIFY_HOST` Default value of whether hostname verification (for SSL/TLS) is enabled = true

    - ### Fields inherited from class io.vertx.core.net.ClientOptionsBase

      `DEFAULT_CONNECT_TIMEOUT, DEFAULT_METRICS_NAME, DEFAULT_TRUST_ALL`

    - ### Fields inherited from class io.vertx.core.net.TCPSSLOptions

      `DEFAULT_IDLE_TIMEOUT, DEFAULT_SO_LINGER, DEFAULT_SSL, DEFAULT_SSL_ENGINE, DEFAULT_TCP_KEEP_ALIVE, DEFAULT_TCP_NO_DELAY, DEFAULT_USE_ALPN, DEFAULT_USE_POOLED_BUFFERS`

    - ### Fields inherited from class io.vertx.core.net.NetworkOptions

      `DEFAULT_LOG_ENABLED, DEFAULT_RECEIVE_BUFFER_SIZE, DEFAULT_REUSE_ADDRESS, DEFAULT_SEND_BUFFER_SIZE, DEFAULT_TRAFFIC_CLASS`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `HttpClientOptions()` Default constructor
    `HttpClientOptions(HttpClientOptions other)` Copy constructor
    `HttpClientOptions(JsonObject json)` Constructor to create an options from JSON

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `HttpClientOptions` | `addCrlPath(String crlPath)` Add a CRL path
    `HttpClientOptions` | `addCrlValue(Buffer crlValue)` Add a CRL value
    `HttpClientOptions` | `addEnabledCipherSuite(String suite)` Add an enabled cipher suite, appended to the ordered suites.
    `HttpClientOptions` | `addEnabledSecureTransportProtocol(String protocol)` Add an enabled SSL/TLS protocols, appended to the ordered protocols.
    `boolean` | `equals(Object o)`
    `List<HttpVersion>` | `getAlpnVersions()`
    `int` | `getDecoderInitialBufferSize()`
    `String` | `getDefaultHost()` Get the default host name to be used by this client in requests if none is provided when making the request.
    `int` | `getDefaultPort()` Get the default port to be used by this client in requests if none is provided when making the request.
    `int` | `getHttp2ConnectionWindowSize()`
    `int` | `getHttp2MaxPoolSize()` Get the maximum pool size for HTTP/2 connections
    `int` | `getHttp2MultiplexingLimit()`
    `Http2Settings` | `getInitialSettings()`
    `int` | `getMaxChunkSize()` Returns the maximum HTTP chunk size
    `int` | `getMaxHeaderSize()`
    `int` | `getMaxInitialLineLength()`
    `int` | `getMaxPoolSize()` Get the maximum pool size for connections
    `int` | `getMaxRedirects()`
    `int` | `getMaxWaitQueueSize()` Returns the maximum wait queue size
    `int` | `getMaxWebsocketFrameSize()` Get the maximum websocket framesize to use
    `int` | `getMaxWebsocketMessageSize()` Get the maximum websocket message size to use
    `int` | `getPipeliningLimit()`
    `HttpVersion` | `getProtocolVersion()` Get the protocol version.
    `int` | `hashCode()`
    `boolean` | `isForceSni()`
    `boolean` | `isHttp2ClearTextUpgrade()`
    `boolean` | `isKeepAlive()` Is keep alive enabled on the client?
    `boolean` | `isPipelining()` Is pipe-lining enabled on the client
    `boolean` | `isSendUnmaskedFrames()` is masking frame skipped ?
    `boolean` | `isTryUseCompression()` Is compression enabled on the client?
    `boolean` | `isVerifyHost()` Is hostname verification (for SSL/TLS) enabled?
    `HttpClientOptions` | `setAlpnVersions(List<HttpVersion> alpnVersions)` Set the list of protocol versions to provide to the server during the Application-Layer Protocol Negotiation.
    `HttpClientOptions` | `setConnectTimeout(int connectTimeout)` Set the connect timeout
    `HttpClientOptions` | `setDecoderInitialBufferSize(int decoderInitialBufferSize)` set to `initialBufferSizeHttpDecoder` the initial buffer of the HttpDecoder.
    `HttpClientOptions` | `setDefaultHost(String defaultHost)` Set the default host name to be used by this client in requests if none is provided when making the request.
    `HttpClientOptions` | `setDefaultPort(int defaultPort)` Set the default port to be used by this client in requests if none is provided when making the request.
    `HttpClientOptions` | `setForceSni(boolean forceSni)` By default, the server name is only sent for Fully Qualified Domain Name (FQDN), setting this property to `true` forces the server name to be always sent.
    `HttpClientOptions` | `setHttp2ClearTextUpgrade(boolean value)` Set to `true` when an h2c connection is established using an HTTP/1.1 upgrade request, and `false` when an h2c connection is established directly (with prior knowledge).
    `HttpClientOptions` | `setHttp2ConnectionWindowSize(int http2ConnectionWindowSize)` Set the default HTTP/2 connection window size.
    `HttpClientOptions` | `setHttp2MaxPoolSize(int max)` Set the maximum pool size for HTTP/2 connections
    `HttpClientOptions` | `setHttp2MultiplexingLimit(int limit)` Set a client limit of the number concurrent streams for each HTTP/2 connection, this limits the number of streams the client can create for a connection.
    `HttpClientOptions` | `setIdleTimeout(int idleTimeout)` Set the idle timeout, in seconds.
    `HttpClientOptions` | `setInitialSettings(Http2Settings settings)` Set the HTTP/2 connection settings immediately sent by to the server when the client connects.
    `HttpClientOptions` | `setJdkSslEngineOptions(JdkSSLEngineOptions sslEngineOptions)`
    `HttpClientOptions` | `setKeepAlive(boolean keepAlive)` Set whether keep alive is enabled on the client
    `HttpClientOptions` | `setKeyCertOptions(KeyCertOptions options)` Set the key/cert options.
    `HttpClientOptions` | `setKeyStoreOptions(JksOptions options)` Set the key/cert options in jks format, aka Java keystore.
    `HttpClientOptions` | `setLocalAddress(String localAddress)` Set the local interface to bind for network connections.
    `HttpClientOptions` | `setLogActivity(boolean logEnabled)` Set to true to enabled network activity logging: Netty's pipeline is configured for logging on Netty's logger.
    `HttpClientOptions` | `setMaxChunkSize(int maxChunkSize)` Set the maximum HTTP chunk size
    `HttpClientOptions` | `setMaxHeaderSize(int maxHeaderSize)` Set the maximum length of all headers for HTTP/1.x .
    `HttpClientOptions` | `setMaxInitialLineLength(int maxInitialLineLength)` Set the maximum length of the initial line for HTTP/1.x (e.g.
    `HttpClientOptions` | `setMaxPoolSize(int maxPoolSize)` Set the maximum pool size for connections
    `HttpClientOptions` | `setMaxRedirects(int maxRedirects)` Set to `maxRedirects` the maximum number of redirection a request can follow.
    `HttpClientOptions` | `setMaxWaitQueueSize(int maxWaitQueueSize)` Set the maximum requests allowed in the wait queue, any requests beyond the max size will result in a ConnectionPoolTooBusyException.
    `HttpClientOptions` | `setMaxWebsocketFrameSize(int maxWebsocketFrameSize)` Set the max websocket frame size
    `HttpClientOptions` | `setMaxWebsocketMessageSize(int maxWebsocketMessageSize)` Set the max websocket message size
    `HttpClientOptions` | `setMetricsName(String metricsName)` Set the metrics name identifying the reported metrics, useful for grouping metrics with the same name.
    `HttpClientOptions` | `setOpenSslEngineOptions(OpenSSLEngineOptions sslEngineOptions)`
    `HttpClientOptions` | `setPemKeyCertOptions(PemKeyCertOptions options)` Set the key/cert store options in pem format.
    `HttpClientOptions` | `setPemTrustOptions(PemTrustOptions options)` Set the trust options in pem format
    `HttpClientOptions` | `setPfxKeyCertOptions(PfxOptions options)` Set the key/cert options in pfx format.
    `HttpClientOptions` | `setPfxTrustOptions(PfxOptions options)` Set the trust options in pfx format
    `HttpClientOptions` | `setPipelining(boolean pipelining)` Set whether pipe-lining is enabled on the client
    `HttpClientOptions` | `setPipeliningLimit(int limit)` Set the limit of pending requests a pipe-lined HTTP/1 connection can send.
    `HttpClientOptions` | `setProtocolVersion(HttpVersion protocolVersion)` Set the protocol version.
    `HttpClientOptions` | `setProxyOptions(ProxyOptions proxyOptions)` Set proxy options for connections via CONNECT proxy (e.g.
    `HttpClientOptions` | `setReceiveBufferSize(int receiveBufferSize)` Set the TCP receive buffer size
    `HttpClientOptions` | `setReuseAddress(boolean reuseAddress)` Set the value of reuse address
    `HttpClientOptions` | `setSendBufferSize(int sendBufferSize)` Set the TCP send buffer size
    `HttpClientOptions` | `setSendUnmaskedFrames(boolean sendUnmaskedFrames)` Set true when the client wants to skip frame masking.
    `HttpClientOptions` | `setSoLinger(int soLinger)` Set whether SO_linger keep alive is enabled
    `HttpClientOptions` | `setSsl(boolean ssl)` Set whether SSL/TLS is enabled
    `HttpClientOptions` | `setSslEngineOptions(SSLEngineOptions sslEngineOptions)` Set to use SSL engine implementation to use.
    `HttpClientOptions` | `setTcpKeepAlive(boolean tcpKeepAlive)` Set whether TCP keep alive is enabled
    `HttpClientOptions` | `setTcpNoDelay(boolean tcpNoDelay)` Set whether TCP no delay is enabled
    `HttpClientOptions` | `setTrafficClass(int trafficClass)` Set the value of traffic class
    `HttpClientOptions` | `setTrustAll(boolean trustAll)` Set whether all server certificates should be trusted
    `HttpClientOptions` | `setTrustOptions(TrustOptions options)` Set the trust options.
    `HttpClientOptions` | `setTrustStoreOptions(JksOptions options)` Set the trust options in jks format, aka Java truststore
    `HttpClientOptions` | `setTryUseCompression(boolean tryUseCompression)` Set whether compression is enabled
    `HttpClientOptions` | `setUseAlpn(boolean useAlpn)` Set the ALPN usage.
    `HttpClientOptions` | `setUsePooledBuffers(boolean usePooledBuffers)` Set whether Netty pooled buffers are enabled
    `HttpClientOptions` | `setVerifyHost(boolean verifyHost)` Set whether hostname verification is enabled
    `JsonObject` | `toJson()` Convert to JSON

    - ### Methods inherited from class io.vertx.core.net.ClientOptionsBase

      `getConnectTimeout, getLocalAddress, getMetricsName, getProxyOptions, isTrustAll`

    - ### Methods inherited from class io.vertx.core.net.TCPSSLOptions

      `getCrlPaths, getCrlValues, getEnabledCipherSuites, getEnabledSecureTransportProtocols, getIdleTimeout, getJdkSslEngineOptions, getKeyCertOptions, getKeyStoreOptions, getOpenSslEngineOptions, getPemKeyCertOptions, getPemTrustOptions, getPfxKeyCertOptions, getPfxTrustOptions, getSoLinger, getSslEngineOptions, getTrustOptions, getTrustStoreOptions, isSsl, isTcpKeepAlive, isTcpNoDelay, isUseAlpn, isUsePooledBuffers`

    - ### Methods inherited from class io.vertx.core.net.NetworkOptions

      `getLogActivity, getReceiveBufferSize, getSendBufferSize, getTrafficClass, isReuseAddress`

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

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

- - ### Field Detail

    - #### DEFAULT_MAX_POOL_SIZE

          public static final int DEFAULT_MAX_POOL_SIZE

      The default maximum number of HTTP/1 connections a client will pool = 5
      See Also:
        Constant Field Values

    - #### DEFAULT_HTTP2_MAX_POOL_SIZE

          public static final int DEFAULT_HTTP2_MAX_POOL_SIZE

      The default maximum number of connections an HTTP/2 client will pool = 1
      See Also:
        Constant Field Values

    - #### DEFAULT_HTTP2_MULTIPLEXING_LIMIT

          public static final int DEFAULT_HTTP2_MULTIPLEXING_LIMIT

      The default maximum number of concurrent streams per connection for HTTP/2 = -1
      See Also:
        Constant Field Values

    - #### DEFAULT_HTTP2_CONNECTION_WINDOW_SIZE

          public static final int DEFAULT_HTTP2_CONNECTION_WINDOW_SIZE

      The default connection window size for HTTP/2 = -1
      See Also:
        Constant Field Values

    - #### DEFAULT_KEEP_ALIVE

          public static final boolean DEFAULT_KEEP_ALIVE

      Default value of whether keep-alive is enabled = true
      See Also:
        Constant Field Values

    - #### DEFAULT_PIPELINING

          public static final boolean DEFAULT_PIPELINING

      Default value of whether pipe-lining is enabled = false
      See Also:
        Constant Field Values

    - #### DEFAULT_PIPELINING_LIMIT

          public static final int DEFAULT_PIPELINING_LIMIT

      The default maximum number of requests an HTTP/1.1 pipe-lined connection can send = 10
      See Also:
        Constant Field Values

    - #### DEFAULT_TRY_USE_COMPRESSION

          public static final boolean DEFAULT_TRY_USE_COMPRESSION

      Default value of whether the client will attempt to use compression = false
      See Also:
        Constant Field Values

    - #### DEFAULT_VERIFY_HOST

          public static final boolean DEFAULT_VERIFY_HOST

      Default value of whether hostname verification (for SSL/TLS) is enabled = true
      See Also:
        Constant Field Values

    - #### DEFAULT_MAX_WEBSOCKET_FRAME_SIZE

          public static final int DEFAULT_MAX_WEBSOCKET_FRAME_SIZE

      The default value for maximum websocket frame size = 65536 bytes
      See Also:
        Constant Field Values

    - #### DEFAULT_MAX_WEBSOCKET_MESSAGE_SIZE

          public static final int DEFAULT_MAX_WEBSOCKET_MESSAGE_SIZE

      The default value for maximum websocket messages (could be assembled from multiple frames) is 4 full frames worth of data
      See Also:
        Constant Field Values

    - #### DEFAULT_DEFAULT_HOST

          public static final String DEFAULT_DEFAULT_HOST

      The default value for host name = "localhost"
      See Also:
        Constant Field Values

    - #### DEFAULT_DEFAULT_PORT

          public static final int DEFAULT_DEFAULT_PORT

      The default value for port = 80
      See Also:
        Constant Field Values

    - #### DEFAULT_PROTOCOL_VERSION

          public static final HttpVersion DEFAULT_PROTOCOL_VERSION

      The default protocol version = HTTP/1.1

    - #### DEFAULT_MAX_CHUNK_SIZE

          public static final int DEFAULT_MAX_CHUNK_SIZE

      Default max HTTP chunk size = 8192
      See Also:
        Constant Field Values

    - #### DEFAULT_MAX_INITIAL_LINE_LENGTH

          public static final int DEFAULT_MAX_INITIAL_LINE_LENGTH

      Default max length of the initial line (e.g. `"HTTP/1.1 200 OK"`) = 4096
      See Also:
        Constant Field Values

    - #### DEFAULT_MAX_HEADER_SIZE

          public static final int DEFAULT_MAX_HEADER_SIZE

      Default max length of all headers = 8192
      See Also:
        Constant Field Values

    - #### DEFAULT_MAX_WAIT_QUEUE_SIZE

          public static final int DEFAULT_MAX_WAIT_QUEUE_SIZE

      Default max wait queue size = -1 (unbounded)
      See Also:
        Constant Field Values

    - #### DEFAULT_ALPN_VERSIONS

          public static final List<HttpVersion> DEFAULT_ALPN_VERSIONS

      Default Application-Layer Protocol Negotiation versions = [] (automatic according to protocol version)

    - #### DEFAULT_HTTP2_CLEAR_TEXT_UPGRADE

          public static final boolean DEFAULT_HTTP2_CLEAR_TEXT_UPGRADE

      Default using HTTP/1.1 upgrade for establishing an h2C connection = true
      See Also:
        Constant Field Values

    - #### DEFAULT_SEND_UNMASKED_FRAMES

          public static final boolean DEFAULT_SEND_UNMASKED_FRAMES

      Default WebSocket Masked bit is true as depicted by RFC. PerformingUnMasking will be false
      See Also:
        Constant Field Values

    - #### DEFAULT_MAX_REDIRECTS

          public static final int DEFAULT_MAX_REDIRECTS

      See Also:
        Constant Field Values

    - #### DEFAULT_FORCE_SNI

          public static final boolean DEFAULT_FORCE_SNI

      See Also:
        Constant Field Values

    - #### DEFAULT_DECODER_INITIAL_BUFFER_SIZE

          public static final int DEFAULT_DECODER_INITIAL_BUFFER_SIZE

      Default initial buffer size for HttpObjectDecoder = 128 bytes
      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### HttpClientOptions

          public HttpClientOptions()

      Default constructor

    - #### HttpClientOptions

          public HttpClientOptions(HttpClientOptions other)

      Copy constructor
      Parameters:
        `other` - the options to copy

    - #### HttpClientOptions

          public HttpClientOptions(JsonObject json)

      Constructor to create an options from JSON
      Parameters:
        `json` - the JSON

  - ### Method Detail

    - #### toJson

          public JsonObject toJson()

      Convert to JSON
      Overrides:
        `toJson` in class `ClientOptionsBase`
      Returns:
        the JSON

    - #### setSendBufferSize

          public HttpClientOptions setSendBufferSize(int sendBufferSize)

      Description copied from class: `NetworkOptions`
      Set the TCP send buffer size
      Overrides:
        `setSendBufferSize` in class `ClientOptionsBase`
      Parameters:
        `sendBufferSize` - the buffers size, in bytes
      Returns:
        a reference to this, so the API can be used fluently

    - #### setReceiveBufferSize

          public HttpClientOptions setReceiveBufferSize(int receiveBufferSize)

      Description copied from class: `NetworkOptions`
      Set the TCP receive buffer size
      Overrides:
        `setReceiveBufferSize` in class `ClientOptionsBase`
      Parameters:
        `receiveBufferSize` - the buffers size, in bytes
      Returns:
        a reference to this, so the API can be used fluently

    - #### setReuseAddress

          public HttpClientOptions setReuseAddress(boolean reuseAddress)

      Description copied from class: `NetworkOptions`
      Set the value of reuse address
      Overrides:
        `setReuseAddress` in class `ClientOptionsBase`
      Parameters:
        `reuseAddress` - the value of reuse address
      Returns:
        a reference to this, so the API can be used fluently

    - #### setTrafficClass

          public HttpClientOptions setTrafficClass(int trafficClass)

      Description copied from class: `NetworkOptions`
      Set the value of traffic class
      Overrides:
        `setTrafficClass` in class `ClientOptionsBase`
      Parameters:
        `trafficClass` - the value of traffic class
      Returns:
        a reference to this, so the API can be used fluently

    - #### setTcpNoDelay

          public HttpClientOptions setTcpNoDelay(boolean tcpNoDelay)

      Description copied from class: `TCPSSLOptions`
      Set whether TCP no delay is enabled
      Overrides:
        `setTcpNoDelay` in class `ClientOptionsBase`
      Parameters:
        `tcpNoDelay` - true if TCP no delay is enabled (Nagle disabled)
      Returns:
        a reference to this, so the API can be used fluently

    - #### setTcpKeepAlive

          public HttpClientOptions setTcpKeepAlive(boolean tcpKeepAlive)

      Description copied from class: `TCPSSLOptions`
      Set whether TCP keep alive is enabled
      Overrides:
        `setTcpKeepAlive` in class `ClientOptionsBase`
      Parameters:
        `tcpKeepAlive` - true if TCP keep alive is enabled
      Returns:
        a reference to this, so the API can be used fluently

    - #### setSoLinger

          public HttpClientOptions setSoLinger(int soLinger)

      Description copied from class: `TCPSSLOptions`
      Set whether SO_linger keep alive is enabled
      Overrides:
        `setSoLinger` in class `ClientOptionsBase`
      Parameters:
        `soLinger` - true if SO_linger is enabled
      Returns:
        a reference to this, so the API can be used fluently

    - #### setUsePooledBuffers

          public HttpClientOptions setUsePooledBuffers(boolean usePooledBuffers)

      Description copied from class: `TCPSSLOptions`
      Set whether Netty pooled buffers are enabled
      Overrides:
        `setUsePooledBuffers` in class `ClientOptionsBase`
      Parameters:
        `usePooledBuffers` - true if pooled buffers enabled
      Returns:
        a reference to this, so the API can be used fluently

    - #### setIdleTimeout

          public HttpClientOptions setIdleTimeout(int idleTimeout)

      Description copied from class: `TCPSSLOptions`
      Set the idle timeout, in seconds. zero means don't timeout. This determines if a connection will timeout and be closed if no data is received within the timeout.
      Overrides:
        `setIdleTimeout` in class `ClientOptionsBase`
      Parameters:
        `idleTimeout` - the timeout, in seconds
      Returns:
        a reference to this, so the API can be used fluently

    - #### setSsl

          public HttpClientOptions setSsl(boolean ssl)

      Description copied from class: `TCPSSLOptions`
      Set whether SSL/TLS is enabled
      Overrides:
        `setSsl` in class `ClientOptionsBase`
      Parameters:
        `ssl` - true if enabled
      Returns:
        a reference to this, so the API can be used fluently

    - #### setKeyCertOptions

          public HttpClientOptions setKeyCertOptions(KeyCertOptions options)

      Description copied from class: `TCPSSLOptions`
      Set the key/cert options.
      Overrides:
        `setKeyCertOptions` in class `ClientOptionsBase`
      Parameters:
        `options` - the key store options
      Returns:
        a reference to this, so the API can be used fluently

    - #### setKeyStoreOptions

          public HttpClientOptions setKeyStoreOptions(JksOptions options)

      Description copied from class: `TCPSSLOptions`
      Set the key/cert options in jks format, aka Java keystore.
      Overrides:
        `setKeyStoreOptions` in class `ClientOptionsBase`
      Parameters:
        `options` - the key store in jks format
      Returns:
        a reference to this, so the API can be used fluently

    - #### setPfxKeyCertOptions

          public HttpClientOptions setPfxKeyCertOptions(PfxOptions options)

      Description copied from class: `TCPSSLOptions`
      Set the key/cert options in pfx format.
      Overrides:
        `setPfxKeyCertOptions` in class `ClientOptionsBase`
      Parameters:
        `options` - the key cert options in pfx format
      Returns:
        a reference to this, so the API can be used fluently

    - #### setTrustOptions

          public HttpClientOptions setTrustOptions(TrustOptions options)

      Description copied from class: `TCPSSLOptions`
      Set the trust options.
      Overrides:
        `setTrustOptions` in class `ClientOptionsBase`
      Parameters:
        `options` - the trust options
      Returns:
        a reference to this, so the API can be used fluently

    - #### setPemKeyCertOptions

          public HttpClientOptions setPemKeyCertOptions(PemKeyCertOptions options)

      Description copied from class: `TCPSSLOptions`
      Set the key/cert store options in pem format.
      Overrides:
        `setPemKeyCertOptions` in class `ClientOptionsBase`
      Parameters:
        `options` - the options in pem format
      Returns:
        a reference to this, so the API can be used fluently

    - #### setTrustStoreOptions

          public HttpClientOptions setTrustStoreOptions(JksOptions options)

      Description copied from class: `TCPSSLOptions`
      Set the trust options in jks format, aka Java truststore
      Overrides:
        `setTrustStoreOptions` in class `ClientOptionsBase`
      Parameters:
        `options` - the trust options in jks format
      Returns:
        a reference to this, so the API can be used fluently

    - #### setPfxTrustOptions

          public HttpClientOptions setPfxTrustOptions(PfxOptions options)

      Description copied from class: `TCPSSLOptions`
      Set the trust options in pfx format
      Overrides:
        `setPfxTrustOptions` in class `ClientOptionsBase`
      Parameters:
        `options` - the trust options in pfx format
      Returns:
        a reference to this, so the API can be used fluently

    - #### setPemTrustOptions

          public HttpClientOptions setPemTrustOptions(PemTrustOptions options)

      Description copied from class: `TCPSSLOptions`
      Set the trust options in pem format
      Overrides:
        `setPemTrustOptions` in class `ClientOptionsBase`
      Parameters:
        `options` - the trust options in pem format
      Returns:
        a reference to this, so the API can be used fluently

    - #### addEnabledCipherSuite

          public HttpClientOptions addEnabledCipherSuite(String suite)

      Description copied from class: `TCPSSLOptions`
      Add an enabled cipher suite, appended to the ordered suites.
      Overrides:
        `addEnabledCipherSuite` in class `TCPSSLOptions`
      Parameters:
        `suite` - the suite
      Returns:
        a reference to this, so the API can be used fluently

    - #### addEnabledSecureTransportProtocol

          public HttpClientOptions addEnabledSecureTransportProtocol(String protocol)

      Description copied from class: `TCPSSLOptions`
      Add an enabled SSL/TLS protocols, appended to the ordered protocols.
      Overrides:
        `addEnabledSecureTransportProtocol` in class `TCPSSLOptions`
      Parameters:
        `protocol` - the SSL/TLS protocol do enabled
      Returns:
        a reference to this, so the API can be used fluently

    - #### addCrlPath

          public HttpClientOptions addCrlPath(String crlPath)
                                       throws NullPointerException

      Description copied from class: `TCPSSLOptions`
      Add a CRL path
      Overrides:
        `addCrlPath` in class `TCPSSLOptions`
      Parameters:
        `crlPath` - the path
      Returns:
        a reference to this, so the API can be used fluently
      Throws:
        `NullPointerException`

    - #### addCrlValue

          public HttpClientOptions addCrlValue(Buffer crlValue)
                                        throws NullPointerException

      Description copied from class: `TCPSSLOptions`
      Add a CRL value
      Overrides:
        `addCrlValue` in class `TCPSSLOptions`
      Parameters:
        `crlValue` - the value
      Returns:
        a reference to this, so the API can be used fluently
      Throws:
        `NullPointerException`

    - #### setConnectTimeout

          public HttpClientOptions setConnectTimeout(int connectTimeout)

      Description copied from class: `ClientOptionsBase`
      Set the connect timeout
      Overrides:
        `setConnectTimeout` in class `ClientOptionsBase`
      Parameters:
        `connectTimeout` - connect timeout, in ms
      Returns:
        a reference to this, so the API can be used fluently

    - #### setTrustAll

          public HttpClientOptions setTrustAll(boolean trustAll)

      Description copied from class: `ClientOptionsBase`
      Set whether all server certificates should be trusted
      Overrides:
        `setTrustAll` in class `ClientOptionsBase`
      Parameters:
        `trustAll` - true if all should be trusted
      Returns:
        a reference to this, so the API can be used fluently

    - #### getMaxPoolSize

          public int getMaxPoolSize()

      Get the maximum pool size for connections
      Returns:
        the maximum pool size

    - #### setMaxPoolSize

          public HttpClientOptions setMaxPoolSize(int maxPoolSize)

      Set the maximum pool size for connections
      Parameters:
        `maxPoolSize` - the maximum pool size
      Returns:
        a reference to this, so the API can be used fluently

    - #### getHttp2MultiplexingLimit

          public int getHttp2MultiplexingLimit()

      Returns:
        the maximum number of concurrent streams for an HTTP/2 connection, `-1` means the value sent by the server

    - #### setHttp2MultiplexingLimit

          public HttpClientOptions setHttp2MultiplexingLimit(int limit)

      Set a client limit of the number concurrent streams for each HTTP/2 connection, this limits the number of streams the client can create for a connection. The effective number of streams for a connection is the min of this value and the server's initial settings.

      Setting the value to `-1` means to use the value sent by the server's initial settings. `-1` is the default value.
      Parameters:
        `limit` - the maximum concurrent for an HTTP/2 connection
      Returns:
        a reference to this, so the API can be used fluently

    - #### getHttp2MaxPoolSize

          public int getHttp2MaxPoolSize()

      Get the maximum pool size for HTTP/2 connections
      Returns:
        the maximum pool size

    - #### setHttp2MaxPoolSize

          public HttpClientOptions setHttp2MaxPoolSize(int max)

      Set the maximum pool size for HTTP/2 connections
      Parameters:
        `max` - the maximum pool size
      Returns:
        a reference to this, so the API can be used fluently

    - #### getHttp2ConnectionWindowSize

          public int getHttp2ConnectionWindowSize()

      Returns:
        the default HTTP/2 connection window size

    - #### setHttp2ConnectionWindowSize

          public HttpClientOptions setHttp2ConnectionWindowSize(int http2ConnectionWindowSize)

      Set the default HTTP/2 connection window size. It overrides the initial window size set by `Http2Settings.getInitialWindowSize()`, so the connection window size is greater than for its streams, in order the data throughput.

      A value of `-1` reuses the initial window size setting.
      Parameters:
        `http2ConnectionWindowSize` - the window size applied to the connection
      Returns:
        a reference to this, so the API can be used fluently

    - #### isKeepAlive

          public boolean isKeepAlive()

      Is keep alive enabled on the client?
      Returns:
        true if enabled

    - #### setKeepAlive

          public HttpClientOptions setKeepAlive(boolean keepAlive)

      Set whether keep alive is enabled on the client
      Parameters:
        `keepAlive` - true if enabled
      Returns:
        a reference to this, so the API can be used fluently

    - #### isPipelining

          public boolean isPipelining()

      Is pipe-lining enabled on the client
      Returns:
        true if pipe-lining is enabled

    - #### setPipelining

          public HttpClientOptions setPipelining(boolean pipelining)

      Set whether pipe-lining is enabled on the client
      Parameters:
        `pipelining` - true if enabled
      Returns:
        a reference to this, so the API can be used fluently

    - #### getPipeliningLimit

          public int getPipeliningLimit()

      Returns:
        the limit of pending requests a pipe-lined HTTP/1 connection can send

    - #### setPipeliningLimit

          public HttpClientOptions setPipeliningLimit(int limit)

      Set the limit of pending requests a pipe-lined HTTP/1 connection can send.
      Parameters:
        `limit` - the limit of pending requests
      Returns:
        a reference to this, so the API can be used fluently

    - #### isVerifyHost

          public boolean isVerifyHost()

      Is hostname verification (for SSL/TLS) enabled?
      Returns:
        true if enabled

    - #### setVerifyHost

          public HttpClientOptions setVerifyHost(boolean verifyHost)

      Set whether hostname verification is enabled
      Parameters:
        `verifyHost` - true if enabled
      Returns:
        a reference to this, so the API can be used fluently

    - #### isTryUseCompression

          public boolean isTryUseCompression()

      Is compression enabled on the client?
      Returns:
        true if enabled

    - #### setTryUseCompression

          public HttpClientOptions setTryUseCompression(boolean tryUseCompression)

      Set whether compression is enabled
      Parameters:
        `tryUseCompression` - true if enabled
      Returns:
        a reference to this, so the API can be used fluently

    - #### isSendUnmaskedFrames

          public boolean isSendUnmaskedFrames()

      is masking frame skipped ?
      Returns:

    - #### setSendUnmaskedFrames

          public HttpClientOptions setSendUnmaskedFrames(boolean sendUnmaskedFrames)

      Set true when the client wants to skip frame masking. You may want to set it true on server by server websocket communication: In this case you are by passing RFC6455 protocol. It's false as default.
      Parameters:
        `sendUnmaskedFrames` - true if enabled
      Returns:
        a reference to this, so the API can be used fluently

    - #### getMaxWebsocketFrameSize

          public int getMaxWebsocketFrameSize()

      Get the maximum websocket framesize to use
      Returns:
        the max websocket framesize

    - #### setMaxWebsocketFrameSize

          public HttpClientOptions setMaxWebsocketFrameSize(int maxWebsocketFrameSize)

      Set the max websocket frame size
      Parameters:
        `maxWebsocketFrameSize` - the max frame size, in bytes
      Returns:
        a reference to this, so the API can be used fluently

    - #### getMaxWebsocketMessageSize

          public int getMaxWebsocketMessageSize()

      Get the maximum websocket message size to use
      Returns:
        the max websocket message size

    - #### setMaxWebsocketMessageSize

          public HttpClientOptions setMaxWebsocketMessageSize(int maxWebsocketMessageSize)

      Set the max websocket message size
      Parameters:
        `maxWebsocketMessageSize` - the max message size, in bytes
      Returns:
        a reference to this, so the API can be used fluently

    - #### getDefaultHost

          public String getDefaultHost()

      Get the default host name to be used by this client in requests if none is provided when making the request.
      Returns:
        the default host name

    - #### setDefaultHost

          public HttpClientOptions setDefaultHost(String defaultHost)

      Set the default host name to be used by this client in requests if none is provided when making the request.
      Returns:
        a reference to this, so the API can be used fluently

    - #### getDefaultPort

          public int getDefaultPort()

      Get the default port to be used by this client in requests if none is provided when making the request.
      Returns:
        the default port

    - #### setDefaultPort

          public HttpClientOptions setDefaultPort(int defaultPort)

      Set the default port to be used by this client in requests if none is provided when making the request.
      Returns:
        a reference to this, so the API can be used fluently

    - #### getProtocolVersion

          public HttpVersion getProtocolVersion()

      Get the protocol version.
      Returns:
        the protocol version

    - #### setProtocolVersion

          public HttpClientOptions setProtocolVersion(HttpVersion protocolVersion)

      Set the protocol version.
      Parameters:
        `protocolVersion` - the protocol version
      Returns:
        a reference to this, so the API can be used fluently

    - #### setMaxChunkSize

          public HttpClientOptions setMaxChunkSize(int maxChunkSize)

      Set the maximum HTTP chunk size
      Parameters:
        `maxChunkSize` - the maximum chunk size
      Returns:
        a reference to this, so the API can be used fluently

    - #### getMaxChunkSize

          public int getMaxChunkSize()

      Returns the maximum HTTP chunk size
      Returns:
        the maximum HTTP chunk size

    - #### getMaxInitialLineLength

          public int getMaxInitialLineLength()

      Returns:
        the maximum length of the initial line for HTTP/1.x (e.g. `"GET / HTTP/1.0"`)

    - #### setMaxInitialLineLength

          public HttpClientOptions setMaxInitialLineLength(int maxInitialLineLength)

      Set the maximum length of the initial line for HTTP/1.x (e.g. `"HTTP/1.1 200 OK"`)
      Parameters:
        `maxInitialLineLength` - the new maximum initial length
      Returns:
        a reference to this, so the API can be used fluently

    - #### getMaxHeaderSize

          public int getMaxHeaderSize()

      Returns:
        Returns the maximum length of all headers for HTTP/1.x

    - #### setMaxHeaderSize

          public HttpClientOptions setMaxHeaderSize(int maxHeaderSize)

      Set the maximum length of all headers for HTTP/1.x .
      Parameters:
        `maxHeaderSize` - the new maximum length
      Returns:
        a reference to this, so the API can be used fluently

    - #### setMaxWaitQueueSize

          public HttpClientOptions setMaxWaitQueueSize(int maxWaitQueueSize)

      Set the maximum requests allowed in the wait queue, any requests beyond the max size will result in a ConnectionPoolTooBusyException. If the value is set to a negative number then the queue will be unbounded.
      Parameters:
        `maxWaitQueueSize` - the maximum number of waiting requests
      Returns:
        a reference to this, so the API can be used fluently

    - #### getMaxWaitQueueSize

          public int getMaxWaitQueueSize()

      Returns the maximum wait queue size
      Returns:
        the maximum wait queue size

    - #### getInitialSettings

          public Http2Settings getInitialSettings()

      Returns:
        the initial HTTP/2 connection settings

    - #### setInitialSettings

          public HttpClientOptions setInitialSettings(Http2Settings settings)

      Set the HTTP/2 connection settings immediately sent by to the server when the client connects.
      Parameters:
        `settings` - the settings value
      Returns:
        a reference to this, so the API can be used fluently

    - #### setUseAlpn

          public HttpClientOptions setUseAlpn(boolean useAlpn)

      Description copied from class: `TCPSSLOptions`
      Set the ALPN usage.
      Overrides:
        `setUseAlpn` in class `ClientOptionsBase`
      Parameters:
        `useAlpn` - true when Application-Layer Protocol Negotiation should be used

    - #### setSslEngineOptions

          public HttpClientOptions setSslEngineOptions(SSLEngineOptions sslEngineOptions)

      Description copied from class: `TCPSSLOptions`
      Set to use SSL engine implementation to use.
      Overrides:
        `setSslEngineOptions` in class `ClientOptionsBase`
      Parameters:
        `sslEngineOptions` - the ssl engine to use
      Returns:
        a reference to this, so the API can be used fluently

    - #### setJdkSslEngineOptions

          public HttpClientOptions setJdkSslEngineOptions(JdkSSLEngineOptions sslEngineOptions)

      Overrides:
        `setJdkSslEngineOptions` in class `ClientOptionsBase`

    - #### setOpenSslEngineOptions

          public HttpClientOptions setOpenSslEngineOptions(OpenSSLEngineOptions sslEngineOptions)

      Overrides:
        `setOpenSslEngineOptions` in class `ClientOptionsBase`

    - #### getAlpnVersions

          public List<HttpVersion> getAlpnVersions()

      Returns:
        the list of protocol versions to provide during the Application-Layer Protocol Negotiation. When the list is empty, the client provides a best effort list according to `setProtocolVersion(io.vertx.core.http.HttpVersion)`

    - #### setAlpnVersions

          public HttpClientOptions setAlpnVersions(List<HttpVersion> alpnVersions)

      Set the list of protocol versions to provide to the server during the Application-Layer Protocol Negotiation. When the list is empty, the client provides a best effort list according to `setProtocolVersion(io.vertx.core.http.HttpVersion)`:
      - `HttpVersion.HTTP_2`: [ "h2", "http/1.1" ]
      - otherwise: [`getProtocolVersion()`]
      Parameters:
        `alpnVersions` - the versions
      Returns:
        a reference to this, so the API can be used fluently

    - #### isHttp2ClearTextUpgrade

          public boolean isHttp2ClearTextUpgrade()

      Returns:
        true when an h2c connection is established using an HTTP/1.1 upgrade request, false when directly

    - #### setHttp2ClearTextUpgrade

          public HttpClientOptions setHttp2ClearTextUpgrade(boolean value)

      Set to `true` when an h2c connection is established using an HTTP/1.1 upgrade request, and `false` when an h2c connection is established directly (with prior knowledge).
      Parameters:
        `value` - the upgrade value
      Returns:
        a reference to this, so the API can be used fluently

    - #### getMaxRedirects

          public int getMaxRedirects()

      Returns:
        the maximum number of redirection a request can follow

    - #### setMaxRedirects

          public HttpClientOptions setMaxRedirects(int maxRedirects)

      Set to `maxRedirects` the maximum number of redirection a request can follow.
      Parameters:
        `maxRedirects` - the maximum number of redirection
      Returns:
        a reference to this, so the API can be used fluently

    - #### isForceSni

          public boolean isForceSni()

      Returns:
        whether the client should always use SNI on TLS/SSL connections

    - #### setForceSni

          public HttpClientOptions setForceSni(boolean forceSni)

      By default, the server name is only sent for Fully Qualified Domain Name (FQDN), setting this property to `true` forces the server name to be always sent.
      Parameters:
        `forceSni` - true when the client should always use SNI on TLS/SSL connections
      Returns:
        a reference to this, so the API can be used fluently

    - #### setMetricsName

          public HttpClientOptions setMetricsName(String metricsName)

      Description copied from class: `ClientOptionsBase`
      Set the metrics name identifying the reported metrics, useful for grouping metrics with the same name.
      Overrides:
        `setMetricsName` in class `ClientOptionsBase`
      Parameters:
        `metricsName` - the metrics name
      Returns:
        a reference to this, so the API can be used fluently

    - #### setProxyOptions

          public HttpClientOptions setProxyOptions(ProxyOptions proxyOptions)

      Description copied from class: `ClientOptionsBase`
      Set proxy options for connections via CONNECT proxy (e.g. Squid) or a SOCKS proxy.
      Overrides:
        `setProxyOptions` in class `ClientOptionsBase`
      Parameters:
        `proxyOptions` - proxy options object
      Returns:
        a reference to this, so the API can be used fluently

    - #### setLocalAddress

          public HttpClientOptions setLocalAddress(String localAddress)

      Description copied from class: `ClientOptionsBase`
      Set the local interface to bind for network connections. When the local address is null, it will pick any local address, the default local address is null.
      Overrides:
        `setLocalAddress` in class `ClientOptionsBase`
      Parameters:
        `localAddress` - the local address
      Returns:
        a reference to this, so the API can be used fluently

    - #### setLogActivity

          public HttpClientOptions setLogActivity(boolean logEnabled)

      Description copied from class: `NetworkOptions`
      Set to true to enabled network activity logging: Netty's pipeline is configured for logging on Netty's logger.
      Overrides:
        `setLogActivity` in class `ClientOptionsBase`
      Parameters:
        `logEnabled` - true for logging the network activity
      Returns:
        a reference to this, so the API can be used fluently

    - #### getDecoderInitialBufferSize

          public int getDecoderInitialBufferSize()

      Returns:
        the initial buffer size for the HTTP decoder

    - #### setDecoderInitialBufferSize

          public HttpClientOptions setDecoderInitialBufferSize(int decoderInitialBufferSize)

      set to `initialBufferSizeHttpDecoder` the initial buffer of the HttpDecoder.
      Parameters:
        `decoderInitialBufferSize` - the initial buffer size
      Returns:
        a reference to this, so the API can be used fluently

    - #### equals

          public boolean equals(Object o)

      Overrides:
        `equals` in class `ClientOptionsBase`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `ClientOptionsBase`

Copyright © 2017. All rights reserved.