Introduction
![]() | Note
This page is being updated |
A byte buffer used by MINA applications.
This is a replacement for ByteBuffer![]()
. MINA does not use NIO ByteBuffer directly for two reasons:
- It doesn't provide useful getters and putters such as fill, get/putString, and get/putAsciiInt() .
- It is difficult to write variable-length data due to its fixed capacity
IoBuffer Operations
Allocating a new Buffer
IoBuffer is an abstract class, hence can't be instantiated directly. To allocate IoBuffer, we need to use allocate() method.
public static IoBuffer allocate(int capacity, boolean direct)
The allocate() method takes two arguments
- capacity - the capacity of the buffer
- direct - type of buffer. true to get direct buffer, false to get heap buffer
The default buffer allocation is handled by SimpleBufferAllocator![]()
Alternatively, following form can also be used
IoBuffer.setUseDirectBuffer(false);
IoBuffer buf = IoBuffer.allocate(1024);
Creating Auto Expanding Buffer
Creating auto expanding buffer is not verye asy with java NIO API's, coz of the fixed size of the buffers. Having a buffer, that can auto expand on needs is a big plus for networking applications. To address this, IoBuffer has introduced autoExpand property. It automatically expands its capacity and limit value.
Lets see how to create an auto expanding buffer
IoBuffer buffer = IoBuffer.allocate(8);
buffer.setAutoExpand(true);
buffer.putString("12345678", encoder);
buffer.put((byte)10);
The underlying ByteBuffer is reallocated by IoBuffer behind the scene if the encoded data is larger than 16 bytes in the example above. Its capacity will double, and its limit will increase to the last position the string is written. This behaviour is very similar to the way StringBuffer class works.
Creating Auto Shrinking Buffer
There are situations which calls for releasing additionally allocated bytes from the buffer, to preserve memory. IoBuffer provides autoShrink property to address the need. If autoShrink is turned on, IoBuffer halves the capacity of the buffer when compact() is invoked and only 1/4 or less of the current capacity is being used. To manually shrink the buffer, use shrink() method.
Lets see this in action
IoBuffer buffer = IoBuffer.allocate(16);
buffer.setAutoShrink(true);
buffer.put((byte)1);
System.out.println("Initial Buffer capacity = "+buffer.capacity());
buffer.shrink();
System.out.println("Initial Buffer capacity after shrink = "+buffer.capacity());
buffer.capacity(32);
System.out.println("Buffer capacity after incrementing capacity to 32 = "+buffer.capacity());
buffer.shrink();
System.out.println("Buffer capacity after shrink= "+buffer.capacity());
We have initially allocated a capacity as 16, and set the autoShrink property as true.
Lets see the output of this
Lets take a break and analyze the output
- Initial buffer capacity is 16, as we created the buffer with this capacity. Internally this becomes the minimum capacity of the buffer
- After calling shrink(), the capacity remains 16, as capacity shall never be less than minimum capacity
- After incrementing capacity to 32, the capacity becomes 32
- Call to shrink(), reduces the capacity to 16, thereby eliminating extra storage
Buffer Allocation
IoBufferAllocater is responsible for allocating and managing buffers. To have precise control on the buffer allocation policy, implement the interface.
MINA ships with following implementations of IoBufferAllocater
- SimpleBufferAllocator (default) - Create a new buffer every time
- CachedBufferAllocator - caches the buffer which are likely to be reused during expansion
You can implement you own implementation of IoBufferAllocator and call setAllocator() on IoBuffer to use the same.
