Vertx (Vert.x Stack - Docs 4.5.11 API)

java.lang.Object
- io.vertx.reactivex.core.Vertx

All Implemented Interfaces:

Measured
```
public class Vertx
extends Object
implements Measured
```
The entry point into the Vert.x Core API.
You use an instance of this class for functionality including:
- Creating TCP clients and servers
- Creating HTTP clients and servers
- Creating DNS clients
- Creating Datagram sockets
- Setting and cancelling periodic and one-shot timers
- Getting a reference to the event bus API
- Getting a reference to the file system API
- Getting a reference to the shared data API
- Deploying and undeploying verticles
Most functionality in Vert.x core is fairly low level.
To create an instance of this class you can use the static factory methods: vertx(), vertx() and clusteredVertx(io.vertx.core.VertxOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.Vertx>>).
Please see the user manual for more detailed usage information.
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 io.vertx.lang.rx.TypeArg<Vertx> __TYPE_ARG

Fields
Modifier and Type	Field and Description
`static io.vertx.lang.rx.TypeArg<Vertx>`	`__TYPE_ARG`

Constructor Summary

Constructors
Constructor and Description

Vertx(Object delegate)

Vertx(Vertx delegate)

Constructors
Constructor and Description
`Vertx(Object delegate)`
`Vertx(Vertx delegate)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static VertxBuilder`	`builder()`
`boolean`	`cancelTimer(long id)` Cancels the timer with the specified `id`.
`void`	`close()` Like `close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but the completionHandler will be called when the close is complete
`void`	`close(Handler<AsyncResult<Void>> completionHandler)` Like `close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but the completionHandler will be called when the close is complete
`static void`	`clusteredVertx(VertxOptions options)` Creates a clustered instance using the specified options.
`static void`	`clusteredVertx(VertxOptions options, Handler<AsyncResult<Vertx>> resultHandler)` Creates a clustered instance using the specified options.
`DatagramSocket`	`createDatagramSocket()` Create a datagram socket using default options
`DatagramSocket`	`createDatagramSocket(DatagramSocketOptions options)` Create a datagram socket using the specified options
`DnsClient`	`createDnsClient()` Create a DNS client to connect to the DNS server configured by `VertxOptions`
`DnsClient`	`createDnsClient(DnsClientOptions options)` Create a DNS client to connect to a DNS server
`DnsClient`	`createDnsClient(int port, String host)` Create a DNS client to connect to a DNS server at the specified host and port, with the default query timeout (5 seconds)
`HttpClient`	`createHttpClient()` Create a HTTP/HTTPS client using default options
`HttpClient`	`createHttpClient(HttpClientOptions clientOptions)` Create a HTTP/HTTPS client using the specified client options
`HttpClient`	`createHttpClient(HttpClientOptions clientOptions, PoolOptions poolOptions)` Create a HTTP/HTTPS client using the specified client and pool options
`HttpClient`	`createHttpClient(PoolOptions poolOptions)` Create a HTTP/HTTPS client using the specified pool options
`HttpServer`	`createHttpServer()` Create an HTTP/HTTPS server using default options
`HttpServer`	`createHttpServer(HttpServerOptions options)` Create an HTTP/HTTPS server using the specified options
`NetClient`	`createNetClient()` Create a TCP/SSL client using default options
`NetClient`	`createNetClient(NetClientOptions options)` Create a TCP/SSL client using the specified options
`NetServer`	`createNetServer()` Create a TCP/SSL server using default options
`NetServer`	`createNetServer(NetServerOptions options)` Create a TCP/SSL server using the specified options
`WorkerExecutor`	`createSharedWorkerExecutor(String name)` Like `createSharedWorkerExecutor(java.lang.String)` but with the `VertxOptions` `poolSize`.
`WorkerExecutor`	`createSharedWorkerExecutor(String name, int poolSize)` Like `createSharedWorkerExecutor(java.lang.String)` but with the `VertxOptions` `maxExecuteTime`.
`WorkerExecutor`	`createSharedWorkerExecutor(String name, int poolSize, long maxExecuteTime)` Like `createSharedWorkerExecutor(java.lang.String)` but with the `VertxOptions` `maxExecuteTimeUnit`.
`WorkerExecutor`	`createSharedWorkerExecutor(String name, int poolSize, long maxExecuteTime, TimeUnit maxExecuteTimeUnit)` Create a named worker executor, the executor should be closed when it's not needed anymore to release resources. This method can be called mutiple times with the same `name`.
`WebSocketClient`	`createWebSocketClient()` Create a WebSocket client using default options
`WebSocketClient`	`createWebSocketClient(WebSocketClientOptions options)` Create a WebSocket client using the specified options
`static Context`	`currentContext()` Gets the current context
`Set<String>`	`deploymentIDs()` Return a Set of deployment IDs for the currently deployed deploymentIDs.
`void`	`deployVerticle(String name)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but the completionHandler will be notified when the deployment is complete.
`void`	`deployVerticle(String name, DeploymentOptions options)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `DeploymentOptions` are provided to configure the deployment.
`void`	`deployVerticle(String name, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `DeploymentOptions` are provided to configure the deployment.
`void`	`deployVerticle(String name, Handler<AsyncResult<String>> completionHandler)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but the completionHandler will be notified when the deployment is complete.
`void`	`deployVerticle(java.util.function.Supplier<Verticle> verticleSupplier, DeploymentOptions options)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `Verticle` instance is created by invoking the `verticleSupplier`.
`void`	`deployVerticle(java.util.function.Supplier<Verticle> verticleSupplier, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `Verticle` instance is created by invoking the `verticleSupplier`.
`void`	`deployVerticle(Verticle verticle)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but the completionHandler will be notified when the deployment is complete.
`void`	`deployVerticle(Verticle verticle, DeploymentOptions options)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `DeploymentOptions` are provided to configure the deployment.
`void`	`deployVerticle(Verticle verticle, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `DeploymentOptions` are provided to configure the deployment.
`void`	`deployVerticle(Verticle verticle, Handler<AsyncResult<String>> completionHandler)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but the completionHandler will be notified when the deployment is complete.
`boolean`	`equals(Object o)`
`EventBus`	`eventBus()` Get the event bus object.
`Vertx`	`exceptionHandler(Handler<Throwable> handler)` Set a default exception handler for `Context`, set on `Context.exceptionHandler(io.vertx.core.Handler<java.lang.Throwable>)` at creation.
`<T> void`	`executeBlocking(Callable<T> blockingCodeHandler)` Like `executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
`<T> void`	`executeBlocking(Callable<T> blockingCodeHandler, boolean ordered)` Like `executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
`<T> void`	`executeBlocking(Callable<T> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Like `executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
`<T> void`	`executeBlocking(Callable<T> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
`<T> void`	`executeBlocking(Handler<Promise<T>> blockingCodeHandler)` Deprecated.
`<T> void`	`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated.
`<T> void`	`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Deprecated.
`<T> void`	`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Deprecated.
`FileSystem`	`fileSystem()` Get the filesystem object.
`Vertx`	`getDelegate()`
`Context`	`getOrCreateContext()` Gets the current context, or creates one if there isn't one
`int`	`hashCode()`
`HttpClientBuilder`	`httpClientBuilder()` Provide a builder for , it can be used to configure advanced HTTP client settings like a redirect handler or a connection handler.
`boolean`	`isClustered()` Is this Vert.x instance clustered?
`boolean`	`isMetricsEnabled()` Whether the metrics are enabled for this measured object
`boolean`	`isNativeTransportEnabled()`
`EventLoopGroup`	`nettyEventLoopGroup()` Deprecated.
`static Vertx`	`newInstance(Vertx arg)`
`TimeoutStream`	`periodicStream(long delay)` Deprecated.
`TimeoutStream`	`periodicStream(long initialDelay, long delay)` Deprecated.
`void`	`registerVerticleFactory(VerticleFactory factory)` Register a `VerticleFactory` that can be used for deploying Verticles based on an identifier.
`void`	`runOnContext(Handler<Void> action)` Puts the handler on the event queue for the current context so it will be run asynchronously ASAP after all preceeding events have been handled.
`Completable`	`rxClose()` Like `close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but the completionHandler will be called when the close is complete
`static Single<Vertx>`	`rxClusteredVertx(VertxOptions options)` Creates a clustered instance using the specified options.
`Single<String>`	`rxDeployVerticle(String name)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but the completionHandler will be notified when the deployment is complete.
`Single<String>`	`rxDeployVerticle(String name, DeploymentOptions options)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `DeploymentOptions` are provided to configure the deployment.
`Single<String>`	`rxDeployVerticle(java.util.function.Supplier<Verticle> verticleSupplier, DeploymentOptions options)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `Verticle` instance is created by invoking the `verticleSupplier`.
`Single<String>`	`rxDeployVerticle(Verticle verticle)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but the completionHandler will be notified when the deployment is complete.
`Single<String>`	`rxDeployVerticle(Verticle verticle, DeploymentOptions options)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `DeploymentOptions` are provided to configure the deployment.
`<T> Maybe<T>`	`rxExecuteBlocking(Callable<T> blockingCodeHandler)` Like `executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
`<T> Maybe<T>`	`rxExecuteBlocking(Callable<T> blockingCodeHandler, boolean ordered)` Like `executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` but using a callback.
`<T> Maybe<T>`	`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)` Deprecated.
`<T> Maybe<T>`	`rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Deprecated.
`Completable`	`rxUndeploy(String deploymentID)` Like `#undeploy(String)` but the completionHandler will be notified when the undeployment is complete.
`long`	`setPeriodic(long delay, Handler<Long> handler)` Set a periodic timer to fire every `delay` milliseconds, at which point `handler` will be called with the id of the timer.
`long`	`setPeriodic(long initialDelay, long delay, Handler<Long> handler)` Set a periodic timer to fire every `delay` milliseconds with initial delay, at which point `handler` will be called with the id of the timer.
`long`	`setTimer(long delay, Handler<Long> handler)` Set a one-shot timer to fire after `delay` milliseconds, at which point `handler` will be called with the id of the timer.
`SharedData`	`sharedData()` Get the shared data object.
`Timer`	`timer(long delay)` Like `timer(long)` with a unit in millis.
`Timer`	`timer(long delay, TimeUnit unit)` Create a timer task configured with the specified `delay`, when the timeout fires the timer future is succeeded, when the timeout is cancelled the timer future is failed with a `CancellationException` instance.
`TimeoutStream`	`timerStream(long delay)` Deprecated.
`String`	`toString()`
`Throwable`	`unavailableNativeTransportCause()`
`void`	`undeploy(String deploymentID)` Like `#undeploy(String)` but the completionHandler will be notified when the undeployment is complete.
`void`	`undeploy(String deploymentID, Handler<AsyncResult<Void>> completionHandler)` Like `#undeploy(String)` but the completionHandler will be notified when the undeployment is complete.
`void`	`unregisterVerticleFactory(VerticleFactory factory)` Unregister a `VerticleFactory`
`Set<VerticleFactory>`	`verticleFactories()` Return the Set of currently registered verticle factories.
`static Vertx`	`vertx()` Creates a non clustered instance using default options.
`static Vertx`	`vertx(VertxOptions options)` Creates a non clustered instance using the specified options

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

Methods inherited from interface io.vertx.reactivex.core.metrics.Measured
newInstance

- Field Detail
  - __TYPE_ARG
```
public static final io.vertx.lang.rx.TypeArg<Vertx> __TYPE_ARG
```
- Constructor Detail
  - Vertx
```
public Vertx(Vertx delegate)
```
  - Vertx
```
public Vertx(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 Vertx 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
  - builder
```
public static VertxBuilder builder()
```
  - vertx
```
public static Vertx vertx()
```
    Creates a non clustered instance using default options.
    
    Returns:
    
    the instance
  - vertx
```
public static Vertx vertx(VertxOptions options)
```
    Creates a non clustered instance using the specified options
    
    Parameters:
    
    options - the options to use
    
    Returns:
    
    the instance
  - clusteredVertx
```
public static void clusteredVertx(VertxOptions options,
                                  Handler<AsyncResult<Vertx>> resultHandler)
```
    Creates a clustered instance using the specified options.
    The instance is created asynchronously and the resultHandler is called with the result when it is ready.
    
    Parameters:
    
    options - the options to use
    
    resultHandler - the result handler that will receive the result
  - clusteredVertx
```
public static void clusteredVertx(VertxOptions options)
```
    Creates a clustered instance using the specified options.
    The instance is created asynchronously and the resultHandler is called with the result when it is ready.
    
    Parameters:
    
    options - the options to use
  - rxClusteredVertx
```
public static Single<Vertx> rxClusteredVertx(VertxOptions options)
```
    Creates a clustered instance using the specified options.
    The instance is created asynchronously and the resultHandler is called with the result when it is ready.
    
    Parameters:
    
    options - the options to use
    
    Returns:
  - currentContext
```
public static Context currentContext()
```
    Gets the current context
    
    Returns:
    
    The current context or null if there is no current context
  - getOrCreateContext
```
public Context getOrCreateContext()
```
    Gets the current context, or creates one if there isn't one
    
    Returns:
    
    The current context (created if didn't exist)
  - createNetServer
```
public NetServer createNetServer(NetServerOptions options)
```
    Create a TCP/SSL server using the specified options
    
    Parameters:
    
    options - the options to use
    
    Returns:
    
    the server
  - createNetServer
```
public NetServer createNetServer()
```
    Create a TCP/SSL server using default options
    
    Returns:
    
    the server
  - createNetClient
```
public NetClient createNetClient(NetClientOptions options)
```
    Create a TCP/SSL client using the specified options
    
    Parameters:
    
    options - the options to use
    
    Returns:
    
    the client
  - createNetClient
```
public NetClient createNetClient()
```
    Create a TCP/SSL client using default options
    
    Returns:
    
    the client
  - createHttpServer
```
public HttpServer createHttpServer(HttpServerOptions options)
```
    Create an HTTP/HTTPS server using the specified options
    
    Parameters:
    
    options - the options to use
    
    Returns:
    
    the server
  - createHttpServer
```
public HttpServer createHttpServer()
```
    Create an HTTP/HTTPS server using default options
    
    Returns:
    
    the server
  - createWebSocketClient
```
public WebSocketClient createWebSocketClient()
```
    Create a WebSocket client using default options
    
    Returns:
    
    the client
  - createWebSocketClient
```
public WebSocketClient createWebSocketClient(WebSocketClientOptions options)
```
    Create a WebSocket client using the specified options
    
    Parameters:
    
    options - the options to use
    
    Returns:
    
    the client
  - httpClientBuilder
```
public HttpClientBuilder httpClientBuilder()
```
    Provide a builder for , it can be used to configure advanced HTTP client settings like a redirect handler or a connection handler.
    Example usage: HttpClient client = vertx.httpClientBuilder().with(options).withConnectHandler(conn -> ...).build()
    
    Returns:
  - createHttpClient
```
public HttpClient createHttpClient(HttpClientOptions clientOptions,
                                   PoolOptions poolOptions)
```
    Create a HTTP/HTTPS client using the specified client and pool options
    
    Parameters:
    
    clientOptions - the client options to use
    
    poolOptions - the pool options to use
    
    Returns:
    
    the client
  - createHttpClient
```
public HttpClient createHttpClient(HttpClientOptions clientOptions)
```
    Create a HTTP/HTTPS client using the specified client options
    
    Parameters:
    
    clientOptions - the options to use
    
    Returns:
    
    the client
  - createHttpClient
```
public HttpClient createHttpClient(PoolOptions poolOptions)
```
    Create a HTTP/HTTPS client using the specified pool options
    
    Parameters:
    
    poolOptions - the pool options to use
    
    Returns:
    
    the client
  - createHttpClient
```
public HttpClient createHttpClient()
```
    Create a HTTP/HTTPS client using default options
    
    Returns:
    
    the client
  - createDatagramSocket
```
public DatagramSocket createDatagramSocket(DatagramSocketOptions options)
```
    Create a datagram socket using the specified options
    
    Parameters:
    
    options - the options to use
    
    Returns:
    
    the socket
  - createDatagramSocket
```
public DatagramSocket createDatagramSocket()
```
    Create a datagram socket using default options
    
    Returns:
    
    the socket
  - fileSystem
```
public FileSystem fileSystem()
```
    Get the filesystem object. There is a single instance of FileSystem per Vertx instance.
    
    Returns:
    
    the filesystem object
  - eventBus
```
public EventBus eventBus()
```
    Get the event bus object. There is a single instance of EventBus per Vertx instance.
    
    Returns:
    
    the event bus object
  - createDnsClient
```
public DnsClient createDnsClient(int port,
                                 String host)
```
    Create a DNS client to connect to a DNS server at the specified host and port, with the default query timeout (5 seconds)
    
    Parameters:
    
    port - the port
    
    host - the host
    
    Returns:
    
    the DNS client
  - createDnsClient
```
public DnsClient createDnsClient()
```
    Create a DNS client to connect to the DNS server configured by VertxOptions
    DNS client takes the first configured resolver address provided by }
    
    Returns:
    
    the DNS client
  - createDnsClient
```
public DnsClient createDnsClient(DnsClientOptions options)
```
    Create a DNS client to connect to a DNS server
    
    Parameters:
    
    options - the client options
    
    Returns:
    
    the DNS client
  - sharedData
```
public SharedData sharedData()
```
    Get the shared data object. There is a single instance of SharedData per Vertx instance.
    
    Returns:
    
    the shared data object
  - timer
```
public Timer timer(long delay)
```
    Like timer(long) with a unit in millis.
    
    Parameters:
    
    delay -
    
    Returns:
  - timer
```
public Timer timer(long delay,
                   TimeUnit unit)
```
    Create a timer task configured with the specified delay, when the timeout fires the timer future is succeeded, when the timeout is cancelled the timer future is failed with a CancellationException instance.
    
    Parameters:
    
    delay - the delay
    
    unit - the delay unit
    
    Returns:
    
    the timer object
  - setTimer
```
public long setTimer(long delay,
                     Handler<Long> handler)
```
    Set a one-shot timer to fire after delay milliseconds, at which point handler will be called with the id of the timer.
    
    Parameters:
    
    delay - the delay in milliseconds, after which the timer will fire
    
    handler - the handler that will be called with the timer ID when the timer fires
    
    Returns:
    
    the unique ID of the timer
  - timerStream
```
@Deprecated
public TimeoutStream timerStream(long delay)
```
    Deprecated.
    
    Returns a one-shot timer as a read stream. The timer will be fired after delay milliseconds after the has been called.
    
    Parameters:
    
    delay - the delay in milliseconds, after which the timer will fire
    
    Returns:
    
    the timer stream
  - setPeriodic
```
public long setPeriodic(long delay,
                        Handler<Long> handler)
```
    Set a periodic timer to fire every delay milliseconds, at which point handler will be called with the id of the timer.
    
    Parameters:
    
    delay - the delay in milliseconds, after which the timer will fire
    
    handler - the handler that will be called with the timer ID when the timer fires
    
    Returns:
    
    the unique ID of the timer
  - setPeriodic
```
public long setPeriodic(long initialDelay,
                        long delay,
                        Handler<Long> handler)
```
    Set a periodic timer to fire every delay milliseconds with initial delay, at which point handler will be called with the id of the timer.
    
    Parameters:
    
    initialDelay - the initial delay in milliseconds
    
    delay - the delay in milliseconds, after which the timer will fire
    
    handler - the handler that will be called with the timer ID when the timer fires
    
    Returns:
    
    the unique ID of the timer
  - periodicStream
```
@Deprecated
public TimeoutStream periodicStream(long delay)
```
    Deprecated.
    
    Returns a periodic timer as a read stream. The timer will be fired every delay milliseconds after the has been called.
    
    Parameters:
    
    delay - the delay in milliseconds, after which the timer will fire
    
    Returns:
    
    the periodic stream
  - periodicStream
```
@Deprecated
public TimeoutStream periodicStream(long initialDelay,
                                                long delay)
```
    Deprecated.
    
    Returns a periodic timer as a read stream. The timer will be fired every delay milliseconds after the has been called.
    
    Parameters:
    
    initialDelay - the initial delay in milliseconds
    
    delay - the delay in milliseconds, after which the timer will fire
    
    Returns:
    
    the periodic stream
  - cancelTimer
```
public boolean cancelTimer(long id)
```
    Cancels the timer with the specified id.
    
    Parameters:
    
    id - The id of the timer to cancel
    
    Returns:
    
    true if the timer was successfully cancelled, or false if the timer does not exist.
  - runOnContext
```
public void runOnContext(Handler<Void> action)
```
    Puts the handler on the event queue for the current context so it will be run asynchronously ASAP after all preceeding events have been handled.
    
    Parameters:
    
    action - - a handler representing the action to execute
  - close
```
public void close(Handler<AsyncResult<Void>> completionHandler)
```
    Like close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but the completionHandler will be called when the close is complete
    
    Parameters:
    
    completionHandler - The handler will be notified when the close is complete.
  - close
```
public void close()
```
    Like close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but the completionHandler will be called when the close is complete
  - rxClose
```
public Completable rxClose()
```
    Like close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but the completionHandler will be called when the close is complete
    
    Returns:
  - deployVerticle
```
public void deployVerticle(String name,
                           Handler<AsyncResult<String>> completionHandler)
```
    Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but the completionHandler will be notified when the deployment is complete.
    If the deployment is successful the result will contain a String representing the unique deployment ID of the deployment.
    This deployment ID can subsequently be used to undeploy the verticle.
    
    Parameters:
    
    name - The identifier
    
    completionHandler - a handler which will be notified when the deployment is complete
  - deployVerticle
```
public void deployVerticle(String name)
```
    Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but the completionHandler will be notified when the deployment is complete.
    If the deployment is successful the result will contain a String representing the unique deployment ID of the deployment.
    This deployment ID can subsequently be used to undeploy the verticle.
    
    Parameters:
    
    name - The identifier
  - rxDeployVerticle
```
public Single<String> rxDeployVerticle(String name)
```
    Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but the completionHandler will be notified when the deployment is complete.
    If the deployment is successful the result will contain a String representing the unique deployment ID of the deployment.
    This deployment ID can subsequently be used to undeploy the verticle.
    
    Parameters:
    
    name - The identifier
    
    Returns:
  - deployVerticle
```
public void deployVerticle(String name,
                           DeploymentOptions options,
                           Handler<AsyncResult<String>> completionHandler)
```
    Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but DeploymentOptions are provided to configure the deployment.
    
    Parameters:
    
    name - the name
    
    options - the deployment options.
    
    completionHandler - a handler which will be notified when the deployment is complete
  - deployVerticle
```
public void deployVerticle(String name,
                           DeploymentOptions options)
```
    Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but DeploymentOptions are provided to configure the deployment.
    
    Parameters:
    
    name - the name
    
    options - the deployment options.
  - rxDeployVerticle
```
public Single<String> rxDeployVerticle(String name,
                                       DeploymentOptions options)
```
    Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but DeploymentOptions are provided to configure the deployment.
    
    Parameters:
    
    name - the name
    
    options - the deployment options.
    
    Returns:
  - undeploy
```
public void undeploy(String deploymentID,
                     Handler<AsyncResult<Void>> completionHandler)
```
    Like #undeploy(String) but the completionHandler will be notified when the undeployment is complete.
    
    Parameters:
    
    deploymentID - the deployment ID
    
    completionHandler - a handler which will be notified when the undeployment is complete
  - undeploy
```
public void undeploy(String deploymentID)
```
    Like #undeploy(String) but the completionHandler will be notified when the undeployment is complete.
    
    Parameters:
    
    deploymentID - the deployment ID
  - rxUndeploy
```
public Completable rxUndeploy(String deploymentID)
```
    Like #undeploy(String) but the completionHandler will be notified when the undeployment is complete.
    
    Parameters:
    
    deploymentID - the deployment ID
    
    Returns:
  - deploymentIDs
```
public Set<String> deploymentIDs()
```
    Return a Set of deployment IDs for the currently deployed deploymentIDs.
    
    Returns:
    
    Set of deployment IDs
  - isClustered
```
public boolean isClustered()
```
    Is this Vert.x instance clustered?
    
    Returns:
    
    true if clustered
  - executeBlocking
```
@Deprecated
public <T> void executeBlocking(Handler<Promise<T>> blockingCodeHandler,
                                            boolean ordered,
                                            Handler<AsyncResult<T>> resultHandler)
```
    Deprecated.
    
    Safely execute some blocking code.
    Executes the blocking code in the handler blockingCodeHandler using a thread from the worker pool.
    The returned future will be completed with the result on the original context (i.e. on the original event loop of the caller) or failed when the handler throws an exception.
    A Future instance is passed into blockingCodeHandler. When the blocking code successfully completes, the handler should call the Promise.complete(T) or Promise.complete(T) method, or the Promise.fail(java.lang.Throwable) method if it failed.
    In the blockingCodeHandler the current context remains the original context and therefore any task scheduled in the blockingCodeHandler will be executed on this context and not on the worker thread.
    The blocking code should block for a reasonable amount of time (i.e no more than a few seconds). Long blocking operations or polling operations (i.e a thread that spin in a loop polling events in a blocking fashion) are precluded.
    When the blocking operation lasts more than the 10 seconds, a message will be printed on the console by the blocked thread checker.
    Long blocking operations should use a dedicated thread managed by the application, which can interact with verticles using the event-bus or Context.runOnContext(io.vertx.core.Handler<java.lang.Void>)
    
    Parameters:
    
    blockingCodeHandler - handler representing the blocking code to run
    
    ordered - if true then if executeBlocking is called several times on the same context, the executions for that context will be executed serially, not in parallel. if false then they will be no ordering guarantees
    
    resultHandler - handler that will be called when the blocking code is complete
  - executeBlocking
```
@Deprecated
public <T> void executeBlocking(Handler<Promise<T>> blockingCodeHandler,
                                            boolean ordered)
```
    Deprecated.
    
    Safely execute some blocking code.
    Executes the blocking code in the handler blockingCodeHandler using a thread from the worker pool.
    The returned future will be completed with the result on the original context (i.e. on the original event loop of the caller) or failed when the handler throws an exception.
    A Future instance is passed into blockingCodeHandler. When the blocking code successfully completes, the handler should call the Promise.complete(T) or Promise.complete(T) method, or the Promise.fail(java.lang.Throwable) method if it failed.
    In the blockingCodeHandler the current context remains the original context and therefore any task scheduled in the blockingCodeHandler will be executed on this context and not on the worker thread.
    The blocking code should block for a reasonable amount of time (i.e no more than a few seconds). Long blocking operations or polling operations (i.e a thread that spin in a loop polling events in a blocking fashion) are precluded.
    When the blocking operation lasts more than the 10 seconds, a message will be printed on the console by the blocked thread checker.
    Long blocking operations should use a dedicated thread managed by the application, which can interact with verticles using the event-bus or Context.runOnContext(io.vertx.core.Handler<java.lang.Void>)
    
    Parameters:
    
    blockingCodeHandler - handler representing the blocking code to run
    
    ordered - if true then if executeBlocking is called several times on the same context, the executions for that context will be executed serially, not in parallel. if false then they will be no ordering guarantees
  - rxExecuteBlocking
```
@Deprecated
public <T> Maybe<T> rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler,
                                                  boolean ordered)
```
    Deprecated.
    
    Safely execute some blocking code.
    Executes the blocking code in the handler blockingCodeHandler using a thread from the worker pool.
    The returned future will be completed with the result on the original context (i.e. on the original event loop of the caller) or failed when the handler throws an exception.
    A Future instance is passed into blockingCodeHandler. When the blocking code successfully completes, the handler should call the Promise.complete(T) or Promise.complete(T) method, or the Promise.fail(java.lang.Throwable) method if it failed.
    In the blockingCodeHandler the current context remains the original context and therefore any task scheduled in the blockingCodeHandler will be executed on this context and not on the worker thread.
    The blocking code should block for a reasonable amount of time (i.e no more than a few seconds). Long blocking operations or polling operations (i.e a thread that spin in a loop polling events in a blocking fashion) are precluded.
    When the blocking operation lasts more than the 10 seconds, a message will be printed on the console by the blocked thread checker.
    Long blocking operations should use a dedicated thread managed by the application, which can interact with verticles using the event-bus or Context.runOnContext(io.vertx.core.Handler<java.lang.Void>)
    
    Parameters:
    
    blockingCodeHandler - handler representing the blocking code to run
    
    ordered - if true then if executeBlocking is called several times on the same context, the executions for that context will be executed serially, not in parallel. if false then they will be no ordering guarantees
    
    Returns:
  - executeBlocking
```
@Deprecated
public <T> void executeBlocking(Handler<Promise<T>> blockingCodeHandler,
                                            Handler<AsyncResult<T>> resultHandler)
```
    Deprecated.
    
    Like executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>) called with ordered = true.
    
    Parameters:
    
    blockingCodeHandler -
    
    resultHandler -
  - executeBlocking
```
@Deprecated
public <T> void executeBlocking(Handler<Promise<T>> blockingCodeHandler)
```
    Deprecated.
    
    Like executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>) called with ordered = true.
    
    Parameters:
    
    blockingCodeHandler -
  - rxExecuteBlocking
```
@Deprecated
public <T> Maybe<T> rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)
```
    Deprecated.
    
    Like executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>) called with ordered = true.
    
    Parameters:
    
    blockingCodeHandler -
    
    Returns:
  - createSharedWorkerExecutor
```
public WorkerExecutor createSharedWorkerExecutor(String name)
```
    Like createSharedWorkerExecutor(java.lang.String) but with the VertxOptions poolSize.
    
    Parameters:
    
    name -
    
    Returns:
  - createSharedWorkerExecutor
```
public WorkerExecutor createSharedWorkerExecutor(String name,
                                                 int poolSize)
```
    Like createSharedWorkerExecutor(java.lang.String) but with the VertxOptions maxExecuteTime.
    
    Parameters:
    
    name -
    
    poolSize -
    
    Returns:
  - createSharedWorkerExecutor
```
public WorkerExecutor createSharedWorkerExecutor(String name,
                                                 int poolSize,
                                                 long maxExecuteTime)
```
    Like createSharedWorkerExecutor(java.lang.String) but with the VertxOptions maxExecuteTimeUnit.
    
    Parameters:
    
    name -
    
    poolSize -
    
    maxExecuteTime -
    
    Returns:
  - createSharedWorkerExecutor
```
public WorkerExecutor createSharedWorkerExecutor(String name,
                                                 int poolSize,
                                                 long maxExecuteTime,
                                                 TimeUnit maxExecuteTimeUnit)
```
    Create a named worker executor, the executor should be closed when it's not needed anymore to release resources.
    This method can be called mutiple times with the same name. Executors with the same name will share the same worker pool. The worker pool size , max execute time and unit of max execute time are set when the worker pool is created and won't change after.
    The worker pool is released when all the WorkerExecutor sharing the same name are closed.
    
    Parameters:
    
    name - the name of the worker executor
    
    poolSize - the size of the pool
    
    maxExecuteTime - the value of max worker execute time
    
    maxExecuteTimeUnit - the value of unit of max worker execute time
    
    Returns:
    
    the named worker executor
  - isNativeTransportEnabled
```
public boolean isNativeTransportEnabled()
```
    Returns:
    
    whether the native transport is used
  - unavailableNativeTransportCause
```
public Throwable unavailableNativeTransportCause()
```
    Returns:
    
    the error (if any) that cause the unavailability of native transport when isNativeTransportEnabled() returns false.
  - exceptionHandler
```
public Vertx exceptionHandler(Handler<Throwable> handler)
```
    Set a default exception handler for Context, set on Context.exceptionHandler(io.vertx.core.Handler<java.lang.Throwable>) at creation.
    
    Parameters:
    
    handler - the exception handler
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - deployVerticle
```
public void deployVerticle(Verticle verticle,
                           Handler<AsyncResult<String>> completionHandler)
```
    Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but the completionHandler will be notified when the deployment is complete.
    If the deployment is successful the result will contain a string representing the unique deployment ID of the deployment.
    This deployment ID can subsequently be used to undeploy the verticle.
    
    Parameters:
    
    verticle - the verticle instance to deploy
    
    completionHandler - a handler which will be notified when the deployment is complete
  - deployVerticle
```
public void deployVerticle(Verticle verticle)
```
    Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but the completionHandler will be notified when the deployment is complete.
    If the deployment is successful the result will contain a string representing the unique deployment ID of the deployment.
    This deployment ID can subsequently be used to undeploy the verticle.
    
    Parameters:
    
    verticle - the verticle instance to deploy
  - rxDeployVerticle
```
public Single<String> rxDeployVerticle(Verticle verticle)
```
    Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but the completionHandler will be notified when the deployment is complete.
    If the deployment is successful the result will contain a string representing the unique deployment ID of the deployment.
    This deployment ID can subsequently be used to undeploy the verticle.
    
    Parameters:
    
    verticle - the verticle instance to deploy
    
    Returns:
  - deployVerticle
```
public void deployVerticle(Verticle verticle,
                           DeploymentOptions options,
                           Handler<AsyncResult<String>> completionHandler)
```
    Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but DeploymentOptions are provided to configure the deployment.
    
    Parameters:
    
    verticle - the verticle instance to deploy
    
    options - the deployment options.
    
    completionHandler - a handler which will be notified when the deployment is complete
  - deployVerticle
```
public void deployVerticle(Verticle verticle,
                           DeploymentOptions options)
```
    Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but DeploymentOptions are provided to configure the deployment.
    
    Parameters:
    
    verticle - the verticle instance to deploy
    
    options - the deployment options.
  - rxDeployVerticle
```
public Single<String> rxDeployVerticle(Verticle verticle,
                                       DeploymentOptions options)
```
    Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but DeploymentOptions are provided to configure the deployment.
    
    Parameters:
    
    verticle - the verticle instance to deploy
    
    options - the deployment options.
    
    Returns:
  - deployVerticle
```
public void deployVerticle(java.util.function.Supplier<Verticle> verticleSupplier,
                           DeploymentOptions options,
                           Handler<AsyncResult<String>> completionHandler)
```
    Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but Verticle instance is created by invoking the verticleSupplier.
    The supplier will be invoked as many times as DeploymentOptions. It must not return the same instance twice.
    Note that the supplier will be invoked on the caller thread.
    
    Parameters:
    
    verticleSupplier -
    
    options -
    
    completionHandler -
  - deployVerticle
```
public void deployVerticle(java.util.function.Supplier<Verticle> verticleSupplier,
                           DeploymentOptions options)
```
    Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but Verticle instance is created by invoking the verticleSupplier.
    The supplier will be invoked as many times as DeploymentOptions. It must not return the same instance twice.
    Note that the supplier will be invoked on the caller thread.
    
    Parameters:
    
    verticleSupplier -
    
    options -
  - rxDeployVerticle
```
public Single<String> rxDeployVerticle(java.util.function.Supplier<Verticle> verticleSupplier,
                                       DeploymentOptions options)
```
    Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but Verticle instance is created by invoking the verticleSupplier.
    The supplier will be invoked as many times as DeploymentOptions. It must not return the same instance twice.
    Note that the supplier will be invoked on the caller thread.
    
    Parameters:
    
    verticleSupplier -
    
    options -
    
    Returns:
  - registerVerticleFactory
```
public void registerVerticleFactory(VerticleFactory factory)
```
    Register a VerticleFactory that can be used for deploying Verticles based on an identifier.
    
    Parameters:
    
    factory - the factory to register
  - unregisterVerticleFactory
```
public void unregisterVerticleFactory(VerticleFactory factory)
```
    Unregister a VerticleFactory
    
    Parameters:
    
    factory - the factory to unregister
  - verticleFactories
```
public Set<VerticleFactory> verticleFactories()
```
    Return the Set of currently registered verticle factories.
    
    Returns:
    
    the set of verticle factories
  - executeBlocking
```
public <T> void executeBlocking(Callable<T> blockingCodeHandler,
                                Handler<AsyncResult<T>> resultHandler)
```
    Like executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>) but using a callback.
    
    Parameters:
    
    blockingCodeHandler -
    
    resultHandler -
  - executeBlocking
```
public <T> void executeBlocking(Callable<T> blockingCodeHandler)
```
    Like executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>) but using a callback.
    
    Parameters:
    
    blockingCodeHandler -
  - rxExecuteBlocking
```
public <T> Maybe<T> rxExecuteBlocking(Callable<T> blockingCodeHandler)
```
    Like executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>) but using a callback.
    
    Parameters:
    
    blockingCodeHandler -
    
    Returns:
  - executeBlocking
```
public <T> void executeBlocking(Callable<T> blockingCodeHandler,
                                boolean ordered,
                                Handler<AsyncResult<T>> resultHandler)
```
    Like executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>) but using a callback.
    
    Parameters:
    
    blockingCodeHandler -
    
    ordered -
    
    resultHandler -
  - executeBlocking
```
public <T> void executeBlocking(Callable<T> blockingCodeHandler,
                                boolean ordered)
```
    Like executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>) but using a callback.
    
    Parameters:
    
    blockingCodeHandler -
    
    ordered -
  - rxExecuteBlocking
```
public <T> Maybe<T> rxExecuteBlocking(Callable<T> blockingCodeHandler,
                                      boolean ordered)
```
    Like executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>) but using a callback.
    
    Parameters:
    
    blockingCodeHandler -
    
    ordered -
    
    Returns:
  - nettyEventLoopGroup
```
@Deprecated
public EventLoopGroup nettyEventLoopGroup()
```
    Deprecated.
    
    Return the Netty EventLoopGroup used by Vert.x
    
    Returns:
    
    the EventLoopGroup
  - newInstance
```
public static Vertx newInstance(Vertx arg)
```

Class Vertx

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface io.vertx.reactivex.core.metrics.Measured

Field Detail

__TYPE_ARG

Constructor Detail

Vertx

Vertx

Method Detail

toString

equals

hashCode

getDelegate

isMetricsEnabled

builder

vertx

vertx

clusteredVertx

clusteredVertx

rxClusteredVertx

currentContext

getOrCreateContext

createNetServer

createNetServer

createNetClient

createNetClient

createHttpServer

createHttpServer

createWebSocketClient

createWebSocketClient

httpClientBuilder

createHttpClient

createHttpClient

createHttpClient

createHttpClient

createDatagramSocket

createDatagramSocket

fileSystem

eventBus

createDnsClient

createDnsClient

createDnsClient

sharedData

timer

timer

setTimer

timerStream

setPeriodic

setPeriodic

periodicStream

periodicStream

cancelTimer

runOnContext

close

close

rxClose

deployVerticle

deployVerticle

rxDeployVerticle

deployVerticle

deployVerticle

rxDeployVerticle

undeploy

undeploy

rxUndeploy

deploymentIDs

isClustered

executeBlocking

executeBlocking

rxExecuteBlocking

executeBlocking

executeBlocking

rxExecuteBlocking

createSharedWorkerExecutor

createSharedWorkerExecutor

createSharedWorkerExecutor

createSharedWorkerExecutor