io.vertx.core.http

## Class HttpServerOptions

- java.lang.Object
- - io.vertx.core.net.NetworkOptions
  - - io.vertx.core.net.TCPSSLOptions
    - - io.vertx.core.net.NetServerOptions
      - - io.vertx.core.http.HttpServerOptions

- Direct Known Subclasses:
    HttpTermOptions

      public class HttpServerOptions
      extends NetServerOptions

  Represents options used by an `HttpServer` instance
  Author:
    Tim Fox

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static boolean` | `DEFAULT_ACCEPT_UNMASKED_FRAMES` Default WebSocket Masked bit is true as depicted by RFC.
    `static List<HttpVersion>` | `DEFAULT_ALPN_VERSIONS` Default Application-Layer Protocol Negotiation versions = [HTTP/2,HTTP/1.1]
    `static int` | `DEFAULT_COMPRESSION_LEVEL` Default gzip/deflate compression level = 6 (Netty legacy)
    `static boolean` | `DEFAULT_COMPRESSION_SUPPORTED` Default value of whether compression is supported = false
    `static boolean` | `DEFAULT_DECOMPRESSION_SUPPORTED` Default value of whether decompression is supported = false
    `static boolean` | `DEFAULT_HANDLE_100_CONTINE_AUTOMATICALLY` Default value of whether 100-Continue should be handled automatically
    `static int` | `DEFAULT_HTTP2_CONNECTION_WINDOW_SIZE`
    `static long` | `DEFAULT_INITIAL_SETTINGS_MAX_CONCURRENT_STREAMS` The default inital settings max concurrent stream for an HTTP/2 server = 100
    `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_WEBSOCKET_FRAME_SIZE` Default max websocket framesize = 65536
    `static int` | `DEFAULT_MAX_WEBSOCKET_MESSAGE_SIZE` Default max websocket message size (could be assembled from multiple frames) is 4 full frames worth of data
    `static int` | `DEFAULT_PORT` Default port the server will listen on = 80

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

      `DEFAULT_ACCEPT_BACKLOG, DEFAULT_CLIENT_AUTH, DEFAULT_HOST`

    - ### 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
    `HttpServerOptions()` Default constructor
    `HttpServerOptions(HttpServerOptions other)` Copy constructor
    `HttpServerOptions(JsonObject json)` Create an options from JSON

  - ### Method Summary

    All Methods Instance Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `HttpServerOptions` | `addCrlPath(String crlPath)` Add a CRL path
    `HttpServerOptions` | `addCrlValue(Buffer crlValue)` Add a CRL value
    `HttpServerOptions` | `addEnabledCipherSuite(String suite)` Add an enabled cipher suite, appended to the ordered suites.
    `HttpServerOptions` | `addEnabledSecureTransportProtocol(String protocol)` Add an enabled SSL/TLS protocols, appended to the ordered protocols.
    `boolean` | `equals(Object o)`
    `List<HttpVersion>` | `getAlpnVersions()`
    `int` | `getCompressionLevel()`
    `int` | `getHttp2ConnectionWindowSize()`
    `Http2Settings` | `getInitialSettings()`
    `int` | `getMaxChunkSize()` Returns the maximum HTTP chunk size
    `int` | `getMaxHeaderSize()`
    `int` | `getMaxInitialLineLength()`
    `int` | `getMaxWebsocketFrameSize()`
    `int` | `getMaxWebsocketMessageSize()`
    `String` | `getWebsocketSubProtocols()`
    `int` | `hashCode()`
    `boolean` | `isAcceptUnmaskedFrames()`
    `boolean` | `isCompressionSupported()`
    `boolean` | `isDecompressionSupported()`
    `boolean` | `isHandle100ContinueAutomatically()`
    `HttpServerOptions` | `setAcceptBacklog(int acceptBacklog)` Set the accept back log
    `HttpServerOptions` | `setAcceptUnmaskedFrames(boolean acceptUnmaskedFrames)` Set true when the server accepts unmasked frame.
    `HttpServerOptions` | `setAlpnVersions(List<HttpVersion> alpnVersions)` Set the list of protocol versions to provide to the server during the Application-Layer Protocol Negotiatiation.
    `HttpServerOptions` | `setClientAuth(ClientAuth clientAuth)` Set whether client auth is required
    `HttpServerOptions` | `setClientAuthRequired(boolean clientAuthRequired)` Deprecated.
    `HttpServerOptions` | `setCompressionLevel(int compressionLevel)` This method allows to set the compression level to be used in http1.x/2 response bodies when compression support is turned on (@see setCompressionSupported) and the client advertises to support `deflate/gzip` compression in the `Accept-Encoding` header default value is : 6 (Netty legacy) The compression level determines how much the data is compressed on a scale from 1 to 9, where '9' is trying to achieve the maximum compression ratio while '1' instead is giving priority to speed instead of compression ratio using some algorithm optimizations and skipping pedantic loops that usually gives just little improvements While one can think that best value is always the maximum compression ratio, there's a trade-off to consider: the most compressed level requires the most computatinal work to compress/decompress data, e.g.
    `HttpServerOptions` | `setCompressionSupported(boolean compressionSupported)` Set whether the server should support gzip/deflate compression (serving compressed responses to clients advertising support for them with Accept-Encoding header)
    `HttpServerOptions` | `setDecompressionSupported(boolean decompressionSupported)` Set whether the server supports decompression
    `HttpServerOptions` | `setHandle100ContinueAutomatically(boolean handle100ContinueAutomatically)` Set whether 100 Continue should be handled automatically
    `HttpServerOptions` | `setHost(String host)` Set the host
    `HttpServerOptions` | `setHttp2ConnectionWindowSize(int http2ConnectionWindowSize)` Set the default HTTP/2 connection window size.
    `HttpServerOptions` | `setIdleTimeout(int idleTimeout)` Set the idle timeout, in seconds.
    `HttpServerOptions` | `setInitialSettings(Http2Settings settings)` Set the HTTP/2 connection settings immediatly sent by the server when a client connects.
    `HttpServerOptions` | `setJdkSslEngineOptions(JdkSSLEngineOptions sslEngineOptions)`
    `HttpServerOptions` | `setKeyCertOptions(KeyCertOptions options)` Set the key/cert options.
    `HttpServerOptions` | `setKeyStoreOptions(JksOptions options)` Set the key/cert options in jks format, aka Java keystore.
    `HttpServerOptions` | `setLogActivity(boolean logEnabled)` Set to true to enabled network activity logging: Netty's pipeline is configured for logging on Netty's logger.
    `HttpServerOptions` | `setMaxChunkSize(int maxChunkSize)` Set the maximum HTTP chunk size
    `HttpServerOptions` | `setMaxHeaderSize(int maxHeaderSize)` Set the maximum length of all headers for HTTP/1.x .
    `HttpServerOptions` | `setMaxInitialLineLength(int maxInitialLineLength)` Set the maximum length of the initial line for HTTP/1.x (e.g.
    `HttpServerOptions` | `setMaxWebsocketFrameSize(int maxWebsocketFrameSize)` Set the maximum websocket frames size
    `HttpServerOptions` | `setMaxWebsocketMessageSize(int maxWebsocketMessageSize)` Set the maximum websocket message size
    `HttpServerOptions` | `setOpenSslEngineOptions(OpenSSLEngineOptions sslEngineOptions)`
    `HttpServerOptions` | `setPemKeyCertOptions(PemKeyCertOptions options)` Set the key/cert store options in pem format.
    `HttpServerOptions` | `setPemTrustOptions(PemTrustOptions options)` Set the trust options in pem format
    `HttpServerOptions` | `setPfxKeyCertOptions(PfxOptions options)` Set the key/cert options in pfx format.
    `HttpServerOptions` | `setPfxTrustOptions(PfxOptions options)` Set the trust options in pfx format
    `HttpServerOptions` | `setPort(int port)` Set the port
    `HttpServerOptions` | `setReceiveBufferSize(int receiveBufferSize)` Set the TCP receive buffer size
    `HttpServerOptions` | `setReuseAddress(boolean reuseAddress)` Set the value of reuse address
    `HttpServerOptions` | `setSendBufferSize(int sendBufferSize)` Set the TCP send buffer size
    `HttpServerOptions` | `setSoLinger(int soLinger)` Set whether SO_linger keep alive is enabled
    `HttpServerOptions` | `setSsl(boolean ssl)` Set whether SSL/TLS is enabled
    `HttpServerOptions` | `setSslEngineOptions(SSLEngineOptions sslEngineOptions)` Set to use SSL engine implementation to use.
    `HttpServerOptions` | `setTcpKeepAlive(boolean tcpKeepAlive)` Set whether TCP keep alive is enabled
    `HttpServerOptions` | `setTcpNoDelay(boolean tcpNoDelay)` Set whether TCP no delay is enabled
    `HttpServerOptions` | `setTrafficClass(int trafficClass)` Set the value of traffic class
    `HttpServerOptions` | `setTrustOptions(TrustOptions options)` Set the trust options.
    `HttpServerOptions` | `setTrustStoreOptions(JksOptions options)` Set the trust options in jks format, aka Java truststore
    `HttpServerOptions` | `setUseAlpn(boolean useAlpn)` Set the ALPN usage.
    `HttpServerOptions` | `setUsePooledBuffers(boolean usePooledBuffers)` Set whether Netty pooled buffers are enabled
    `HttpServerOptions` | `setWebsocketSubProtocols(String subProtocols)` Set the websocket subprotocols supported by the server.
    `JsonObject` | `toJson()` Convert to JSON

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

      `getAcceptBacklog, getClientAuth, getHost, getPort, isClientAuthRequired`

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

          public static final int DEFAULT_PORT

      Default port the server will listen on = 80
      See Also:
        Constant Field Values

    - #### DEFAULT_COMPRESSION_SUPPORTED

          public static final boolean DEFAULT_COMPRESSION_SUPPORTED

      Default value of whether compression is supported = false
      See Also:
        Constant Field Values

    - #### DEFAULT_COMPRESSION_LEVEL

          public static final int DEFAULT_COMPRESSION_LEVEL

      Default gzip/deflate compression level = 6 (Netty legacy)
      See Also:
        Constant Field Values

    - #### DEFAULT_MAX_WEBSOCKET_FRAME_SIZE

          public static final int DEFAULT_MAX_WEBSOCKET_FRAME_SIZE

      Default max websocket framesize = 65536
      See Also:
        Constant Field Values

    - #### DEFAULT_MAX_WEBSOCKET_MESSAGE_SIZE

          public static final int DEFAULT_MAX_WEBSOCKET_MESSAGE_SIZE

      Default max websocket message size (could be assembled from multiple frames) is 4 full frames worth of data
      See Also:
        Constant Field Values

    - #### 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. `"GET / HTTP/1.0"`) = 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_HANDLE_100_CONTINE_AUTOMATICALLY

          public static final boolean DEFAULT_HANDLE_100_CONTINE_AUTOMATICALLY

      Default value of whether 100-Continue should be handled automatically
      See Also:
        Constant Field Values

    - #### DEFAULT_ALPN_VERSIONS

          public static final List<HttpVersion> DEFAULT_ALPN_VERSIONS

      Default Application-Layer Protocol Negotiation versions = [HTTP/2,HTTP/1.1]

    - #### DEFAULT_INITIAL_SETTINGS_MAX_CONCURRENT_STREAMS

          public static final long DEFAULT_INITIAL_SETTINGS_MAX_CONCURRENT_STREAMS

      The default inital settings max concurrent stream for an HTTP/2 server = 100
      See Also:
        Constant Field Values

    - #### DEFAULT_HTTP2_CONNECTION_WINDOW_SIZE

          public static final int DEFAULT_HTTP2_CONNECTION_WINDOW_SIZE

      See Also:
        Constant Field Values

    - #### DEFAULT_DECOMPRESSION_SUPPORTED

          public static final boolean DEFAULT_DECOMPRESSION_SUPPORTED

      Default value of whether decompression is supported = false
      See Also:
        Constant Field Values

    - #### DEFAULT_ACCEPT_UNMASKED_FRAMES

          public static final boolean DEFAULT_ACCEPT_UNMASKED_FRAMES

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

  - ### Constructor Detail

    - #### HttpServerOptions

          public HttpServerOptions()

      Default constructor

    - #### HttpServerOptions

          public HttpServerOptions(HttpServerOptions other)

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

    - #### HttpServerOptions

          public HttpServerOptions(JsonObject json)

      Create an options from JSON
      Parameters:
        `json` - the JSON

  - ### Method Detail

    - #### toJson

          public JsonObject toJson()

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

    - #### setSendBufferSize

          public HttpServerOptions setSendBufferSize(int sendBufferSize)

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

    - #### setReceiveBufferSize

          public HttpServerOptions setReceiveBufferSize(int receiveBufferSize)

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

    - #### setReuseAddress

          public HttpServerOptions setReuseAddress(boolean reuseAddress)

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

    - #### setTrafficClass

          public HttpServerOptions setTrafficClass(int trafficClass)

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

    - #### setTcpNoDelay

          public HttpServerOptions setTcpNoDelay(boolean tcpNoDelay)

      Description copied from class: `TCPSSLOptions`
      Set whether TCP no delay is enabled
      Overrides:
        `setTcpNoDelay` in class `NetServerOptions`
      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 HttpServerOptions setTcpKeepAlive(boolean tcpKeepAlive)

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

    - #### setSoLinger

          public HttpServerOptions setSoLinger(int soLinger)

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

    - #### setUsePooledBuffers

          public HttpServerOptions setUsePooledBuffers(boolean usePooledBuffers)

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

    - #### setIdleTimeout

          public HttpServerOptions 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 `NetServerOptions`
      Parameters:
        `idleTimeout` - the timeout, in seconds
      Returns:
        a reference to this, so the API can be used fluently

    - #### setSsl

          public HttpServerOptions setSsl(boolean ssl)

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

    - #### setUseAlpn

          public HttpServerOptions setUseAlpn(boolean useAlpn)

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

    - #### setKeyCertOptions

          public HttpServerOptions setKeyCertOptions(KeyCertOptions options)

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

    - #### setKeyStoreOptions

          public HttpServerOptions setKeyStoreOptions(JksOptions options)

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

    - #### setPfxKeyCertOptions

          public HttpServerOptions setPfxKeyCertOptions(PfxOptions options)

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

    - #### setPemKeyCertOptions

          public HttpServerOptions setPemKeyCertOptions(PemKeyCertOptions options)

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

    - #### setTrustOptions

          public HttpServerOptions setTrustOptions(TrustOptions options)

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

    - #### setTrustStoreOptions

          public HttpServerOptions setTrustStoreOptions(JksOptions options)

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

    - #### setPemTrustOptions

          public HttpServerOptions setPemTrustOptions(PemTrustOptions options)

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

    - #### setPfxTrustOptions

          public HttpServerOptions setPfxTrustOptions(PfxOptions options)

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

    - #### addEnabledCipherSuite

          public HttpServerOptions addEnabledCipherSuite(String suite)

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

    - #### addEnabledSecureTransportProtocol

          public HttpServerOptions addEnabledSecureTransportProtocol(String protocol)

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

    - #### addCrlPath

          public HttpServerOptions addCrlPath(String crlPath)
                                       throws NullPointerException

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

    - #### addCrlValue

          public HttpServerOptions addCrlValue(Buffer crlValue)
                                        throws NullPointerException

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

    - #### setAcceptBacklog

          public HttpServerOptions setAcceptBacklog(int acceptBacklog)

      Description copied from class: `NetServerOptions`
      Set the accept back log
      Overrides:
        `setAcceptBacklog` in class `NetServerOptions`
      Parameters:
        `acceptBacklog` - accept backlog
      Returns:
        a reference to this, so the API can be used fluently

    - #### setPort

          public HttpServerOptions setPort(int port)

      Description copied from class: `NetServerOptions`
      Set the port
      Overrides:
        `setPort` in class `NetServerOptions`
      Parameters:
        `port` - the port
      Returns:
        a reference to this, so the API can be used fluently

    - #### setHost

          public HttpServerOptions setHost(String host)

      Description copied from class: `NetServerOptions`
      Set the host
      Overrides:
        `setHost` in class `NetServerOptions`
      Parameters:
        `host` - the host
      Returns:
        a reference to this, so the API can be used fluently

    - #### setClientAuthRequired

          @Deprecated
          public HttpServerOptions setClientAuthRequired(boolean clientAuthRequired)

      Deprecated.
      Description copied from class: `NetServerOptions`
      Set whether client auth is required
      Overrides:
        `setClientAuthRequired` in class `NetServerOptions`
      Parameters:
        `clientAuthRequired` - true if client auth is required
      Returns:
        a reference to this, so the API can be used fluently

    - #### setClientAuth

          public HttpServerOptions setClientAuth(ClientAuth clientAuth)

      Description copied from class: `NetServerOptions`
      Set whether client auth is required
      Overrides:
        `setClientAuth` in class `NetServerOptions`
      Parameters:
        `clientAuth` - One of "NONE, REQUEST, REQUIRED". If it's set to "REQUIRED" then server will require the SSL cert to be presented otherwise it won't accept the request. If it's set to "REQUEST" then it won't mandate the certificate to be presented, basically make it optional.
      Returns:
        a reference to this, so the API can be used fluently

    - #### setSslEngineOptions

          public HttpServerOptions setSslEngineOptions(SSLEngineOptions sslEngineOptions)

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

    - #### setJdkSslEngineOptions

          public HttpServerOptions setJdkSslEngineOptions(JdkSSLEngineOptions sslEngineOptions)

      Overrides:
        `setJdkSslEngineOptions` in class `NetServerOptions`

    - #### setOpenSslEngineOptions

          public HttpServerOptions setOpenSslEngineOptions(OpenSSLEngineOptions sslEngineOptions)

      Overrides:
        `setOpenSslEngineOptions` in class `NetServerOptions`

    - #### isCompressionSupported

          public boolean isCompressionSupported()

      Returns:
        true if the server supports gzip/deflate compression

    - #### setCompressionSupported

          public HttpServerOptions setCompressionSupported(boolean compressionSupported)

      Set whether the server should support gzip/deflate compression (serving compressed responses to clients advertising support for them with Accept-Encoding header)
      Parameters:
        `compressionSupported` - true to enable compression support
      Returns:
        a reference to this, so the API can be used fluently

    - #### getCompressionLevel

          public int getCompressionLevel()

      Returns:
        the server gzip/deflate 'compression level' to be used in responses when client and server support is turned on

    - #### setCompressionLevel

          public HttpServerOptions setCompressionLevel(int compressionLevel)

      This method allows to set the compression level to be used in http1.x/2 response bodies when compression support is turned on (@see setCompressionSupported) and the client advertises to support `deflate/gzip` compression in the `Accept-Encoding` header default value is : 6 (Netty legacy) The compression level determines how much the data is compressed on a scale from 1 to 9, where '9' is trying to achieve the maximum compression ratio while '1' instead is giving priority to speed instead of compression ratio using some algorithm optimizations and skipping pedantic loops that usually gives just little improvements While one can think that best value is always the maximum compression ratio, there's a trade-off to consider: the most compressed level requires the most computatinal work to compress/decompress data, e.g. more dictionary lookups and loops. E.g. you have it set fairly high on a high-volume website, you may experience performance degradation and latency on resource serving due to CPU overload, and, however - as the comptational work is required also client side while decompressing - setting an higher compression level can result in an overall higher page load time especially nowadays when many clients are handled mobile devices with a low CPU profile. see also: http://www.gzip.org/algorithm.txt
      Parameters:
        `compressionLevel` - integer 1-9, 1 means use fastest algorithm, 9 slower algorithm but better compression ratio
      Returns:
        a reference to this, so the API can be used fluently

    - #### isAcceptUnmaskedFrames

          public boolean isAcceptUnmaskedFrames()

    - #### setAcceptUnmaskedFrames

          public HttpServerOptions setAcceptUnmaskedFrames(boolean acceptUnmaskedFrames)

      Set true when the server accepts unmasked frame. As default Server doesn't accept unmasked frame, you can bypass this behaviour (RFC 6455) setting true It's set to false as default.
      Parameters:
        `acceptUnmaskedFrames` - true if enabled
      Returns:
        a reference to this, so the API can be used fluently

    - #### getMaxWebsocketFrameSize

          public int getMaxWebsocketFrameSize()

      Returns:
        the maximum websocket framesize

    - #### setMaxWebsocketFrameSize

          public HttpServerOptions setMaxWebsocketFrameSize(int maxWebsocketFrameSize)

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

    - #### getMaxWebsocketMessageSize

          public int getMaxWebsocketMessageSize()

      Returns:
        the maximum websocket message size

    - #### setMaxWebsocketMessageSize

          public HttpServerOptions setMaxWebsocketMessageSize(int maxWebsocketMessageSize)

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

    - #### setWebsocketSubProtocols

          public HttpServerOptions setWebsocketSubProtocols(String subProtocols)

      Set the websocket subprotocols supported by the server.
      Parameters:
        `subProtocols` - comma separated list of subprotocols
      Returns:
        a reference to this, so the API can be used fluently

    - #### getWebsocketSubProtocols

          public String getWebsocketSubProtocols()

      Returns:
        Get the websocket subprotocols

    - #### isHandle100ContinueAutomatically

          public boolean isHandle100ContinueAutomatically()

      Returns:
        whether 100 Continue should be handled automatically

    - #### setHandle100ContinueAutomatically

          public HttpServerOptions setHandle100ContinueAutomatically(boolean handle100ContinueAutomatically)

      Set whether 100 Continue should be handled automatically
      Parameters:
        `handle100ContinueAutomatically` - true if it should be handled automatically
      Returns:
        a reference to this, so the API can be used fluently

    - #### setMaxChunkSize

          public HttpServerOptions 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 HttpServerOptions setMaxInitialLineLength(int maxInitialLineLength)

      Set the maximum length of the initial line for HTTP/1.x (e.g. `"GET / HTTP/1.0"`)
      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 HttpServerOptions 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

    - #### getInitialSettings

          public Http2Settings getInitialSettings()

      Returns:
        the initial HTTP/2 connection settings

    - #### setInitialSettings

          public HttpServerOptions setInitialSettings(Http2Settings settings)

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

    - #### getAlpnVersions

          public List<HttpVersion> getAlpnVersions()

      Returns:
        the list of protocol versions to provide during the Application-Layer Protocol Negotiatiation

    - #### setAlpnVersions

          public HttpServerOptions setAlpnVersions(List<HttpVersion> alpnVersions)

      Set the list of protocol versions to provide to the server during the Application-Layer Protocol Negotiatiation.
      Parameters:
        `alpnVersions` - the versions
      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 HttpServerOptions 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

    - #### setLogActivity

          public HttpServerOptions 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 `NetServerOptions`
      Parameters:
        `logEnabled` - true for logging the network activity
      Returns:
        a reference to this, so the API can be used fluently

    - #### isDecompressionSupported

          public boolean isDecompressionSupported()

      Returns:
        true if the server supports decompression

    - #### setDecompressionSupported

          public HttpServerOptions setDecompressionSupported(boolean decompressionSupported)

      Set whether the server supports decompression
      Parameters:
        `decompressionSupported` - true if decompression supported
      Returns:
        a reference to this, so the API can be used fluently

    - #### equals

          public boolean equals(Object o)

      Overrides:
        `equals` in class `NetServerOptions`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `NetServerOptions`

Copyright © 2017. All rights reserved.