io.vertx.core.http

## Interface HttpServer

- All Superinterfaces:
    Measured

      public interface HttpServer
      extends Measured

  An HTTP and WebSockets server.

  You receive HTTP requests by providing a `requestHandler(io.vertx.core.Handler<io.vertx.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.core.http.ServerWebSocket>)`. As WebSocket connections arrive on the server, the WebSocket is passed to the handler.

  Author:
    Tim Fox

- - ### Method Summary

    All Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `int` | `actualPort()` The actual port the server is listening on.
    `Future<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).
    `HttpServer` | `connectionHandler(Handler<HttpConnection> handler)` Set a connection handler for the server.
    `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` | `invalidRequestHandler(Handler<HttpServerRequest> handler)` Set a `handler` for handling invalid requests.
    `Future<HttpServer>` | `listen()` Tell the server to start listening.
    `default 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).
    `default Future<HttpServer>` | `listen(int port)` Like `listen(int, String)` 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.
    `default HttpServer` | `listen(int port, Handler<AsyncResult<HttpServer>> listenHandler)` Like `listen(int)` but supplying a handler that will be called when the server is actually listening (or has failed).
    `default Future<HttpServer>` | `listen(int port, String host)` Tell the server to start listening.
    `default HttpServer` | `listen(int port, String host, Handler<AsyncResult<HttpServer>> listenHandler)` Like `listen(int, String)` but supplying a handler that will be called when the server is actually listening (or has failed).
    `Future<HttpServer>` | `listen(SocketAddress address)` Like `listen(SocketAddress, Handler)` but returns a `Future` of the asynchronous result
    `default 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).
    `Handler<HttpServerRequest>` | `requestHandler()`
    `HttpServer` | `requestHandler(Handler<HttpServerRequest> handler)` Set the request handler for the server to `requestHandler`.
    `ReadStream<HttpServerRequest>` | `requestStream()` Deprecated. instead use `requestHandler(Handler)`
    `Future<Void>` | `updateSSLOptions(SSLOptions options)` Update the server SSL options.
    `default void` | `updateSSLOptions(SSLOptions options, Handler<AsyncResult<Void>> handler)` Like `updateSSLOptions(SSLOptions)` but supplying a handler that will be called when the update happened (or has failed).
    `Handler<ServerWebSocket>` | `webSocketHandler()`
    `HttpServer` | `webSocketHandler(Handler<ServerWebSocket> handler)` Set the WebSocket handler for the server to `wsHandler`.
    `ReadStream<ServerWebSocket>` | `webSocketStream()` Deprecated. instead use `webSocketHandler(Handler)`

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

      `isMetricsEnabled`

- - ### Method Detail

    - #### requestStream

          @Deprecated
          ReadStream<HttpServerRequest> requestStream()

      Deprecated. instead use `requestHandler(Handler)`
      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)`.
      Returns:
        the request stream

    - #### requestHandler

          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.
      Returns:
        a reference to this, so the API can be used fluently

    - #### requestHandler

          Handler<HttpServerRequest> requestHandler()

      Returns:
        the request handler

    - #### invalidRequestHandler

          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. `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.DEFAULT_INVALID_REQUEST_HANDLER` is used.

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

    - #### connectionHandler

          HttpServer connectionHandler(Handler<HttpConnection> handler)

      Set a connection handler for the server.
      The handler will always be called on the event-loop thread.
      Returns:
        a reference to this, so the API can be used fluently

    - #### exceptionHandler

          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
          ReadStream<ServerWebSocket> webSocketStream()

      Deprecated. instead use `webSocketHandler(Handler)`
      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)`.
      Returns:
        the WebSocket stream

    - #### webSocketHandler

          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.
      Returns:
        a reference to this, so the API can be used fluently

    - #### webSocketHandler

          Handler<ServerWebSocket> webSocketHandler()

      Returns:
        the WebSocket handler

    - #### updateSSLOptions

          Future<Void> updateSSLOptions(SSLOptions options)

      Update the server SSL options. Update only happens if the SSL options is valid.
      Parameters:
        `options` - the new SSL options
      Returns:
        a future signaling the update success

    - #### updateSSLOptions

          default void updateSSLOptions(SSLOptions options,
                                        Handler<AsyncResult<Void>> handler)

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

    - #### listen

          Future<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 future completed with the listen operation result

    - #### listen

          default Future<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 future completed with the listen operation result

    - #### listen

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

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

    - #### listen

          default 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

    - #### listen

          Future<HttpServer> listen(SocketAddress address)

      Like `listen(SocketAddress, Handler)` but returns a `Future` of the asynchronous result

    - #### listen

          default Future<HttpServer> listen(int port)

      Like `listen(int, String)` 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 future completed with the listen operation result

    - #### listen

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

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

    - #### listen

          default 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

    - #### close

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

      Returns:
        a future completed with the result

    - #### close

          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

    - #### actualPort

          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.

Copyright © 2024 Eclipse. All rights reserved.