io.vertx.core.net

## Interface NetServer

- All Superinterfaces:
    Measured

      public interface NetServer
      extends Measured

  Represents a TCP server
  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 notified when close is complete.
    `Handler<NetSocket>` | `connectHandler()`
    `NetServer` | `connectHandler(Handler<NetSocket> handler)` Supply a connect handler for this server.
    `ReadStream<NetSocket>` | `connectStream()` Deprecated. instead use `connectHandler(Handler)`
    `NetServer` | `exceptionHandler(Handler<Throwable> handler)` Set an exception handler called for socket errors happening before the connection is passed to the `connectHandler(io.vertx.core.Handler<io.vertx.core.net.NetSocket>)`, e.g during the TLS handshake.
    `Future<NetServer>` | `listen()` Start listening on the port and host as configured in the `NetServerOptions` used when creating the server.
    `default NetServer` | `listen(Handler<AsyncResult<NetServer>> listenHandler)` Like `listen()` but providing a handler that will be notified when the server is listening, or fails.
    `default Future<NetServer>` | `listen(int port)` Start listening on the specified port and host "0.0.0.0", ignoring port and host configured in the `NetServerOptions` used when creating the server.
    `default NetServer` | `listen(int port, Handler<AsyncResult<NetServer>> listenHandler)` Like `listen(int)` but providing a handler that will be notified when the server is listening, or fails.
    `default Future<NetServer>` | `listen(int port, String host)` Start listening on the specified port and host, ignoring port and host configured in the `NetServerOptions` used when creating the server.
    `default NetServer` | `listen(int port, String host, Handler<AsyncResult<NetServer>> listenHandler)` Like `listen(int, String)` but providing a handler that will be notified when the server is listening, or fails.
    `Future<NetServer>` | `listen(SocketAddress localAddress)` Start listening on the specified local address, ignoring port and host configured in the `NetServerOptions` used when creating the server.
    `default NetServer` | `listen(SocketAddress localAddress, Handler<AsyncResult<NetServer>> listenHandler)` Like `listen(SocketAddress)` but providing a handler that will be notified when the server is listening, or fails.
    `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).

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

      `isMetricsEnabled`

- - ### Method Detail

    - #### connectStream

          @Deprecated
          ReadStream<NetSocket> connectStream()

      Deprecated. instead use `connectHandler(Handler)`
      Return the connect stream for this server. The server can only have at most one handler at any one time. As the server accepts TCP or SSL connections it creates an instance of `NetSocket` and passes it to the connect stream `ReadStream.handler(io.vertx.core.Handler)`.
      Returns:
        the connect stream

    - #### connectHandler

          NetServer connectHandler(Handler<NetSocket> handler)

      Supply a connect handler for this server. The server can only have at most one connect handler at any one time. As the server accepts TCP or SSL connections it creates an instance of `NetSocket` and passes it to the connect handler.
      Returns:
        a reference to this, so the API can be used fluently

    - #### connectHandler

          Handler<NetSocket> connectHandler()

    - #### listen

          Future<NetServer> listen()

      Start listening on the port and host as configured in the `NetServerOptions` used when creating the server.

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

      Returns:
        a future completed with the listen operation result

    - #### listen

          default NetServer listen(Handler<AsyncResult<NetServer>> listenHandler)

      Like `listen()` but providing a handler that will be notified when the server is listening, or fails.
      Parameters:
        `listenHandler` - handler that will be notified when listening or failed
      Returns:
        a reference to this, so the API can be used fluently

    - #### listen

          default Future<NetServer> listen(int port,
                                           String host)

      Start listening on the specified port and host, ignoring port and host configured in the `NetServerOptions` used when creating the server.

      Port `0` can be specified meaning "choose an random port".

      Host `0.0.0.0` can be specified meaning "listen on all available interfaces".

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

      Returns:
        a future completed with the listen operation result

    - #### listen

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

      Like `listen(int, String)` but providing a handler that will be notified when the server is listening, or fails.
      Parameters:
        `port` - the port to listen on
        `host` - the host to listen on
        `listenHandler` - handler that will be notified when listening or failed
      Returns:
        a reference to this, so the API can be used fluently

    - #### listen

          default Future<NetServer> listen(int port)

      Start listening on the specified port and host "0.0.0.0", ignoring port and host configured in the `NetServerOptions` used when creating the server.

      Port `0` can be specified meaning "choose an random port".

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

      Returns:
        a future completed with the listen operation result

    - #### listen

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

      Like `listen(int)` but providing a handler that will be notified when the server is listening, or fails.
      Parameters:
        `port` - the port to listen on
        `listenHandler` - handler that will be notified when listening or failed
      Returns:
        a reference to this, so the API can be used fluently

    - #### listen

          Future<NetServer> listen(SocketAddress localAddress)

      Start listening on the specified local address, ignoring port and host configured in the `NetServerOptions` used when creating the server.

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

      Parameters:
        `localAddress` - the local address to listen on
      Returns:
        a future completed with the listen operation result

    - #### listen

          default NetServer listen(SocketAddress localAddress,
                                   Handler<AsyncResult<NetServer>> listenHandler)

      Like `listen(SocketAddress)` but providing a handler that will be notified when the server is listening, or fails.
      Parameters:
        `localAddress` - the local address to listen on
        `listenHandler` - handler that will be notified when listening or failed
      Returns:
        a reference to this, so the API can be used fluently

    - #### exceptionHandler

          NetServer exceptionHandler(Handler<Throwable> handler)

      Set an exception handler called for socket errors happening before the connection is passed to the `connectHandler(io.vertx.core.Handler<io.vertx.core.net.NetSocket>)`, e.g during the TLS handshake.
      Parameters:
        `handler` - the handler to set
      Returns:
        a reference to this, so the API can be used fluently

    - #### close

          Future<Void> close()

      Close the server. This will close any currently open connections. The close may not complete until after this method has returned.
      Returns:
        a future completed with the listen operation result

    - #### close

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

      Like `close()` but supplying a handler that will be notified when close is complete.
      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.

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

Copyright © 2023 Eclipse. All rights reserved.