Vert.x Core

The Expect: 100-Continue header allows a client to send request headers and wait for a 100 (Continue) response from the server before sending a large request body. This saves bandwidth if the server intends to reject the request.

Client Side

Use HttpClientRequest#continueHandler(Handler) to receive the signal from the server. This must be used in conjunction with writeHead().

Server Side

• Automatic: Set HttpServerConfig#setHandle100ContinueAutomatically(true) to automatically respond with 100 Continue when the header is detected.
• Manual: Set the option to false (default) to inspect headers manually. Use HttpServerResponse#writeContinue() to allow the client to proceed, or send a failure status code to reject the request.

// Client side example
request.continueHandler(ctx -> {
  // logic to handle 100-Continue
});
request.writeHead(status, headers);

// Server side manual example
if (shouldContinue) {
  response.writeContinue();
} else {
  response.setStatusCode(403).end();
}

The Vert.x DNS resolver provides several configuration options via io.vertx.core.dns.AddressResolverOptions:

• Failover: If a server does not respond in time, the resolver tries the next one. The search is limited by setMaxQueries(int) (default: 4). A query fails if no answer is received within getQueryTimeout() milliseconds (default: 5 seconds).
• Server list rotation: By default, the first server is used and others are for failover. Set setRotateServers(true) to use round-robin selection to spread load.
• Hosts mapping: Vert.x uses the OS hosts file by default, but you can provide an alternative.
• Search domains: You can provide an explicit list of search domains. When a list is used, the dot threshold is 1 (or from /etc/resolv.conf on Linux), which can be adjusted using setNdots(int).

You can also use the JVM system property -Dvertx.disableDnsResolver=true to use the JVM's built-in resolver instead of the Vert.x resolver.

An AsyncMap allows you to store and retrieve data locally or from any other node in a Vert.x cluster. This is ideal for session state in a farm of servers.

Key Characteristics:

• Asynchronous: Getting the map and performing operations returns a Future or uses a handler.
• Clustered: In clustered mode, data is accessible across all cluster members. Note that latency may be higher than local maps due to network overhead.
• Data Types: Keys and values must be immutable, implement io.vertx.core.shareddata.ClusterSerializable, or implement java.io.Serializable.

Operations:

• put(key, value): Asynchronously puts data into the map.
• get(key): Asynchronously retrieves data from the map.
• remove(key): Removes an entry.
• clear(): Clears the map.
• size(): Returns the number of entries.

If you only need an asynchronous map that is restricted to the local node, use localAsyncMap instead.

// Example of getting an asynchronous shared map
// See examples.SharedDataExamples#asyncMap for implementation details

To handle new connections on a NetServer, set a connectHandler. This handler is called with a NetSocket instance representing the connection.

With the NetSocket, you can:

• Read data: Set a handler on the socket. It will be called with a Buffer every time data is received.
• Write data: Use write methods (operations are asynchronous).
• Get addresses: Use localAddress() and remoteAddress().
• Send files: Use sendFile to efficiently stream files or classpath resources directly via the OS kernel.
• Handle lifecycle: Use closeHandler to be notified when a socket closes and exceptionHandler to catch errors on the socket.
• Stream data: NetSocket implements ReadStream and WriteStream, allowing it to be used with Vert.x pipes.

server.connectHandler(socket -> {
    socket.handler(buffer -> {
        System.out.println("Received: " + buffer.toString());
    });
    socket.write("Hello!");
});

The io.vertx.core.file.AsyncFile abstraction allows you to manipulate files asynchronously. Because it implements both ReadStream and WriteStream, you can use the pipe method to stream data between files and other stream objects like net sockets, HTTP requests/responses, or WebSockets.

Random Access Writes

Use AsyncFile#write(Buffer buffer, long position) to write data at a specific offset. If the position is greater than or equal to the current file size, the file will be enlarged to accommodate the offset.

Random Access Reads

Use AsyncFile#read(Buffer buffer, int offset, long position, int length, Handler<AsyncFile> handler) to read a specific number of bytes from a specific position into a buffer at a given offset.

// Random access write
asyncFile.write(buffer, position, handler);

// Random access read
asyncFile.read(buffer, bufferOffset, filePosition, length, handler);