java.lang.Object
- io.vertx.reactivex.core.http.HttpServer

All Implemented Interfaces:

Measured
```
public class HttpServer
extends Object
implements Measured
```
An HTTP and WebSockets server.
You receive HTTP requests by providing a requestHandler(io.vertx.core.Handler<io.vertx.reactivex.core.http.HttpServerRequest>). As requests arrive on the server the handler will be called with the requests.
You receive WebSockets by providing a webSocketHandler(io.vertx.core.Handler<io.vertx.reactivex.core.http.ServerWebSocket>). As WebSocket connections arrive on the server, the WebSocket is passed to the handler.
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 Description

static TypeArg<HttpServer> __TYPE_ARG

Constructor Summary

Constructors
Constructor Description

HttpServer(HttpServer delegate)

HttpServer(Object delegate)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`int`	`actualPort()`	The actual port the server is listening on.
`void`	`close()`	Like `close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but supplying a handler that will be called when the server is actually closed (or has failed).
`void`	`close(Handler<AsyncResult<Void>> completionHandler)`	Like `close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but supplying a handler that will be called when the server is actually closed (or has failed).
`HttpServer`	`connectionHandler(Handler<HttpConnection> handler)`	Set a connection handler for the server.
`boolean`	`equals(Object o)`
`HttpServer`	`exceptionHandler(Handler<Throwable> handler)`	Set an exception handler called for socket errors happening before the HTTP connection is established, e.g during the TLS handshake.
`HttpServer`	`getDelegate()`
`int`	`hashCode()`
`HttpServer`	`invalidRequestHandler(Handler<HttpServerRequest> handler)`	Set a `handler` for handling invalid requests.
`boolean`	`isMetricsEnabled()`	Whether the metrics are enabled for this measured object
`HttpServer`	`listen()`	Like `listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServer>>)` but supplying a handler that will be called when the server is actually listening (or has failed).
`HttpServer`	`listen(int port)`	Like `listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServer>>)` but supplying a handler that will be called when the server is actually listening (or has failed).
`HttpServer`	`listen(int port, Handler<AsyncResult<HttpServer>> listenHandler)`	Like `listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServer>>)` but supplying a handler that will be called when the server is actually listening (or has failed).
`HttpServer`	`listen(int port, String host)`	Like `listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServer>>)` but supplying a handler that will be called when the server is actually listening (or has failed).
`HttpServer`	`listen(int port, String host, Handler<AsyncResult<HttpServer>> listenHandler)`	Like `listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServer>>)` but supplying a handler that will be called when the server is actually listening (or has failed).
`HttpServer`	`listen(Handler<AsyncResult<HttpServer>> listenHandler)`	Like `listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServer>>)` but supplying a handler that will be called when the server is actually listening (or has failed).
`HttpServer`	`listen(SocketAddress address)`	Tell the server to start listening on the given address supplying a handler that will be called when the server is actually listening (or has failed).
`HttpServer`	`listen(SocketAddress address, Handler<AsyncResult<HttpServer>> listenHandler)`	Tell the server to start listening on the given address supplying a handler that will be called when the server is actually listening (or has failed).
`static HttpServer`	`newInstance(HttpServer arg)`
`HttpServer`	`requestHandler(Handler<HttpServerRequest> handler)`	Set the request handler for the server to `requestHandler`.
`ReadStream<HttpServerRequest>`	`requestStream()`	Deprecated.
`io.reactivex.Completable`	`rxClose()`	Like `close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but supplying a handler that will be called when the server is actually closed (or has failed).
`io.reactivex.Single<HttpServer>`	`rxListen()`	Like `listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServer>>)` but supplying a handler that will be called when the server is actually listening (or has failed).
`io.reactivex.Single<HttpServer>`	`rxListen(int port)`	Like `listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServer>>)` but supplying a handler that will be called when the server is actually listening (or has failed).
`io.reactivex.Single<HttpServer>`	`rxListen(int port, String host)`	Like `listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServer>>)` but supplying a handler that will be called when the server is actually listening (or has failed).
`io.reactivex.Single<HttpServer>`	`rxListen(SocketAddress address)`	Tell the server to start listening on the given address supplying a handler that will be called when the server is actually listening (or has failed).
`io.reactivex.Completable`	`rxUpdateSSLOptions(SSLOptions options)`	Like `updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but supplying a handler that will be called when the update happened (or has failed).
`String`	`toString()`
`void`	`updateSSLOptions(SSLOptions options)`	Like `updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but supplying a handler that will be called when the update happened (or has failed).
`void`	`updateSSLOptions(SSLOptions options, Handler<AsyncResult<Void>> handler)`	Like `updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but supplying a handler that will be called when the update happened (or has failed).
`HttpServer`	`webSocketHandler(Handler<ServerWebSocket> handler)`	Set the WebSocket handler for the server to `wsHandler`.
`ReadStream<ServerWebSocket>`	`webSocketStream()`	Deprecated.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - __TYPE_ARG
```
public static final TypeArg<HttpServer> __TYPE_ARG
```
- Constructor Detail
  - HttpServer
```
public HttpServer(HttpServer delegate)
```
  - HttpServer
```
public HttpServer(Object delegate)
```
- 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 HttpServer getDelegate()
```
    Specified by:
    
    getDelegate in interface Measured
  - isMetricsEnabled
```
public boolean isMetricsEnabled()
```
    Whether the metrics are enabled for this measured object
    
    Specified by:
    
    isMetricsEnabled in interface Measured
    
    Returns:
    
    true if metrics are enabled
  - requestStream
```
@Deprecated
public ReadStream<HttpServerRequest> requestStream()
```
    Deprecated.
    
    Return the request stream for the server. As HTTP requests are received by the server, instances of HttpServerRequest will be created and passed to the stream ReadStream.handler(io.vertx.core.Handler<T>).
    
    Returns:
    
    the request stream
  - requestHandler
```
public HttpServer requestHandler(Handler<HttpServerRequest> handler)
```
    Set the request handler for the server to requestHandler. As HTTP requests are received by the server, instances of HttpServerRequest will be created and passed to this handler.
    
    Parameters:
    
    handler -
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - invalidRequestHandler
```
public HttpServer invalidRequestHandler(Handler<HttpServerRequest> handler)
```
    Set a handler for handling invalid requests. When an invalid request is received by the server this handler will be called with the request. The handler can send any HTTP response, when the response ends, the server shall close the connection. io.vertx.reactivex.core.http.HttpServerRequest#decoderResult can be used to obtain the Netty decoder result and the failure cause reported by the decoder.
    Currently this handler is only used for HTTP/1.x requests.
    When no specific handler is set, the HttpServerRequest is used.
    
    Parameters:
    
    handler -
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - connectionHandler
```
public HttpServer connectionHandler(Handler<HttpConnection> handler)
```
    Set a connection handler for the server.
    The handler will always be called on the event-loop thread.
    
    Parameters:
    
    handler -
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - exceptionHandler
```
public HttpServer exceptionHandler(Handler<Throwable> handler)
```
    Set an exception handler called for socket errors happening before the HTTP connection is established, e.g during the TLS handshake.
    
    Parameters:
    
    handler - the handler to set
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - webSocketStream
```
@Deprecated
public ReadStream<ServerWebSocket> webSocketStream()
```
    Deprecated.
    
    Return the WebSocket stream for the server. If a WebSocket connect handshake is successful a new ServerWebSocket instance will be created and passed to the stream ReadStream.handler(io.vertx.core.Handler<T>).
    
    Returns:
    
    the WebSocket stream
  - webSocketHandler
```
public HttpServer webSocketHandler(Handler<ServerWebSocket> handler)
```
    Set the WebSocket handler for the server to wsHandler. If a WebSocket connect handshake is successful a new ServerWebSocket instance will be created and passed to the handler.
    
    Parameters:
    
    handler -
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - updateSSLOptions
```
public void updateSSLOptions(SSLOptions options,
                             Handler<AsyncResult<Void>> handler)
```
    Like updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but supplying a handler that will be called when the update happened (or has failed).
    
    Parameters:
    
    options - the new SSL options
    
    handler - the update handler
  - updateSSLOptions
```
public void updateSSLOptions(SSLOptions options)
```
    Like updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but supplying a handler that will be called when the update happened (or has failed).
    
    Parameters:
    
    options - the new SSL options
  - rxUpdateSSLOptions
```
public io.reactivex.Completable rxUpdateSSLOptions(SSLOptions options)
```
    Like updateSSLOptions(io.vertx.core.net.SSLOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but supplying a handler that will be called when the update happened (or has failed).
    
    Parameters:
    
    options - the new SSL options
    
    Returns:
  - listen
```
public HttpServer listen(int port,
                         String host,
                         Handler<AsyncResult<HttpServer>> listenHandler)
```
    Like listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServer>>) but supplying a handler that will be called when the server is actually listening (or has failed).
    
    Parameters:
    
    port - the port to listen on
    
    host - the host to listen on
    
    listenHandler - the listen handler
    
    Returns:
  - listen
```
public HttpServer listen(int port,
                         String host)
```
    Like listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServer>>) but supplying a handler that will be called when the server is actually listening (or has failed).
    
    Parameters:
    
    port - the port to listen on
    
    host - the host to listen on
    
    Returns:
  - rxListen
```
public io.reactivex.Single<HttpServer> rxListen(int port,
                                                String host)
```
    Like listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServer>>) but supplying a handler that will be called when the server is actually listening (or has failed).
    
    Parameters:
    
    port - the port to listen on
    
    host - the host to listen on
    
    Returns:
  - listen
```
public HttpServer listen(SocketAddress address,
                         Handler<AsyncResult<HttpServer>> listenHandler)
```
    Tell the server to start listening on the given address supplying a handler that will be called when the server is actually listening (or has failed).
    
    Parameters:
    
    address - the address to listen on
    
    listenHandler - the listen handler
    
    Returns:
  - listen
```
public HttpServer listen(SocketAddress address)
```
    Tell the server to start listening on the given address supplying a handler that will be called when the server is actually listening (or has failed).
    
    Parameters:
    
    address - the address to listen on
    
    Returns:
  - rxListen
```
public io.reactivex.Single<HttpServer> rxListen(SocketAddress address)
```
    Tell the server to start listening on the given address supplying a handler that will be called when the server is actually listening (or has failed).
    
    Parameters:
    
    address - the address to listen on
    
    Returns:
  - listen
```
public HttpServer listen(int port,
                         Handler<AsyncResult<HttpServer>> listenHandler)
```
    Like listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServer>>) but supplying a handler that will be called when the server is actually listening (or has failed).
    
    Parameters:
    
    port - the port to listen on
    
    listenHandler - the listen handler
    
    Returns:
  - listen
```
public HttpServer listen(int port)
```
    Like listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServer>>) but supplying a handler that will be called when the server is actually listening (or has failed).
    
    Parameters:
    
    port - the port to listen on
    
    Returns:
  - rxListen
```
public io.reactivex.Single<HttpServer> rxListen(int port)
```
    Like listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServer>>) but supplying a handler that will be called when the server is actually listening (or has failed).
    
    Parameters:
    
    port - the port to listen on
    
    Returns:
  - listen
```
public HttpServer listen(Handler<AsyncResult<HttpServer>> listenHandler)
```
    Like listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServer>>) but supplying a handler that will be called when the server is actually listening (or has failed).
    
    Parameters:
    
    listenHandler - the listen handler
    
    Returns:
  - listen
```
public HttpServer listen()
```
    Like listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServer>>) but supplying a handler that will be called when the server is actually listening (or has failed).
    
    Returns:
  - rxListen
```
public io.reactivex.Single<HttpServer> rxListen()
```
    Like listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServer>>) but supplying a handler that will be called when the server is actually listening (or has failed).
    
    Returns:
  - close
```
public void close(Handler<AsyncResult<Void>> completionHandler)
```
    Like close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but supplying a handler that will be called when the server is actually closed (or has failed).
    
    Parameters:
    
    completionHandler - the handler
  - close
```
public void close()
```
    Like close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but supplying a handler that will be called when the server is actually closed (or has failed).
  - rxClose
```
public io.reactivex.Completable rxClose()
```
    Like close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but supplying a handler that will be called when the server is actually closed (or has failed).
    
    Returns:
  - actualPort
```
public int actualPort()
```
    The actual port the server is listening on. This is useful if you bound the server specifying 0 as port number signifying an ephemeral port
    
    Returns:
    
    the actual port the server is listening on.
  - newInstance
```
public static HttpServer newInstance(HttpServer arg)
```

Constructor	Description
`HttpServer(HttpServer delegate)`
`HttpServer(Object delegate)`

Class HttpServer

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

__TYPE_ARG

Constructor Detail

HttpServer

HttpServer

Method Detail

toString

equals

hashCode

getDelegate

isMetricsEnabled

requestStream

requestHandler

invalidRequestHandler

connectionHandler

exceptionHandler

webSocketStream

webSocketHandler

updateSSLOptions

updateSSLOptions

rxUpdateSSLOptions

listen

listen

rxListen

listen

listen

rxListen

listen

listen

rxListen

listen

listen

rxListen

close

close

rxClose

actualPort

newInstance