Deprecated API

Contents

• Deprecated Interfaces
• Deprecated Classes
• Deprecated Fields
• Deprecated Methods
• Deprecated Constructors

Deprecated Interfaces

Interface and Description
io.vertx.core.streams.Pump instead use ReadStream.pipe() or ReadStream.pipeTo(WriteStream)
io.vertx.core.TimeoutStream use Vertx.setTimer(long, io.vertx.core.Handler<java.lang.Long>)/Vertx.setPeriodic(long, io.vertx.core.Handler<java.lang.Long>) instead. RxJava like integrations should use the Vert.x scheduler integration.

Deprecated Classes

Class and Description
io.vertx.core.logging.Logger see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.LoggerFactory see https://github.com/eclipse-vertx/vert.x/issues/2774

Deprecated Fields

Field and Description
io.vertx.core.http.HttpClientOptions.DEFAULT_TRY_USE_COMPRESSION as of 4.5, use HttpClientOptions.DEFAULT_DECOMPRESSION_SUPPORTED

Deprecated Methods

Method and Description
io.vertx.core.CompositeFuture.all(Future<T1>, Future<T2>) instead use Future.all(Future, Future)
io.vertx.core.CompositeFuture.all(Future<T1>, Future<T2>, Future<T3>) instead use Future.all(Future, Future, Future)
io.vertx.core.CompositeFuture.all(Future<T1>, Future<T2>, Future<T3>, Future<T4>) instead use Future.all(Future, Future, Future, Future)
io.vertx.core.CompositeFuture.all(Future<T1>, Future<T2>, Future<T3>, Future<T4>, Future<T5>) instead use Future.all(Future, Future, Future, Future, Future)
io.vertx.core.CompositeFuture.all(Future<T1>, Future<T2>, Future<T3>, Future<T4>, Future<T5>, Future<T6>) instead use Future.all(Future, Future, Future, Future, Future, Future)
io.vertx.core.CompositeFuture.all(List<Future>) instead use Future.all(List)
io.vertx.core.CompositeFuture.any(Future<T1>, Future<T2>) instead use Future.any(Future, Future)
io.vertx.core.CompositeFuture.any(Future<T1>, Future<T2>, Future<T3>) instead use Future.any(Future, Future, Future)
io.vertx.core.CompositeFuture.any(Future<T1>, Future<T2>, Future<T3>, Future<T4>) instead use Future.any(Future, Future, Future, Future)
io.vertx.core.CompositeFuture.any(Future<T1>, Future<T2>, Future<T3>, Future<T4>, Future<T5>) instead use Future.any(Future, Future, Future, Future, Future)
io.vertx.core.CompositeFuture.any(Future<T1>, Future<T2>, Future<T3>, Future<T4>, Future<T5>, Future<T6>) instead use Future.any(Future, Future, Future, Future, Future, Future)
io.vertx.core.CompositeFuture.any(List<Future>) instead use Future.any(List)
io.vertx.core.buffer.Buffer.buffer(ByteBuf) removed from public API in Vert.x 5
io.vertx.core.http.HttpServerResponse.close() instead use HttpConnection.close() or HttpServerResponse.reset(long), this method is removed in Vert.x 5
io.vertx.core.http.HttpClient.connectionHandler(Handler<HttpConnection>) instead use HttpClientBuilder.withConnectHandler(Handler)
io.vertx.core.net.NetServer.connectStream() instead use NetServer.connectHandler(Handler)
io.vertx.core.http.HttpServerRequest.cookieMap() the implementation made a wrong assumption that cookies could be identified only by their name. The RFC states that the tuple of <name, domain, path> is the unique identifier. When more than one cookie has the same name, the map will hold that lost one to be parsed and any previously parsed value will be silently overwritten.
io.vertx.core.logging.Logger.debug(Object) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.debug(Object, Object...) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.debug(Object, Throwable) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.debug(Object, Throwable, Object...) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.datagram.DatagramSocket.endHandler(Handler<Void>) removed in Vert.x 5
io.vertx.core.logging.Logger.error(Object) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.error(Object, Object...) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.error(Object, Throwable) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.error(Object, Throwable, Object...) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.Future.eventually(Function<Void, Future<U>>) instead use Future.eventually(Supplier), this method will be removed in Vert.x 5
io.vertx.core.Context.executeBlocking(Handler<Promise<T>>) instead use Context.executeBlocking(Callable)
io.vertx.core.Vertx.executeBlocking(Handler<Promise<T>>) instead use Vertx.executeBlocking(Callable)
io.vertx.core.WorkerExecutor.executeBlocking(Handler<Promise<T>>) instead use WorkerExecutor.executeBlocking(Callable)
io.vertx.core.Context.executeBlocking(Handler<Promise<T>>, boolean) instead use Context.executeBlocking(Callable, boolean)
io.vertx.core.Vertx.executeBlocking(Handler<Promise<T>>, boolean) instead use Vertx.executeBlocking(Callable, boolean)
io.vertx.core.WorkerExecutor.executeBlocking(Handler<Promise<T>>, boolean) instead use WorkerExecutor.executeBlocking(Callable, boolean)
io.vertx.core.Context.executeBlocking(Handler<Promise<T>>, boolean, Handler<AsyncResult<T>>) instead use Context.executeBlocking(Callable, boolean)
io.vertx.core.Vertx.executeBlocking(Handler<Promise<T>>, boolean, Handler<AsyncResult<T>>) use instead Vertx.executeBlocking(Callable, boolean)
io.vertx.core.WorkerExecutor.executeBlocking(Handler<Promise<T>>, boolean, Handler<AsyncResult<T>>) instead use WorkerExecutor.executeBlocking(Callable, boolean)
io.vertx.core.Context.executeBlocking(Handler<Promise<T>>, Handler<AsyncResult<T>>) instead use Context.executeBlocking(Callable)
io.vertx.core.Vertx.executeBlocking(Handler<Promise<T>>, Handler<AsyncResult<T>>) instead use Vertx.executeBlocking(Callable)
io.vertx.core.WorkerExecutor.executeBlocking(Handler<Promise<T>>, Handler<AsyncResult<T>>) instead use WorkerExecutor.executeBlocking(Callable)
io.vertx.core.logging.Logger.fatal(Object) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.fatal(Object, Throwable) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.datagram.DatagramSocket.fetch(long) no replacement for back-pressure, instead ignore the packet or buffer it somewhere
io.vertx.core.buffer.Buffer.getByteBuf() removed from public API in Vert.x 5
io.vertx.core.logging.Logger.getDelegate() see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.DeploymentOptions.getExtraClasspath()
io.vertx.core.http.HttpClientRequest.getHost()
io.vertx.core.DeploymentOptions.getIsolatedClasses()
io.vertx.core.DeploymentOptions.getIsolationGroup()
io.vertx.core.net.TCPSSLOptions.getJdkSslEngineOptions() instead use TCPSSLOptions.getSslEngineOptions()
io.vertx.core.net.TCPSSLOptions.getKeyStoreOptions() instead use TCPSSLOptions.getKeyCertOptions()
io.vertx.core.logging.LoggerFactory.getLogger(Class<?>) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.LoggerFactory.getLogger(String) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.net.TCPSSLOptions.getOpenSslEngineOptions() instead use TCPSSLOptions.getSslEngineOptions()
io.vertx.core.net.TCPSSLOptions.getPemKeyCertOptions() instead use TCPSSLOptions.getKeyCertOptions()
io.vertx.core.net.TCPSSLOptions.getPemTrustOptions() instead use TCPSSLOptions.getTrustOptions()
io.vertx.core.net.TCPSSLOptions.getPfxKeyCertOptions() instead use TCPSSLOptions.getKeyCertOptions()
io.vertx.core.net.TCPSSLOptions.getPfxTrustOptions() instead use TCPSSLOptions.getTrustOptions()
io.vertx.core.http.HttpClientRequest.getPort()
io.vertx.core.cli.CommandLine.getRawValues(Option) use CommandLine.getRawValuesForOption(Option)
io.vertx.core.net.TCPSSLOptions.getTrustStoreOptions() instead use TCPSSLOptions.getTrustOptions()
io.vertx.core.http.HttpClientOptions.getTryWebSocketDeflateFrameCompression() instead use HttpClientOptions.tryUsePerFrameWebSocketCompression
io.vertx.core.http.ServerWebSocket.host() use ServerWebSocket.authority() instead
io.vertx.core.http.HttpServerRequest.host() instead use HttpServerRequest.authority()
io.vertx.core.logging.Logger.info(Object) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.info(Object, Object...) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.info(Object, Throwable) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.info(Object, Throwable, Object...) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.isDebugEnabled() see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.isInfoEnabled() see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.isTraceEnabled() see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.http.HttpClientOptions.isTryUseCompression() as of 4.5, use HttpClientOptions.isDecompressionSupported() instead
io.vertx.core.logging.Logger.isWarnEnabled() see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.DeploymentOptions.isWorker() instead use DeploymentOptions.getThreadingModel()
io.vertx.core.CompositeFuture.join(Future<T1>, Future<T2>) instead use Future.join(Future, Future)
io.vertx.core.CompositeFuture.join(Future<T1>, Future<T2>, Future<T3>) instead use Future.join(Future, Future, Future)
io.vertx.core.CompositeFuture.join(Future<T1>, Future<T2>, Future<T3>, Future<T4>) instead use Future.join(Future, Future, Future, Future)
io.vertx.core.CompositeFuture.join(Future<T1>, Future<T2>, Future<T3>, Future<T4>, Future<T5>) instead use Future.join(Future, Future, Future, Future, Future)
io.vertx.core.CompositeFuture.join(Future<T1>, Future<T2>, Future<T3>, Future<T4>, Future<T5>, Future<T6>) instead use Future.join(Future, Future, Future, Future, Future, Future)
io.vertx.core.CompositeFuture.join(List<Future>) instead use Future.join(List)
io.vertx.core.net.KeyCertOptions.keyManagerMapper(Vertx) instead use KeyCertOptions.keyManagerFactoryMapper(Vertx)
io.vertx.core.Vertx.nettyEventLoopGroup() removed from public API in Vert.x 5
io.vertx.core.datagram.DatagramSocket.pause() no replacement for back-pressure, instead ignore the packet or buffer it somewhere
io.vertx.core.net.NetSocket.peerCertificateChain() instead use NetSocket.peerCertificates() or NetSocket.sslSession()
io.vertx.core.http.HttpConnection.peerCertificateChain() instead use HttpConnection.peerCertificates() or HttpConnection.sslSession()
io.vertx.core.http.WebSocketBase.peerCertificateChain() instead use WebSocketBase.peerCertificates() or WebSocketBase.sslSession()
io.vertx.core.Vertx.periodicStream(long) use Vertx.setPeriodic(long, io.vertx.core.Handler<java.lang.Long>) instead. RxJava like integrations should use the Vert.x scheduler integration.
io.vertx.core.Vertx.periodicStream(long, long) use Vertx.setPeriodic(long, io.vertx.core.Handler<java.lang.Long>) instead. RxJava like integrations should use the Vert.x scheduler integration.
io.vertx.core.http.HttpServerResponse.push(HttpMethod, String, String, MultiMap) instead use HttpServerResponse.push(HttpMethod, HostAndPort, String, MultiMap)
io.vertx.core.http.HttpClient.redirectHandler()
io.vertx.core.http.HttpClient.redirectHandler(Function<HttpClientResponse, Future<RequestOptions>>) instead use HttpClientBuilder.withRedirectHandler(Function)
io.vertx.core.logging.LoggerFactory.removeLogger(String) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.http.HttpServer.requestStream() instead use HttpServer.requestHandler(Handler)
io.vertx.core.datagram.DatagramSocket.resume() no replacement for back-pressure, instead ignore the packet or buffer it somewhere
io.vertx.core.VertxOptions.setClusterManager(ClusterManager) instead use VertxBuilder.withClusterManager(ClusterManager)
io.vertx.core.DeploymentOptions.setExtraClasspath(List<String>)
io.vertx.core.metrics.MetricsOptions.setFactory(VertxMetricsFactory) instead use VertxBuilder.withMetrics(VertxMetricsFactory)
io.vertx.core.tracing.TracingOptions.setFactory(VertxTracerFactory) instead use VertxBuilder.withTracer(VertxTracerFactory)
io.vertx.core.http.HttpClientRequest.setHost(String) instead use HttpClientRequest.authority(HostAndPort)
io.vertx.core.DeploymentOptions.setIsolatedClasses(List<String>)
io.vertx.core.DeploymentOptions.setIsolationGroup(String)
io.vertx.core.eventbus.EventBusOptions.setJdkSslEngineOptions(JdkSSLEngineOptions)
io.vertx.core.net.TCPSSLOptions.setJdkSslEngineOptions(JdkSSLEngineOptions) instead use TCPSSLOptions.setSslEngineOptions(SSLEngineOptions)
io.vertx.core.net.NetServerOptions.setJdkSslEngineOptions(JdkSSLEngineOptions)
io.vertx.core.net.ClientOptionsBase.setJdkSslEngineOptions(JdkSSLEngineOptions)
io.vertx.core.net.NetClientOptions.setJdkSslEngineOptions(JdkSSLEngineOptions)
io.vertx.core.http.WebSocketClientOptions.setJdkSslEngineOptions(JdkSSLEngineOptions)
io.vertx.core.http.HttpClientOptions.setJdkSslEngineOptions(JdkSSLEngineOptions)
io.vertx.core.http.HttpServerOptions.setJdkSslEngineOptions(JdkSSLEngineOptions)
io.vertx.core.eventbus.EventBusOptions.setKeyStoreOptions(JksOptions)
io.vertx.core.net.TCPSSLOptions.setKeyStoreOptions(JksOptions) instead use TCPSSLOptions.setKeyCertOptions(KeyCertOptions)
io.vertx.core.net.NetServerOptions.setKeyStoreOptions(JksOptions)
io.vertx.core.net.ClientOptionsBase.setKeyStoreOptions(JksOptions)
io.vertx.core.net.NetClientOptions.setKeyStoreOptions(JksOptions)
io.vertx.core.http.WebSocketClientOptions.setKeyStoreOptions(JksOptions)
io.vertx.core.http.HttpClientOptions.setKeyStoreOptions(JksOptions)
io.vertx.core.http.HttpServerOptions.setKeyStoreOptions(JksOptions)
io.vertx.core.eventbus.EventBusOptions.setOpenSslEngineOptions(OpenSSLEngineOptions)
io.vertx.core.net.TCPSSLOptions.setOpenSslEngineOptions(OpenSSLEngineOptions) instead use TCPSSLOptions.setSslEngineOptions(SSLEngineOptions)
io.vertx.core.net.NetServerOptions.setOpenSslEngineOptions(OpenSSLEngineOptions)
io.vertx.core.net.ClientOptionsBase.setOpenSslEngineOptions(OpenSSLEngineOptions)
io.vertx.core.net.NetClientOptions.setOpenSslEngineOptions(OpenSSLEngineOptions)
io.vertx.core.http.WebSocketClientOptions.setOpenSslEngineOptions(OpenSSLEngineOptions)
io.vertx.core.http.HttpClientOptions.setOpenSslEngineOptions(OpenSSLEngineOptions)
io.vertx.core.http.HttpServerOptions.setOpenSslEngineOptions(OpenSSLEngineOptions)
io.vertx.core.eventbus.EventBusOptions.setPemKeyCertOptions(PemKeyCertOptions)
io.vertx.core.net.TCPSSLOptions.setPemKeyCertOptions(PemKeyCertOptions) instead use TCPSSLOptions.setKeyCertOptions(KeyCertOptions)
io.vertx.core.net.NetServerOptions.setPemKeyCertOptions(PemKeyCertOptions)
io.vertx.core.net.ClientOptionsBase.setPemKeyCertOptions(PemKeyCertOptions)
io.vertx.core.net.NetClientOptions.setPemKeyCertOptions(PemKeyCertOptions)
io.vertx.core.http.WebSocketClientOptions.setPemKeyCertOptions(PemKeyCertOptions)
io.vertx.core.http.HttpClientOptions.setPemKeyCertOptions(PemKeyCertOptions)
io.vertx.core.http.HttpServerOptions.setPemKeyCertOptions(PemKeyCertOptions)
io.vertx.core.eventbus.EventBusOptions.setPemTrustOptions(PemTrustOptions)
io.vertx.core.net.TCPSSLOptions.setPemTrustOptions(PemTrustOptions) instead use TCPSSLOptions.setTrustOptions(TrustOptions)
io.vertx.core.net.NetServerOptions.setPemTrustOptions(PemTrustOptions)
io.vertx.core.net.ClientOptionsBase.setPemTrustOptions(PemTrustOptions)
io.vertx.core.net.NetClientOptions.setPemTrustOptions(PemTrustOptions)
io.vertx.core.http.WebSocketClientOptions.setPemTrustOptions(PemTrustOptions)
io.vertx.core.http.HttpClientOptions.setPemTrustOptions(PemTrustOptions)
io.vertx.core.http.HttpServerOptions.setPemTrustOptions(PemTrustOptions)
io.vertx.core.eventbus.EventBusOptions.setPfxKeyCertOptions(PfxOptions)
io.vertx.core.net.TCPSSLOptions.setPfxKeyCertOptions(PfxOptions) instead use TCPSSLOptions.setKeyCertOptions(KeyCertOptions)
io.vertx.core.net.NetServerOptions.setPfxKeyCertOptions(PfxOptions)
io.vertx.core.net.ClientOptionsBase.setPfxKeyCertOptions(PfxOptions)
io.vertx.core.net.NetClientOptions.setPfxKeyCertOptions(PfxOptions)
io.vertx.core.http.WebSocketClientOptions.setPfxKeyCertOptions(PfxOptions)
io.vertx.core.http.HttpClientOptions.setPfxKeyCertOptions(PfxOptions)
io.vertx.core.http.HttpServerOptions.setPfxKeyCertOptions(PfxOptions)
io.vertx.core.eventbus.EventBusOptions.setPfxTrustOptions(PfxOptions)
io.vertx.core.net.TCPSSLOptions.setPfxTrustOptions(PfxOptions) instead use TCPSSLOptions.setTrustOptions(TrustOptions)
io.vertx.core.net.NetServerOptions.setPfxTrustOptions(PfxOptions)
io.vertx.core.net.ClientOptionsBase.setPfxTrustOptions(PfxOptions)
io.vertx.core.net.NetClientOptions.setPfxTrustOptions(PfxOptions)
io.vertx.core.http.WebSocketClientOptions.setPfxTrustOptions(PfxOptions)
io.vertx.core.http.HttpClientOptions.setPfxTrustOptions(PfxOptions)
io.vertx.core.http.HttpServerOptions.setPfxTrustOptions(PfxOptions)
io.vertx.core.http.HttpClientRequest.setPort(int) instead use HttpClientRequest.authority(HostAndPort)
io.vertx.core.http.HttpClientRequest.setTimeout(long) instead use HttpClientRequest.idleTimeout(long)
io.vertx.core.eventbus.EventBusOptions.setTrustStoreOptions(JksOptions)
io.vertx.core.net.TCPSSLOptions.setTrustStoreOptions(JksOptions) instead use TCPSSLOptions.setTrustOptions(TrustOptions)
io.vertx.core.net.NetServerOptions.setTrustStoreOptions(JksOptions)
io.vertx.core.net.ClientOptionsBase.setTrustStoreOptions(JksOptions)
io.vertx.core.net.NetClientOptions.setTrustStoreOptions(JksOptions)
io.vertx.core.http.WebSocketClientOptions.setTrustStoreOptions(JksOptions)
io.vertx.core.http.HttpClientOptions.setTrustStoreOptions(JksOptions)
io.vertx.core.http.HttpServerOptions.setTrustStoreOptions(JksOptions)
io.vertx.core.http.HttpClientOptions.setTryUseCompression(boolean) as of 4.5, use HttpClientOptions.setDecompressionSupported(boolean) instead
io.vertx.core.DeploymentOptions.setWorker(boolean) instead use DeploymentOptions.setThreadingModel(ThreadingModel)
io.vertx.core.Vertx.timerStream(long) use Vertx.setTimer(long, io.vertx.core.Handler<java.lang.Long>) instead. RxJava like integrations should use the Vert.x scheduler integration.
io.vertx.core.logging.Logger.trace(Object) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.trace(Object, Object...) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.trace(Object, Throwable) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.trace(Object, Throwable, Object...) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.warn(Object) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.warn(Object, Object...) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.warn(Object, Throwable) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.logging.Logger.warn(Object, Throwable, Object...) see https://github.com/eclipse-vertx/vert.x/issues/2774
io.vertx.core.http.HttpClient.webSocket(int, String, String) instead use WebSocketClient.connect(int, String, String)
io.vertx.core.http.HttpClient.webSocket(int, String, String, Handler<AsyncResult<WebSocket>>) instead use WebSocketClient.connect(int, String, String, Handler)
io.vertx.core.http.HttpClient.webSocket(String) instead use WebSocketClient.connect(int, String, String)
io.vertx.core.http.HttpClient.webSocket(String, Handler<AsyncResult<WebSocket>>) instead use WebSocketClient.connect(int, String, String, Handler)
io.vertx.core.http.HttpClient.webSocket(String, String) instead use WebSocketClient.connect(int, String, String)
io.vertx.core.http.HttpClient.webSocket(String, String, Handler<AsyncResult<WebSocket>>) instead use WebSocketClient.connect(int, String, String, Handler)
io.vertx.core.http.HttpClient.webSocket(WebSocketConnectOptions) instead use WebSocketClient.connect(WebSocketConnectOptions)
io.vertx.core.http.HttpClient.webSocket(WebSocketConnectOptions, Handler<AsyncResult<WebSocket>>) instead use WebSocketClient.connect(WebSocketConnectOptions, Handler)
io.vertx.core.http.HttpClient.webSocketAbs(String, MultiMap, WebsocketVersion, List<String>) instead use WebSocketClient.connect(WebSocketConnectOptions)
io.vertx.core.http.HttpClient.webSocketAbs(String, MultiMap, WebsocketVersion, List<String>, Handler<AsyncResult<WebSocket>>) instead use WebSocketClient.connect(WebSocketConnectOptions, Handler)
io.vertx.core.http.HttpServer.webSocketStream() instead use HttpServer.webSocketHandler(Handler)

Deprecated Constructors

Constructor and Description
io.vertx.core.spi.launcher.DefaultCommandFactory(Class<C>) Please use DefaultCommandFactory(Class, Supplier)
io.vertx.core.logging.Logger(LogDelegate) see https://github.com/eclipse-vertx/vert.x/issues/2774