Vert.x Buffers
Jakob Jenkov |
Verticles running in Vert.x often need to process blocks of data. For instance, data from an incoming HTTP
request, data loaded from disk, or data generated as response to an HTTP request etc. Vert.x provides
a Buffer
interface (io.vertx.core.buffer.Buffer)
to help you handle such data blocks.
A Buffer
in Vert.x can hold binary data. As such a Buffer
is similar to a byte
array, except the Buffer
can expand its capacity dynamically as you write data to it.
Creating a Buffer
Creating a Buffer
is done using the static buffer()
method in the Buffer
interface. Here is how creating a Vert.x Buffer
looks:
Buffer buffer = Buffer.buffer();
You can also create a Buffer
with some data inside from the start.
Here is how you create a Buffer
initialized with bytes from a byte
array:
byte[] initialData = new byte[]{1, 2, 3}; Buffer buffer2 = Buffer.buffer(initialData);
You can also initialize a Buffer
with the contents of a String. Here is an example of creating
a Buffer
initialized to the value of a String:
Buffer buffer3 = Buffer.buffer("initial data");
If you want the bytes stored in the Buffer
to be encoded using a special encoding (e.g. UTF-8, UTF-16
etc.) you can specify the encoding as the second parameter to the buffer()
method, like this:
Buffer buffer4 = Buffer.buffer("initial data", "UTF-8"); Buffer buffer5 = Buffer.buffer("initial data", "UTF-16");
This is equivalent to this:
Buffer buffer6 = Buffer.buffer("initial data".getBytes("UTF-8")); Buffer buffer7 = Buffer.buffer("initial data".getBytes("UTF-16"));
Buffer Length
You can read the length of a Buffer
using its length()
method. Here is an example:
Buffer buffer = Buffer.buffer(); System.out.println("buffer.length() = " + buffer.length());
Writing to a Buffer
You can write to a specific position inside a buffer using one of the set...()
methods.
Here are some examples:
Buffer buffer = Buffer.buffer(); System.out.println("buffer.length() = " + buffer.length()); buffer.setByte ( 0, (byte) 127); buffer.setShort ( 2, (short) 127); buffer.setInt ( 4, 127); buffer.setLong ( 8, 127); buffer.setFloat (16, 127.0F); buffer.setDouble(20, 127.0D); System.out.println("buffer.length() = " + buffer.length());
Notice that the length of the buffer starts as 0. Then, as data is written into it, the buffer expands to fit the required size. After executing the code above, the length of the buffer is 28.
You can also write data to a Buffer
using one of the append...()
methods.
Here are some examples:
Buffer buffer = Buffer.buffer(); System.out.println("buffer.length() = " + buffer.length()); buffer.appendByte ((byte) 127); buffer.appendShort ((short) 127); buffer.appendInt ( 127); buffer.appendLong ( 127); buffer.appendFloat ( 127.0F); buffer.appendDouble( 127.0D); System.out.println("buffer.length() = " + buffer.length());
The append...()
methods do not need an index as parameter. They always append the data to the end
of the Buffer
. The length of the Buffer
will be 27 after executing this code (because
all data following the first byte is inserted from index 1, and not index 2 as in the previous example).
Reading From a Buffer
You can read the data stored in a Buffer
using the many get...()
methods. Here
are some examples:
byte aByte = buffer.getByte ( 0); short aShort = buffer.getShort ( 2); int anInt = buffer.getInt ( 4); long aLong = buffer.getLong ( 8); float aFloat = buffer.getFloat (16); double aDouble = buffer.getDouble(20);
Tweet | |
Jakob Jenkov |