io.vertx.rxjava.core.http

## Class HttpServer

- java.lang.Object
- - io.vertx.rxjava.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.rxjava.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.rxjava.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 and Description
    --- | ---
    `static TypeArg<HttpServer>` | `__TYPE_ARG`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `HttpServer(HttpServer delegate)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `int` | `actualPort()` The actual port the server is listening on.
    `void` | `close()` Close the server.
    `void` | `close(Handler<AsyncResult<Void>> completionHandler)` Like `close()` but supplying a handler that will be called when the server is actually closed (or has failed).
    `rx.Observable<Void>` | `closeObservable()` Deprecated. use `rxClose()` instead
    `HttpServer` | `connectionHandler(Handler<HttpConnection> handler)` Set a connection handler for the server.
    `HttpServer` | `getDelegate()`
    `boolean` | `isMetricsEnabled()` Whether the metrics are enabled for this measured object
    `HttpServer` | `listen()` Tell the server to start listening.
    `HttpServer` | `listen(Handler<AsyncResult<HttpServer>> listenHandler)` Like `listen()` but supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpServer` | `listen(int port)` Like `listen()` but the server will listen on host "0.0.0.0" and port specified here ignoring any value in the `HttpServerOptions` that was used when creating the server.
    `HttpServer` | `listen(int port, Handler<AsyncResult<HttpServer>> listenHandler)` Like `listen()` but supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpServer` | `listen(int port, String host)` Tell the server to start listening.
    `HttpServer` | `listen(int port, String host, Handler<AsyncResult<HttpServer>> listenHandler)` Like `listen()` but supplying a handler that will be called when the server is actually listening (or has failed).
    `rx.Observable<HttpServer>` | `listenObservable()` Deprecated. use `rxListen(int, java.lang.String)` instead
    `rx.Observable<HttpServer>` | `listenObservable(int port)` Deprecated. use `rxListen(int, java.lang.String)` instead
    `rx.Observable<HttpServer>` | `listenObservable(int port, String host)` Deprecated. use `rxListen(int, java.lang.String)` instead
    `static HttpServer` | `newInstance(HttpServer arg)`
    `HttpServer` | `requestHandler(Handler<HttpServerRequest> handler)` Set the request handler for the server to `requestHandler`.
    `ReadStream<HttpServerRequest>` | `requestStream()` Return the request stream for the server.
    `rx.Single<Void>` | `rxClose()` Like `close()` but supplying a handler that will be called when the server is actually closed (or has failed).
    `rx.Single<HttpServer>` | `rxListen()` Like `listen()` but supplying a handler that will be called when the server is actually listening (or has failed).
    `rx.Single<HttpServer>` | `rxListen(int port)` Like `listen()` but supplying a handler that will be called when the server is actually listening (or has failed).
    `rx.Single<HttpServer>` | `rxListen(int port, String host)` Like `listen()` but supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpServer` | `websocketHandler(Handler<ServerWebSocket> handler)` Set the websocket handler for the server to `wsHandler`.
    `ReadStream<ServerWebSocket>` | `websocketStream()` Return the websocket stream for the server.

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

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

    - ### Methods inherited from interface io.vertx.rxjava.core.metrics.Measured

      `newInstance`

- - ### Field Detail

    - #### __TYPE_ARG

          public static final TypeArg<HttpServer> __TYPE_ARG

  - ### Constructor Detail

    - #### HttpServer

          public HttpServer(HttpServer delegate)

  - ### Method Detail

    - #### 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 the metrics are enabled

    - #### requestStream

          public ReadStream<HttpServerRequest> requestStream()

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

    - #### connectionHandler

          public HttpServer connectionHandler(Handler<HttpConnection> handler)

      Set a connection handler for the server.
      Parameters:
        `handler` -
      Returns:
        a reference to this, so the API can be used fluently

    - #### websocketStream

          public ReadStream<ServerWebSocket> websocketStream()

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

    - #### listen

          public HttpServer listen()

      Tell the server to start listening. The server will listen on the port and host specified in the `HttpServerOptions` that was used when creating the server.

      The listen happens asynchronously and the server may not be listening until some time after the call has returned.

      Returns:
        a reference to this, so the API can be used fluently

    - #### listen

          public HttpServer listen(int port,
                                   String host)

      Tell the server to start listening. The server will listen on the port and host specified here, ignoring any value set in the `HttpServerOptions` that was used when creating the server.

      The listen happens asynchronously and the server may not be listening until some time after the call has returned.

      Parameters:
        `port` - the port to listen on
        `host` - the host to listen on
      Returns:
        a reference to this, so the API can be used fluently

    - #### listen

          public HttpServer listen(int port,
                                   String host,
                                   Handler<AsyncResult<HttpServer>> listenHandler)

      Like `listen()` 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:

    - #### listenObservable

          @Deprecated
          public rx.Observable<HttpServer> listenObservable(int port,
                                                                        String host)

      Deprecated. use `rxListen(int, java.lang.String)` instead
      Like `listen()` 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 rx.Single<HttpServer> rxListen(int port,
                                                String host)

      Like `listen()` 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(int port)

      Like `listen()` but the server will listen on host "0.0.0.0" and port specified here ignoring any value in the `HttpServerOptions` that was used when creating the server.
      Parameters:
        `port` - the port to listen on
      Returns:
        a reference to this, so the API can be used fluently

    - #### listen

          public HttpServer listen(int port,
                                   Handler<AsyncResult<HttpServer>> listenHandler)

      Like `listen()` 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:

    - #### listenObservable

          @Deprecated
          public rx.Observable<HttpServer> listenObservable(int port)

      Deprecated. use `rxListen(int, java.lang.String)` instead
      Like `listen()` 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 rx.Single<HttpServer> rxListen(int port)

      Like `listen()` 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()` but supplying a handler that will be called when the server is actually listening (or has failed).
      Parameters:
        `listenHandler` - the listen handler
      Returns:

    - #### listenObservable

          @Deprecated
          public rx.Observable<HttpServer> listenObservable()

      Deprecated. use `rxListen(int, java.lang.String)` instead
      Like `listen()` but supplying a handler that will be called when the server is actually listening (or has failed).
      Returns:

    - #### rxListen

          public rx.Single<HttpServer> rxListen()

      Like `listen()` but supplying a handler that will be called when the server is actually listening (or has failed).
      Returns:

    - #### close

          public void close()

      Close the server. Any open HTTP connections will be closed.

      The close happens asynchronously and the server may not be closed until some time after the call has returned.

    - #### close

          public void close(Handler<AsyncResult<Void>> completionHandler)

      Like `close()` but supplying a handler that will be called when the server is actually closed (or has failed).
      Parameters:
        `completionHandler` - the handler

    - #### closeObservable

          @Deprecated
          public rx.Observable<Void> closeObservable()

      Deprecated. use `rxClose()` instead
      Like `close()` but supplying a handler that will be called when the server is actually closed (or has failed).
      Returns:

    - #### rxClose

          public rx.Single<Void> rxClose()

      Like `close()` 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)

Copyright © 2017. All rights reserved.